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 (set_isempty(u->manager->subscribed)) {
332 u->sent_dbus_new_signal = true;
336 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
337 u->in_dbus_queue = true;
340 static void bidi_set_free(Unit *u, Set *s) {
346 /* Frees the set and makes sure we are dropped from the
347 * inverse pointers */
349 SET_FOREACH(other, s, i) {
352 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
353 set_remove(other->dependencies[d], u);
355 unit_add_to_gc_queue(other);
361 static void unit_remove_transient(Unit *u) {
369 if (u->fragment_path)
370 unlink(u->fragment_path);
372 STRV_FOREACH(i, u->dropin_paths) {
373 _cleanup_free_ char *p = NULL;
378 r = path_get_parent(*i, &p);
384 static void unit_free_requires_mounts_for(Unit *u) {
387 STRV_FOREACH(j, u->requires_mounts_for) {
388 char s[strlen(*j) + 1];
390 PATH_FOREACH_PREFIX_MORE(s, *j) {
394 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
400 if (set_isempty(x)) {
401 hashmap_remove(u->manager->units_requiring_mounts_for, y);
408 strv_free(u->requires_mounts_for);
409 u->requires_mounts_for = NULL;
412 void unit_free(Unit *u) {
419 if (u->manager->n_reloading <= 0)
420 unit_remove_transient(u);
422 bus_unit_send_removed_signal(u);
424 if (u->load_state != UNIT_STUB)
425 if (UNIT_VTABLE(u)->done)
426 UNIT_VTABLE(u)->done(u);
428 unit_free_requires_mounts_for(u);
430 SET_FOREACH(t, u->names, i)
431 hashmap_remove_value(u->manager->units, t, u);
445 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
446 bidi_set_free(u, u->dependencies[d]);
448 if (u->type != _UNIT_TYPE_INVALID)
449 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
451 if (u->in_load_queue)
452 LIST_REMOVE(load_queue, u->manager->load_queue, u);
454 if (u->in_dbus_queue)
455 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
457 if (u->in_cleanup_queue)
458 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
460 if (u->in_gc_queue) {
461 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
462 u->manager->n_in_gc_queue--;
465 if (u->in_cgroup_queue)
466 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
468 if (u->cgroup_path) {
469 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
470 free(u->cgroup_path);
473 free(u->description);
474 strv_free(u->documentation);
475 free(u->fragment_path);
476 free(u->source_path);
477 strv_free(u->dropin_paths);
480 set_free_free(u->names);
482 unit_unwatch_all_pids(u);
484 condition_free_list(u->conditions);
486 unit_ref_unset(&u->slice);
489 unit_ref_unset(u->refs);
494 UnitActiveState unit_active_state(Unit *u) {
497 if (u->load_state == UNIT_MERGED)
498 return unit_active_state(unit_follow_merge(u));
500 /* After a reload it might happen that a unit is not correctly
501 * loaded but still has a process around. That's why we won't
502 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
504 return UNIT_VTABLE(u)->active_state(u);
507 const char* unit_sub_state_to_string(Unit *u) {
510 return UNIT_VTABLE(u)->sub_state_to_string(u);
513 static void complete_move(Set **s, Set **other) {
521 set_move(*s, *other);
528 static void merge_names(Unit *u, Unit *other) {
535 complete_move(&u->names, &other->names);
537 set_free_free(other->names);
541 SET_FOREACH(t, u->names, i)
542 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
545 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
552 assert(d < _UNIT_DEPENDENCY_MAX);
554 /* Fix backwards pointers */
555 SET_FOREACH(back, other->dependencies[d], i) {
558 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
559 r = set_remove_and_put(back->dependencies[k], other, u);
561 set_remove(back->dependencies[k], other);
563 assert(r >= 0 || r == -ENOENT);
567 complete_move(&u->dependencies[d], &other->dependencies[d]);
569 set_free(other->dependencies[d]);
570 other->dependencies[d] = NULL;
573 int unit_merge(Unit *u, Unit *other) {
578 assert(u->manager == other->manager);
579 assert(u->type != _UNIT_TYPE_INVALID);
581 other = unit_follow_merge(other);
586 if (u->type != other->type)
589 if (!u->instance != !other->instance)
592 if (other->load_state != UNIT_STUB &&
593 other->load_state != UNIT_NOT_FOUND)
602 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
606 merge_names(u, other);
608 /* Redirect all references */
610 unit_ref_set(other->refs, u);
612 /* Merge dependencies */
613 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
614 merge_dependencies(u, other, d);
616 other->load_state = UNIT_MERGED;
617 other->merged_into = u;
619 /* If there is still some data attached to the other node, we
620 * don't need it anymore, and can free it. */
621 if (other->load_state != UNIT_STUB)
622 if (UNIT_VTABLE(other)->done)
623 UNIT_VTABLE(other)->done(other);
625 unit_add_to_dbus_queue(u);
626 unit_add_to_cleanup_queue(other);
631 int unit_merge_by_name(Unit *u, const char *name) {
634 _cleanup_free_ char *s = NULL;
639 if (unit_name_is_template(name)) {
643 s = unit_name_replace_instance(name, u->instance);
650 other = manager_get_unit(u->manager, name);
652 r = unit_add_name(u, name);
654 r = unit_merge(u, other);
659 Unit* unit_follow_merge(Unit *u) {
662 while (u->load_state == UNIT_MERGED)
663 assert_se(u = u->merged_into);
668 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
674 if (c->working_directory) {
675 r = unit_require_mounts_for(u, c->working_directory);
680 if (c->root_directory) {
681 r = unit_require_mounts_for(u, c->root_directory);
686 if (c->std_output != EXEC_OUTPUT_KMSG &&
687 c->std_output != EXEC_OUTPUT_SYSLOG &&
688 c->std_output != EXEC_OUTPUT_JOURNAL &&
689 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
690 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
691 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
692 c->std_error != EXEC_OUTPUT_KMSG &&
693 c->std_error != EXEC_OUTPUT_SYSLOG &&
694 c->std_error != EXEC_OUTPUT_JOURNAL &&
695 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
696 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
697 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
700 /* If syslog or kernel logging is requested, make sure our own
701 * logging daemon is run first. */
703 if (u->manager->running_as == SYSTEMD_SYSTEM) {
704 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
712 const char *unit_description(Unit *u) {
716 return u->description;
721 void unit_dump(Unit *u, FILE *f, const char *prefix) {
725 _cleanup_free_ char *p2 = NULL;
728 timestamp1[FORMAT_TIMESTAMP_MAX],
729 timestamp2[FORMAT_TIMESTAMP_MAX],
730 timestamp3[FORMAT_TIMESTAMP_MAX],
731 timestamp4[FORMAT_TIMESTAMP_MAX],
732 timespan[FORMAT_TIMESPAN_MAX];
734 _cleanup_set_free_ Set *following_set = NULL;
738 assert(u->type >= 0);
742 p2 = strappend(prefix, "\t");
743 prefix2 = p2 ? p2 : prefix;
747 "%s\tDescription: %s\n"
749 "%s\tUnit Load State: %s\n"
750 "%s\tUnit Active State: %s\n"
751 "%s\tInactive Exit Timestamp: %s\n"
752 "%s\tActive Enter Timestamp: %s\n"
753 "%s\tActive Exit Timestamp: %s\n"
754 "%s\tInactive Enter Timestamp: %s\n"
755 "%s\tGC Check Good: %s\n"
756 "%s\tNeed Daemon Reload: %s\n"
757 "%s\tTransient: %s\n"
760 "%s\tCGroup realized: %s\n"
761 "%s\tCGroup mask: 0x%x\n"
762 "%s\tCGroup members mask: 0x%x\n",
764 prefix, unit_description(u),
765 prefix, strna(u->instance),
766 prefix, unit_load_state_to_string(u->load_state),
767 prefix, unit_active_state_to_string(unit_active_state(u)),
768 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
769 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
770 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
771 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
772 prefix, yes_no(unit_check_gc(u)),
773 prefix, yes_no(unit_need_daemon_reload(u)),
774 prefix, yes_no(u->transient),
775 prefix, strna(unit_slice_name(u)),
776 prefix, strna(u->cgroup_path),
777 prefix, yes_no(u->cgroup_realized),
778 prefix, u->cgroup_realized_mask,
779 prefix, u->cgroup_members_mask);
781 SET_FOREACH(t, u->names, i)
782 fprintf(f, "%s\tName: %s\n", prefix, t);
784 STRV_FOREACH(j, u->documentation)
785 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
787 following = unit_following(u);
789 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
791 r = unit_following_set(u, &following_set);
795 SET_FOREACH(other, following_set, i)
796 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
799 if (u->fragment_path)
800 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
803 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
805 STRV_FOREACH(j, u->dropin_paths)
806 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
808 if (u->job_timeout > 0)
809 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
811 condition_dump_list(u->conditions, f, prefix);
813 if (dual_timestamp_is_set(&u->condition_timestamp))
815 "%s\tCondition Timestamp: %s\n"
816 "%s\tCondition Result: %s\n",
817 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
818 prefix, yes_no(u->condition_result));
820 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
823 SET_FOREACH(other, u->dependencies[d], i)
824 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
827 if (!strv_isempty(u->requires_mounts_for)) {
829 "%s\tRequiresMountsFor:", prefix);
831 STRV_FOREACH(j, u->requires_mounts_for)
832 fprintf(f, " %s", *j);
837 if (u->load_state == UNIT_LOADED) {
840 "%s\tStopWhenUnneeded: %s\n"
841 "%s\tRefuseManualStart: %s\n"
842 "%s\tRefuseManualStop: %s\n"
843 "%s\tDefaultDependencies: %s\n"
844 "%s\tOnFailureJobMode: %s\n"
845 "%s\tIgnoreOnIsolate: %s\n"
846 "%s\tIgnoreOnSnapshot: %s\n",
847 prefix, yes_no(u->stop_when_unneeded),
848 prefix, yes_no(u->refuse_manual_start),
849 prefix, yes_no(u->refuse_manual_stop),
850 prefix, yes_no(u->default_dependencies),
851 prefix, job_mode_to_string(u->on_failure_job_mode),
852 prefix, yes_no(u->ignore_on_isolate),
853 prefix, yes_no(u->ignore_on_snapshot));
855 if (UNIT_VTABLE(u)->dump)
856 UNIT_VTABLE(u)->dump(u, f, prefix2);
858 } else if (u->load_state == UNIT_MERGED)
860 "%s\tMerged into: %s\n",
861 prefix, u->merged_into->id);
862 else if (u->load_state == UNIT_ERROR)
863 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
867 job_dump(u->job, f, prefix2);
870 job_dump(u->nop_job, f, prefix2);
874 /* Common implementation for multiple backends */
875 int unit_load_fragment_and_dropin(Unit *u) {
880 /* Load a .{service,socket,...} file */
881 r = unit_load_fragment(u);
885 if (u->load_state == UNIT_STUB)
888 /* Load drop-in directory data */
889 r = unit_load_dropin(unit_follow_merge(u));
896 /* Common implementation for multiple backends */
897 int unit_load_fragment_and_dropin_optional(Unit *u) {
902 /* Same as unit_load_fragment_and_dropin(), but whether
903 * something can be loaded or not doesn't matter. */
905 /* Load a .service file */
906 r = unit_load_fragment(u);
910 if (u->load_state == UNIT_STUB)
911 u->load_state = UNIT_LOADED;
913 /* Load drop-in directory data */
914 r = unit_load_dropin(unit_follow_merge(u));
921 int unit_add_default_target_dependency(Unit *u, Unit *target) {
925 if (target->type != UNIT_TARGET)
928 /* Only add the dependency if both units are loaded, so that
929 * that loop check below is reliable */
930 if (u->load_state != UNIT_LOADED ||
931 target->load_state != UNIT_LOADED)
934 /* If either side wants no automatic dependencies, then let's
936 if (!u->default_dependencies ||
937 !target->default_dependencies)
940 /* Don't create loops */
941 if (set_get(target->dependencies[UNIT_BEFORE], u))
944 return unit_add_dependency(target, UNIT_AFTER, u, true);
947 static int unit_add_target_dependencies(Unit *u) {
949 static const UnitDependency deps[] = {
951 UNIT_REQUIRED_BY_OVERRIDABLE,
963 for (k = 0; k < ELEMENTSOF(deps); k++)
964 SET_FOREACH(target, u->dependencies[deps[k]], i) {
965 r = unit_add_default_target_dependency(u, target);
973 static int unit_add_slice_dependencies(Unit *u) {
976 if (!unit_get_cgroup_context(u))
979 if (UNIT_ISSET(u->slice))
980 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
982 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
985 static int unit_add_mount_dependencies(Unit *u) {
991 STRV_FOREACH(i, u->requires_mounts_for) {
992 char prefix[strlen(*i) + 1];
994 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
997 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1005 if (m->load_state != UNIT_LOADED)
1008 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1012 if (m->fragment_path) {
1013 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1023 int unit_load(Unit *u) {
1028 if (u->in_load_queue) {
1029 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1030 u->in_load_queue = false;
1033 if (u->type == _UNIT_TYPE_INVALID)
1036 if (u->load_state != UNIT_STUB)
1039 if (UNIT_VTABLE(u)->load) {
1040 r = UNIT_VTABLE(u)->load(u);
1045 if (u->load_state == UNIT_STUB) {
1050 if (u->load_state == UNIT_LOADED) {
1052 r = unit_add_target_dependencies(u);
1056 r = unit_add_slice_dependencies(u);
1060 r = unit_add_mount_dependencies(u);
1064 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1065 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1070 unit_update_cgroup_members_masks(u);
1073 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1075 unit_add_to_dbus_queue(unit_follow_merge(u));
1076 unit_add_to_gc_queue(u);
1081 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1083 unit_add_to_dbus_queue(u);
1084 unit_add_to_gc_queue(u);
1086 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1087 u->id, strerror(-r));
1092 static bool unit_condition_test(Unit *u) {
1095 dual_timestamp_get(&u->condition_timestamp);
1096 u->condition_result = condition_test_list(u->id, u->conditions);
1098 return u->condition_result;
1101 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1102 const UnitStatusMessageFormats *format_table;
1106 assert(t < _JOB_TYPE_MAX);
1108 if (t != JOB_START && t != JOB_STOP)
1111 format_table = &UNIT_VTABLE(u)->status_message_formats;
1115 return format_table->starting_stopping[t == JOB_STOP];
1118 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1123 assert(t < _JOB_TYPE_MAX);
1125 format = unit_get_status_message_format(u, t);
1129 /* Return generic strings */
1131 return "Starting %s.";
1132 else if (t == JOB_STOP)
1133 return "Stopping %s.";
1134 else if (t == JOB_RELOAD)
1135 return "Reloading %s.";
1140 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1145 /* We only print status messages for selected units on
1146 * selected operations. */
1148 format = unit_get_status_message_format(u, t);
1152 DISABLE_WARNING_FORMAT_NONLITERAL;
1153 unit_status_printf(u, "", format);
1157 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1164 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1167 if (log_on_console())
1170 /* We log status messages for all units and all operations. */
1172 format = unit_get_status_message_format_try_harder(u, t);
1176 DISABLE_WARNING_FORMAT_NONLITERAL;
1177 snprintf(buf, sizeof(buf), format, unit_description(u));
1181 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1182 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1183 SD_MESSAGE_UNIT_RELOADING;
1185 log_struct_unit(LOG_INFO,
1193 * -EBADR: This unit type does not support starting.
1194 * -EALREADY: Unit is already started.
1195 * -EAGAIN: An operation is already in progress. Retry later.
1196 * -ECANCELED: Too many requests for now.
1198 int unit_start(Unit *u) {
1199 UnitActiveState state;
1204 if (u->load_state != UNIT_LOADED)
1207 /* If this is already started, then this will succeed. Note
1208 * that this will even succeed if this unit is not startable
1209 * by the user. This is relied on to detect when we need to
1210 * wait for units and when waiting is finished. */
1211 state = unit_active_state(u);
1212 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1215 /* If the conditions failed, don't do anything at all. If we
1216 * already are activating this call might still be useful to
1217 * speed up activation in case there is some hold-off time,
1218 * but we don't want to recheck the condition in that case. */
1219 if (state != UNIT_ACTIVATING &&
1220 !unit_condition_test(u)) {
1221 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1225 /* Forward to the main object, if we aren't it. */
1226 following = unit_following(u);
1228 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1229 u->id, following->id);
1230 return unit_start(following);
1233 unit_status_log_starting_stopping_reloading(u, JOB_START);
1234 unit_status_print_starting_stopping(u, JOB_START);
1236 /* If it is stopped, but we cannot start it, then fail */
1237 if (!UNIT_VTABLE(u)->start)
1240 /* We don't suppress calls to ->start() here when we are
1241 * already starting, to allow this request to be used as a
1242 * "hurry up" call, for example when the unit is in some "auto
1243 * restart" state where it waits for a holdoff timer to elapse
1244 * before it will start again. */
1246 unit_add_to_dbus_queue(u);
1248 return UNIT_VTABLE(u)->start(u);
1251 bool unit_can_start(Unit *u) {
1254 return !!UNIT_VTABLE(u)->start;
1257 bool unit_can_isolate(Unit *u) {
1260 return unit_can_start(u) &&
1265 * -EBADR: This unit type does not support stopping.
1266 * -EALREADY: Unit is already stopped.
1267 * -EAGAIN: An operation is already in progress. Retry later.
1269 int unit_stop(Unit *u) {
1270 UnitActiveState state;
1275 state = unit_active_state(u);
1276 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1279 if ((following = unit_following(u))) {
1280 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1281 u->id, following->id);
1282 return unit_stop(following);
1285 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1286 unit_status_print_starting_stopping(u, JOB_STOP);
1288 if (!UNIT_VTABLE(u)->stop)
1291 unit_add_to_dbus_queue(u);
1293 return UNIT_VTABLE(u)->stop(u);
1297 * -EBADR: This unit type does not support reloading.
1298 * -ENOEXEC: Unit is not started.
1299 * -EAGAIN: An operation is already in progress. Retry later.
1301 int unit_reload(Unit *u) {
1302 UnitActiveState state;
1307 if (u->load_state != UNIT_LOADED)
1310 if (!unit_can_reload(u))
1313 state = unit_active_state(u);
1314 if (state == UNIT_RELOADING)
1317 if (state != UNIT_ACTIVE) {
1318 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1323 following = unit_following(u);
1325 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1326 u->id, following->id);
1327 return unit_reload(following);
1330 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1332 unit_add_to_dbus_queue(u);
1333 return UNIT_VTABLE(u)->reload(u);
1336 bool unit_can_reload(Unit *u) {
1339 if (!UNIT_VTABLE(u)->reload)
1342 if (!UNIT_VTABLE(u)->can_reload)
1345 return UNIT_VTABLE(u)->can_reload(u);
1348 static void unit_check_unneeded(Unit *u) {
1354 /* If this service shall be shut down when unneeded then do
1357 if (!u->stop_when_unneeded)
1360 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1363 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1364 if (unit_active_or_pending(other))
1367 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1368 if (unit_active_or_pending(other))
1371 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1372 if (unit_active_or_pending(other))
1375 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1376 if (unit_active_or_pending(other))
1379 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1381 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1382 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1385 static void retroactively_start_dependencies(Unit *u) {
1390 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1392 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1393 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1394 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1395 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1397 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], 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_REQUIRES_OVERRIDABLE], 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_FAIL, false, NULL, NULL);
1407 SET_FOREACH(other, u->dependencies[UNIT_WANTS], 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_CONFLICTS], i)
1413 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1414 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1416 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1417 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1418 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1421 static void retroactively_stop_dependencies(Unit *u) {
1426 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1428 /* Pull down units which are bound to us recursively if enabled */
1429 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1430 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1431 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1434 static void check_unneeded_dependencies(Unit *u) {
1439 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1441 /* Garbage collect services that might not be needed anymore, if enabled */
1442 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1443 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1444 unit_check_unneeded(other);
1445 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1446 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1447 unit_check_unneeded(other);
1448 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1449 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1450 unit_check_unneeded(other);
1451 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1452 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1453 unit_check_unneeded(other);
1454 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1455 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1456 unit_check_unneeded(other);
1457 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1458 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1459 unit_check_unneeded(other);
1462 void unit_start_on_failure(Unit *u) {
1468 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1471 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1473 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1476 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1478 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1482 void unit_trigger_notify(Unit *u) {
1488 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1489 if (UNIT_VTABLE(other)->trigger_notify)
1490 UNIT_VTABLE(other)->trigger_notify(other, u);
1493 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1498 assert(os < _UNIT_ACTIVE_STATE_MAX);
1499 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1501 /* Note that this is called for all low-level state changes,
1502 * even if they might map to the same high-level
1503 * UnitActiveState! That means that ns == os is OK an expected
1504 * behavior here. For example: if a mount point is remounted
1505 * this function will be called too! */
1509 if (m->n_reloading <= 0) {
1512 dual_timestamp_get(&ts);
1514 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1515 u->inactive_exit_timestamp = ts;
1516 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1517 u->inactive_enter_timestamp = ts;
1519 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1520 u->active_enter_timestamp = ts;
1521 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1522 u->active_exit_timestamp = ts;
1525 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1526 unit_destroy_cgroup(u);
1528 /* Note that this doesn't apply to RemainAfterExit services exiting
1529 * sucessfully, since there's no change of state in that case. Which is
1530 * why it is handled in service_set_state() */
1531 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1534 ec = unit_get_exec_context(u);
1535 if (ec && exec_context_may_touch_console(ec)) {
1536 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1539 if (m->n_on_console == 0)
1540 /* unset no_console_output flag, since the console is free */
1541 m->no_console_output = false;
1550 if (u->job->state == JOB_WAITING)
1552 /* So we reached a different state for this
1553 * job. Let's see if we can run it now if it
1554 * failed previously due to EAGAIN. */
1555 job_add_to_run_queue(u->job);
1557 /* Let's check whether this state change constitutes a
1558 * finished job, or maybe contradicts a running job and
1559 * hence needs to invalidate jobs. */
1561 switch (u->job->type) {
1564 case JOB_VERIFY_ACTIVE:
1566 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1567 job_finish_and_invalidate(u->job, JOB_DONE, true);
1568 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1571 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1572 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1578 case JOB_RELOAD_OR_START:
1580 if (u->job->state == JOB_RUNNING) {
1581 if (ns == UNIT_ACTIVE)
1582 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1583 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1586 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1587 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1595 case JOB_TRY_RESTART:
1597 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1598 job_finish_and_invalidate(u->job, JOB_DONE, true);
1599 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1601 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1607 assert_not_reached("Job type unknown");
1613 if (m->n_reloading <= 0) {
1615 /* If this state change happened without being
1616 * requested by a job, then let's retroactively start
1617 * or stop dependencies. We skip that step when
1618 * deserializing, since we don't want to create any
1619 * additional jobs just because something is already
1623 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1624 retroactively_start_dependencies(u);
1625 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1626 retroactively_stop_dependencies(u);
1629 /* stop unneeded units regardless if going down was expected or not */
1630 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1631 check_unneeded_dependencies(u);
1633 if (ns != os && ns == UNIT_FAILED) {
1634 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1635 unit_start_on_failure(u);
1639 /* Some names are special */
1640 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1642 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1643 /* The bus just might have become available,
1644 * hence try to connect to it, if we aren't
1648 if (u->type == UNIT_SERVICE &&
1649 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1650 m->n_reloading <= 0) {
1651 /* Write audit record if we have just finished starting up */
1652 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1656 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1657 manager_send_unit_plymouth(m, u);
1661 /* We don't care about D-Bus here, since we'll get an
1662 * asynchronous notification for it anyway. */
1664 if (u->type == UNIT_SERVICE &&
1665 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1666 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1667 m->n_reloading <= 0) {
1669 /* Hmm, if there was no start record written
1670 * write it now, so that we always have a nice
1673 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1675 if (ns == UNIT_INACTIVE)
1676 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1678 /* Write audit record if we have just finished shutting down */
1679 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1681 u->in_audit = false;
1685 manager_recheck_journal(m);
1686 unit_trigger_notify(u);
1688 /* Maybe we finished startup and are now ready for being
1689 * stopped because unneeded? */
1690 if (u->manager->n_reloading <= 0)
1691 unit_check_unneeded(u);
1693 unit_add_to_dbus_queue(u);
1694 unit_add_to_gc_queue(u);
1697 int unit_watch_pid(Unit *u, pid_t pid) {
1703 /* Watch a specific PID. We only support one or two units
1704 * watching each PID for now, not more. */
1706 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1710 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1714 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1716 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1720 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1723 q = set_put(u->pids, LONG_TO_PTR(pid));
1730 void unit_unwatch_pid(Unit *u, pid_t pid) {
1734 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1735 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1736 set_remove(u->pids, LONG_TO_PTR(pid));
1739 static int watch_pids_in_path(Unit *u, const char *path) {
1740 _cleanup_closedir_ DIR *d = NULL;
1741 _cleanup_fclose_ FILE *f = NULL;
1747 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1749 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1753 while ((r = cg_read_pid(f, &pid)) > 0) {
1754 r = unit_watch_pid(u, pid);
1755 if (r < 0 && ret >= 0)
1758 if (r < 0 && ret >= 0)
1761 } else if (ret >= 0)
1764 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1768 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1769 _cleanup_free_ char *p = NULL;
1771 p = strjoin(path, "/", fn, NULL);
1777 r = watch_pids_in_path(u, p);
1778 if (r < 0 && ret >= 0)
1781 if (r < 0 && ret >= 0)
1784 } else if (ret >= 0)
1791 int unit_watch_all_pids(Unit *u) {
1794 if (!u->cgroup_path)
1797 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1799 return watch_pids_in_path(u, u->cgroup_path);
1802 void unit_unwatch_all_pids(Unit *u) {
1808 SET_FOREACH(e, u->pids, i) {
1809 hashmap_remove_value(u->manager->watch_pids1, e, u);
1810 hashmap_remove_value(u->manager->watch_pids2, e, u);
1817 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1823 /* Cleans dead PIDs from our list */
1825 SET_FOREACH(e, u->pids, i) {
1826 pid_t pid = PTR_TO_LONG(e);
1828 if (pid == except1 || pid == except2)
1831 if (!pid_is_unwaited(pid))
1832 set_remove(u->pids, e);
1836 bool unit_job_is_applicable(Unit *u, JobType j) {
1838 assert(j >= 0 && j < _JOB_TYPE_MAX);
1842 case JOB_VERIFY_ACTIVE:
1849 case JOB_TRY_RESTART:
1850 return unit_can_start(u);
1853 return unit_can_reload(u);
1855 case JOB_RELOAD_OR_START:
1856 return unit_can_reload(u) && unit_can_start(u);
1859 assert_not_reached("Invalid job type");
1863 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1865 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1866 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1867 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1868 [UNIT_WANTS] = UNIT_WANTED_BY,
1869 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1870 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1871 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1872 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1873 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1874 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1875 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1876 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1877 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1878 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1879 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1880 [UNIT_BEFORE] = UNIT_AFTER,
1881 [UNIT_AFTER] = UNIT_BEFORE,
1882 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1883 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1884 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1885 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1886 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1887 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1888 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1889 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1891 int r, q = 0, v = 0, w = 0;
1894 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1897 u = unit_follow_merge(u);
1898 other = unit_follow_merge(other);
1900 /* We won't allow dependencies on ourselves. We will not
1901 * consider them an error however. */
1905 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1909 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1910 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1915 if (add_reference) {
1916 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1920 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1925 q = set_put(u->dependencies[d], other);
1929 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1930 v = set_put(other->dependencies[inverse_table[d]], u);
1937 if (add_reference) {
1938 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1944 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1949 unit_add_to_dbus_queue(u);
1954 set_remove(u->dependencies[d], other);
1957 set_remove(other->dependencies[inverse_table[d]], u);
1960 set_remove(u->dependencies[UNIT_REFERENCES], other);
1965 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1970 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1973 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1979 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1983 assert(name || path);
1987 name = basename(path);
1989 if (!unit_name_is_template(name)) {
1995 s = unit_name_replace_instance(name, u->instance);
1997 _cleanup_free_ char *i = NULL;
1999 i = unit_name_to_prefix(u->id);
2003 s = unit_name_replace_instance(name, i);
2013 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2016 _cleanup_free_ char *s = NULL;
2019 assert(name || path);
2021 name = resolve_template(u, name, path, &s);
2025 r = manager_load_unit(u->manager, name, path, NULL, &other);
2029 return unit_add_dependency(u, d, other, add_reference);
2032 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2035 _cleanup_free_ char *s = NULL;
2038 assert(name || path);
2040 if (!(name = resolve_template(u, name, path, &s)))
2043 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2046 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2051 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2054 _cleanup_free_ char *s = NULL;
2057 assert(name || path);
2059 if (!(name = resolve_template(u, name, path, &s)))
2062 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2065 r = unit_add_dependency(other, d, u, add_reference);
2070 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2073 _cleanup_free_ char *s = NULL;
2076 assert(name || path);
2078 if (!(name = resolve_template(u, name, path, &s)))
2081 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2084 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2090 int set_unit_path(const char *p) {
2091 _cleanup_free_ char *c = NULL;
2093 /* This is mostly for debug purposes */
2094 c = path_make_absolute_cwd(p);
2095 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2101 char *unit_dbus_path(Unit *u) {
2107 return unit_dbus_path_from_name(u->id);
2110 char *unit_default_cgroup_path(Unit *u) {
2111 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2116 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2117 return strdup(u->manager->cgroup_root);
2119 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2120 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2125 escaped = cg_escape(u->id);
2130 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2132 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2135 int unit_add_default_slice(Unit *u) {
2136 _cleanup_free_ char *b = NULL;
2137 const char *slice_name;
2143 if (UNIT_ISSET(u->slice))
2146 if (!unit_get_cgroup_context(u))
2150 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2152 /* Implicitly place all instantiated units in their
2153 * own per-template slice */
2155 prefix = unit_name_to_prefix(u->id);
2159 /* The prefix is already escaped, but it might include
2160 * "-" which has a special meaning for slice units,
2161 * hence escape it here extra. */
2162 escaped = strreplace(prefix, "-", "\\x2d");
2166 if (u->manager->running_as == SYSTEMD_SYSTEM)
2167 b = strjoin("system-", escaped, ".slice", NULL);
2169 b = strappend(escaped, ".slice");
2176 u->manager->running_as == SYSTEMD_SYSTEM
2177 ? SPECIAL_SYSTEM_SLICE
2178 : SPECIAL_ROOT_SLICE;
2180 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2184 unit_ref_set(&u->slice, slice);
2188 const char *unit_slice_name(Unit *u) {
2191 if (!UNIT_ISSET(u->slice))
2194 return UNIT_DEREF(u->slice)->id;
2197 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2198 _cleanup_free_ char *t = NULL;
2205 t = unit_name_change_suffix(u->id, type);
2209 assert(!unit_has_name(u, t));
2211 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2212 assert(r < 0 || *_found != u);
2216 int unit_watch_bus_name(Unit *u, const char *name) {
2220 /* Watch a specific name on the bus. We only support one unit
2221 * watching each name for now. */
2223 return hashmap_put(u->manager->watch_bus, name, u);
2226 void unit_unwatch_bus_name(Unit *u, const char *name) {
2230 hashmap_remove_value(u->manager->watch_bus, name, u);
2233 bool unit_can_serialize(Unit *u) {
2236 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2239 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2247 if (!unit_can_serialize(u))
2250 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2254 rt = unit_get_exec_runtime(u);
2256 r = exec_runtime_serialize(rt, u, f, fds);
2261 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2262 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2263 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2264 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2265 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2267 if (dual_timestamp_is_set(&u->condition_timestamp))
2268 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2270 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2273 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2275 if (serialize_jobs) {
2277 fprintf(f, "job\n");
2278 job_serialize(u->job, f, fds);
2282 fprintf(f, "job\n");
2283 job_serialize(u->nop_job, f, fds);
2292 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2303 va_start(ap, format);
2304 vfprintf(f, format, ap);
2310 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2316 fprintf(f, "%s=%s\n", key, value);
2319 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2321 ExecRuntime **rt = NULL;
2328 if (!unit_can_serialize(u))
2331 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2333 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2336 char line[LINE_MAX], *l, *v;
2339 if (!fgets(line, sizeof(line), f)) {
2352 k = strcspn(l, "=");
2360 if (streq(l, "job")) {
2362 /* new-style serialized job */
2363 Job *j = job_new_raw(u);
2367 r = job_deserialize(j, f, fds);
2373 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2379 r = job_install_deserialized(j);
2381 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2386 if (j->state == JOB_RUNNING)
2387 u->manager->n_running_jobs++;
2390 JobType type = job_type_from_string(v);
2392 log_debug("Failed to parse job type value %s", v);
2394 u->deserialized_job = type;
2397 } else if (streq(l, "inactive-exit-timestamp")) {
2398 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2400 } else if (streq(l, "active-enter-timestamp")) {
2401 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2403 } else if (streq(l, "active-exit-timestamp")) {
2404 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2406 } else if (streq(l, "inactive-enter-timestamp")) {
2407 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2409 } else if (streq(l, "condition-timestamp")) {
2410 dual_timestamp_deserialize(v, &u->condition_timestamp);
2412 } else if (streq(l, "condition-result")) {
2415 b = parse_boolean(v);
2417 log_debug("Failed to parse condition result value %s", v);
2419 u->condition_result = b;
2423 } else if (streq(l, "transient")) {
2426 b = parse_boolean(v);
2428 log_debug("Failed to parse transient bool %s", v);
2433 } else if (streq(l, "cgroup")) {
2440 free(u->cgroup_path);
2443 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2448 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2455 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2461 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2463 _cleanup_free_ char *e = NULL;
2471 /* Adds in links to the device node that this unit is based on */
2473 if (!is_device_path(what))
2476 e = unit_name_from_path(what, ".device");
2480 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2485 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2490 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2498 int unit_coldplug(Unit *u) {
2503 if (UNIT_VTABLE(u)->coldplug)
2504 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2508 r = job_coldplug(u->job);
2511 } else if (u->deserialized_job >= 0) {
2513 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2517 u->deserialized_job = _JOB_TYPE_INVALID;
2523 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2524 DISABLE_WARNING_FORMAT_NONLITERAL;
2525 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2529 bool unit_need_daemon_reload(Unit *u) {
2530 _cleanup_strv_free_ char **t = NULL;
2533 unsigned loaded_cnt, current_cnt;
2537 if (u->fragment_path) {
2539 if (stat(u->fragment_path, &st) < 0)
2540 /* What, cannot access this anymore? */
2543 if (u->fragment_mtime > 0 &&
2544 timespec_load(&st.st_mtim) != u->fragment_mtime)
2548 if (u->source_path) {
2550 if (stat(u->source_path, &st) < 0)
2553 if (u->source_mtime > 0 &&
2554 timespec_load(&st.st_mtim) != u->source_mtime)
2558 t = unit_find_dropin_paths(u);
2559 loaded_cnt = strv_length(t);
2560 current_cnt = strv_length(u->dropin_paths);
2562 if (loaded_cnt == current_cnt) {
2563 if (loaded_cnt == 0)
2566 if (strv_overlap(u->dropin_paths, t)) {
2567 STRV_FOREACH(path, u->dropin_paths) {
2569 if (stat(*path, &st) < 0)
2572 if (u->dropin_mtime > 0 &&
2573 timespec_load(&st.st_mtim) > u->dropin_mtime)
2584 void unit_reset_failed(Unit *u) {
2587 if (UNIT_VTABLE(u)->reset_failed)
2588 UNIT_VTABLE(u)->reset_failed(u);
2591 Unit *unit_following(Unit *u) {
2594 if (UNIT_VTABLE(u)->following)
2595 return UNIT_VTABLE(u)->following(u);
2600 bool unit_stop_pending(Unit *u) {
2603 /* This call does check the current state of the unit. It's
2604 * hence useful to be called from state change calls of the
2605 * unit itself, where the state isn't updated yet. This is
2606 * different from unit_inactive_or_pending() which checks both
2607 * the current state and for a queued job. */
2609 return u->job && u->job->type == JOB_STOP;
2612 bool unit_inactive_or_pending(Unit *u) {
2615 /* Returns true if the unit is inactive or going down */
2617 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2620 if (unit_stop_pending(u))
2626 bool unit_active_or_pending(Unit *u) {
2629 /* Returns true if the unit is active or going up */
2631 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2635 (u->job->type == JOB_START ||
2636 u->job->type == JOB_RELOAD_OR_START ||
2637 u->job->type == JOB_RESTART))
2643 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2645 assert(w >= 0 && w < _KILL_WHO_MAX);
2647 assert(signo < _NSIG);
2649 if (!UNIT_VTABLE(u)->kill)
2652 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2655 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2659 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2663 /* Exclude the main/control pids from being killed via the cgroup */
2665 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2670 if (control_pid > 0) {
2671 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2683 int unit_kill_common(
2689 sd_bus_error *error) {
2693 if (who == KILL_MAIN && main_pid <= 0) {
2695 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2697 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2701 if (who == KILL_CONTROL && control_pid <= 0) {
2702 if (control_pid < 0)
2703 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2705 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2709 if (who == KILL_CONTROL || who == KILL_ALL)
2710 if (control_pid > 0)
2711 if (kill(control_pid, signo) < 0)
2714 if (who == KILL_MAIN || who == KILL_ALL)
2716 if (kill(main_pid, signo) < 0)
2719 if (who == KILL_ALL && u->cgroup_path) {
2720 _cleanup_set_free_ Set *pid_set = NULL;
2723 /* Exclude the main/control pids from being killed via the cgroup */
2724 pid_set = unit_pid_set(main_pid, control_pid);
2728 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2729 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2736 int unit_following_set(Unit *u, Set **s) {
2740 if (UNIT_VTABLE(u)->following_set)
2741 return UNIT_VTABLE(u)->following_set(u, s);
2747 UnitFileState unit_get_unit_file_state(Unit *u) {
2750 if (u->unit_file_state < 0 && u->fragment_path)
2751 u->unit_file_state = unit_file_get_state(
2752 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2753 NULL, basename(u->fragment_path));
2755 return u->unit_file_state;
2758 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2763 unit_ref_unset(ref);
2766 LIST_PREPEND(refs, u->refs, ref);
2770 void unit_ref_unset(UnitRef *ref) {
2776 LIST_REMOVE(refs, ref->unit->refs, ref);
2780 int unit_cgroup_context_init_defaults(Unit *u, CGroupContext *c) {
2784 /* Copy in the manager defaults into the cgroup context,
2785 * _before_ the rest of the settings have been initialized */
2787 c->cpu_accounting = u->manager->default_cpu_accounting;
2788 c->blockio_accounting = u->manager->default_blockio_accounting;
2789 c->memory_accounting = u->manager->default_memory_accounting;
2794 int unit_exec_context_patch_defaults(Unit *u, ExecContext *c) {
2801 /* Patch in the manager defaults into the exec context,
2802 * _after_ the rest of the settings have been initialized */
2804 /* This only copies in the ones that need memory */
2805 for (i = 0; i < RLIMIT_NLIMITS; i++)
2806 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2807 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2812 if (u->manager->running_as == SYSTEMD_USER &&
2813 !c->working_directory) {
2815 r = get_home_dir(&c->working_directory);
2820 if (u->manager->running_as == SYSTEMD_USER &&
2821 (c->syscall_whitelist ||
2822 !set_isempty(c->syscall_filter) ||
2823 !set_isempty(c->syscall_archs) ||
2824 c->address_families_whitelist ||
2825 !set_isempty(c->address_families)))
2826 c->no_new_privileges = true;
2831 ExecContext *unit_get_exec_context(Unit *u) {
2835 offset = UNIT_VTABLE(u)->exec_context_offset;
2839 return (ExecContext*) ((uint8_t*) u + offset);
2842 KillContext *unit_get_kill_context(Unit *u) {
2846 offset = UNIT_VTABLE(u)->kill_context_offset;
2850 return (KillContext*) ((uint8_t*) u + offset);
2853 CGroupContext *unit_get_cgroup_context(Unit *u) {
2856 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2860 return (CGroupContext*) ((uint8_t*) u + offset);
2863 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2866 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2870 return *(ExecRuntime**) ((uint8_t*) u + offset);
2873 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2874 _cleanup_free_ char *b = NULL;
2883 b = xescape(name, "/.");
2887 if (!filename_is_safe(b))
2890 if (u->manager->running_as == SYSTEMD_USER) {
2891 _cleanup_free_ char *c = NULL;
2893 r = user_config_home(&c);
2899 p = strjoin(c, "/", u->id, ".d", NULL);
2900 } else if (mode == UNIT_PERSISTENT && !u->transient)
2901 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2903 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2907 q = strjoin(p, "/90-", b, ".conf", NULL);
2918 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2919 _cleanup_free_ char *p = NULL, *q = NULL;
2926 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2929 r = drop_in_file(u, mode, name, &p, &q);
2934 return write_string_file_atomic_label(q, data);
2937 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2938 _cleanup_free_ char *p = NULL;
2946 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2949 va_start(ap, format);
2950 r = vasprintf(&p, format, ap);
2956 return unit_write_drop_in(u, mode, name, p);
2959 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2960 _cleanup_free_ char *ndata = NULL;
2966 if (!UNIT_VTABLE(u)->private_section)
2969 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2972 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2976 return unit_write_drop_in(u, mode, name, ndata);
2979 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2980 _cleanup_free_ char *p = NULL;
2988 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2991 va_start(ap, format);
2992 r = vasprintf(&p, format, ap);
2998 return unit_write_drop_in_private(u, mode, name, p);
3001 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3002 _cleanup_free_ char *p = NULL, *q = NULL;
3007 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3010 r = drop_in_file(u, mode, name, &p, &q);
3015 r = errno == ENOENT ? 0 : -errno;
3023 int unit_make_transient(Unit *u) {
3028 u->load_state = UNIT_STUB;
3030 u->transient = true;
3032 free(u->fragment_path);
3033 u->fragment_path = NULL;
3035 if (u->manager->running_as == SYSTEMD_USER) {
3036 _cleanup_free_ char *c = NULL;
3038 r = user_config_home(&c);
3044 u->fragment_path = strjoin(c, "/", u->id, NULL);
3045 if (!u->fragment_path)
3050 u->fragment_path = strappend("/run/systemd/system/", u->id);
3051 if (!u->fragment_path)
3054 mkdir_p("/run/systemd/system", 0755);
3057 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3060 int unit_kill_context(
3066 bool main_pid_alien) {
3068 int sig, wait_for_exit = false, r;
3073 if (c->kill_mode == KILL_NONE)
3076 sig = sigkill ? SIGKILL : c->kill_signal;
3079 r = kill_and_sigcont(main_pid, sig);
3081 if (r < 0 && r != -ESRCH) {
3082 _cleanup_free_ char *comm = NULL;
3083 get_process_comm(main_pid, &comm);
3085 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3087 if (!main_pid_alien)
3088 wait_for_exit = true;
3090 if (c->send_sighup && !sigkill)
3091 kill(main_pid, SIGHUP);
3095 if (control_pid > 0) {
3096 r = kill_and_sigcont(control_pid, sig);
3098 if (r < 0 && r != -ESRCH) {
3099 _cleanup_free_ char *comm = NULL;
3100 get_process_comm(control_pid, &comm);
3102 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3104 wait_for_exit = true;
3106 if (c->send_sighup && !sigkill)
3107 kill(control_pid, SIGHUP);
3111 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3112 _cleanup_set_free_ Set *pid_set = NULL;
3114 /* Exclude the main/control pids from being killed via the cgroup */
3115 pid_set = unit_pid_set(main_pid, control_pid);
3119 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3121 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3122 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3125 /* FIXME: For now, we will not wait for the
3126 * cgroup members to die, simply because
3127 * cgroup notification is unreliable. It
3128 * doesn't work at all in containers, and
3129 * outside of containers it can be confused
3130 * easily by leaving directories in the
3133 /* wait_for_exit = true; */
3135 if (c->send_sighup && !sigkill) {
3138 pid_set = unit_pid_set(main_pid, control_pid);
3142 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3147 return wait_for_exit;
3150 int unit_require_mounts_for(Unit *u, const char *path) {
3151 char prefix[strlen(path) + 1], *p;
3157 /* Registers a unit for requiring a certain path and all its
3158 * prefixes. We keep a simple array of these paths in the
3159 * unit, since its usually short. However, we build a prefix
3160 * table for all possible prefixes so that new appearing mount
3161 * units can easily determine which units to make themselves a
3164 if (!path_is_absolute(path))
3171 path_kill_slashes(p);
3173 if (!path_is_safe(p)) {
3178 if (strv_contains(u->requires_mounts_for, p)) {
3183 r = strv_push(&u->requires_mounts_for, p);
3189 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3192 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3196 if (!u->manager->units_requiring_mounts_for) {
3197 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3198 if (!u->manager->units_requiring_mounts_for)
3206 x = set_new(NULL, NULL);
3212 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3228 int unit_setup_exec_runtime(Unit *u) {
3234 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3237 /* Check if ther already is an ExecRuntime for this unit? */
3238 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3242 /* Try to get it from somebody else */
3243 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3245 *rt = unit_get_exec_runtime(other);
3247 exec_runtime_ref(*rt);
3252 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3255 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3256 [UNIT_ACTIVE] = "active",
3257 [UNIT_RELOADING] = "reloading",
3258 [UNIT_INACTIVE] = "inactive",
3259 [UNIT_FAILED] = "failed",
3260 [UNIT_ACTIVATING] = "activating",
3261 [UNIT_DEACTIVATING] = "deactivating"
3264 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3266 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3267 [UNIT_REQUIRES] = "Requires",
3268 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3269 [UNIT_REQUISITE] = "Requisite",
3270 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3271 [UNIT_WANTS] = "Wants",
3272 [UNIT_BINDS_TO] = "BindsTo",
3273 [UNIT_PART_OF] = "PartOf",
3274 [UNIT_REQUIRED_BY] = "RequiredBy",
3275 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3276 [UNIT_WANTED_BY] = "WantedBy",
3277 [UNIT_BOUND_BY] = "BoundBy",
3278 [UNIT_CONSISTS_OF] = "ConsistsOf",
3279 [UNIT_CONFLICTS] = "Conflicts",
3280 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3281 [UNIT_BEFORE] = "Before",
3282 [UNIT_AFTER] = "After",
3283 [UNIT_ON_FAILURE] = "OnFailure",
3284 [UNIT_TRIGGERS] = "Triggers",
3285 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3286 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3287 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3288 [UNIT_REFERENCES] = "References",
3289 [UNIT_REFERENCED_BY] = "ReferencedBy",
3290 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3293 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);