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 free(u->description);
475 strv_free(u->documentation);
476 free(u->fragment_path);
477 free(u->source_path);
478 strv_free(u->dropin_paths);
481 set_free_free(u->names);
483 unit_unwatch_all_pids(u);
485 condition_free_list(u->conditions);
487 unit_ref_unset(&u->slice);
490 unit_ref_unset(u->refs);
495 UnitActiveState unit_active_state(Unit *u) {
498 if (u->load_state == UNIT_MERGED)
499 return unit_active_state(unit_follow_merge(u));
501 /* After a reload it might happen that a unit is not correctly
502 * loaded but still has a process around. That's why we won't
503 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
505 return UNIT_VTABLE(u)->active_state(u);
508 const char* unit_sub_state_to_string(Unit *u) {
511 return UNIT_VTABLE(u)->sub_state_to_string(u);
514 static void complete_move(Set **s, Set **other) {
522 set_move(*s, *other);
529 static void merge_names(Unit *u, Unit *other) {
536 complete_move(&u->names, &other->names);
538 set_free_free(other->names);
542 SET_FOREACH(t, u->names, i)
543 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
546 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
553 assert(d < _UNIT_DEPENDENCY_MAX);
555 /* Fix backwards pointers */
556 SET_FOREACH(back, other->dependencies[d], i) {
559 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
560 r = set_remove_and_put(back->dependencies[k], other, u);
562 set_remove(back->dependencies[k], other);
564 assert(r >= 0 || r == -ENOENT);
568 complete_move(&u->dependencies[d], &other->dependencies[d]);
570 set_free(other->dependencies[d]);
571 other->dependencies[d] = NULL;
574 int unit_merge(Unit *u, Unit *other) {
579 assert(u->manager == other->manager);
580 assert(u->type != _UNIT_TYPE_INVALID);
582 other = unit_follow_merge(other);
587 if (u->type != other->type)
590 if (!u->instance != !other->instance)
593 if (other->load_state != UNIT_STUB &&
594 other->load_state != UNIT_NOT_FOUND)
603 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
607 merge_names(u, other);
609 /* Redirect all references */
611 unit_ref_set(other->refs, u);
613 /* Merge dependencies */
614 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
615 merge_dependencies(u, other, d);
617 other->load_state = UNIT_MERGED;
618 other->merged_into = u;
620 /* If there is still some data attached to the other node, we
621 * don't need it anymore, and can free it. */
622 if (other->load_state != UNIT_STUB)
623 if (UNIT_VTABLE(other)->done)
624 UNIT_VTABLE(other)->done(other);
626 unit_add_to_dbus_queue(u);
627 unit_add_to_cleanup_queue(other);
632 int unit_merge_by_name(Unit *u, const char *name) {
635 _cleanup_free_ char *s = NULL;
640 if (unit_name_is_template(name)) {
644 s = unit_name_replace_instance(name, u->instance);
651 other = manager_get_unit(u->manager, name);
653 r = unit_add_name(u, name);
655 r = unit_merge(u, other);
660 Unit* unit_follow_merge(Unit *u) {
663 while (u->load_state == UNIT_MERGED)
664 assert_se(u = u->merged_into);
669 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
675 if (c->working_directory) {
676 r = unit_require_mounts_for(u, c->working_directory);
681 if (c->root_directory) {
682 r = unit_require_mounts_for(u, c->root_directory);
687 if (c->std_output != EXEC_OUTPUT_KMSG &&
688 c->std_output != EXEC_OUTPUT_SYSLOG &&
689 c->std_output != EXEC_OUTPUT_JOURNAL &&
690 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
691 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
692 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
693 c->std_error != EXEC_OUTPUT_KMSG &&
694 c->std_error != EXEC_OUTPUT_SYSLOG &&
695 c->std_error != EXEC_OUTPUT_JOURNAL &&
696 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
697 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
698 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
701 /* If syslog or kernel logging is requested, make sure our own
702 * logging daemon is run first. */
704 if (u->manager->running_as == SYSTEMD_SYSTEM) {
705 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
713 const char *unit_description(Unit *u) {
717 return u->description;
722 void unit_dump(Unit *u, FILE *f, const char *prefix) {
726 _cleanup_free_ char *p2 = NULL;
729 timestamp1[FORMAT_TIMESTAMP_MAX],
730 timestamp2[FORMAT_TIMESTAMP_MAX],
731 timestamp3[FORMAT_TIMESTAMP_MAX],
732 timestamp4[FORMAT_TIMESTAMP_MAX],
733 timespan[FORMAT_TIMESPAN_MAX];
735 _cleanup_set_free_ Set *following_set = NULL;
739 assert(u->type >= 0);
743 p2 = strappend(prefix, "\t");
744 prefix2 = p2 ? p2 : prefix;
748 "%s\tDescription: %s\n"
750 "%s\tUnit Load State: %s\n"
751 "%s\tUnit Active State: %s\n"
752 "%s\tInactive Exit Timestamp: %s\n"
753 "%s\tActive Enter Timestamp: %s\n"
754 "%s\tActive Exit Timestamp: %s\n"
755 "%s\tInactive Enter Timestamp: %s\n"
756 "%s\tGC Check Good: %s\n"
757 "%s\tNeed Daemon Reload: %s\n"
758 "%s\tTransient: %s\n"
761 "%s\tCGroup realized: %s\n"
762 "%s\tCGroup mask: 0x%x\n"
763 "%s\tCGroup members mask: 0x%x\n",
765 prefix, unit_description(u),
766 prefix, strna(u->instance),
767 prefix, unit_load_state_to_string(u->load_state),
768 prefix, unit_active_state_to_string(unit_active_state(u)),
769 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
770 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
771 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
772 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
773 prefix, yes_no(unit_check_gc(u)),
774 prefix, yes_no(unit_need_daemon_reload(u)),
775 prefix, yes_no(u->transient),
776 prefix, strna(unit_slice_name(u)),
777 prefix, strna(u->cgroup_path),
778 prefix, yes_no(u->cgroup_realized),
779 prefix, u->cgroup_realized_mask,
780 prefix, u->cgroup_members_mask);
782 SET_FOREACH(t, u->names, i)
783 fprintf(f, "%s\tName: %s\n", prefix, t);
785 STRV_FOREACH(j, u->documentation)
786 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
788 following = unit_following(u);
790 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
792 r = unit_following_set(u, &following_set);
796 SET_FOREACH(other, following_set, i)
797 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
800 if (u->fragment_path)
801 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
804 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
806 STRV_FOREACH(j, u->dropin_paths)
807 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
809 if (u->job_timeout > 0)
810 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
812 condition_dump_list(u->conditions, f, prefix);
814 if (dual_timestamp_is_set(&u->condition_timestamp))
816 "%s\tCondition Timestamp: %s\n"
817 "%s\tCondition Result: %s\n",
818 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
819 prefix, yes_no(u->condition_result));
821 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
824 SET_FOREACH(other, u->dependencies[d], i)
825 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
828 if (!strv_isempty(u->requires_mounts_for)) {
830 "%s\tRequiresMountsFor:", prefix);
832 STRV_FOREACH(j, u->requires_mounts_for)
833 fprintf(f, " %s", *j);
838 if (u->load_state == UNIT_LOADED) {
841 "%s\tStopWhenUnneeded: %s\n"
842 "%s\tRefuseManualStart: %s\n"
843 "%s\tRefuseManualStop: %s\n"
844 "%s\tDefaultDependencies: %s\n"
845 "%s\tOnFailureJobMode: %s\n"
846 "%s\tIgnoreOnIsolate: %s\n"
847 "%s\tIgnoreOnSnapshot: %s\n",
848 prefix, yes_no(u->stop_when_unneeded),
849 prefix, yes_no(u->refuse_manual_start),
850 prefix, yes_no(u->refuse_manual_stop),
851 prefix, yes_no(u->default_dependencies),
852 prefix, job_mode_to_string(u->on_failure_job_mode),
853 prefix, yes_no(u->ignore_on_isolate),
854 prefix, yes_no(u->ignore_on_snapshot));
856 if (UNIT_VTABLE(u)->dump)
857 UNIT_VTABLE(u)->dump(u, f, prefix2);
859 } else if (u->load_state == UNIT_MERGED)
861 "%s\tMerged into: %s\n",
862 prefix, u->merged_into->id);
863 else if (u->load_state == UNIT_ERROR)
864 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
868 job_dump(u->job, f, prefix2);
871 job_dump(u->nop_job, f, prefix2);
875 /* Common implementation for multiple backends */
876 int unit_load_fragment_and_dropin(Unit *u) {
881 /* Load a .{service,socket,...} file */
882 r = unit_load_fragment(u);
886 if (u->load_state == UNIT_STUB)
889 /* Load drop-in directory data */
890 r = unit_load_dropin(unit_follow_merge(u));
897 /* Common implementation for multiple backends */
898 int unit_load_fragment_and_dropin_optional(Unit *u) {
903 /* Same as unit_load_fragment_and_dropin(), but whether
904 * something can be loaded or not doesn't matter. */
906 /* Load a .service file */
907 r = unit_load_fragment(u);
911 if (u->load_state == UNIT_STUB)
912 u->load_state = UNIT_LOADED;
914 /* Load drop-in directory data */
915 r = unit_load_dropin(unit_follow_merge(u));
922 int unit_add_default_target_dependency(Unit *u, Unit *target) {
926 if (target->type != UNIT_TARGET)
929 /* Only add the dependency if both units are loaded, so that
930 * that loop check below is reliable */
931 if (u->load_state != UNIT_LOADED ||
932 target->load_state != UNIT_LOADED)
935 /* If either side wants no automatic dependencies, then let's
937 if (!u->default_dependencies ||
938 !target->default_dependencies)
941 /* Don't create loops */
942 if (set_get(target->dependencies[UNIT_BEFORE], u))
945 return unit_add_dependency(target, UNIT_AFTER, u, true);
948 static int unit_add_target_dependencies(Unit *u) {
950 static const UnitDependency deps[] = {
952 UNIT_REQUIRED_BY_OVERRIDABLE,
964 for (k = 0; k < ELEMENTSOF(deps); k++)
965 SET_FOREACH(target, u->dependencies[deps[k]], i) {
966 r = unit_add_default_target_dependency(u, target);
974 static int unit_add_slice_dependencies(Unit *u) {
977 if (!unit_get_cgroup_context(u))
980 if (UNIT_ISSET(u->slice))
981 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
983 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
986 static int unit_add_mount_dependencies(Unit *u) {
992 STRV_FOREACH(i, u->requires_mounts_for) {
993 char prefix[strlen(*i) + 1];
995 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
998 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1006 if (m->load_state != UNIT_LOADED)
1009 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1013 if (m->fragment_path) {
1014 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1024 int unit_load(Unit *u) {
1029 if (u->in_load_queue) {
1030 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1031 u->in_load_queue = false;
1034 if (u->type == _UNIT_TYPE_INVALID)
1037 if (u->load_state != UNIT_STUB)
1040 if (UNIT_VTABLE(u)->load) {
1041 r = UNIT_VTABLE(u)->load(u);
1046 if (u->load_state == UNIT_STUB) {
1051 if (u->load_state == UNIT_LOADED) {
1053 r = unit_add_target_dependencies(u);
1057 r = unit_add_slice_dependencies(u);
1061 r = unit_add_mount_dependencies(u);
1065 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1066 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1071 unit_update_cgroup_members_masks(u);
1074 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1076 unit_add_to_dbus_queue(unit_follow_merge(u));
1077 unit_add_to_gc_queue(u);
1082 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1084 unit_add_to_dbus_queue(u);
1085 unit_add_to_gc_queue(u);
1087 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1088 u->id, strerror(-r));
1093 static bool unit_condition_test(Unit *u) {
1096 dual_timestamp_get(&u->condition_timestamp);
1097 u->condition_result = condition_test_list(u->id, u->conditions);
1099 return u->condition_result;
1102 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1103 const UnitStatusMessageFormats *format_table;
1107 assert(t < _JOB_TYPE_MAX);
1109 if (t != JOB_START && t != JOB_STOP)
1112 format_table = &UNIT_VTABLE(u)->status_message_formats;
1116 return format_table->starting_stopping[t == JOB_STOP];
1119 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1124 assert(t < _JOB_TYPE_MAX);
1126 format = unit_get_status_message_format(u, t);
1130 /* Return generic strings */
1132 return "Starting %s.";
1133 else if (t == JOB_STOP)
1134 return "Stopping %s.";
1135 else if (t == JOB_RELOAD)
1136 return "Reloading %s.";
1141 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1146 /* We only print status messages for selected units on
1147 * selected operations. */
1149 format = unit_get_status_message_format(u, t);
1153 DISABLE_WARNING_FORMAT_NONLITERAL;
1154 unit_status_printf(u, "", format);
1158 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1165 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1168 if (log_on_console())
1171 /* We log status messages for all units and all operations. */
1173 format = unit_get_status_message_format_try_harder(u, t);
1177 DISABLE_WARNING_FORMAT_NONLITERAL;
1178 snprintf(buf, sizeof(buf), format, unit_description(u));
1182 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1183 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1184 SD_MESSAGE_UNIT_RELOADING;
1186 log_struct_unit(LOG_INFO,
1194 * -EBADR: This unit type does not support starting.
1195 * -EALREADY: Unit is already started.
1196 * -EAGAIN: An operation is already in progress. Retry later.
1197 * -ECANCELED: Too many requests for now.
1199 int unit_start(Unit *u) {
1200 UnitActiveState state;
1205 if (u->load_state != UNIT_LOADED)
1208 /* If this is already started, then this will succeed. Note
1209 * that this will even succeed if this unit is not startable
1210 * by the user. This is relied on to detect when we need to
1211 * wait for units and when waiting is finished. */
1212 state = unit_active_state(u);
1213 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1216 /* If the conditions failed, don't do anything at all. If we
1217 * already are activating this call might still be useful to
1218 * speed up activation in case there is some hold-off time,
1219 * but we don't want to recheck the condition in that case. */
1220 if (state != UNIT_ACTIVATING &&
1221 !unit_condition_test(u)) {
1222 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1226 /* Forward to the main object, if we aren't it. */
1227 following = unit_following(u);
1229 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1230 u->id, following->id);
1231 return unit_start(following);
1234 unit_status_log_starting_stopping_reloading(u, JOB_START);
1235 unit_status_print_starting_stopping(u, JOB_START);
1237 /* If it is stopped, but we cannot start it, then fail */
1238 if (!UNIT_VTABLE(u)->start)
1241 /* We don't suppress calls to ->start() here when we are
1242 * already starting, to allow this request to be used as a
1243 * "hurry up" call, for example when the unit is in some "auto
1244 * restart" state where it waits for a holdoff timer to elapse
1245 * before it will start again. */
1247 unit_add_to_dbus_queue(u);
1249 return UNIT_VTABLE(u)->start(u);
1252 bool unit_can_start(Unit *u) {
1255 return !!UNIT_VTABLE(u)->start;
1258 bool unit_can_isolate(Unit *u) {
1261 return unit_can_start(u) &&
1266 * -EBADR: This unit type does not support stopping.
1267 * -EALREADY: Unit is already stopped.
1268 * -EAGAIN: An operation is already in progress. Retry later.
1270 int unit_stop(Unit *u) {
1271 UnitActiveState state;
1276 state = unit_active_state(u);
1277 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1280 if ((following = unit_following(u))) {
1281 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1282 u->id, following->id);
1283 return unit_stop(following);
1286 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1287 unit_status_print_starting_stopping(u, JOB_STOP);
1289 if (!UNIT_VTABLE(u)->stop)
1292 unit_add_to_dbus_queue(u);
1294 return UNIT_VTABLE(u)->stop(u);
1298 * -EBADR: This unit type does not support reloading.
1299 * -ENOEXEC: Unit is not started.
1300 * -EAGAIN: An operation is already in progress. Retry later.
1302 int unit_reload(Unit *u) {
1303 UnitActiveState state;
1308 if (u->load_state != UNIT_LOADED)
1311 if (!unit_can_reload(u))
1314 state = unit_active_state(u);
1315 if (state == UNIT_RELOADING)
1318 if (state != UNIT_ACTIVE) {
1319 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1324 following = unit_following(u);
1326 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1327 u->id, following->id);
1328 return unit_reload(following);
1331 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1333 unit_add_to_dbus_queue(u);
1334 return UNIT_VTABLE(u)->reload(u);
1337 bool unit_can_reload(Unit *u) {
1340 if (!UNIT_VTABLE(u)->reload)
1343 if (!UNIT_VTABLE(u)->can_reload)
1346 return UNIT_VTABLE(u)->can_reload(u);
1349 static void unit_check_unneeded(Unit *u) {
1355 /* If this service shall be shut down when unneeded then do
1358 if (!u->stop_when_unneeded)
1361 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1364 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1365 if (unit_active_or_pending(other))
1368 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1369 if (unit_active_or_pending(other))
1372 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1373 if (unit_active_or_pending(other))
1376 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1377 if (unit_active_or_pending(other))
1380 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1382 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1383 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1386 static void retroactively_start_dependencies(Unit *u) {
1391 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1393 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1394 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1395 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1396 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1398 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1399 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1400 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1401 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1403 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1404 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1405 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1406 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1408 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1409 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1410 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1411 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1413 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1414 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1415 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1417 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1418 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1419 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1422 static void retroactively_stop_dependencies(Unit *u) {
1427 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1429 /* Pull down units which are bound to us recursively if enabled */
1430 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1431 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1432 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1435 static void check_unneeded_dependencies(Unit *u) {
1440 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1442 /* Garbage collect services that might not be needed anymore, if enabled */
1443 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1444 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1445 unit_check_unneeded(other);
1446 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1447 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1448 unit_check_unneeded(other);
1449 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1450 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1451 unit_check_unneeded(other);
1452 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1453 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1454 unit_check_unneeded(other);
1455 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1456 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1457 unit_check_unneeded(other);
1458 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1459 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1460 unit_check_unneeded(other);
1463 void unit_start_on_failure(Unit *u) {
1469 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1472 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1474 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1477 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1479 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1483 void unit_trigger_notify(Unit *u) {
1489 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1490 if (UNIT_VTABLE(other)->trigger_notify)
1491 UNIT_VTABLE(other)->trigger_notify(other, u);
1494 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1499 assert(os < _UNIT_ACTIVE_STATE_MAX);
1500 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1502 /* Note that this is called for all low-level state changes,
1503 * even if they might map to the same high-level
1504 * UnitActiveState! That means that ns == os is OK an expected
1505 * behavior here. For example: if a mount point is remounted
1506 * this function will be called too! */
1510 if (m->n_reloading <= 0) {
1513 dual_timestamp_get(&ts);
1515 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1516 u->inactive_exit_timestamp = ts;
1517 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1518 u->inactive_enter_timestamp = ts;
1520 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1521 u->active_enter_timestamp = ts;
1522 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1523 u->active_exit_timestamp = ts;
1526 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1527 unit_destroy_cgroup(u);
1529 /* Note that this doesn't apply to RemainAfterExit services exiting
1530 * sucessfully, since there's no change of state in that case. Which is
1531 * why it is handled in service_set_state() */
1532 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1535 ec = unit_get_exec_context(u);
1536 if (ec && exec_context_may_touch_console(ec)) {
1537 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1540 if (m->n_on_console == 0)
1541 /* unset no_console_output flag, since the console is free */
1542 m->no_console_output = false;
1551 if (u->job->state == JOB_WAITING)
1553 /* So we reached a different state for this
1554 * job. Let's see if we can run it now if it
1555 * failed previously due to EAGAIN. */
1556 job_add_to_run_queue(u->job);
1558 /* Let's check whether this state change constitutes a
1559 * finished job, or maybe contradicts a running job and
1560 * hence needs to invalidate jobs. */
1562 switch (u->job->type) {
1565 case JOB_VERIFY_ACTIVE:
1567 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1568 job_finish_and_invalidate(u->job, JOB_DONE, true);
1569 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1572 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1573 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1579 case JOB_RELOAD_OR_START:
1581 if (u->job->state == JOB_RUNNING) {
1582 if (ns == UNIT_ACTIVE)
1583 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1584 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1587 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1588 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1596 case JOB_TRY_RESTART:
1598 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1599 job_finish_and_invalidate(u->job, JOB_DONE, true);
1600 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1602 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1608 assert_not_reached("Job type unknown");
1614 if (m->n_reloading <= 0) {
1616 /* If this state change happened without being
1617 * requested by a job, then let's retroactively start
1618 * or stop dependencies. We skip that step when
1619 * deserializing, since we don't want to create any
1620 * additional jobs just because something is already
1624 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1625 retroactively_start_dependencies(u);
1626 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1627 retroactively_stop_dependencies(u);
1630 /* stop unneeded units regardless if going down was expected or not */
1631 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1632 check_unneeded_dependencies(u);
1634 if (ns != os && ns == UNIT_FAILED) {
1635 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1636 unit_start_on_failure(u);
1640 /* Some names are special */
1641 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1643 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1644 /* The bus just might have become available,
1645 * hence try to connect to it, if we aren't
1649 if (u->type == UNIT_SERVICE &&
1650 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1651 m->n_reloading <= 0) {
1652 /* Write audit record if we have just finished starting up */
1653 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1657 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1658 manager_send_unit_plymouth(m, u);
1662 /* We don't care about D-Bus here, since we'll get an
1663 * asynchronous notification for it anyway. */
1665 if (u->type == UNIT_SERVICE &&
1666 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1667 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1668 m->n_reloading <= 0) {
1670 /* Hmm, if there was no start record written
1671 * write it now, so that we always have a nice
1674 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1676 if (ns == UNIT_INACTIVE)
1677 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1679 /* Write audit record if we have just finished shutting down */
1680 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1682 u->in_audit = false;
1686 manager_recheck_journal(m);
1687 unit_trigger_notify(u);
1689 /* Maybe we finished startup and are now ready for being
1690 * stopped because unneeded? */
1691 if (u->manager->n_reloading <= 0)
1692 unit_check_unneeded(u);
1694 unit_add_to_dbus_queue(u);
1695 unit_add_to_gc_queue(u);
1698 int unit_watch_pid(Unit *u, pid_t pid) {
1704 /* Watch a specific PID. We only support one or two units
1705 * watching each PID for now, not more. */
1707 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1711 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1715 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1717 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1721 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1724 q = set_put(u->pids, LONG_TO_PTR(pid));
1731 void unit_unwatch_pid(Unit *u, pid_t pid) {
1735 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1736 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1737 set_remove(u->pids, LONG_TO_PTR(pid));
1740 void unit_unwatch_all_pids(Unit *u) {
1743 while (!set_isempty(u->pids))
1744 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1750 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1751 _cleanup_closedir_ DIR *d = NULL;
1752 _cleanup_fclose_ FILE *f = NULL;
1758 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1760 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1764 while ((r = cg_read_pid(f, &pid)) > 0) {
1765 r = unit_watch_pid(u, pid);
1766 if (r < 0 && ret >= 0)
1769 if (r < 0 && ret >= 0)
1772 } else if (ret >= 0)
1775 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1779 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1780 _cleanup_free_ char *p = NULL;
1782 p = strjoin(path, "/", fn, NULL);
1788 r = unit_watch_pids_in_path(u, p);
1789 if (r < 0 && ret >= 0)
1792 if (r < 0 && ret >= 0)
1795 } else if (ret >= 0)
1801 int unit_watch_all_pids(Unit *u) {
1804 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1806 if (!u->cgroup_path)
1809 return unit_watch_pids_in_path(u, u->cgroup_path);
1812 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1818 /* Cleans dead PIDs from our list */
1820 SET_FOREACH(e, u->pids, i) {
1821 pid_t pid = PTR_TO_LONG(e);
1823 if (pid == except1 || pid == except2)
1826 if (!pid_is_unwaited(pid))
1827 unit_unwatch_pid(u, pid);
1831 bool unit_job_is_applicable(Unit *u, JobType j) {
1833 assert(j >= 0 && j < _JOB_TYPE_MAX);
1837 case JOB_VERIFY_ACTIVE:
1844 case JOB_TRY_RESTART:
1845 return unit_can_start(u);
1848 return unit_can_reload(u);
1850 case JOB_RELOAD_OR_START:
1851 return unit_can_reload(u) && unit_can_start(u);
1854 assert_not_reached("Invalid job type");
1858 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1860 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1861 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1862 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1863 [UNIT_WANTS] = UNIT_WANTED_BY,
1864 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1865 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1866 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1867 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1868 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1869 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1870 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1871 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1872 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1873 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1874 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1875 [UNIT_BEFORE] = UNIT_AFTER,
1876 [UNIT_AFTER] = UNIT_BEFORE,
1877 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1878 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1879 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1880 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1881 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1882 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1883 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1884 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1886 int r, q = 0, v = 0, w = 0;
1889 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1892 u = unit_follow_merge(u);
1893 other = unit_follow_merge(other);
1895 /* We won't allow dependencies on ourselves. We will not
1896 * consider them an error however. */
1900 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1904 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1905 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1910 if (add_reference) {
1911 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1915 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1920 q = set_put(u->dependencies[d], other);
1924 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1925 v = set_put(other->dependencies[inverse_table[d]], u);
1932 if (add_reference) {
1933 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1939 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1944 unit_add_to_dbus_queue(u);
1949 set_remove(u->dependencies[d], other);
1952 set_remove(other->dependencies[inverse_table[d]], u);
1955 set_remove(u->dependencies[UNIT_REFERENCES], other);
1960 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1965 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1968 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1974 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1978 assert(name || path);
1982 name = basename(path);
1984 if (!unit_name_is_template(name)) {
1990 s = unit_name_replace_instance(name, u->instance);
1992 _cleanup_free_ char *i = NULL;
1994 i = unit_name_to_prefix(u->id);
1998 s = unit_name_replace_instance(name, i);
2008 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2011 _cleanup_free_ char *s = NULL;
2014 assert(name || path);
2016 name = resolve_template(u, name, path, &s);
2020 r = manager_load_unit(u->manager, name, path, NULL, &other);
2024 return unit_add_dependency(u, d, other, add_reference);
2027 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2030 _cleanup_free_ char *s = NULL;
2033 assert(name || path);
2035 if (!(name = resolve_template(u, name, path, &s)))
2038 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2041 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2046 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2049 _cleanup_free_ char *s = NULL;
2052 assert(name || path);
2054 if (!(name = resolve_template(u, name, path, &s)))
2057 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2060 r = unit_add_dependency(other, d, u, add_reference);
2065 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2068 _cleanup_free_ char *s = NULL;
2071 assert(name || path);
2073 if (!(name = resolve_template(u, name, path, &s)))
2076 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2079 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2085 int set_unit_path(const char *p) {
2086 _cleanup_free_ char *c = NULL;
2088 /* This is mostly for debug purposes */
2089 c = path_make_absolute_cwd(p);
2090 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2096 char *unit_dbus_path(Unit *u) {
2102 return unit_dbus_path_from_name(u->id);
2105 char *unit_default_cgroup_path(Unit *u) {
2106 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2111 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2112 return strdup(u->manager->cgroup_root);
2114 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2115 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2120 escaped = cg_escape(u->id);
2125 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2127 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2130 int unit_add_default_slice(Unit *u) {
2131 _cleanup_free_ char *b = NULL;
2132 const char *slice_name;
2138 if (UNIT_ISSET(u->slice))
2141 if (!unit_get_cgroup_context(u))
2145 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2147 /* Implicitly place all instantiated units in their
2148 * own per-template slice */
2150 prefix = unit_name_to_prefix(u->id);
2154 /* The prefix is already escaped, but it might include
2155 * "-" which has a special meaning for slice units,
2156 * hence escape it here extra. */
2157 escaped = strreplace(prefix, "-", "\\x2d");
2161 if (u->manager->running_as == SYSTEMD_SYSTEM)
2162 b = strjoin("system-", escaped, ".slice", NULL);
2164 b = strappend(escaped, ".slice");
2171 u->manager->running_as == SYSTEMD_SYSTEM
2172 ? SPECIAL_SYSTEM_SLICE
2173 : SPECIAL_ROOT_SLICE;
2175 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2179 unit_ref_set(&u->slice, slice);
2183 const char *unit_slice_name(Unit *u) {
2186 if (!UNIT_ISSET(u->slice))
2189 return UNIT_DEREF(u->slice)->id;
2192 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2193 _cleanup_free_ char *t = NULL;
2200 t = unit_name_change_suffix(u->id, type);
2204 assert(!unit_has_name(u, t));
2206 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2207 assert(r < 0 || *_found != u);
2211 int unit_watch_bus_name(Unit *u, const char *name) {
2215 /* Watch a specific name on the bus. We only support one unit
2216 * watching each name for now. */
2218 return hashmap_put(u->manager->watch_bus, name, u);
2221 void unit_unwatch_bus_name(Unit *u, const char *name) {
2225 hashmap_remove_value(u->manager->watch_bus, name, u);
2228 bool unit_can_serialize(Unit *u) {
2231 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2234 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2242 if (!unit_can_serialize(u))
2245 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2249 rt = unit_get_exec_runtime(u);
2251 r = exec_runtime_serialize(rt, u, f, fds);
2256 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2257 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2258 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2259 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2260 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2262 if (dual_timestamp_is_set(&u->condition_timestamp))
2263 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2265 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2268 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2270 if (serialize_jobs) {
2272 fprintf(f, "job\n");
2273 job_serialize(u->job, f, fds);
2277 fprintf(f, "job\n");
2278 job_serialize(u->nop_job, f, fds);
2287 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2298 va_start(ap, format);
2299 vfprintf(f, format, ap);
2305 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2311 fprintf(f, "%s=%s\n", key, value);
2314 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2316 ExecRuntime **rt = NULL;
2323 if (!unit_can_serialize(u))
2326 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2328 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2331 char line[LINE_MAX], *l, *v;
2334 if (!fgets(line, sizeof(line), f)) {
2347 k = strcspn(l, "=");
2355 if (streq(l, "job")) {
2357 /* new-style serialized job */
2358 Job *j = job_new_raw(u);
2362 r = job_deserialize(j, f, fds);
2368 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2374 r = job_install_deserialized(j);
2376 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2381 if (j->state == JOB_RUNNING)
2382 u->manager->n_running_jobs++;
2385 JobType type = job_type_from_string(v);
2387 log_debug("Failed to parse job type value %s", v);
2389 u->deserialized_job = type;
2392 } else if (streq(l, "inactive-exit-timestamp")) {
2393 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2395 } else if (streq(l, "active-enter-timestamp")) {
2396 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2398 } else if (streq(l, "active-exit-timestamp")) {
2399 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2401 } else if (streq(l, "inactive-enter-timestamp")) {
2402 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2404 } else if (streq(l, "condition-timestamp")) {
2405 dual_timestamp_deserialize(v, &u->condition_timestamp);
2407 } else if (streq(l, "condition-result")) {
2410 b = parse_boolean(v);
2412 log_debug("Failed to parse condition result value %s", v);
2414 u->condition_result = b;
2418 } else if (streq(l, "transient")) {
2421 b = parse_boolean(v);
2423 log_debug("Failed to parse transient bool %s", v);
2428 } else if (streq(l, "cgroup")) {
2435 free(u->cgroup_path);
2438 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2443 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2450 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2456 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2458 _cleanup_free_ char *e = NULL;
2466 /* Adds in links to the device node that this unit is based on */
2468 if (!is_device_path(what))
2471 e = unit_name_from_path(what, ".device");
2475 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2480 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2485 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2493 int unit_coldplug(Unit *u) {
2498 if (UNIT_VTABLE(u)->coldplug)
2499 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2503 r = job_coldplug(u->job);
2506 } else if (u->deserialized_job >= 0) {
2508 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2512 u->deserialized_job = _JOB_TYPE_INVALID;
2518 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2519 DISABLE_WARNING_FORMAT_NONLITERAL;
2520 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2524 bool unit_need_daemon_reload(Unit *u) {
2525 _cleanup_strv_free_ char **t = NULL;
2528 unsigned loaded_cnt, current_cnt;
2532 if (u->fragment_path) {
2534 if (stat(u->fragment_path, &st) < 0)
2535 /* What, cannot access this anymore? */
2538 if (u->fragment_mtime > 0 &&
2539 timespec_load(&st.st_mtim) != u->fragment_mtime)
2543 if (u->source_path) {
2545 if (stat(u->source_path, &st) < 0)
2548 if (u->source_mtime > 0 &&
2549 timespec_load(&st.st_mtim) != u->source_mtime)
2553 t = unit_find_dropin_paths(u);
2554 loaded_cnt = strv_length(t);
2555 current_cnt = strv_length(u->dropin_paths);
2557 if (loaded_cnt == current_cnt) {
2558 if (loaded_cnt == 0)
2561 if (strv_overlap(u->dropin_paths, t)) {
2562 STRV_FOREACH(path, u->dropin_paths) {
2564 if (stat(*path, &st) < 0)
2567 if (u->dropin_mtime > 0 &&
2568 timespec_load(&st.st_mtim) > u->dropin_mtime)
2579 void unit_reset_failed(Unit *u) {
2582 if (UNIT_VTABLE(u)->reset_failed)
2583 UNIT_VTABLE(u)->reset_failed(u);
2586 Unit *unit_following(Unit *u) {
2589 if (UNIT_VTABLE(u)->following)
2590 return UNIT_VTABLE(u)->following(u);
2595 bool unit_stop_pending(Unit *u) {
2598 /* This call does check the current state of the unit. It's
2599 * hence useful to be called from state change calls of the
2600 * unit itself, where the state isn't updated yet. This is
2601 * different from unit_inactive_or_pending() which checks both
2602 * the current state and for a queued job. */
2604 return u->job && u->job->type == JOB_STOP;
2607 bool unit_inactive_or_pending(Unit *u) {
2610 /* Returns true if the unit is inactive or going down */
2612 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2615 if (unit_stop_pending(u))
2621 bool unit_active_or_pending(Unit *u) {
2624 /* Returns true if the unit is active or going up */
2626 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2630 (u->job->type == JOB_START ||
2631 u->job->type == JOB_RELOAD_OR_START ||
2632 u->job->type == JOB_RESTART))
2638 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2640 assert(w >= 0 && w < _KILL_WHO_MAX);
2642 assert(signo < _NSIG);
2644 if (!UNIT_VTABLE(u)->kill)
2647 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2650 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2654 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2658 /* Exclude the main/control pids from being killed via the cgroup */
2660 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2665 if (control_pid > 0) {
2666 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2678 int unit_kill_common(
2684 sd_bus_error *error) {
2688 if (who == KILL_MAIN && main_pid <= 0) {
2690 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2692 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2696 if (who == KILL_CONTROL && control_pid <= 0) {
2697 if (control_pid < 0)
2698 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2700 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2704 if (who == KILL_CONTROL || who == KILL_ALL)
2705 if (control_pid > 0)
2706 if (kill(control_pid, signo) < 0)
2709 if (who == KILL_MAIN || who == KILL_ALL)
2711 if (kill(main_pid, signo) < 0)
2714 if (who == KILL_ALL && u->cgroup_path) {
2715 _cleanup_set_free_ Set *pid_set = NULL;
2718 /* Exclude the main/control pids from being killed via the cgroup */
2719 pid_set = unit_pid_set(main_pid, control_pid);
2723 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2724 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2731 int unit_following_set(Unit *u, Set **s) {
2735 if (UNIT_VTABLE(u)->following_set)
2736 return UNIT_VTABLE(u)->following_set(u, s);
2742 UnitFileState unit_get_unit_file_state(Unit *u) {
2745 if (u->unit_file_state < 0 && u->fragment_path)
2746 u->unit_file_state = unit_file_get_state(
2747 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2748 NULL, basename(u->fragment_path));
2750 return u->unit_file_state;
2753 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2758 unit_ref_unset(ref);
2761 LIST_PREPEND(refs, u->refs, ref);
2765 void unit_ref_unset(UnitRef *ref) {
2771 LIST_REMOVE(refs, ref->unit->refs, ref);
2775 int unit_cgroup_context_init_defaults(Unit *u, CGroupContext *c) {
2779 /* Copy in the manager defaults into the cgroup context,
2780 * _before_ the rest of the settings have been initialized */
2782 c->cpu_accounting = u->manager->default_cpu_accounting;
2783 c->blockio_accounting = u->manager->default_blockio_accounting;
2784 c->memory_accounting = u->manager->default_memory_accounting;
2789 int unit_exec_context_patch_defaults(Unit *u, ExecContext *c) {
2796 /* Patch in the manager defaults into the exec context,
2797 * _after_ the rest of the settings have been initialized */
2799 /* This only copies in the ones that need memory */
2800 for (i = 0; i < _RLIMIT_MAX; i++)
2801 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2802 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2807 if (u->manager->running_as == SYSTEMD_USER &&
2808 !c->working_directory) {
2810 r = get_home_dir(&c->working_directory);
2815 if (u->manager->running_as == SYSTEMD_USER &&
2816 (c->syscall_whitelist ||
2817 !set_isempty(c->syscall_filter) ||
2818 !set_isempty(c->syscall_archs) ||
2819 c->address_families_whitelist ||
2820 !set_isempty(c->address_families)))
2821 c->no_new_privileges = true;
2826 ExecContext *unit_get_exec_context(Unit *u) {
2830 offset = UNIT_VTABLE(u)->exec_context_offset;
2834 return (ExecContext*) ((uint8_t*) u + offset);
2837 KillContext *unit_get_kill_context(Unit *u) {
2841 offset = UNIT_VTABLE(u)->kill_context_offset;
2845 return (KillContext*) ((uint8_t*) u + offset);
2848 CGroupContext *unit_get_cgroup_context(Unit *u) {
2851 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2855 return (CGroupContext*) ((uint8_t*) u + offset);
2858 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2861 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2865 return *(ExecRuntime**) ((uint8_t*) u + offset);
2868 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2869 _cleanup_free_ char *b = NULL;
2878 b = xescape(name, "/.");
2882 if (!filename_is_safe(b))
2885 if (u->manager->running_as == SYSTEMD_USER) {
2886 _cleanup_free_ char *c = NULL;
2888 r = user_config_home(&c);
2894 p = strjoin(c, "/", u->id, ".d", NULL);
2895 } else if (mode == UNIT_PERSISTENT && !u->transient)
2896 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2898 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2902 q = strjoin(p, "/90-", b, ".conf", NULL);
2913 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2914 _cleanup_free_ char *p = NULL, *q = NULL;
2921 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2924 r = drop_in_file(u, mode, name, &p, &q);
2929 return write_string_file_atomic_label(q, data);
2932 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2933 _cleanup_free_ char *p = NULL;
2941 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2944 va_start(ap, format);
2945 r = vasprintf(&p, format, ap);
2951 return unit_write_drop_in(u, mode, name, p);
2954 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2955 _cleanup_free_ char *ndata = NULL;
2961 if (!UNIT_VTABLE(u)->private_section)
2964 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2967 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2971 return unit_write_drop_in(u, mode, name, ndata);
2974 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2975 _cleanup_free_ char *p = NULL;
2983 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2986 va_start(ap, format);
2987 r = vasprintf(&p, format, ap);
2993 return unit_write_drop_in_private(u, mode, name, p);
2996 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2997 _cleanup_free_ char *p = NULL, *q = NULL;
3002 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3005 r = drop_in_file(u, mode, name, &p, &q);
3010 r = errno == ENOENT ? 0 : -errno;
3018 int unit_make_transient(Unit *u) {
3023 u->load_state = UNIT_STUB;
3025 u->transient = true;
3027 free(u->fragment_path);
3028 u->fragment_path = NULL;
3030 if (u->manager->running_as == SYSTEMD_USER) {
3031 _cleanup_free_ char *c = NULL;
3033 r = user_config_home(&c);
3039 u->fragment_path = strjoin(c, "/", u->id, NULL);
3040 if (!u->fragment_path)
3045 u->fragment_path = strappend("/run/systemd/system/", u->id);
3046 if (!u->fragment_path)
3049 mkdir_p("/run/systemd/system", 0755);
3052 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3055 int unit_kill_context(
3061 bool main_pid_alien) {
3063 int sig, wait_for_exit = false, r;
3068 if (c->kill_mode == KILL_NONE)
3071 sig = sigkill ? SIGKILL : c->kill_signal;
3074 r = kill_and_sigcont(main_pid, sig);
3076 if (r < 0 && r != -ESRCH) {
3077 _cleanup_free_ char *comm = NULL;
3078 get_process_comm(main_pid, &comm);
3080 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3082 if (!main_pid_alien)
3083 wait_for_exit = true;
3085 if (c->send_sighup && !sigkill)
3086 kill(main_pid, SIGHUP);
3090 if (control_pid > 0) {
3091 r = kill_and_sigcont(control_pid, sig);
3093 if (r < 0 && r != -ESRCH) {
3094 _cleanup_free_ char *comm = NULL;
3095 get_process_comm(control_pid, &comm);
3097 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3099 wait_for_exit = true;
3101 if (c->send_sighup && !sigkill)
3102 kill(control_pid, SIGHUP);
3106 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3107 _cleanup_set_free_ Set *pid_set = NULL;
3109 /* Exclude the main/control pids from being killed via the cgroup */
3110 pid_set = unit_pid_set(main_pid, control_pid);
3114 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3116 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3117 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3120 /* FIXME: For now, we will not wait for the
3121 * cgroup members to die, simply because
3122 * cgroup notification is unreliable. It
3123 * doesn't work at all in containers, and
3124 * outside of containers it can be confused
3125 * easily by leaving directories in the
3128 /* wait_for_exit = true; */
3130 if (c->send_sighup && !sigkill) {
3133 pid_set = unit_pid_set(main_pid, control_pid);
3137 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3142 return wait_for_exit;
3145 int unit_require_mounts_for(Unit *u, const char *path) {
3146 char prefix[strlen(path) + 1], *p;
3152 /* Registers a unit for requiring a certain path and all its
3153 * prefixes. We keep a simple array of these paths in the
3154 * unit, since its usually short. However, we build a prefix
3155 * table for all possible prefixes so that new appearing mount
3156 * units can easily determine which units to make themselves a
3159 if (!path_is_absolute(path))
3166 path_kill_slashes(p);
3168 if (!path_is_safe(p)) {
3173 if (strv_contains(u->requires_mounts_for, p)) {
3178 r = strv_consume(&u->requires_mounts_for, p);
3182 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3185 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3189 if (!u->manager->units_requiring_mounts_for) {
3190 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3191 if (!u->manager->units_requiring_mounts_for)
3199 x = set_new(NULL, NULL);
3205 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3221 int unit_setup_exec_runtime(Unit *u) {
3227 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3230 /* Check if ther already is an ExecRuntime for this unit? */
3231 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3235 /* Try to get it from somebody else */
3236 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3238 *rt = unit_get_exec_runtime(other);
3240 exec_runtime_ref(*rt);
3245 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3248 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3249 [UNIT_ACTIVE] = "active",
3250 [UNIT_RELOADING] = "reloading",
3251 [UNIT_INACTIVE] = "inactive",
3252 [UNIT_FAILED] = "failed",
3253 [UNIT_ACTIVATING] = "activating",
3254 [UNIT_DEACTIVATING] = "deactivating"
3257 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3259 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3260 [UNIT_REQUIRES] = "Requires",
3261 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3262 [UNIT_REQUISITE] = "Requisite",
3263 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3264 [UNIT_WANTS] = "Wants",
3265 [UNIT_BINDS_TO] = "BindsTo",
3266 [UNIT_PART_OF] = "PartOf",
3267 [UNIT_REQUIRED_BY] = "RequiredBy",
3268 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3269 [UNIT_WANTED_BY] = "WantedBy",
3270 [UNIT_BOUND_BY] = "BoundBy",
3271 [UNIT_CONSISTS_OF] = "ConsistsOf",
3272 [UNIT_CONFLICTS] = "Conflicts",
3273 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3274 [UNIT_BEFORE] = "Before",
3275 [UNIT_AFTER] = "After",
3276 [UNIT_ON_FAILURE] = "OnFailure",
3277 [UNIT_TRIGGERS] = "Triggers",
3278 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3279 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3280 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3281 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3282 [UNIT_REFERENCES] = "References",
3283 [UNIT_REFERENCED_BY] = "ReferencedBy",
3286 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);