1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
33 #include "sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
55 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
56 [UNIT_SERVICE] = &service_vtable,
57 [UNIT_SOCKET] = &socket_vtable,
58 [UNIT_BUSNAME] = &busname_vtable,
59 [UNIT_TARGET] = &target_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_DEVICE] = &device_vtable,
62 [UNIT_MOUNT] = &mount_vtable,
63 [UNIT_AUTOMOUNT] = &automount_vtable,
64 [UNIT_SWAP] = &swap_vtable,
65 [UNIT_TIMER] = &timer_vtable,
66 [UNIT_PATH] = &path_vtable,
67 [UNIT_SLICE] = &slice_vtable,
68 [UNIT_SCOPE] = &scope_vtable
71 Unit *unit_new(Manager *m, size_t size) {
75 assert(size >= sizeof(Unit));
81 u->names = set_new(string_hash_func, string_compare_func);
88 u->type = _UNIT_TYPE_INVALID;
89 u->deserialized_job = _JOB_TYPE_INVALID;
90 u->default_dependencies = true;
91 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 u->on_failure_job_mode = JOB_REPLACE;
97 bool unit_has_name(Unit *u, const char *name) {
101 return !!set_get(u->names, (char*) name);
104 int unit_add_name(Unit *u, const char *text) {
112 if (unit_name_is_template(text)) {
116 s = unit_name_replace_instance(text, u->instance);
123 if (!unit_name_is_valid(s, TEMPLATE_INVALID)) {
128 assert_se((t = unit_name_to_type(s)) >= 0);
130 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
135 r = unit_name_to_instance(s, &i);
139 if (i && unit_vtable[t]->no_instances) {
144 /* Ensure that this unit is either instanced or not instanced,
146 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
151 if (unit_vtable[t]->no_alias &&
152 !set_isempty(u->names) &&
153 !set_get(u->names, s)) {
158 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
163 r = set_put(u->names, s);
170 r = hashmap_put(u->manager->units, s, u);
172 set_remove(u->names, s);
176 if (u->type == _UNIT_TYPE_INVALID) {
182 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
184 if (UNIT_VTABLE(u)->init)
185 UNIT_VTABLE(u)->init(u);
189 unit_add_to_dbus_queue(u);
199 int unit_choose_id(Unit *u, const char *name) {
201 _cleanup_free_ char *t = NULL;
207 if (unit_name_is_template(name)) {
212 t = unit_name_replace_instance(name, u->instance);
219 /* Selects one of the names of this unit as the id */
220 s = set_get(u->names, (char*) name);
225 r = unit_name_to_instance(s, &i);
234 unit_add_to_dbus_queue(u);
239 int unit_set_description(Unit *u, const char *description) {
244 if (isempty(description))
247 s = strdup(description);
252 free(u->description);
255 unit_add_to_dbus_queue(u);
259 bool unit_check_gc(Unit *u) {
262 if (UNIT_VTABLE(u)->no_gc)
274 if (unit_active_state(u) != UNIT_INACTIVE)
280 if (UNIT_VTABLE(u)->check_gc)
281 if (UNIT_VTABLE(u)->check_gc(u))
287 void unit_add_to_load_queue(Unit *u) {
289 assert(u->type != _UNIT_TYPE_INVALID);
291 if (u->load_state != UNIT_STUB || u->in_load_queue)
294 LIST_PREPEND(load_queue, u->manager->load_queue, u);
295 u->in_load_queue = true;
298 void unit_add_to_cleanup_queue(Unit *u) {
301 if (u->in_cleanup_queue)
304 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
305 u->in_cleanup_queue = true;
308 void unit_add_to_gc_queue(Unit *u) {
311 if (u->in_gc_queue || u->in_cleanup_queue)
314 if (unit_check_gc(u))
317 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
318 u->in_gc_queue = true;
320 u->manager->n_in_gc_queue ++;
323 void unit_add_to_dbus_queue(Unit *u) {
325 assert(u->type != _UNIT_TYPE_INVALID);
327 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
330 /* Shortcut things if nobody cares */
331 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
332 set_isempty(u->manager->private_buses)) {
333 u->sent_dbus_new_signal = true;
337 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
338 u->in_dbus_queue = true;
341 static void bidi_set_free(Unit *u, Set *s) {
347 /* Frees the set and makes sure we are dropped from the
348 * inverse pointers */
350 SET_FOREACH(other, s, i) {
353 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
354 set_remove(other->dependencies[d], u);
356 unit_add_to_gc_queue(other);
362 static void unit_remove_transient(Unit *u) {
370 if (u->fragment_path)
371 unlink(u->fragment_path);
373 STRV_FOREACH(i, u->dropin_paths) {
374 _cleanup_free_ char *p = NULL;
379 r = path_get_parent(*i, &p);
385 static void unit_free_requires_mounts_for(Unit *u) {
388 STRV_FOREACH(j, u->requires_mounts_for) {
389 char s[strlen(*j) + 1];
391 PATH_FOREACH_PREFIX_MORE(s, *j) {
395 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
401 if (set_isempty(x)) {
402 hashmap_remove(u->manager->units_requiring_mounts_for, y);
409 strv_free(u->requires_mounts_for);
410 u->requires_mounts_for = NULL;
413 void unit_free(Unit *u) {
420 if (u->manager->n_reloading <= 0)
421 unit_remove_transient(u);
423 bus_unit_send_removed_signal(u);
425 if (u->load_state != UNIT_STUB)
426 if (UNIT_VTABLE(u)->done)
427 UNIT_VTABLE(u)->done(u);
429 unit_free_requires_mounts_for(u);
431 SET_FOREACH(t, u->names, i)
432 hashmap_remove_value(u->manager->units, t, u);
446 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
447 bidi_set_free(u, u->dependencies[d]);
449 if (u->type != _UNIT_TYPE_INVALID)
450 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
452 if (u->in_load_queue)
453 LIST_REMOVE(load_queue, u->manager->load_queue, u);
455 if (u->in_dbus_queue)
456 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
458 if (u->in_cleanup_queue)
459 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
461 if (u->in_gc_queue) {
462 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
463 u->manager->n_in_gc_queue--;
466 if (u->in_cgroup_queue)
467 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
469 if (u->cgroup_path) {
470 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
471 free(u->cgroup_path);
474 set_remove(u->manager->failed_units, u);
476 free(u->description);
477 strv_free(u->documentation);
478 free(u->fragment_path);
479 free(u->source_path);
480 strv_free(u->dropin_paths);
483 set_free_free(u->names);
485 unit_unwatch_all_pids(u);
487 condition_free_list(u->conditions);
489 unit_ref_unset(&u->slice);
492 unit_ref_unset(u->refs);
497 UnitActiveState unit_active_state(Unit *u) {
500 if (u->load_state == UNIT_MERGED)
501 return unit_active_state(unit_follow_merge(u));
503 /* After a reload it might happen that a unit is not correctly
504 * loaded but still has a process around. That's why we won't
505 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
507 return UNIT_VTABLE(u)->active_state(u);
510 const char* unit_sub_state_to_string(Unit *u) {
513 return UNIT_VTABLE(u)->sub_state_to_string(u);
516 static void complete_move(Set **s, Set **other) {
524 set_move(*s, *other);
531 static void merge_names(Unit *u, Unit *other) {
538 complete_move(&u->names, &other->names);
540 set_free_free(other->names);
544 SET_FOREACH(t, u->names, i)
545 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
548 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
555 assert(d < _UNIT_DEPENDENCY_MAX);
557 /* Fix backwards pointers */
558 SET_FOREACH(back, other->dependencies[d], i) {
561 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
562 r = set_remove_and_put(back->dependencies[k], other, u);
564 set_remove(back->dependencies[k], other);
566 assert(r >= 0 || r == -ENOENT);
570 complete_move(&u->dependencies[d], &other->dependencies[d]);
572 set_free(other->dependencies[d]);
573 other->dependencies[d] = NULL;
576 int unit_merge(Unit *u, Unit *other) {
581 assert(u->manager == other->manager);
582 assert(u->type != _UNIT_TYPE_INVALID);
584 other = unit_follow_merge(other);
589 if (u->type != other->type)
592 if (!u->instance != !other->instance)
595 if (other->load_state != UNIT_STUB &&
596 other->load_state != UNIT_NOT_FOUND)
605 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
609 merge_names(u, other);
611 /* Redirect all references */
613 unit_ref_set(other->refs, u);
615 /* Merge dependencies */
616 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
617 merge_dependencies(u, other, d);
619 other->load_state = UNIT_MERGED;
620 other->merged_into = u;
622 /* If there is still some data attached to the other node, we
623 * don't need it anymore, and can free it. */
624 if (other->load_state != UNIT_STUB)
625 if (UNIT_VTABLE(other)->done)
626 UNIT_VTABLE(other)->done(other);
628 unit_add_to_dbus_queue(u);
629 unit_add_to_cleanup_queue(other);
634 int unit_merge_by_name(Unit *u, const char *name) {
637 _cleanup_free_ char *s = NULL;
642 if (unit_name_is_template(name)) {
646 s = unit_name_replace_instance(name, u->instance);
653 other = manager_get_unit(u->manager, name);
655 r = unit_add_name(u, name);
657 r = unit_merge(u, other);
662 Unit* unit_follow_merge(Unit *u) {
665 while (u->load_state == UNIT_MERGED)
666 assert_se(u = u->merged_into);
671 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
677 if (c->working_directory) {
678 r = unit_require_mounts_for(u, c->working_directory);
683 if (c->root_directory) {
684 r = unit_require_mounts_for(u, c->root_directory);
689 if (c->std_output != EXEC_OUTPUT_KMSG &&
690 c->std_output != EXEC_OUTPUT_SYSLOG &&
691 c->std_output != EXEC_OUTPUT_JOURNAL &&
692 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
693 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
694 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
695 c->std_error != EXEC_OUTPUT_KMSG &&
696 c->std_error != EXEC_OUTPUT_SYSLOG &&
697 c->std_error != EXEC_OUTPUT_JOURNAL &&
698 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
699 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
700 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
703 /* If syslog or kernel logging is requested, make sure our own
704 * logging daemon is run first. */
706 if (u->manager->running_as == SYSTEMD_SYSTEM) {
707 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
715 const char *unit_description(Unit *u) {
719 return u->description;
724 void unit_dump(Unit *u, FILE *f, const char *prefix) {
728 _cleanup_free_ char *p2 = NULL;
731 timestamp1[FORMAT_TIMESTAMP_MAX],
732 timestamp2[FORMAT_TIMESTAMP_MAX],
733 timestamp3[FORMAT_TIMESTAMP_MAX],
734 timestamp4[FORMAT_TIMESTAMP_MAX],
735 timespan[FORMAT_TIMESPAN_MAX];
737 _cleanup_set_free_ Set *following_set = NULL;
741 assert(u->type >= 0);
745 p2 = strappend(prefix, "\t");
746 prefix2 = p2 ? p2 : prefix;
750 "%s\tDescription: %s\n"
752 "%s\tUnit Load State: %s\n"
753 "%s\tUnit Active State: %s\n"
754 "%s\tInactive Exit Timestamp: %s\n"
755 "%s\tActive Enter Timestamp: %s\n"
756 "%s\tActive Exit Timestamp: %s\n"
757 "%s\tInactive Enter Timestamp: %s\n"
758 "%s\tGC Check Good: %s\n"
759 "%s\tNeed Daemon Reload: %s\n"
760 "%s\tTransient: %s\n"
763 "%s\tCGroup realized: %s\n"
764 "%s\tCGroup mask: 0x%x\n"
765 "%s\tCGroup members mask: 0x%x\n",
767 prefix, unit_description(u),
768 prefix, strna(u->instance),
769 prefix, unit_load_state_to_string(u->load_state),
770 prefix, unit_active_state_to_string(unit_active_state(u)),
771 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
772 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
773 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
774 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
775 prefix, yes_no(unit_check_gc(u)),
776 prefix, yes_no(unit_need_daemon_reload(u)),
777 prefix, yes_no(u->transient),
778 prefix, strna(unit_slice_name(u)),
779 prefix, strna(u->cgroup_path),
780 prefix, yes_no(u->cgroup_realized),
781 prefix, u->cgroup_realized_mask,
782 prefix, u->cgroup_members_mask);
784 SET_FOREACH(t, u->names, i)
785 fprintf(f, "%s\tName: %s\n", prefix, t);
787 STRV_FOREACH(j, u->documentation)
788 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
790 following = unit_following(u);
792 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
794 r = unit_following_set(u, &following_set);
798 SET_FOREACH(other, following_set, i)
799 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
802 if (u->fragment_path)
803 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
806 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
808 STRV_FOREACH(j, u->dropin_paths)
809 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
811 if (u->job_timeout > 0)
812 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
814 condition_dump_list(u->conditions, f, prefix);
816 if (dual_timestamp_is_set(&u->condition_timestamp))
818 "%s\tCondition Timestamp: %s\n"
819 "%s\tCondition Result: %s\n",
820 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
821 prefix, yes_no(u->condition_result));
823 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
826 SET_FOREACH(other, u->dependencies[d], i)
827 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
830 if (!strv_isempty(u->requires_mounts_for)) {
832 "%s\tRequiresMountsFor:", prefix);
834 STRV_FOREACH(j, u->requires_mounts_for)
835 fprintf(f, " %s", *j);
840 if (u->load_state == UNIT_LOADED) {
843 "%s\tStopWhenUnneeded: %s\n"
844 "%s\tRefuseManualStart: %s\n"
845 "%s\tRefuseManualStop: %s\n"
846 "%s\tDefaultDependencies: %s\n"
847 "%s\tOnFailureJobMode: %s\n"
848 "%s\tIgnoreOnIsolate: %s\n"
849 "%s\tIgnoreOnSnapshot: %s\n",
850 prefix, yes_no(u->stop_when_unneeded),
851 prefix, yes_no(u->refuse_manual_start),
852 prefix, yes_no(u->refuse_manual_stop),
853 prefix, yes_no(u->default_dependencies),
854 prefix, job_mode_to_string(u->on_failure_job_mode),
855 prefix, yes_no(u->ignore_on_isolate),
856 prefix, yes_no(u->ignore_on_snapshot));
858 if (UNIT_VTABLE(u)->dump)
859 UNIT_VTABLE(u)->dump(u, f, prefix2);
861 } else if (u->load_state == UNIT_MERGED)
863 "%s\tMerged into: %s\n",
864 prefix, u->merged_into->id);
865 else if (u->load_state == UNIT_ERROR)
866 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
870 job_dump(u->job, f, prefix2);
873 job_dump(u->nop_job, f, prefix2);
877 /* Common implementation for multiple backends */
878 int unit_load_fragment_and_dropin(Unit *u) {
883 /* Load a .{service,socket,...} file */
884 r = unit_load_fragment(u);
888 if (u->load_state == UNIT_STUB)
891 /* Load drop-in directory data */
892 r = unit_load_dropin(unit_follow_merge(u));
899 /* Common implementation for multiple backends */
900 int unit_load_fragment_and_dropin_optional(Unit *u) {
905 /* Same as unit_load_fragment_and_dropin(), but whether
906 * something can be loaded or not doesn't matter. */
908 /* Load a .service file */
909 r = unit_load_fragment(u);
913 if (u->load_state == UNIT_STUB)
914 u->load_state = UNIT_LOADED;
916 /* Load drop-in directory data */
917 r = unit_load_dropin(unit_follow_merge(u));
924 int unit_add_default_target_dependency(Unit *u, Unit *target) {
928 if (target->type != UNIT_TARGET)
931 /* Only add the dependency if both units are loaded, so that
932 * that loop check below is reliable */
933 if (u->load_state != UNIT_LOADED ||
934 target->load_state != UNIT_LOADED)
937 /* If either side wants no automatic dependencies, then let's
939 if (!u->default_dependencies ||
940 !target->default_dependencies)
943 /* Don't create loops */
944 if (set_get(target->dependencies[UNIT_BEFORE], u))
947 return unit_add_dependency(target, UNIT_AFTER, u, true);
950 static int unit_add_target_dependencies(Unit *u) {
952 static const UnitDependency deps[] = {
954 UNIT_REQUIRED_BY_OVERRIDABLE,
966 for (k = 0; k < ELEMENTSOF(deps); k++)
967 SET_FOREACH(target, u->dependencies[deps[k]], i) {
968 r = unit_add_default_target_dependency(u, target);
976 static int unit_add_slice_dependencies(Unit *u) {
979 if (!unit_get_cgroup_context(u))
982 if (UNIT_ISSET(u->slice))
983 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
985 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
988 static int unit_add_mount_dependencies(Unit *u) {
994 STRV_FOREACH(i, u->requires_mounts_for) {
995 char prefix[strlen(*i) + 1];
997 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1000 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1008 if (m->load_state != UNIT_LOADED)
1011 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1015 if (m->fragment_path) {
1016 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1026 int unit_load(Unit *u) {
1031 if (u->in_load_queue) {
1032 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1033 u->in_load_queue = false;
1036 if (u->type == _UNIT_TYPE_INVALID)
1039 if (u->load_state != UNIT_STUB)
1042 if (UNIT_VTABLE(u)->load) {
1043 r = UNIT_VTABLE(u)->load(u);
1048 if (u->load_state == UNIT_STUB) {
1053 if (u->load_state == UNIT_LOADED) {
1055 r = unit_add_target_dependencies(u);
1059 r = unit_add_slice_dependencies(u);
1063 r = unit_add_mount_dependencies(u);
1067 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1068 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1073 unit_update_cgroup_members_masks(u);
1076 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1078 unit_add_to_dbus_queue(unit_follow_merge(u));
1079 unit_add_to_gc_queue(u);
1084 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1086 unit_add_to_dbus_queue(u);
1087 unit_add_to_gc_queue(u);
1089 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1090 u->id, strerror(-r));
1095 static bool unit_condition_test(Unit *u) {
1098 dual_timestamp_get(&u->condition_timestamp);
1099 u->condition_result = condition_test_list(u->id, u->conditions);
1101 return u->condition_result;
1104 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1105 const UnitStatusMessageFormats *format_table;
1109 assert(t < _JOB_TYPE_MAX);
1111 if (t != JOB_START && t != JOB_STOP)
1114 format_table = &UNIT_VTABLE(u)->status_message_formats;
1118 return format_table->starting_stopping[t == JOB_STOP];
1121 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1126 assert(t < _JOB_TYPE_MAX);
1128 format = unit_get_status_message_format(u, t);
1132 /* Return generic strings */
1134 return "Starting %s.";
1135 else if (t == JOB_STOP)
1136 return "Stopping %s.";
1137 else if (t == JOB_RELOAD)
1138 return "Reloading %s.";
1143 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1148 /* We only print status messages for selected units on
1149 * selected operations. */
1151 format = unit_get_status_message_format(u, t);
1155 DISABLE_WARNING_FORMAT_NONLITERAL;
1156 unit_status_printf(u, "", format);
1160 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1167 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1170 if (log_on_console())
1173 /* We log status messages for all units and all operations. */
1175 format = unit_get_status_message_format_try_harder(u, t);
1179 DISABLE_WARNING_FORMAT_NONLITERAL;
1180 snprintf(buf, sizeof(buf), format, unit_description(u));
1184 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1185 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1186 SD_MESSAGE_UNIT_RELOADING;
1188 log_struct_unit(LOG_INFO,
1196 * -EBADR: This unit type does not support starting.
1197 * -EALREADY: Unit is already started.
1198 * -EAGAIN: An operation is already in progress. Retry later.
1199 * -ECANCELED: Too many requests for now.
1201 int unit_start(Unit *u) {
1202 UnitActiveState state;
1207 if (u->load_state != UNIT_LOADED)
1210 /* If this is already started, then this will succeed. Note
1211 * that this will even succeed if this unit is not startable
1212 * by the user. This is relied on to detect when we need to
1213 * wait for units and when waiting is finished. */
1214 state = unit_active_state(u);
1215 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1218 /* If the conditions failed, don't do anything at all. If we
1219 * already are activating this call might still be useful to
1220 * speed up activation in case there is some hold-off time,
1221 * but we don't want to recheck the condition in that case. */
1222 if (state != UNIT_ACTIVATING &&
1223 !unit_condition_test(u)) {
1224 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1228 /* Forward to the main object, if we aren't it. */
1229 following = unit_following(u);
1231 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1232 u->id, following->id);
1233 return unit_start(following);
1236 unit_status_log_starting_stopping_reloading(u, JOB_START);
1237 unit_status_print_starting_stopping(u, JOB_START);
1239 /* If it is stopped, but we cannot start it, then fail */
1240 if (!UNIT_VTABLE(u)->start)
1243 /* We don't suppress calls to ->start() here when we are
1244 * already starting, to allow this request to be used as a
1245 * "hurry up" call, for example when the unit is in some "auto
1246 * restart" state where it waits for a holdoff timer to elapse
1247 * before it will start again. */
1249 unit_add_to_dbus_queue(u);
1251 return UNIT_VTABLE(u)->start(u);
1254 bool unit_can_start(Unit *u) {
1257 return !!UNIT_VTABLE(u)->start;
1260 bool unit_can_isolate(Unit *u) {
1263 return unit_can_start(u) &&
1268 * -EBADR: This unit type does not support stopping.
1269 * -EALREADY: Unit is already stopped.
1270 * -EAGAIN: An operation is already in progress. Retry later.
1272 int unit_stop(Unit *u) {
1273 UnitActiveState state;
1278 state = unit_active_state(u);
1279 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1282 if ((following = unit_following(u))) {
1283 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1284 u->id, following->id);
1285 return unit_stop(following);
1288 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1289 unit_status_print_starting_stopping(u, JOB_STOP);
1291 if (!UNIT_VTABLE(u)->stop)
1294 unit_add_to_dbus_queue(u);
1296 return UNIT_VTABLE(u)->stop(u);
1300 * -EBADR: This unit type does not support reloading.
1301 * -ENOEXEC: Unit is not started.
1302 * -EAGAIN: An operation is already in progress. Retry later.
1304 int unit_reload(Unit *u) {
1305 UnitActiveState state;
1310 if (u->load_state != UNIT_LOADED)
1313 if (!unit_can_reload(u))
1316 state = unit_active_state(u);
1317 if (state == UNIT_RELOADING)
1320 if (state != UNIT_ACTIVE) {
1321 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1326 following = unit_following(u);
1328 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1329 u->id, following->id);
1330 return unit_reload(following);
1333 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1335 unit_add_to_dbus_queue(u);
1336 return UNIT_VTABLE(u)->reload(u);
1339 bool unit_can_reload(Unit *u) {
1342 if (!UNIT_VTABLE(u)->reload)
1345 if (!UNIT_VTABLE(u)->can_reload)
1348 return UNIT_VTABLE(u)->can_reload(u);
1351 static void unit_check_unneeded(Unit *u) {
1357 /* If this service shall be shut down when unneeded then do
1360 if (!u->stop_when_unneeded)
1363 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1366 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1367 if (unit_active_or_pending(other))
1370 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1371 if (unit_active_or_pending(other))
1374 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1375 if (unit_active_or_pending(other))
1378 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1379 if (unit_active_or_pending(other))
1382 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1384 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1385 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1388 static void retroactively_start_dependencies(Unit *u) {
1393 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1395 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1396 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1397 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1398 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1400 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1401 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1402 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1403 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1405 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1406 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1407 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1408 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1410 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1411 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1412 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1413 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1415 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1416 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1417 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1419 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1420 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1421 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1424 static void retroactively_stop_dependencies(Unit *u) {
1429 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1431 /* Pull down units which are bound to us recursively if enabled */
1432 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1433 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1434 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1437 static void check_unneeded_dependencies(Unit *u) {
1442 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1444 /* Garbage collect services that might not be needed anymore, if enabled */
1445 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1446 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1447 unit_check_unneeded(other);
1448 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1449 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1450 unit_check_unneeded(other);
1451 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1452 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1453 unit_check_unneeded(other);
1454 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1455 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1456 unit_check_unneeded(other);
1457 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1458 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1459 unit_check_unneeded(other);
1460 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1461 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1462 unit_check_unneeded(other);
1465 void unit_start_on_failure(Unit *u) {
1471 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1474 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1476 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1479 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1481 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1485 void unit_trigger_notify(Unit *u) {
1491 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1492 if (UNIT_VTABLE(other)->trigger_notify)
1493 UNIT_VTABLE(other)->trigger_notify(other, u);
1496 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1501 assert(os < _UNIT_ACTIVE_STATE_MAX);
1502 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1504 /* Note that this is called for all low-level state changes,
1505 * even if they might map to the same high-level
1506 * UnitActiveState! That means that ns == os is OK an expected
1507 * behavior here. For example: if a mount point is remounted
1508 * this function will be called too! */
1512 /* Update timestamps for state changes */
1513 if (m->n_reloading <= 0) {
1516 dual_timestamp_get(&ts);
1518 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1519 u->inactive_exit_timestamp = ts;
1520 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1521 u->inactive_enter_timestamp = ts;
1523 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1524 u->active_enter_timestamp = ts;
1525 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1526 u->active_exit_timestamp = ts;
1529 /* Keep track of failed of units */
1530 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1531 set_put(u->manager->failed_units, u);
1532 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1533 set_remove(u->manager->failed_units, u);
1535 /* Make sure the cgroup is always removed when we become inactive */
1536 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1537 unit_destroy_cgroup(u);
1539 /* Note that this doesn't apply to RemainAfterExit services exiting
1540 * sucessfully, since there's no change of state in that case. Which is
1541 * why it is handled in service_set_state() */
1542 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1545 ec = unit_get_exec_context(u);
1546 if (ec && exec_context_may_touch_console(ec)) {
1547 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1550 if (m->n_on_console == 0)
1551 /* unset no_console_output flag, since the console is free */
1552 m->no_console_output = false;
1561 if (u->job->state == JOB_WAITING)
1563 /* So we reached a different state for this
1564 * job. Let's see if we can run it now if it
1565 * failed previously due to EAGAIN. */
1566 job_add_to_run_queue(u->job);
1568 /* Let's check whether this state change constitutes a
1569 * finished job, or maybe contradicts a running job and
1570 * hence needs to invalidate jobs. */
1572 switch (u->job->type) {
1575 case JOB_VERIFY_ACTIVE:
1577 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1578 job_finish_and_invalidate(u->job, JOB_DONE, true);
1579 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1582 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1583 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1589 case JOB_RELOAD_OR_START:
1591 if (u->job->state == JOB_RUNNING) {
1592 if (ns == UNIT_ACTIVE)
1593 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1594 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1597 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1598 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1606 case JOB_TRY_RESTART:
1608 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1609 job_finish_and_invalidate(u->job, JOB_DONE, true);
1610 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1612 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1618 assert_not_reached("Job type unknown");
1624 if (m->n_reloading <= 0) {
1626 /* If this state change happened without being
1627 * requested by a job, then let's retroactively start
1628 * or stop dependencies. We skip that step when
1629 * deserializing, since we don't want to create any
1630 * additional jobs just because something is already
1634 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1635 retroactively_start_dependencies(u);
1636 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1637 retroactively_stop_dependencies(u);
1640 /* stop unneeded units regardless if going down was expected or not */
1641 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1642 check_unneeded_dependencies(u);
1644 if (ns != os && ns == UNIT_FAILED) {
1645 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1646 unit_start_on_failure(u);
1650 /* Some names are special */
1651 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1653 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1654 /* The bus just might have become available,
1655 * hence try to connect to it, if we aren't
1659 if (u->type == UNIT_SERVICE &&
1660 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1661 m->n_reloading <= 0) {
1662 /* Write audit record if we have just finished starting up */
1663 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1667 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1668 manager_send_unit_plymouth(m, u);
1672 /* We don't care about D-Bus here, since we'll get an
1673 * asynchronous notification for it anyway. */
1675 if (u->type == UNIT_SERVICE &&
1676 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1677 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1678 m->n_reloading <= 0) {
1680 /* Hmm, if there was no start record written
1681 * write it now, so that we always have a nice
1684 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1686 if (ns == UNIT_INACTIVE)
1687 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1689 /* Write audit record if we have just finished shutting down */
1690 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1692 u->in_audit = false;
1696 manager_recheck_journal(m);
1697 unit_trigger_notify(u);
1699 /* Maybe we finished startup and are now ready for being
1700 * stopped because unneeded? */
1701 if (u->manager->n_reloading <= 0)
1702 unit_check_unneeded(u);
1704 unit_add_to_dbus_queue(u);
1705 unit_add_to_gc_queue(u);
1708 int unit_watch_pid(Unit *u, pid_t pid) {
1714 /* Watch a specific PID. We only support one or two units
1715 * watching each PID for now, not more. */
1717 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1721 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1725 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1727 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1731 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1734 q = set_put(u->pids, LONG_TO_PTR(pid));
1741 void unit_unwatch_pid(Unit *u, pid_t pid) {
1745 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1746 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1747 set_remove(u->pids, LONG_TO_PTR(pid));
1750 void unit_unwatch_all_pids(Unit *u) {
1753 while (!set_isempty(u->pids))
1754 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1760 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1761 _cleanup_closedir_ DIR *d = NULL;
1762 _cleanup_fclose_ FILE *f = NULL;
1768 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1770 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1774 while ((r = cg_read_pid(f, &pid)) > 0) {
1775 r = unit_watch_pid(u, pid);
1776 if (r < 0 && ret >= 0)
1779 if (r < 0 && ret >= 0)
1782 } else if (ret >= 0)
1785 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1789 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1790 _cleanup_free_ char *p = NULL;
1792 p = strjoin(path, "/", fn, NULL);
1798 r = unit_watch_pids_in_path(u, p);
1799 if (r < 0 && ret >= 0)
1802 if (r < 0 && ret >= 0)
1805 } else if (ret >= 0)
1811 int unit_watch_all_pids(Unit *u) {
1814 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1816 if (!u->cgroup_path)
1819 return unit_watch_pids_in_path(u, u->cgroup_path);
1822 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1828 /* Cleans dead PIDs from our list */
1830 SET_FOREACH(e, u->pids, i) {
1831 pid_t pid = PTR_TO_LONG(e);
1833 if (pid == except1 || pid == except2)
1836 if (!pid_is_unwaited(pid))
1837 unit_unwatch_pid(u, pid);
1841 bool unit_job_is_applicable(Unit *u, JobType j) {
1843 assert(j >= 0 && j < _JOB_TYPE_MAX);
1847 case JOB_VERIFY_ACTIVE:
1854 case JOB_TRY_RESTART:
1855 return unit_can_start(u);
1858 return unit_can_reload(u);
1860 case JOB_RELOAD_OR_START:
1861 return unit_can_reload(u) && unit_can_start(u);
1864 assert_not_reached("Invalid job type");
1868 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1870 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1871 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1872 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1873 [UNIT_WANTS] = UNIT_WANTED_BY,
1874 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1875 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1876 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1877 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1878 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1879 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1880 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1881 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1882 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1883 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1884 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1885 [UNIT_BEFORE] = UNIT_AFTER,
1886 [UNIT_AFTER] = UNIT_BEFORE,
1887 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1888 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1889 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1890 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1891 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1892 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1893 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1894 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1896 int r, q = 0, v = 0, w = 0;
1899 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1902 u = unit_follow_merge(u);
1903 other = unit_follow_merge(other);
1905 /* We won't allow dependencies on ourselves. We will not
1906 * consider them an error however. */
1910 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1914 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1915 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1920 if (add_reference) {
1921 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1925 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1930 q = set_put(u->dependencies[d], other);
1934 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1935 v = set_put(other->dependencies[inverse_table[d]], u);
1942 if (add_reference) {
1943 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1949 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1954 unit_add_to_dbus_queue(u);
1959 set_remove(u->dependencies[d], other);
1962 set_remove(other->dependencies[inverse_table[d]], u);
1965 set_remove(u->dependencies[UNIT_REFERENCES], other);
1970 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1975 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1978 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1984 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1988 assert(name || path);
1992 name = basename(path);
1994 if (!unit_name_is_template(name)) {
2000 s = unit_name_replace_instance(name, u->instance);
2002 _cleanup_free_ char *i = NULL;
2004 i = unit_name_to_prefix(u->id);
2008 s = unit_name_replace_instance(name, i);
2018 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2021 _cleanup_free_ char *s = NULL;
2024 assert(name || path);
2026 name = resolve_template(u, name, path, &s);
2030 r = manager_load_unit(u->manager, name, path, NULL, &other);
2034 return unit_add_dependency(u, d, other, add_reference);
2037 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2040 _cleanup_free_ char *s = NULL;
2043 assert(name || path);
2045 if (!(name = resolve_template(u, name, path, &s)))
2048 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2051 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2056 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2059 _cleanup_free_ char *s = NULL;
2062 assert(name || path);
2064 if (!(name = resolve_template(u, name, path, &s)))
2067 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2070 r = unit_add_dependency(other, d, u, add_reference);
2075 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2078 _cleanup_free_ char *s = NULL;
2081 assert(name || path);
2083 if (!(name = resolve_template(u, name, path, &s)))
2086 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2089 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2095 int set_unit_path(const char *p) {
2096 _cleanup_free_ char *c = NULL;
2098 /* This is mostly for debug purposes */
2099 c = path_make_absolute_cwd(p);
2100 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2106 char *unit_dbus_path(Unit *u) {
2112 return unit_dbus_path_from_name(u->id);
2115 char *unit_default_cgroup_path(Unit *u) {
2116 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2121 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2122 return strdup(u->manager->cgroup_root);
2124 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2125 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2130 escaped = cg_escape(u->id);
2135 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2137 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2140 int unit_add_default_slice(Unit *u) {
2141 _cleanup_free_ char *b = NULL;
2142 const char *slice_name;
2148 if (UNIT_ISSET(u->slice))
2151 if (!unit_get_cgroup_context(u))
2155 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2157 /* Implicitly place all instantiated units in their
2158 * own per-template slice */
2160 prefix = unit_name_to_prefix(u->id);
2164 /* The prefix is already escaped, but it might include
2165 * "-" which has a special meaning for slice units,
2166 * hence escape it here extra. */
2167 escaped = strreplace(prefix, "-", "\\x2d");
2171 if (u->manager->running_as == SYSTEMD_SYSTEM)
2172 b = strjoin("system-", escaped, ".slice", NULL);
2174 b = strappend(escaped, ".slice");
2181 u->manager->running_as == SYSTEMD_SYSTEM
2182 ? SPECIAL_SYSTEM_SLICE
2183 : SPECIAL_ROOT_SLICE;
2185 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2189 unit_ref_set(&u->slice, slice);
2193 const char *unit_slice_name(Unit *u) {
2196 if (!UNIT_ISSET(u->slice))
2199 return UNIT_DEREF(u->slice)->id;
2202 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2203 _cleanup_free_ char *t = NULL;
2210 t = unit_name_change_suffix(u->id, type);
2214 assert(!unit_has_name(u, t));
2216 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2217 assert(r < 0 || *_found != u);
2221 int unit_watch_bus_name(Unit *u, const char *name) {
2225 /* Watch a specific name on the bus. We only support one unit
2226 * watching each name for now. */
2228 return hashmap_put(u->manager->watch_bus, name, u);
2231 void unit_unwatch_bus_name(Unit *u, const char *name) {
2235 hashmap_remove_value(u->manager->watch_bus, name, u);
2238 bool unit_can_serialize(Unit *u) {
2241 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2244 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2252 if (!unit_can_serialize(u))
2255 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2259 rt = unit_get_exec_runtime(u);
2261 r = exec_runtime_serialize(rt, u, f, fds);
2266 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2267 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2268 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2269 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2270 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2272 if (dual_timestamp_is_set(&u->condition_timestamp))
2273 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2275 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2278 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2280 if (serialize_jobs) {
2282 fprintf(f, "job\n");
2283 job_serialize(u->job, f, fds);
2287 fprintf(f, "job\n");
2288 job_serialize(u->nop_job, f, fds);
2297 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2308 va_start(ap, format);
2309 vfprintf(f, format, ap);
2315 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2321 fprintf(f, "%s=%s\n", key, value);
2324 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2326 ExecRuntime **rt = NULL;
2333 if (!unit_can_serialize(u))
2336 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2338 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2341 char line[LINE_MAX], *l, *v;
2344 if (!fgets(line, sizeof(line), f)) {
2357 k = strcspn(l, "=");
2365 if (streq(l, "job")) {
2367 /* new-style serialized job */
2368 Job *j = job_new_raw(u);
2372 r = job_deserialize(j, f, fds);
2378 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2384 r = job_install_deserialized(j);
2386 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2391 if (j->state == JOB_RUNNING)
2392 u->manager->n_running_jobs++;
2395 JobType type = job_type_from_string(v);
2397 log_debug("Failed to parse job type value %s", v);
2399 u->deserialized_job = type;
2402 } else if (streq(l, "inactive-exit-timestamp")) {
2403 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2405 } else if (streq(l, "active-enter-timestamp")) {
2406 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2408 } else if (streq(l, "active-exit-timestamp")) {
2409 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2411 } else if (streq(l, "inactive-enter-timestamp")) {
2412 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2414 } else if (streq(l, "condition-timestamp")) {
2415 dual_timestamp_deserialize(v, &u->condition_timestamp);
2417 } else if (streq(l, "condition-result")) {
2420 b = parse_boolean(v);
2422 log_debug("Failed to parse condition result value %s", v);
2424 u->condition_result = b;
2428 } else if (streq(l, "transient")) {
2431 b = parse_boolean(v);
2433 log_debug("Failed to parse transient bool %s", v);
2438 } else if (streq(l, "cgroup")) {
2445 free(u->cgroup_path);
2448 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2453 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2460 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2466 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2468 _cleanup_free_ char *e = NULL;
2476 /* Adds in links to the device node that this unit is based on */
2478 if (!is_device_path(what))
2481 e = unit_name_from_path(what, ".device");
2485 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2490 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2495 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2503 int unit_coldplug(Unit *u) {
2508 if (UNIT_VTABLE(u)->coldplug)
2509 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2513 r = job_coldplug(u->job);
2516 } else if (u->deserialized_job >= 0) {
2518 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2522 u->deserialized_job = _JOB_TYPE_INVALID;
2528 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2529 DISABLE_WARNING_FORMAT_NONLITERAL;
2530 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2534 bool unit_need_daemon_reload(Unit *u) {
2535 _cleanup_strv_free_ char **t = NULL;
2538 unsigned loaded_cnt, current_cnt;
2542 if (u->fragment_path) {
2544 if (stat(u->fragment_path, &st) < 0)
2545 /* What, cannot access this anymore? */
2548 if (u->fragment_mtime > 0 &&
2549 timespec_load(&st.st_mtim) != u->fragment_mtime)
2553 if (u->source_path) {
2555 if (stat(u->source_path, &st) < 0)
2558 if (u->source_mtime > 0 &&
2559 timespec_load(&st.st_mtim) != u->source_mtime)
2563 t = unit_find_dropin_paths(u);
2564 loaded_cnt = strv_length(t);
2565 current_cnt = strv_length(u->dropin_paths);
2567 if (loaded_cnt == current_cnt) {
2568 if (loaded_cnt == 0)
2571 if (strv_overlap(u->dropin_paths, t)) {
2572 STRV_FOREACH(path, u->dropin_paths) {
2574 if (stat(*path, &st) < 0)
2577 if (u->dropin_mtime > 0 &&
2578 timespec_load(&st.st_mtim) > u->dropin_mtime)
2589 void unit_reset_failed(Unit *u) {
2592 if (UNIT_VTABLE(u)->reset_failed)
2593 UNIT_VTABLE(u)->reset_failed(u);
2596 Unit *unit_following(Unit *u) {
2599 if (UNIT_VTABLE(u)->following)
2600 return UNIT_VTABLE(u)->following(u);
2605 bool unit_stop_pending(Unit *u) {
2608 /* This call does check the current state of the unit. It's
2609 * hence useful to be called from state change calls of the
2610 * unit itself, where the state isn't updated yet. This is
2611 * different from unit_inactive_or_pending() which checks both
2612 * the current state and for a queued job. */
2614 return u->job && u->job->type == JOB_STOP;
2617 bool unit_inactive_or_pending(Unit *u) {
2620 /* Returns true if the unit is inactive or going down */
2622 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2625 if (unit_stop_pending(u))
2631 bool unit_active_or_pending(Unit *u) {
2634 /* Returns true if the unit is active or going up */
2636 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2640 (u->job->type == JOB_START ||
2641 u->job->type == JOB_RELOAD_OR_START ||
2642 u->job->type == JOB_RESTART))
2648 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2650 assert(w >= 0 && w < _KILL_WHO_MAX);
2652 assert(signo < _NSIG);
2654 if (!UNIT_VTABLE(u)->kill)
2657 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2660 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2664 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2668 /* Exclude the main/control pids from being killed via the cgroup */
2670 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2675 if (control_pid > 0) {
2676 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2688 int unit_kill_common(
2694 sd_bus_error *error) {
2698 if (who == KILL_MAIN && main_pid <= 0) {
2700 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2702 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2706 if (who == KILL_CONTROL && control_pid <= 0) {
2707 if (control_pid < 0)
2708 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2710 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2714 if (who == KILL_CONTROL || who == KILL_ALL)
2715 if (control_pid > 0)
2716 if (kill(control_pid, signo) < 0)
2719 if (who == KILL_MAIN || who == KILL_ALL)
2721 if (kill(main_pid, signo) < 0)
2724 if (who == KILL_ALL && u->cgroup_path) {
2725 _cleanup_set_free_ Set *pid_set = NULL;
2728 /* Exclude the main/control pids from being killed via the cgroup */
2729 pid_set = unit_pid_set(main_pid, control_pid);
2733 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2734 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2741 int unit_following_set(Unit *u, Set **s) {
2745 if (UNIT_VTABLE(u)->following_set)
2746 return UNIT_VTABLE(u)->following_set(u, s);
2752 UnitFileState unit_get_unit_file_state(Unit *u) {
2755 if (u->unit_file_state < 0 && u->fragment_path)
2756 u->unit_file_state = unit_file_get_state(
2757 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2758 NULL, basename(u->fragment_path));
2760 return u->unit_file_state;
2763 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2768 unit_ref_unset(ref);
2771 LIST_PREPEND(refs, u->refs, ref);
2775 void unit_ref_unset(UnitRef *ref) {
2781 LIST_REMOVE(refs, ref->unit->refs, ref);
2785 int unit_cgroup_context_init_defaults(Unit *u, CGroupContext *c) {
2789 /* Copy in the manager defaults into the cgroup context,
2790 * _before_ the rest of the settings have been initialized */
2792 c->cpu_accounting = u->manager->default_cpu_accounting;
2793 c->blockio_accounting = u->manager->default_blockio_accounting;
2794 c->memory_accounting = u->manager->default_memory_accounting;
2799 int unit_exec_context_patch_defaults(Unit *u, ExecContext *c) {
2806 /* Patch in the manager defaults into the exec context,
2807 * _after_ the rest of the settings have been initialized */
2809 /* This only copies in the ones that need memory */
2810 for (i = 0; i < _RLIMIT_MAX; i++)
2811 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2812 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2817 if (u->manager->running_as == SYSTEMD_USER &&
2818 !c->working_directory) {
2820 r = get_home_dir(&c->working_directory);
2825 if (u->manager->running_as == SYSTEMD_USER &&
2826 (c->syscall_whitelist ||
2827 !set_isempty(c->syscall_filter) ||
2828 !set_isempty(c->syscall_archs) ||
2829 c->address_families_whitelist ||
2830 !set_isempty(c->address_families)))
2831 c->no_new_privileges = true;
2836 ExecContext *unit_get_exec_context(Unit *u) {
2840 offset = UNIT_VTABLE(u)->exec_context_offset;
2844 return (ExecContext*) ((uint8_t*) u + offset);
2847 KillContext *unit_get_kill_context(Unit *u) {
2851 offset = UNIT_VTABLE(u)->kill_context_offset;
2855 return (KillContext*) ((uint8_t*) u + offset);
2858 CGroupContext *unit_get_cgroup_context(Unit *u) {
2861 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2865 return (CGroupContext*) ((uint8_t*) u + offset);
2868 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2871 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2875 return *(ExecRuntime**) ((uint8_t*) u + offset);
2878 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2879 _cleanup_free_ char *b = NULL;
2888 b = xescape(name, "/.");
2892 if (!filename_is_safe(b))
2895 if (u->manager->running_as == SYSTEMD_USER) {
2896 _cleanup_free_ char *c = NULL;
2898 r = user_config_home(&c);
2904 p = strjoin(c, "/", u->id, ".d", NULL);
2905 } else if (mode == UNIT_PERSISTENT && !u->transient)
2906 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2908 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2912 q = strjoin(p, "/90-", b, ".conf", NULL);
2923 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2924 _cleanup_free_ char *p = NULL, *q = NULL;
2931 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2934 r = drop_in_file(u, mode, name, &p, &q);
2939 return write_string_file_atomic_label(q, data);
2942 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2943 _cleanup_free_ char *p = NULL;
2951 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2954 va_start(ap, format);
2955 r = vasprintf(&p, format, ap);
2961 return unit_write_drop_in(u, mode, name, p);
2964 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2965 _cleanup_free_ char *ndata = NULL;
2971 if (!UNIT_VTABLE(u)->private_section)
2974 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2977 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2981 return unit_write_drop_in(u, mode, name, ndata);
2984 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2985 _cleanup_free_ char *p = NULL;
2993 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2996 va_start(ap, format);
2997 r = vasprintf(&p, format, ap);
3003 return unit_write_drop_in_private(u, mode, name, p);
3006 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3007 _cleanup_free_ char *p = NULL, *q = NULL;
3012 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3015 r = drop_in_file(u, mode, name, &p, &q);
3020 r = errno == ENOENT ? 0 : -errno;
3028 int unit_make_transient(Unit *u) {
3033 u->load_state = UNIT_STUB;
3035 u->transient = true;
3037 free(u->fragment_path);
3038 u->fragment_path = NULL;
3040 if (u->manager->running_as == SYSTEMD_USER) {
3041 _cleanup_free_ char *c = NULL;
3043 r = user_config_home(&c);
3049 u->fragment_path = strjoin(c, "/", u->id, NULL);
3050 if (!u->fragment_path)
3055 u->fragment_path = strappend("/run/systemd/system/", u->id);
3056 if (!u->fragment_path)
3059 mkdir_p("/run/systemd/system", 0755);
3062 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3065 int unit_kill_context(
3071 bool main_pid_alien) {
3073 int sig, wait_for_exit = false, r;
3078 if (c->kill_mode == KILL_NONE)
3081 sig = sigkill ? SIGKILL : c->kill_signal;
3084 r = kill_and_sigcont(main_pid, sig);
3086 if (r < 0 && r != -ESRCH) {
3087 _cleanup_free_ char *comm = NULL;
3088 get_process_comm(main_pid, &comm);
3090 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3092 if (!main_pid_alien)
3093 wait_for_exit = true;
3095 if (c->send_sighup && !sigkill)
3096 kill(main_pid, SIGHUP);
3100 if (control_pid > 0) {
3101 r = kill_and_sigcont(control_pid, sig);
3103 if (r < 0 && r != -ESRCH) {
3104 _cleanup_free_ char *comm = NULL;
3105 get_process_comm(control_pid, &comm);
3107 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3109 wait_for_exit = true;
3111 if (c->send_sighup && !sigkill)
3112 kill(control_pid, SIGHUP);
3116 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3117 _cleanup_set_free_ Set *pid_set = NULL;
3119 /* Exclude the main/control pids from being killed via the cgroup */
3120 pid_set = unit_pid_set(main_pid, control_pid);
3124 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3126 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3127 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3130 /* FIXME: For now, we will not wait for the
3131 * cgroup members to die, simply because
3132 * cgroup notification is unreliable. It
3133 * doesn't work at all in containers, and
3134 * outside of containers it can be confused
3135 * easily by leaving directories in the
3138 /* wait_for_exit = true; */
3140 if (c->send_sighup && !sigkill) {
3143 pid_set = unit_pid_set(main_pid, control_pid);
3147 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3152 return wait_for_exit;
3155 int unit_require_mounts_for(Unit *u, const char *path) {
3156 char prefix[strlen(path) + 1], *p;
3162 /* Registers a unit for requiring a certain path and all its
3163 * prefixes. We keep a simple array of these paths in the
3164 * unit, since its usually short. However, we build a prefix
3165 * table for all possible prefixes so that new appearing mount
3166 * units can easily determine which units to make themselves a
3169 if (!path_is_absolute(path))
3176 path_kill_slashes(p);
3178 if (!path_is_safe(p)) {
3183 if (strv_contains(u->requires_mounts_for, p)) {
3188 r = strv_consume(&u->requires_mounts_for, p);
3192 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3195 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3199 if (!u->manager->units_requiring_mounts_for) {
3200 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3201 if (!u->manager->units_requiring_mounts_for)
3209 x = set_new(NULL, NULL);
3215 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3231 int unit_setup_exec_runtime(Unit *u) {
3237 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3240 /* Check if ther already is an ExecRuntime for this unit? */
3241 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3245 /* Try to get it from somebody else */
3246 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3248 *rt = unit_get_exec_runtime(other);
3250 exec_runtime_ref(*rt);
3255 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3258 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3259 [UNIT_ACTIVE] = "active",
3260 [UNIT_RELOADING] = "reloading",
3261 [UNIT_INACTIVE] = "inactive",
3262 [UNIT_FAILED] = "failed",
3263 [UNIT_ACTIVATING] = "activating",
3264 [UNIT_DEACTIVATING] = "deactivating"
3267 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3269 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3270 [UNIT_REQUIRES] = "Requires",
3271 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3272 [UNIT_REQUISITE] = "Requisite",
3273 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3274 [UNIT_WANTS] = "Wants",
3275 [UNIT_BINDS_TO] = "BindsTo",
3276 [UNIT_PART_OF] = "PartOf",
3277 [UNIT_REQUIRED_BY] = "RequiredBy",
3278 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3279 [UNIT_WANTED_BY] = "WantedBy",
3280 [UNIT_BOUND_BY] = "BoundBy",
3281 [UNIT_CONSISTS_OF] = "ConsistsOf",
3282 [UNIT_CONFLICTS] = "Conflicts",
3283 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3284 [UNIT_BEFORE] = "Before",
3285 [UNIT_AFTER] = "After",
3286 [UNIT_ON_FAILURE] = "OnFailure",
3287 [UNIT_TRIGGERS] = "Triggers",
3288 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3289 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3290 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3291 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3292 [UNIT_REFERENCES] = "References",
3293 [UNIT_REFERENCED_BY] = "ReferencedBy",
3296 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);