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 (u->load_state == UNIT_STUB)
265 if (UNIT_VTABLE(u)->no_gc)
277 if (unit_active_state(u) != UNIT_INACTIVE)
283 if (UNIT_VTABLE(u)->check_gc)
284 if (UNIT_VTABLE(u)->check_gc(u))
290 void unit_add_to_load_queue(Unit *u) {
292 assert(u->type != _UNIT_TYPE_INVALID);
294 if (u->load_state != UNIT_STUB || u->in_load_queue)
297 LIST_PREPEND(load_queue, u->manager->load_queue, u);
298 u->in_load_queue = true;
301 void unit_add_to_cleanup_queue(Unit *u) {
304 if (u->in_cleanup_queue)
307 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
308 u->in_cleanup_queue = true;
311 void unit_add_to_gc_queue(Unit *u) {
314 if (u->in_gc_queue || u->in_cleanup_queue)
317 if (unit_check_gc(u))
320 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
321 u->in_gc_queue = true;
323 u->manager->n_in_gc_queue ++;
326 void unit_add_to_dbus_queue(Unit *u) {
328 assert(u->type != _UNIT_TYPE_INVALID);
330 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
333 /* Shortcut things if nobody cares */
334 if (set_isempty(u->manager->subscribed)) {
335 u->sent_dbus_new_signal = true;
339 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
340 u->in_dbus_queue = true;
343 static void bidi_set_free(Unit *u, Set *s) {
349 /* Frees the set and makes sure we are dropped from the
350 * inverse pointers */
352 SET_FOREACH(other, s, i) {
355 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
356 set_remove(other->dependencies[d], u);
358 unit_add_to_gc_queue(other);
364 static void unit_remove_transient(Unit *u) {
372 if (u->fragment_path)
373 unlink(u->fragment_path);
375 STRV_FOREACH(i, u->dropin_paths) {
376 _cleanup_free_ char *p = NULL;
381 r = path_get_parent(*i, &p);
387 static void unit_free_requires_mounts_for(Unit *u) {
390 STRV_FOREACH(j, u->requires_mounts_for) {
391 char s[strlen(*j) + 1];
393 PATH_FOREACH_PREFIX_MORE(s, *j) {
397 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
403 if (set_isempty(x)) {
404 hashmap_remove(u->manager->units_requiring_mounts_for, y);
411 strv_free(u->requires_mounts_for);
412 u->requires_mounts_for = NULL;
415 void unit_free(Unit *u) {
422 if (u->manager->n_reloading <= 0)
423 unit_remove_transient(u);
425 bus_unit_send_removed_signal(u);
427 if (u->load_state != UNIT_STUB)
428 if (UNIT_VTABLE(u)->done)
429 UNIT_VTABLE(u)->done(u);
431 unit_free_requires_mounts_for(u);
433 SET_FOREACH(t, u->names, i)
434 hashmap_remove_value(u->manager->units, t, u);
448 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
449 bidi_set_free(u, u->dependencies[d]);
451 if (u->type != _UNIT_TYPE_INVALID)
452 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
454 if (u->in_load_queue)
455 LIST_REMOVE(load_queue, u->manager->load_queue, u);
457 if (u->in_dbus_queue)
458 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
460 if (u->in_cleanup_queue)
461 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
463 if (u->in_gc_queue) {
464 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
465 u->manager->n_in_gc_queue--;
468 if (u->in_cgroup_queue)
469 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
471 if (u->cgroup_path) {
472 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
473 free(u->cgroup_path);
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_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_default_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);
973 if (u->default_dependencies && unit_get_cgroup_context(u)) {
974 if (UNIT_ISSET(u->slice))
975 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
977 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
986 static int unit_add_mount_links(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 if (u->default_dependencies) {
1054 r = unit_add_default_dependencies(u);
1059 unit_update_member_masks(u);
1061 r = unit_add_mount_links(u);
1065 if (u->on_failure_job_mode == JOB_ISOLATE &&
1066 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1068 log_error_unit(u->id,
1069 "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
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 #pragma GCC diagnostic push
1144 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1145 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1150 /* We only print status messages for selected units on
1151 * selected operations. */
1153 format = unit_get_status_message_format(u, t);
1157 unit_status_printf(u, "", format);
1159 #pragma GCC diagnostic pop
1161 #pragma GCC diagnostic push
1162 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1163 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1170 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1173 if (log_on_console())
1176 /* We log status messages for all units and all operations. */
1178 format = unit_get_status_message_format_try_harder(u, t);
1182 snprintf(buf, sizeof(buf), format, unit_description(u));
1185 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1186 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1187 SD_MESSAGE_UNIT_RELOADING;
1189 log_struct_unit(LOG_INFO,
1195 #pragma GCC diagnostic pop
1198 * -EBADR: This unit type does not support starting.
1199 * -EALREADY: Unit is already started.
1200 * -EAGAIN: An operation is already in progress. Retry later.
1201 * -ECANCELED: Too many requests for now.
1203 int unit_start(Unit *u) {
1204 UnitActiveState state;
1209 if (u->load_state != UNIT_LOADED)
1212 /* If this is already started, then this will succeed. Note
1213 * that this will even succeed if this unit is not startable
1214 * by the user. This is relied on to detect when we need to
1215 * wait for units and when waiting is finished. */
1216 state = unit_active_state(u);
1217 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1220 /* If the conditions failed, don't do anything at all. If we
1221 * already are activating this call might still be useful to
1222 * speed up activation in case there is some hold-off time,
1223 * but we don't want to recheck the condition in that case. */
1224 if (state != UNIT_ACTIVATING &&
1225 !unit_condition_test(u)) {
1226 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1230 /* Forward to the main object, if we aren't it. */
1231 following = unit_following(u);
1233 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1234 u->id, following->id);
1235 return unit_start(following);
1238 unit_status_log_starting_stopping_reloading(u, JOB_START);
1239 unit_status_print_starting_stopping(u, JOB_START);
1241 /* If it is stopped, but we cannot start it, then fail */
1242 if (!UNIT_VTABLE(u)->start)
1245 /* We don't suppress calls to ->start() here when we are
1246 * already starting, to allow this request to be used as a
1247 * "hurry up" call, for example when the unit is in some "auto
1248 * restart" state where it waits for a holdoff timer to elapse
1249 * before it will start again. */
1251 unit_add_to_dbus_queue(u);
1253 return UNIT_VTABLE(u)->start(u);
1256 bool unit_can_start(Unit *u) {
1259 return !!UNIT_VTABLE(u)->start;
1262 bool unit_can_isolate(Unit *u) {
1265 return unit_can_start(u) &&
1270 * -EBADR: This unit type does not support stopping.
1271 * -EALREADY: Unit is already stopped.
1272 * -EAGAIN: An operation is already in progress. Retry later.
1274 int unit_stop(Unit *u) {
1275 UnitActiveState state;
1280 state = unit_active_state(u);
1281 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1284 if ((following = unit_following(u))) {
1285 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1286 u->id, following->id);
1287 return unit_stop(following);
1290 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1291 unit_status_print_starting_stopping(u, JOB_STOP);
1293 if (!UNIT_VTABLE(u)->stop)
1296 unit_add_to_dbus_queue(u);
1298 return UNIT_VTABLE(u)->stop(u);
1302 * -EBADR: This unit type does not support reloading.
1303 * -ENOEXEC: Unit is not started.
1304 * -EAGAIN: An operation is already in progress. Retry later.
1306 int unit_reload(Unit *u) {
1307 UnitActiveState state;
1312 if (u->load_state != UNIT_LOADED)
1315 if (!unit_can_reload(u))
1318 state = unit_active_state(u);
1319 if (state == UNIT_RELOADING)
1322 if (state != UNIT_ACTIVE) {
1323 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1328 following = unit_following(u);
1330 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1331 u->id, following->id);
1332 return unit_reload(following);
1335 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1337 unit_add_to_dbus_queue(u);
1338 return UNIT_VTABLE(u)->reload(u);
1341 bool unit_can_reload(Unit *u) {
1344 if (!UNIT_VTABLE(u)->reload)
1347 if (!UNIT_VTABLE(u)->can_reload)
1350 return UNIT_VTABLE(u)->can_reload(u);
1353 static void unit_check_unneeded(Unit *u) {
1359 /* If this service shall be shut down when unneeded then do
1362 if (!u->stop_when_unneeded)
1365 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1368 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1369 if (unit_active_or_pending(other))
1372 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1373 if (unit_active_or_pending(other))
1376 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1377 if (unit_active_or_pending(other))
1380 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1381 if (unit_active_or_pending(other))
1384 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1386 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1387 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1390 static void retroactively_start_dependencies(Unit *u) {
1395 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1397 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1398 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1399 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1400 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1402 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1403 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1404 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1405 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1407 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1408 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1409 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1410 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1412 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1413 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1414 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1415 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1417 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], 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);
1421 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1422 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1423 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1426 static void retroactively_stop_dependencies(Unit *u) {
1431 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1433 /* Pull down units which are bound to us recursively if enabled */
1434 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1435 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1436 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1439 static void check_unneeded_dependencies(Unit *u) {
1444 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1446 /* Garbage collect services that might not be needed anymore, if enabled */
1447 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1448 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1449 unit_check_unneeded(other);
1450 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1451 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1452 unit_check_unneeded(other);
1453 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1454 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1455 unit_check_unneeded(other);
1456 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1457 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1458 unit_check_unneeded(other);
1459 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1460 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1461 unit_check_unneeded(other);
1462 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1463 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1464 unit_check_unneeded(other);
1467 void unit_start_on_failure(Unit *u) {
1473 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1476 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1478 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1481 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1483 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1487 void unit_trigger_notify(Unit *u) {
1493 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1494 if (UNIT_VTABLE(other)->trigger_notify)
1495 UNIT_VTABLE(other)->trigger_notify(other, u);
1498 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1503 assert(os < _UNIT_ACTIVE_STATE_MAX);
1504 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1506 /* Note that this is called for all low-level state changes,
1507 * even if they might map to the same high-level
1508 * UnitActiveState! That means that ns == os is OK an expected
1509 * behavior here. For example: if a mount point is remounted
1510 * this function will be called too! */
1514 if (m->n_reloading <= 0) {
1517 dual_timestamp_get(&ts);
1519 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1520 u->inactive_exit_timestamp = ts;
1521 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1522 u->inactive_enter_timestamp = ts;
1524 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1525 u->active_enter_timestamp = ts;
1526 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1527 u->active_exit_timestamp = ts;
1530 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1531 unit_destroy_cgroup(u);
1533 /* Note that this doesn't apply to RemainAfterExit services exiting
1534 * sucessfully, since there's no change of state in that case. Which is
1535 * why it is handled in service_set_state() */
1536 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1537 ExecContext *ec = unit_get_exec_context(u);
1538 if (ec && exec_context_may_touch_console(ec)) {
1539 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1542 if (m->n_on_console == 0)
1543 /* unset no_console_output flag, since the console is free */
1544 m->no_console_output = false;
1553 if (u->job->state == JOB_WAITING)
1555 /* So we reached a different state for this
1556 * job. Let's see if we can run it now if it
1557 * failed previously due to EAGAIN. */
1558 job_add_to_run_queue(u->job);
1560 /* Let's check whether this state change constitutes a
1561 * finished job, or maybe contradicts a running job and
1562 * hence needs to invalidate jobs. */
1564 switch (u->job->type) {
1567 case JOB_VERIFY_ACTIVE:
1569 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1570 job_finish_and_invalidate(u->job, JOB_DONE, true);
1571 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1574 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1575 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1581 case JOB_RELOAD_OR_START:
1583 if (u->job->state == JOB_RUNNING) {
1584 if (ns == UNIT_ACTIVE)
1585 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1586 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1589 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1590 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1598 case JOB_TRY_RESTART:
1600 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1601 job_finish_and_invalidate(u->job, JOB_DONE, true);
1602 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1604 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1610 assert_not_reached("Job type unknown");
1616 if (m->n_reloading <= 0) {
1618 /* If this state change happened without being
1619 * requested by a job, then let's retroactively start
1620 * or stop dependencies. We skip that step when
1621 * deserializing, since we don't want to create any
1622 * additional jobs just because something is already
1626 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1627 retroactively_start_dependencies(u);
1628 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1629 retroactively_stop_dependencies(u);
1632 /* stop unneeded units regardless if going down was expected or not */
1633 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1634 check_unneeded_dependencies(u);
1636 if (ns != os && ns == UNIT_FAILED) {
1637 log_notice_unit(u->id,
1638 "Unit %s entered failed state.", u->id);
1639 unit_start_on_failure(u);
1643 /* Some names are special */
1644 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1646 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1647 /* The bus just might have become available,
1648 * hence try to connect to it, if we aren't
1652 if (u->type == UNIT_SERVICE &&
1653 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1654 m->n_reloading <= 0) {
1655 /* Write audit record if we have just finished starting up */
1656 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1660 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1661 manager_send_unit_plymouth(m, u);
1665 /* We don't care about D-Bus here, since we'll get an
1666 * asynchronous notification for it anyway. */
1668 if (u->type == UNIT_SERVICE &&
1669 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1670 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1671 m->n_reloading <= 0) {
1673 /* Hmm, if there was no start record written
1674 * write it now, so that we always have a nice
1677 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1679 if (ns == UNIT_INACTIVE)
1680 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1682 /* Write audit record if we have just finished shutting down */
1683 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1685 u->in_audit = false;
1689 manager_recheck_journal(m);
1690 unit_trigger_notify(u);
1692 /* Maybe we finished startup and are now ready for being
1693 * stopped because unneeded? */
1694 if (u->manager->n_reloading <= 0)
1695 unit_check_unneeded(u);
1697 unit_add_to_dbus_queue(u);
1698 unit_add_to_gc_queue(u);
1701 int unit_watch_pid(Unit *u, pid_t pid) {
1707 /* Watch a specific PID. We only support one or two units
1708 * watching each PID for now, not more. */
1710 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1714 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1718 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1720 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1724 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1727 q = set_put(u->pids, LONG_TO_PTR(pid));
1734 void unit_unwatch_pid(Unit *u, pid_t pid) {
1738 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1739 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1740 set_remove(u->pids, LONG_TO_PTR(pid));
1743 static int watch_pids_in_path(Unit *u, const char *path) {
1744 _cleanup_closedir_ DIR *d = NULL;
1745 _cleanup_fclose_ FILE *f = NULL;
1751 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1753 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1757 while ((r = cg_read_pid(f, &pid)) > 0) {
1758 r = unit_watch_pid(u, pid);
1759 if (r < 0 && ret >= 0)
1762 if (r < 0 && ret >= 0)
1765 } else if (ret >= 0)
1768 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1772 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1773 _cleanup_free_ char *p = NULL;
1775 p = strjoin(path, "/", fn, NULL);
1781 r = watch_pids_in_path(u, p);
1782 if (r < 0 && ret >= 0)
1785 if (r < 0 && ret >= 0)
1788 } else if (ret >= 0)
1795 int unit_watch_all_pids(Unit *u) {
1798 if (!u->cgroup_path)
1801 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1803 return watch_pids_in_path(u, u->cgroup_path);
1806 void unit_unwatch_all_pids(Unit *u) {
1812 SET_FOREACH(e, u->pids, i) {
1813 hashmap_remove_value(u->manager->watch_pids1, e, u);
1814 hashmap_remove_value(u->manager->watch_pids2, e, u);
1821 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1827 /* Cleans dead PIDs from our list */
1829 SET_FOREACH(e, u->pids, i) {
1830 pid_t pid = PTR_TO_LONG(e);
1832 if (pid == except1 || pid == except2)
1835 if (kill(pid, 0) < 0 && errno == ESRCH)
1836 set_remove(u->pids, e);
1840 bool unit_job_is_applicable(Unit *u, JobType j) {
1842 assert(j >= 0 && j < _JOB_TYPE_MAX);
1846 case JOB_VERIFY_ACTIVE:
1853 case JOB_TRY_RESTART:
1854 return unit_can_start(u);
1857 return unit_can_reload(u);
1859 case JOB_RELOAD_OR_START:
1860 return unit_can_reload(u) && unit_can_start(u);
1863 assert_not_reached("Invalid job type");
1867 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1869 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1870 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1871 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1872 [UNIT_WANTS] = UNIT_WANTED_BY,
1873 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1874 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1875 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1876 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1877 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1878 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1879 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1880 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1881 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1882 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1883 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1884 [UNIT_BEFORE] = UNIT_AFTER,
1885 [UNIT_AFTER] = UNIT_BEFORE,
1886 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1887 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1888 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1889 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1890 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1891 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1892 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1893 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1895 int r, q = 0, v = 0, w = 0;
1898 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1901 u = unit_follow_merge(u);
1902 other = unit_follow_merge(other);
1904 /* We won't allow dependencies on ourselves. We will not
1905 * consider them an error however. */
1909 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1913 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1914 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1919 if (add_reference) {
1920 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1924 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1929 q = set_put(u->dependencies[d], other);
1933 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1934 v = set_put(other->dependencies[inverse_table[d]], u);
1941 if (add_reference) {
1942 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1948 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1953 unit_add_to_dbus_queue(u);
1958 set_remove(u->dependencies[d], other);
1961 set_remove(other->dependencies[inverse_table[d]], u);
1964 set_remove(u->dependencies[UNIT_REFERENCES], other);
1969 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1974 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1977 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1983 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1987 assert(name || path);
1991 name = basename(path);
1993 if (!unit_name_is_template(name)) {
1999 s = unit_name_replace_instance(name, u->instance);
2001 _cleanup_free_ char *i = NULL;
2003 i = unit_name_to_prefix(u->id);
2007 s = unit_name_replace_instance(name, i);
2017 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2020 _cleanup_free_ char *s = NULL;
2023 assert(name || path);
2025 name = resolve_template(u, name, path, &s);
2029 r = manager_load_unit(u->manager, name, path, NULL, &other);
2033 return unit_add_dependency(u, d, other, add_reference);
2036 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2039 _cleanup_free_ char *s = NULL;
2042 assert(name || path);
2044 if (!(name = resolve_template(u, name, path, &s)))
2047 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2050 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2055 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2058 _cleanup_free_ char *s = NULL;
2061 assert(name || path);
2063 if (!(name = resolve_template(u, name, path, &s)))
2066 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2069 r = unit_add_dependency(other, d, u, add_reference);
2074 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2077 _cleanup_free_ char *s = NULL;
2080 assert(name || path);
2082 if (!(name = resolve_template(u, name, path, &s)))
2085 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2088 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2094 int set_unit_path(const char *p) {
2095 _cleanup_free_ char *c = NULL;
2097 /* This is mostly for debug purposes */
2098 c = path_make_absolute_cwd(p);
2099 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2105 char *unit_dbus_path(Unit *u) {
2111 return unit_dbus_path_from_name(u->id);
2114 char *unit_default_cgroup_path(Unit *u) {
2115 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2120 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2121 return strdup(u->manager->cgroup_root);
2123 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2124 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2129 escaped = cg_escape(u->id);
2134 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2136 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2139 int unit_add_default_slice(Unit *u) {
2140 _cleanup_free_ char *b = NULL;
2141 const char *slice_name;
2147 if (UNIT_ISSET(u->slice))
2150 if (!unit_get_cgroup_context(u))
2154 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2156 /* Implicitly place all instantiated units in their
2157 * own per-template slice */
2159 prefix = unit_name_to_prefix(u->id);
2163 /* The prefix is already escaped, but it might include
2164 * "-" which has a special meaning for slice units,
2165 * hence escape it here extra. */
2166 escaped = strreplace(prefix, "-", "\\x2d");
2170 if (u->manager->running_as == SYSTEMD_SYSTEM)
2171 b = strjoin("system-", escaped, ".slice", NULL);
2173 b = strappend(escaped, ".slice");
2180 u->manager->running_as == SYSTEMD_SYSTEM
2181 ? SPECIAL_SYSTEM_SLICE
2182 : SPECIAL_ROOT_SLICE;
2184 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2188 unit_ref_set(&u->slice, slice);
2192 const char *unit_slice_name(Unit *u) {
2195 if (!UNIT_ISSET(u->slice))
2198 return UNIT_DEREF(u->slice)->id;
2201 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2202 _cleanup_free_ char *t = NULL;
2209 t = unit_name_change_suffix(u->id, type);
2213 assert(!unit_has_name(u, t));
2215 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2216 assert(r < 0 || *_found != u);
2220 int unit_watch_bus_name(Unit *u, const char *name) {
2224 /* Watch a specific name on the bus. We only support one unit
2225 * watching each name for now. */
2227 return hashmap_put(u->manager->watch_bus, name, u);
2230 void unit_unwatch_bus_name(Unit *u, const char *name) {
2234 hashmap_remove_value(u->manager->watch_bus, name, u);
2237 bool unit_can_serialize(Unit *u) {
2240 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2243 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2251 if (!unit_can_serialize(u))
2254 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2258 rt = unit_get_exec_runtime(u);
2260 r = exec_runtime_serialize(rt, u, f, fds);
2265 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2266 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2267 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2268 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2269 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2271 if (dual_timestamp_is_set(&u->condition_timestamp))
2272 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2274 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2277 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2279 if (serialize_jobs) {
2281 fprintf(f, "job\n");
2282 job_serialize(u->job, f, fds);
2286 fprintf(f, "job\n");
2287 job_serialize(u->nop_job, f, fds);
2296 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2307 va_start(ap, format);
2308 vfprintf(f, format, ap);
2314 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2320 fprintf(f, "%s=%s\n", key, value);
2323 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2325 ExecRuntime **rt = NULL;
2332 if (!unit_can_serialize(u))
2335 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2337 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2340 char line[LINE_MAX], *l, *v;
2343 if (!fgets(line, sizeof(line), f)) {
2356 k = strcspn(l, "=");
2364 if (streq(l, "job")) {
2366 /* new-style serialized job */
2367 Job *j = job_new_raw(u);
2371 r = job_deserialize(j, f, fds);
2377 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2383 r = job_install_deserialized(j);
2385 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2390 if (j->state == JOB_RUNNING)
2391 u->manager->n_running_jobs++;
2394 JobType type = job_type_from_string(v);
2396 log_debug("Failed to parse job type value %s", v);
2398 u->deserialized_job = type;
2401 } else if (streq(l, "inactive-exit-timestamp")) {
2402 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2404 } else if (streq(l, "active-enter-timestamp")) {
2405 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2407 } else if (streq(l, "active-exit-timestamp")) {
2408 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2410 } else if (streq(l, "inactive-enter-timestamp")) {
2411 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2413 } else if (streq(l, "condition-timestamp")) {
2414 dual_timestamp_deserialize(v, &u->condition_timestamp);
2416 } else if (streq(l, "condition-result")) {
2419 b = parse_boolean(v);
2421 log_debug("Failed to parse condition result value %s", v);
2423 u->condition_result = b;
2427 } else if (streq(l, "transient")) {
2430 b = parse_boolean(v);
2432 log_debug("Failed to parse transient bool %s", v);
2437 } else if (streq(l, "cgroup")) {
2444 free(u->cgroup_path);
2447 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2452 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2459 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2465 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2467 _cleanup_free_ char *e = NULL;
2475 /* Adds in links to the device node that this unit is based on */
2477 if (!is_device_path(what))
2480 e = unit_name_from_path(what, ".device");
2484 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2489 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2494 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2502 int unit_coldplug(Unit *u) {
2507 if (UNIT_VTABLE(u)->coldplug)
2508 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2512 r = job_coldplug(u->job);
2515 } else if (u->deserialized_job >= 0) {
2517 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2521 u->deserialized_job = _JOB_TYPE_INVALID;
2527 #pragma GCC diagnostic push
2528 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2529 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2530 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2532 #pragma GCC diagnostic pop
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_exec_context_defaults(Unit *u, ExecContext *c) {
2792 /* This only copies in the ones that need memory */
2793 for (i = 0; i < RLIMIT_NLIMITS; i++)
2794 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2795 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2800 if (u->manager->running_as == SYSTEMD_USER &&
2801 !c->working_directory) {
2803 r = get_home_dir(&c->working_directory);
2811 ExecContext *unit_get_exec_context(Unit *u) {
2815 offset = UNIT_VTABLE(u)->exec_context_offset;
2819 return (ExecContext*) ((uint8_t*) u + offset);
2822 KillContext *unit_get_kill_context(Unit *u) {
2826 offset = UNIT_VTABLE(u)->kill_context_offset;
2830 return (KillContext*) ((uint8_t*) u + offset);
2833 CGroupContext *unit_get_cgroup_context(Unit *u) {
2836 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2840 return (CGroupContext*) ((uint8_t*) u + offset);
2843 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2846 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2850 return *(ExecRuntime**) ((uint8_t*) u + offset);
2853 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2854 _cleanup_free_ char *b = NULL;
2862 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2864 b = xescape(name, "/.");
2868 if (!filename_is_safe(b))
2871 if (u->manager->running_as == SYSTEMD_USER) {
2872 _cleanup_free_ char *c = NULL;
2874 r = user_config_home(&c);
2880 p = strjoin(c, "/", u->id, ".d", NULL);
2881 } else if (mode & UNIT_PERSISTENT)
2882 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2884 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2888 q = strjoin(p, "/90-", b, ".conf", NULL);
2899 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2900 _cleanup_free_ char *p = NULL, *q = NULL;
2907 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2910 r = drop_in_file(u, mode, name, &p, &q);
2915 return write_string_file_atomic_label(q, data);
2918 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2919 _cleanup_free_ char *p = NULL;
2927 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2930 va_start(ap, format);
2931 r = vasprintf(&p, format, ap);
2937 return unit_write_drop_in(u, mode, name, p);
2940 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2941 _cleanup_free_ char *ndata = NULL;
2947 if (!UNIT_VTABLE(u)->private_section)
2950 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2953 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2957 return unit_write_drop_in(u, mode, name, ndata);
2960 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2961 _cleanup_free_ char *p = NULL;
2969 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2972 va_start(ap, format);
2973 r = vasprintf(&p, format, ap);
2979 return unit_write_drop_in_private(u, mode, name, p);
2982 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2983 _cleanup_free_ char *p = NULL, *q = NULL;
2988 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2991 r = drop_in_file(u, mode, name, &p, &q);
2996 r = errno == ENOENT ? 0 : -errno;
3004 int unit_make_transient(Unit *u) {
3009 u->load_state = UNIT_STUB;
3011 u->transient = true;
3013 free(u->fragment_path);
3014 u->fragment_path = NULL;
3016 if (u->manager->running_as == SYSTEMD_USER) {
3017 _cleanup_free_ char *c = NULL;
3019 r = user_config_home(&c);
3025 u->fragment_path = strjoin(c, "/", u->id, NULL);
3026 if (!u->fragment_path)
3031 u->fragment_path = strappend("/run/systemd/system/", u->id);
3032 if (!u->fragment_path)
3035 mkdir_p("/run/systemd/system", 0755);
3038 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3041 int unit_kill_context(
3047 bool main_pid_alien) {
3049 int sig, wait_for_exit = false, r;
3054 if (c->kill_mode == KILL_NONE)
3057 sig = sigkill ? SIGKILL : c->kill_signal;
3060 r = kill_and_sigcont(main_pid, sig);
3062 if (r < 0 && r != -ESRCH) {
3063 _cleanup_free_ char *comm = NULL;
3064 get_process_comm(main_pid, &comm);
3066 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3068 if (!main_pid_alien)
3069 wait_for_exit = true;
3071 if (c->send_sighup && !sigkill)
3072 kill(main_pid, SIGHUP);
3076 if (control_pid > 0) {
3077 r = kill_and_sigcont(control_pid, sig);
3079 if (r < 0 && r != -ESRCH) {
3080 _cleanup_free_ char *comm = NULL;
3081 get_process_comm(control_pid, &comm);
3083 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3085 wait_for_exit = true;
3087 if (c->send_sighup && !sigkill)
3088 kill(control_pid, SIGHUP);
3092 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3093 _cleanup_set_free_ Set *pid_set = NULL;
3095 /* Exclude the main/control pids from being killed via the cgroup */
3096 pid_set = unit_pid_set(main_pid, control_pid);
3100 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3102 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3103 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3106 /* FIXME: For now, we will not wait for the
3107 * cgroup members to die, simply because
3108 * cgroup notification is unreliable. It
3109 * doesn't work at all in containers, and
3110 * outside of containers it can be confused
3111 * easily by leaving directories in the
3114 /* wait_for_exit = true; */
3116 if (c->send_sighup && !sigkill) {
3119 pid_set = unit_pid_set(main_pid, control_pid);
3123 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3128 return wait_for_exit;
3131 int unit_require_mounts_for(Unit *u, const char *path) {
3132 char prefix[strlen(path) + 1], *p;
3138 /* Registers a unit for requiring a certain path and all its
3139 * prefixes. We keep a simple array of these paths in the
3140 * unit, since its usually short. However, we build a prefix
3141 * table for all possible prefixes so that new appearing mount
3142 * units can easily determine which units to make themselves a
3145 if (!path_is_absolute(path))
3152 path_kill_slashes(p);
3154 if (!path_is_safe(p)) {
3159 if (strv_contains(u->requires_mounts_for, p)) {
3164 r = strv_push(&u->requires_mounts_for, p);
3170 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3173 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3177 if (!u->manager->units_requiring_mounts_for) {
3178 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3179 if (!u->manager->units_requiring_mounts_for)
3187 x = set_new(NULL, NULL);
3193 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3209 int unit_setup_exec_runtime(Unit *u) {
3215 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3218 /* Check if ther already is an ExecRuntime for this unit? */
3219 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3223 /* Try to get it from somebody else */
3224 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3226 *rt = unit_get_exec_runtime(other);
3228 exec_runtime_ref(*rt);
3233 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3236 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3237 [UNIT_ACTIVE] = "active",
3238 [UNIT_RELOADING] = "reloading",
3239 [UNIT_INACTIVE] = "inactive",
3240 [UNIT_FAILED] = "failed",
3241 [UNIT_ACTIVATING] = "activating",
3242 [UNIT_DEACTIVATING] = "deactivating"
3245 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3247 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3248 [UNIT_REQUIRES] = "Requires",
3249 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3250 [UNIT_REQUISITE] = "Requisite",
3251 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3252 [UNIT_WANTS] = "Wants",
3253 [UNIT_BINDS_TO] = "BindsTo",
3254 [UNIT_PART_OF] = "PartOf",
3255 [UNIT_REQUIRED_BY] = "RequiredBy",
3256 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3257 [UNIT_WANTED_BY] = "WantedBy",
3258 [UNIT_BOUND_BY] = "BoundBy",
3259 [UNIT_CONSISTS_OF] = "ConsistsOf",
3260 [UNIT_CONFLICTS] = "Conflicts",
3261 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3262 [UNIT_BEFORE] = "Before",
3263 [UNIT_AFTER] = "After",
3264 [UNIT_ON_FAILURE] = "OnFailure",
3265 [UNIT_TRIGGERS] = "Triggers",
3266 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3267 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3268 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3269 [UNIT_REFERENCES] = "References",
3270 [UNIT_REFERENCED_BY] = "ReferencedBy",
3271 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3274 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);