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/>.
29 #include "sd-messages.h"
34 #include "path-util.h"
35 #include "load-fragment.h"
36 #include "load-dropin.h"
38 #include "unit-name.h"
39 #include "dbus-unit.h"
41 #include "cgroup-util.h"
44 #include "fileio-label.h"
45 #include "bus-common-errors.h"
50 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
51 [UNIT_SERVICE] = &service_vtable,
52 [UNIT_SOCKET] = &socket_vtable,
53 [UNIT_BUSNAME] = &busname_vtable,
54 [UNIT_TARGET] = &target_vtable,
55 [UNIT_SNAPSHOT] = &snapshot_vtable,
56 [UNIT_DEVICE] = &device_vtable,
57 [UNIT_MOUNT] = &mount_vtable,
58 [UNIT_AUTOMOUNT] = &automount_vtable,
59 [UNIT_SWAP] = &swap_vtable,
60 [UNIT_TIMER] = &timer_vtable,
61 [UNIT_PATH] = &path_vtable,
62 [UNIT_SLICE] = &slice_vtable,
63 [UNIT_SCOPE] = &scope_vtable
66 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency);
68 Unit *unit_new(Manager *m, size_t size) {
72 assert(size >= sizeof(Unit));
78 u->names = set_new(&string_hash_ops);
85 u->type = _UNIT_TYPE_INVALID;
86 u->deserialized_job = _JOB_TYPE_INVALID;
87 u->default_dependencies = true;
88 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
89 u->unit_file_preset = -1;
90 u->on_failure_job_mode = JOB_REPLACE;
95 bool unit_has_name(Unit *u, const char *name) {
99 return !!set_get(u->names, (char*) name);
102 static void unit_init(Unit *u) {
109 assert(u->type >= 0);
111 cc = unit_get_cgroup_context(u);
113 cgroup_context_init(cc);
115 /* Copy in the manager defaults into the cgroup
116 * context, _before_ the rest of the settings have
117 * been initialized */
119 cc->cpu_accounting = u->manager->default_cpu_accounting;
120 cc->blockio_accounting = u->manager->default_blockio_accounting;
121 cc->memory_accounting = u->manager->default_memory_accounting;
124 ec = unit_get_exec_context(u);
126 exec_context_init(ec);
128 kc = unit_get_kill_context(u);
130 kill_context_init(kc);
132 if (UNIT_VTABLE(u)->init)
133 UNIT_VTABLE(u)->init(u);
136 int unit_add_name(Unit *u, const char *text) {
137 _cleanup_free_ char *s = NULL, *i = NULL;
144 if (unit_name_is_template(text)) {
149 s = unit_name_replace_instance(text, u->instance);
155 if (!unit_name_is_valid(s, TEMPLATE_INVALID))
158 assert_se((t = unit_name_to_type(s)) >= 0);
160 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
163 r = unit_name_to_instance(s, &i);
167 if (i && unit_vtable[t]->no_instances)
170 /* Ensure that this unit is either instanced or not instanced,
172 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
175 if (unit_vtable[t]->no_alias &&
176 !set_isempty(u->names) &&
177 !set_get(u->names, s))
180 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
183 r = set_put(u->names, s);
191 r = hashmap_put(u->manager->units, s, u);
193 set_remove(u->names, s);
197 if (u->type == _UNIT_TYPE_INVALID) {
202 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
211 unit_add_to_dbus_queue(u);
215 int unit_choose_id(Unit *u, const char *name) {
216 _cleanup_free_ char *t = NULL;
223 if (unit_name_is_template(name)) {
228 t = unit_name_replace_instance(name, u->instance);
235 /* Selects one of the names of this unit as the id */
236 s = set_get(u->names, (char*) name);
240 r = unit_name_to_instance(s, &i);
249 unit_add_to_dbus_queue(u);
254 int unit_set_description(Unit *u, const char *description) {
259 if (isempty(description))
262 s = strdup(description);
267 free(u->description);
270 unit_add_to_dbus_queue(u);
274 bool unit_check_gc(Unit *u) {
275 UnitActiveState state;
284 state = unit_active_state(u);
286 /* If the unit is inactive and failed and no job is queued for
287 * it, then release its runtime resources */
288 if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
289 UNIT_VTABLE(u)->release_resources)
290 UNIT_VTABLE(u)->release_resources(u);
292 /* But we keep the unit object around for longer when it is
293 * referenced or configured to not be gc'ed */
294 if (state != UNIT_INACTIVE)
297 if (UNIT_VTABLE(u)->no_gc)
306 if (UNIT_VTABLE(u)->check_gc)
307 if (UNIT_VTABLE(u)->check_gc(u))
313 void unit_add_to_load_queue(Unit *u) {
315 assert(u->type != _UNIT_TYPE_INVALID);
317 if (u->load_state != UNIT_STUB || u->in_load_queue)
320 LIST_PREPEND(load_queue, u->manager->load_queue, u);
321 u->in_load_queue = true;
324 void unit_add_to_cleanup_queue(Unit *u) {
327 if (u->in_cleanup_queue)
330 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
331 u->in_cleanup_queue = true;
334 void unit_add_to_gc_queue(Unit *u) {
337 if (u->in_gc_queue || u->in_cleanup_queue)
340 if (unit_check_gc(u))
343 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
344 u->in_gc_queue = true;
346 u->manager->n_in_gc_queue ++;
349 void unit_add_to_dbus_queue(Unit *u) {
351 assert(u->type != _UNIT_TYPE_INVALID);
353 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
356 /* Shortcut things if nobody cares */
357 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
358 set_isempty(u->manager->private_buses)) {
359 u->sent_dbus_new_signal = true;
363 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
364 u->in_dbus_queue = true;
367 static void bidi_set_free(Unit *u, Set *s) {
373 /* Frees the set and makes sure we are dropped from the
374 * inverse pointers */
376 SET_FOREACH(other, s, i) {
379 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
380 set_remove(other->dependencies[d], u);
382 unit_add_to_gc_queue(other);
388 static void unit_remove_transient(Unit *u) {
396 if (u->fragment_path)
397 unlink(u->fragment_path);
399 STRV_FOREACH(i, u->dropin_paths) {
400 _cleanup_free_ char *p = NULL;
405 r = path_get_parent(*i, &p);
411 static void unit_free_requires_mounts_for(Unit *u) {
414 STRV_FOREACH(j, u->requires_mounts_for) {
415 char s[strlen(*j) + 1];
417 PATH_FOREACH_PREFIX_MORE(s, *j) {
421 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
427 if (set_isempty(x)) {
428 hashmap_remove(u->manager->units_requiring_mounts_for, y);
435 strv_free(u->requires_mounts_for);
436 u->requires_mounts_for = NULL;
439 static void unit_done(Unit *u) {
448 if (UNIT_VTABLE(u)->done)
449 UNIT_VTABLE(u)->done(u);
451 ec = unit_get_exec_context(u);
453 exec_context_done(ec);
455 cc = unit_get_cgroup_context(u);
457 cgroup_context_done(cc);
460 void unit_free(Unit *u) {
467 if (u->manager->n_reloading <= 0)
468 unit_remove_transient(u);
470 bus_unit_send_removed_signal(u);
474 unit_free_requires_mounts_for(u);
476 SET_FOREACH(t, u->names, i)
477 hashmap_remove_value(u->manager->units, t, u);
491 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
492 bidi_set_free(u, u->dependencies[d]);
494 if (u->type != _UNIT_TYPE_INVALID)
495 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
497 if (u->in_load_queue)
498 LIST_REMOVE(load_queue, u->manager->load_queue, u);
500 if (u->in_dbus_queue)
501 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
503 if (u->in_cleanup_queue)
504 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
506 if (u->in_gc_queue) {
507 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
508 u->manager->n_in_gc_queue--;
511 if (u->in_cgroup_queue)
512 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
514 if (u->cgroup_path) {
515 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
516 free(u->cgroup_path);
519 manager_update_failed_units(u->manager, u, false);
520 set_remove(u->manager->startup_units, u);
522 free(u->description);
523 strv_free(u->documentation);
524 free(u->fragment_path);
525 free(u->source_path);
526 strv_free(u->dropin_paths);
529 free(u->job_timeout_reboot_arg);
531 set_free_free(u->names);
533 unit_unwatch_all_pids(u);
535 condition_free_list(u->conditions);
536 condition_free_list(u->asserts);
538 unit_ref_unset(&u->slice);
541 unit_ref_unset(u->refs);
546 UnitActiveState unit_active_state(Unit *u) {
549 if (u->load_state == UNIT_MERGED)
550 return unit_active_state(unit_follow_merge(u));
552 /* After a reload it might happen that a unit is not correctly
553 * loaded but still has a process around. That's why we won't
554 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
556 return UNIT_VTABLE(u)->active_state(u);
559 const char* unit_sub_state_to_string(Unit *u) {
562 return UNIT_VTABLE(u)->sub_state_to_string(u);
565 static int complete_move(Set **s, Set **other) {
575 r = set_move(*s, *other);
586 static int merge_names(Unit *u, Unit *other) {
594 r = complete_move(&u->names, &other->names);
598 set_free_free(other->names);
602 SET_FOREACH(t, u->names, i)
603 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
608 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
613 assert(d < _UNIT_DEPENDENCY_MAX);
616 * If u does not have this dependency set allocated, there is no need
617 * to reserve anything. In that case other's set will be transferred
618 * as a whole to u by complete_move().
620 if (!u->dependencies[d])
623 /* merge_dependencies() will skip a u-on-u dependency */
624 n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
626 return set_reserve(u->dependencies[d], n_reserve);
629 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
636 assert(d < _UNIT_DEPENDENCY_MAX);
638 /* Fix backwards pointers */
639 SET_FOREACH(back, other->dependencies[d], i) {
642 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
643 /* Do not add dependencies between u and itself */
645 if (set_remove(back->dependencies[k], other))
646 maybe_warn_about_dependency(u->id, other_id, k);
648 r = set_remove_and_put(back->dependencies[k], other, u);
650 set_remove(back->dependencies[k], other);
652 assert(r >= 0 || r == -ENOENT);
657 /* Also do not move dependencies on u to itself */
658 back = set_remove(other->dependencies[d], u);
660 maybe_warn_about_dependency(u->id, other_id, d);
662 /* The move cannot fail. The caller must have performed a reservation. */
663 assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
665 set_free(other->dependencies[d]);
666 other->dependencies[d] = NULL;
669 int unit_merge(Unit *u, Unit *other) {
671 const char *other_id = NULL;
676 assert(u->manager == other->manager);
677 assert(u->type != _UNIT_TYPE_INVALID);
679 other = unit_follow_merge(other);
684 if (u->type != other->type)
687 if (!u->instance != !other->instance)
690 if (other->load_state != UNIT_STUB &&
691 other->load_state != UNIT_NOT_FOUND)
700 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
704 other_id = strdupa(other->id);
706 /* Make reservations to ensure merge_dependencies() won't fail */
707 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
708 r = reserve_dependencies(u, other, d);
710 * We don't rollback reservations if we fail. We don't have
711 * a way to undo reservations. A reservation is not a leak.
718 r = merge_names(u, other);
722 /* Redirect all references */
724 unit_ref_set(other->refs, u);
726 /* Merge dependencies */
727 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
728 merge_dependencies(u, other, other_id, d);
730 other->load_state = UNIT_MERGED;
731 other->merged_into = u;
733 /* If there is still some data attached to the other node, we
734 * don't need it anymore, and can free it. */
735 if (other->load_state != UNIT_STUB)
736 if (UNIT_VTABLE(other)->done)
737 UNIT_VTABLE(other)->done(other);
739 unit_add_to_dbus_queue(u);
740 unit_add_to_cleanup_queue(other);
745 int unit_merge_by_name(Unit *u, const char *name) {
748 _cleanup_free_ char *s = NULL;
753 if (unit_name_is_template(name)) {
757 s = unit_name_replace_instance(name, u->instance);
764 other = manager_get_unit(u->manager, name);
766 r = unit_add_name(u, name);
768 r = unit_merge(u, other);
773 Unit* unit_follow_merge(Unit *u) {
776 while (u->load_state == UNIT_MERGED)
777 assert_se(u = u->merged_into);
782 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
788 if (c->working_directory) {
789 r = unit_require_mounts_for(u, c->working_directory);
794 if (c->root_directory) {
795 r = unit_require_mounts_for(u, c->root_directory);
800 if (u->manager->running_as != SYSTEMD_SYSTEM)
803 if (c->private_tmp) {
804 r = unit_require_mounts_for(u, "/tmp");
808 r = unit_require_mounts_for(u, "/var/tmp");
813 if (c->std_output != EXEC_OUTPUT_KMSG &&
814 c->std_output != EXEC_OUTPUT_SYSLOG &&
815 c->std_output != EXEC_OUTPUT_JOURNAL &&
816 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
817 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
818 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
819 c->std_error != EXEC_OUTPUT_KMSG &&
820 c->std_error != EXEC_OUTPUT_SYSLOG &&
821 c->std_error != EXEC_OUTPUT_JOURNAL &&
822 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
823 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
824 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
827 /* If syslog or kernel logging is requested, make sure our own
828 * logging daemon is run first. */
830 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
837 const char *unit_description(Unit *u) {
841 return u->description;
846 void unit_dump(Unit *u, FILE *f, const char *prefix) {
852 timestamp1[FORMAT_TIMESTAMP_MAX],
853 timestamp2[FORMAT_TIMESTAMP_MAX],
854 timestamp3[FORMAT_TIMESTAMP_MAX],
855 timestamp4[FORMAT_TIMESTAMP_MAX],
856 timespan[FORMAT_TIMESPAN_MAX];
858 _cleanup_set_free_ Set *following_set = NULL;
862 assert(u->type >= 0);
864 prefix = strempty(prefix);
865 prefix2 = strjoina(prefix, "\t");
869 "%s\tDescription: %s\n"
871 "%s\tUnit Load State: %s\n"
872 "%s\tUnit Active State: %s\n"
873 "%s\tInactive Exit Timestamp: %s\n"
874 "%s\tActive Enter Timestamp: %s\n"
875 "%s\tActive Exit Timestamp: %s\n"
876 "%s\tInactive Enter Timestamp: %s\n"
877 "%s\tGC Check Good: %s\n"
878 "%s\tNeed Daemon Reload: %s\n"
879 "%s\tTransient: %s\n"
882 "%s\tCGroup realized: %s\n"
883 "%s\tCGroup mask: 0x%x\n"
884 "%s\tCGroup members mask: 0x%x\n",
886 prefix, unit_description(u),
887 prefix, strna(u->instance),
888 prefix, unit_load_state_to_string(u->load_state),
889 prefix, unit_active_state_to_string(unit_active_state(u)),
890 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
891 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
892 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
893 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
894 prefix, yes_no(unit_check_gc(u)),
895 prefix, yes_no(unit_need_daemon_reload(u)),
896 prefix, yes_no(u->transient),
897 prefix, strna(unit_slice_name(u)),
898 prefix, strna(u->cgroup_path),
899 prefix, yes_no(u->cgroup_realized),
900 prefix, u->cgroup_realized_mask,
901 prefix, u->cgroup_members_mask);
903 SET_FOREACH(t, u->names, i)
904 fprintf(f, "%s\tName: %s\n", prefix, t);
906 STRV_FOREACH(j, u->documentation)
907 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
909 following = unit_following(u);
911 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
913 r = unit_following_set(u, &following_set);
917 SET_FOREACH(other, following_set, i)
918 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
921 if (u->fragment_path)
922 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
925 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
927 STRV_FOREACH(j, u->dropin_paths)
928 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
930 if (u->job_timeout > 0)
931 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
933 if (u->job_timeout_action != FAILURE_ACTION_NONE)
934 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
936 if (u->job_timeout_reboot_arg)
937 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
939 condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
940 condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
942 if (dual_timestamp_is_set(&u->condition_timestamp))
944 "%s\tCondition Timestamp: %s\n"
945 "%s\tCondition Result: %s\n",
946 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
947 prefix, yes_no(u->condition_result));
949 if (dual_timestamp_is_set(&u->assert_timestamp))
951 "%s\tAssert Timestamp: %s\n"
952 "%s\tAssert Result: %s\n",
953 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),
954 prefix, yes_no(u->assert_result));
956 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
959 SET_FOREACH(other, u->dependencies[d], i)
960 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
963 if (!strv_isempty(u->requires_mounts_for)) {
965 "%s\tRequiresMountsFor:", prefix);
967 STRV_FOREACH(j, u->requires_mounts_for)
968 fprintf(f, " %s", *j);
973 if (u->load_state == UNIT_LOADED) {
976 "%s\tStopWhenUnneeded: %s\n"
977 "%s\tRefuseManualStart: %s\n"
978 "%s\tRefuseManualStop: %s\n"
979 "%s\tDefaultDependencies: %s\n"
980 "%s\tOnFailureJobMode: %s\n"
981 "%s\tIgnoreOnIsolate: %s\n"
982 "%s\tIgnoreOnSnapshot: %s\n",
983 prefix, yes_no(u->stop_when_unneeded),
984 prefix, yes_no(u->refuse_manual_start),
985 prefix, yes_no(u->refuse_manual_stop),
986 prefix, yes_no(u->default_dependencies),
987 prefix, job_mode_to_string(u->on_failure_job_mode),
988 prefix, yes_no(u->ignore_on_isolate),
989 prefix, yes_no(u->ignore_on_snapshot));
991 if (UNIT_VTABLE(u)->dump)
992 UNIT_VTABLE(u)->dump(u, f, prefix2);
994 } else if (u->load_state == UNIT_MERGED)
996 "%s\tMerged into: %s\n",
997 prefix, u->merged_into->id);
998 else if (u->load_state == UNIT_ERROR)
999 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
1003 job_dump(u->job, f, prefix2);
1006 job_dump(u->nop_job, f, prefix2);
1010 /* Common implementation for multiple backends */
1011 int unit_load_fragment_and_dropin(Unit *u) {
1016 /* Load a .{service,socket,...} file */
1017 r = unit_load_fragment(u);
1021 if (u->load_state == UNIT_STUB)
1024 /* Load drop-in directory data */
1025 r = unit_load_dropin(unit_follow_merge(u));
1032 /* Common implementation for multiple backends */
1033 int unit_load_fragment_and_dropin_optional(Unit *u) {
1038 /* Same as unit_load_fragment_and_dropin(), but whether
1039 * something can be loaded or not doesn't matter. */
1041 /* Load a .service file */
1042 r = unit_load_fragment(u);
1046 if (u->load_state == UNIT_STUB)
1047 u->load_state = UNIT_LOADED;
1049 /* Load drop-in directory data */
1050 r = unit_load_dropin(unit_follow_merge(u));
1057 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1061 if (target->type != UNIT_TARGET)
1064 /* Only add the dependency if both units are loaded, so that
1065 * that loop check below is reliable */
1066 if (u->load_state != UNIT_LOADED ||
1067 target->load_state != UNIT_LOADED)
1070 /* If either side wants no automatic dependencies, then let's
1072 if (!u->default_dependencies ||
1073 !target->default_dependencies)
1076 /* Don't create loops */
1077 if (set_get(target->dependencies[UNIT_BEFORE], u))
1080 return unit_add_dependency(target, UNIT_AFTER, u, true);
1083 static int unit_add_target_dependencies(Unit *u) {
1085 static const UnitDependency deps[] = {
1087 UNIT_REQUIRED_BY_OVERRIDABLE,
1099 for (k = 0; k < ELEMENTSOF(deps); k++)
1100 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1101 r = unit_add_default_target_dependency(u, target);
1109 static int unit_add_slice_dependencies(Unit *u) {
1112 if (!unit_get_cgroup_context(u))
1115 if (UNIT_ISSET(u->slice))
1116 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1118 if (streq(u->id, SPECIAL_ROOT_SLICE))
1121 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1124 static int unit_add_mount_dependencies(Unit *u) {
1130 STRV_FOREACH(i, u->requires_mounts_for) {
1131 char prefix[strlen(*i) + 1];
1133 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1136 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1144 if (m->load_state != UNIT_LOADED)
1147 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1151 if (m->fragment_path) {
1152 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1162 static int unit_add_startup_units(Unit *u) {
1166 c = unit_get_cgroup_context(u);
1170 if (c->startup_cpu_shares == (unsigned long) -1 &&
1171 c->startup_blockio_weight == (unsigned long) -1)
1174 r = set_put(u->manager->startup_units, u);
1181 int unit_load(Unit *u) {
1186 if (u->in_load_queue) {
1187 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1188 u->in_load_queue = false;
1191 if (u->type == _UNIT_TYPE_INVALID)
1194 if (u->load_state != UNIT_STUB)
1197 if (UNIT_VTABLE(u)->load) {
1198 r = UNIT_VTABLE(u)->load(u);
1203 if (u->load_state == UNIT_STUB) {
1208 if (u->load_state == UNIT_LOADED) {
1210 r = unit_add_target_dependencies(u);
1214 r = unit_add_slice_dependencies(u);
1218 r = unit_add_mount_dependencies(u);
1222 r = unit_add_startup_units(u);
1226 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1227 log_unit_error(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1232 unit_update_cgroup_members_masks(u);
1235 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1237 unit_add_to_dbus_queue(unit_follow_merge(u));
1238 unit_add_to_gc_queue(u);
1243 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1245 unit_add_to_dbus_queue(u);
1246 unit_add_to_gc_queue(u);
1248 log_unit_debug(u->id, "Failed to load configuration for %s: %s",
1249 u->id, strerror(-r));
1254 static bool unit_condition_test_list(Unit *u, Condition *first, const char *(*to_string)(ConditionType t)) {
1261 /* If the condition list is empty, then it is true */
1265 /* Otherwise, if all of the non-trigger conditions apply and
1266 * if any of the trigger conditions apply (unless there are
1267 * none) we return true */
1268 LIST_FOREACH(conditions, c, first) {
1271 r = condition_test(c);
1273 log_unit_warning(u->id,
1274 "Couldn't determine result for %s=%s%s%s for %s, assuming failed: %s",
1276 c->trigger ? "|" : "",
1277 c->negate ? "!" : "",
1282 log_unit_debug(u->id,
1283 "%s=%s%s%s %s for %s.",
1285 c->trigger ? "|" : "",
1286 c->negate ? "!" : "",
1288 condition_result_to_string(c->result),
1291 if (!c->trigger && r <= 0)
1294 if (c->trigger && triggered <= 0)
1298 return triggered != 0;
1301 static bool unit_condition_test(Unit *u) {
1304 dual_timestamp_get(&u->condition_timestamp);
1305 u->condition_result = unit_condition_test_list(u, u->conditions, condition_type_to_string);
1307 return u->condition_result;
1310 static bool unit_assert_test(Unit *u) {
1313 dual_timestamp_get(&u->assert_timestamp);
1314 u->assert_result = unit_condition_test_list(u, u->asserts, assert_type_to_string);
1316 return u->assert_result;
1319 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1320 const UnitStatusMessageFormats *format_table;
1324 assert(t < _JOB_TYPE_MAX);
1326 if (t != JOB_START && t != JOB_STOP)
1329 format_table = &UNIT_VTABLE(u)->status_message_formats;
1333 return format_table->starting_stopping[t == JOB_STOP];
1336 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1341 assert(t < _JOB_TYPE_MAX);
1343 format = unit_get_status_message_format(u, t);
1347 /* Return generic strings */
1349 return "Starting %s.";
1350 else if (t == JOB_STOP)
1351 return "Stopping %s.";
1352 else if (t == JOB_RELOAD)
1353 return "Reloading %s.";
1358 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1363 /* We only print status messages for selected units on
1364 * selected operations. */
1366 format = unit_get_status_message_format(u, t);
1370 DISABLE_WARNING_FORMAT_NONLITERAL;
1371 unit_status_printf(u, "", format);
1375 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1382 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1385 if (log_on_console())
1388 /* We log status messages for all units and all operations. */
1390 format = unit_get_status_message_format_try_harder(u, t);
1394 DISABLE_WARNING_FORMAT_NONLITERAL;
1395 snprintf(buf, sizeof(buf), format, unit_description(u));
1398 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1399 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1400 SD_MESSAGE_UNIT_RELOADING;
1402 log_unit_struct(u->id,
1404 LOG_MESSAGE_ID(mid),
1405 LOG_MESSAGE("%s", buf),
1410 * -EBADR: This unit type does not support starting.
1411 * -EALREADY: Unit is already started.
1412 * -EAGAIN: An operation is already in progress. Retry later.
1413 * -ECANCELED: Too many requests for now.
1414 * -EPROTO: Assert failed
1416 int unit_start(Unit *u) {
1417 UnitActiveState state;
1423 if (u->load_state != UNIT_LOADED)
1426 /* If this is already started, then this will succeed. Note
1427 * that this will even succeed if this unit is not startable
1428 * by the user. This is relied on to detect when we need to
1429 * wait for units and when waiting is finished. */
1430 state = unit_active_state(u);
1431 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1434 /* If the conditions failed, don't do anything at all. If we
1435 * already are activating this call might still be useful to
1436 * speed up activation in case there is some hold-off time,
1437 * but we don't want to recheck the condition in that case. */
1438 if (state != UNIT_ACTIVATING &&
1439 !unit_condition_test(u)) {
1440 log_unit_debug(u->id, "Starting of %s requested but condition failed. Not starting unit.", u->id);
1444 /* If the asserts failed, fail the entire job */
1445 if (state != UNIT_ACTIVATING &&
1446 !unit_assert_test(u)) {
1447 log_unit_debug(u->id, "Starting of %s requested but asserts failed.", u->id);
1451 /* Forward to the main object, if we aren't it. */
1452 following = unit_following(u);
1454 log_unit_debug(u->id, "Redirecting start request from %s to %s.", u->id, following->id);
1455 return unit_start(following);
1458 if (UNIT_VTABLE(u)->supported && !UNIT_VTABLE(u)->supported(u->manager))
1461 /* If it is stopped, but we cannot start it, then fail */
1462 if (!UNIT_VTABLE(u)->start)
1465 /* We don't suppress calls to ->start() here when we are
1466 * already starting, to allow this request to be used as a
1467 * "hurry up" call, for example when the unit is in some "auto
1468 * restart" state where it waits for a holdoff timer to elapse
1469 * before it will start again. */
1471 unit_add_to_dbus_queue(u);
1473 r = UNIT_VTABLE(u)->start(u);
1477 /* Log if the start function actually did something */
1478 unit_status_log_starting_stopping_reloading(u, JOB_START);
1479 unit_status_print_starting_stopping(u, JOB_START);
1483 bool unit_can_start(Unit *u) {
1486 return !!UNIT_VTABLE(u)->start;
1489 bool unit_can_isolate(Unit *u) {
1492 return unit_can_start(u) &&
1497 * -EBADR: This unit type does not support stopping.
1498 * -EALREADY: Unit is already stopped.
1499 * -EAGAIN: An operation is already in progress. Retry later.
1501 int unit_stop(Unit *u) {
1502 UnitActiveState state;
1508 state = unit_active_state(u);
1509 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1512 following = unit_following(u);
1514 log_unit_debug(u->id, "Redirecting stop request from %s to %s.", u->id, following->id);
1515 return unit_stop(following);
1518 if (!UNIT_VTABLE(u)->stop)
1521 unit_add_to_dbus_queue(u);
1523 r = UNIT_VTABLE(u)->stop(u);
1527 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1528 unit_status_print_starting_stopping(u, JOB_STOP);
1533 * -EBADR: This unit type does not support reloading.
1534 * -ENOEXEC: Unit is not started.
1535 * -EAGAIN: An operation is already in progress. Retry later.
1537 int unit_reload(Unit *u) {
1538 UnitActiveState state;
1544 if (u->load_state != UNIT_LOADED)
1547 if (!unit_can_reload(u))
1550 state = unit_active_state(u);
1551 if (state == UNIT_RELOADING)
1554 if (state != UNIT_ACTIVE) {
1555 log_unit_warning(u->id, "Unit %s cannot be reloaded because it is inactive.", u->id);
1559 following = unit_following(u);
1561 log_unit_debug(u->id, "Redirecting reload request from %s to %s.", u->id, following->id);
1562 return unit_reload(following);
1565 unit_add_to_dbus_queue(u);
1567 r = UNIT_VTABLE(u)->reload(u);
1571 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1575 bool unit_can_reload(Unit *u) {
1578 if (!UNIT_VTABLE(u)->reload)
1581 if (!UNIT_VTABLE(u)->can_reload)
1584 return UNIT_VTABLE(u)->can_reload(u);
1587 static void unit_check_unneeded(Unit *u) {
1593 /* If this service shall be shut down when unneeded then do
1596 if (!u->stop_when_unneeded)
1599 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1602 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1603 if (unit_active_or_pending(other))
1606 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1607 if (unit_active_or_pending(other))
1610 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1611 if (unit_active_or_pending(other))
1614 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1615 if (unit_active_or_pending(other))
1618 log_unit_info(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
1620 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1621 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1624 static void unit_check_binds_to(Unit *u) {
1634 if (unit_active_state(u) != UNIT_ACTIVE)
1637 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1641 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1652 log_unit_info(u->id, "Unit %s is bound to inactive unit %s. Stopping, too.", u->id, other->id);
1654 /* A unit we need to run is gone. Sniff. Let's stop this. */
1655 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1658 static void retroactively_start_dependencies(Unit *u) {
1663 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1665 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1666 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1667 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1668 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1670 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1671 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1672 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1673 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1675 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1676 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1677 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1678 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1680 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1681 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1682 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1683 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1685 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1686 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1687 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1689 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1690 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1691 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1694 static void retroactively_stop_dependencies(Unit *u) {
1699 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1701 /* Pull down units which are bound to us recursively if enabled */
1702 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1703 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1704 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1707 static void check_unneeded_dependencies(Unit *u) {
1712 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1714 /* Garbage collect services that might not be needed anymore, if enabled */
1715 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1716 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1717 unit_check_unneeded(other);
1718 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1719 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1720 unit_check_unneeded(other);
1721 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1722 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1723 unit_check_unneeded(other);
1724 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1725 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1726 unit_check_unneeded(other);
1727 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1728 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1729 unit_check_unneeded(other);
1730 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1731 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1732 unit_check_unneeded(other);
1735 void unit_start_on_failure(Unit *u) {
1741 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1744 log_unit_info(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1746 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1749 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1751 log_unit_error_errno(u->id, r, "Failed to enqueue OnFailure= job: %m");
1755 void unit_trigger_notify(Unit *u) {
1761 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1762 if (UNIT_VTABLE(other)->trigger_notify)
1763 UNIT_VTABLE(other)->trigger_notify(other, u);
1766 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1771 assert(os < _UNIT_ACTIVE_STATE_MAX);
1772 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1774 /* Note that this is called for all low-level state changes,
1775 * even if they might map to the same high-level
1776 * UnitActiveState! That means that ns == os is an expected
1777 * behavior here. For example: if a mount point is remounted
1778 * this function will be called too! */
1782 /* Update timestamps for state changes */
1783 if (m->n_reloading <= 0) {
1786 dual_timestamp_get(&ts);
1788 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1789 u->inactive_exit_timestamp = ts;
1790 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1791 u->inactive_enter_timestamp = ts;
1793 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1794 u->active_enter_timestamp = ts;
1795 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1796 u->active_exit_timestamp = ts;
1799 /* Keep track of failed units */
1800 manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);
1802 /* Make sure the cgroup is always removed when we become inactive */
1803 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1804 unit_destroy_cgroup_if_empty(u);
1806 /* Note that this doesn't apply to RemainAfterExit services exiting
1807 * successfully, since there's no change of state in that case. Which is
1808 * why it is handled in service_set_state() */
1809 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1812 ec = unit_get_exec_context(u);
1813 if (ec && exec_context_may_touch_console(ec)) {
1814 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1817 if (m->n_on_console == 0)
1818 /* unset no_console_output flag, since the console is free */
1819 m->no_console_output = false;
1828 if (u->job->state == JOB_WAITING)
1830 /* So we reached a different state for this
1831 * job. Let's see if we can run it now if it
1832 * failed previously due to EAGAIN. */
1833 job_add_to_run_queue(u->job);
1835 /* Let's check whether this state change constitutes a
1836 * finished job, or maybe contradicts a running job and
1837 * hence needs to invalidate jobs. */
1839 switch (u->job->type) {
1842 case JOB_VERIFY_ACTIVE:
1844 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1845 job_finish_and_invalidate(u->job, JOB_DONE, true);
1846 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1849 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1850 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1856 case JOB_RELOAD_OR_START:
1858 if (u->job->state == JOB_RUNNING) {
1859 if (ns == UNIT_ACTIVE)
1860 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1861 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1864 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1865 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1873 case JOB_TRY_RESTART:
1875 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1876 job_finish_and_invalidate(u->job, JOB_DONE, true);
1877 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1879 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1885 assert_not_reached("Job type unknown");
1891 if (m->n_reloading <= 0) {
1893 /* If this state change happened without being
1894 * requested by a job, then let's retroactively start
1895 * or stop dependencies. We skip that step when
1896 * deserializing, since we don't want to create any
1897 * additional jobs just because something is already
1901 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1902 retroactively_start_dependencies(u);
1903 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1904 retroactively_stop_dependencies(u);
1907 /* stop unneeded units regardless if going down was expected or not */
1908 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1909 check_unneeded_dependencies(u);
1911 if (ns != os && ns == UNIT_FAILED) {
1912 log_unit_notice(u->id, "Unit %s entered failed state.", u->id);
1913 unit_start_on_failure(u);
1917 /* Some names are special */
1918 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1920 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1921 /* The bus might have just become available,
1922 * hence try to connect to it, if we aren't
1926 if (u->type == UNIT_SERVICE &&
1927 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1928 m->n_reloading <= 0) {
1929 /* Write audit record if we have just finished starting up */
1930 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1934 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1935 manager_send_unit_plymouth(m, u);
1939 /* We don't care about D-Bus here, since we'll get an
1940 * asynchronous notification for it anyway. */
1942 if (u->type == UNIT_SERVICE &&
1943 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1944 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1945 m->n_reloading <= 0) {
1947 /* Hmm, if there was no start record written
1948 * write it now, so that we always have a nice
1951 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1953 if (ns == UNIT_INACTIVE)
1954 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1956 /* Write audit record if we have just finished shutting down */
1957 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1959 u->in_audit = false;
1963 manager_recheck_journal(m);
1964 unit_trigger_notify(u);
1966 if (u->manager->n_reloading <= 0) {
1967 /* Maybe we finished startup and are now ready for
1968 * being stopped because unneeded? */
1969 unit_check_unneeded(u);
1971 /* Maybe we finished startup, but something we needed
1972 * has vanished? Let's die then. (This happens when
1973 * something BindsTo= to a Type=oneshot unit, as these
1974 * units go directly from starting to inactive,
1975 * without ever entering started.) */
1976 unit_check_binds_to(u);
1979 unit_add_to_dbus_queue(u);
1980 unit_add_to_gc_queue(u);
1983 int unit_watch_pid(Unit *u, pid_t pid) {
1989 /* Watch a specific PID. We only support one or two units
1990 * watching each PID for now, not more. */
1992 r = set_ensure_allocated(&u->pids, NULL);
1996 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
2000 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2002 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
2006 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2009 q = set_put(u->pids, LONG_TO_PTR(pid));
2016 void unit_unwatch_pid(Unit *u, pid_t pid) {
2020 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2021 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2022 set_remove(u->pids, LONG_TO_PTR(pid));
2025 void unit_unwatch_all_pids(Unit *u) {
2028 while (!set_isempty(u->pids))
2029 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
2035 static int unit_watch_pids_in_path(Unit *u, const char *path) {
2036 _cleanup_closedir_ DIR *d = NULL;
2037 _cleanup_fclose_ FILE *f = NULL;
2043 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
2045 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
2049 while ((r = cg_read_pid(f, &pid)) > 0) {
2050 r = unit_watch_pid(u, pid);
2051 if (r < 0 && ret >= 0)
2054 if (r < 0 && ret >= 0)
2057 } else if (ret >= 0)
2060 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
2064 while ((r = cg_read_subgroup(d, &fn)) > 0) {
2065 _cleanup_free_ char *p = NULL;
2067 p = strjoin(path, "/", fn, NULL);
2073 r = unit_watch_pids_in_path(u, p);
2074 if (r < 0 && ret >= 0)
2077 if (r < 0 && ret >= 0)
2080 } else if (ret >= 0)
2086 int unit_watch_all_pids(Unit *u) {
2089 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2091 if (!u->cgroup_path)
2094 return unit_watch_pids_in_path(u, u->cgroup_path);
2097 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2103 /* Cleans dead PIDs from our list */
2105 SET_FOREACH(e, u->pids, i) {
2106 pid_t pid = PTR_TO_LONG(e);
2108 if (pid == except1 || pid == except2)
2111 if (!pid_is_unwaited(pid))
2112 unit_unwatch_pid(u, pid);
2116 bool unit_job_is_applicable(Unit *u, JobType j) {
2118 assert(j >= 0 && j < _JOB_TYPE_MAX);
2122 case JOB_VERIFY_ACTIVE:
2129 case JOB_TRY_RESTART:
2130 return unit_can_start(u);
2133 return unit_can_reload(u);
2135 case JOB_RELOAD_OR_START:
2136 return unit_can_reload(u) && unit_can_start(u);
2139 assert_not_reached("Invalid job type");
2143 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2146 switch (dependency) {
2148 case UNIT_REQUIRES_OVERRIDABLE:
2150 case UNIT_REQUISITE:
2151 case UNIT_REQUISITE_OVERRIDABLE:
2154 case UNIT_REQUIRED_BY:
2155 case UNIT_REQUIRED_BY_OVERRIDABLE:
2156 case UNIT_WANTED_BY:
2158 case UNIT_CONSISTS_OF:
2159 case UNIT_REFERENCES:
2160 case UNIT_REFERENCED_BY:
2161 case UNIT_PROPAGATES_RELOAD_TO:
2162 case UNIT_RELOAD_PROPAGATED_FROM:
2163 case UNIT_JOINS_NAMESPACE_OF:
2166 case UNIT_CONFLICTS:
2167 case UNIT_CONFLICTED_BY:
2170 case UNIT_ON_FAILURE:
2172 case UNIT_TRIGGERED_BY:
2173 if (streq_ptr(id, other))
2174 log_unit_warning(id, "Dependency %s=%s dropped from unit %s",
2175 unit_dependency_to_string(dependency), id, other);
2177 log_unit_warning(id, "Dependency %s=%s dropped from unit %s merged into %s",
2178 unit_dependency_to_string(dependency), id,
2182 case _UNIT_DEPENDENCY_MAX:
2183 case _UNIT_DEPENDENCY_INVALID:
2187 assert_not_reached("Invalid dependency type");
2190 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2192 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2193 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2194 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2195 [UNIT_WANTS] = UNIT_WANTED_BY,
2196 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2197 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2198 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2199 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2200 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2201 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2202 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2203 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2204 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2205 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2206 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2207 [UNIT_BEFORE] = UNIT_AFTER,
2208 [UNIT_AFTER] = UNIT_BEFORE,
2209 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2210 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2211 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2212 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2213 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2214 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2215 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2216 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2218 int r, q = 0, v = 0, w = 0;
2219 Unit *orig_u = u, *orig_other = other;
2222 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2225 u = unit_follow_merge(u);
2226 other = unit_follow_merge(other);
2228 /* We won't allow dependencies on ourselves. We will not
2229 * consider them an error however. */
2231 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2235 r = set_ensure_allocated(&u->dependencies[d], NULL);
2239 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2240 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2245 if (add_reference) {
2246 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2250 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2255 q = set_put(u->dependencies[d], other);
2259 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2260 v = set_put(other->dependencies[inverse_table[d]], u);
2267 if (add_reference) {
2268 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2274 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2279 unit_add_to_dbus_queue(u);
2284 set_remove(u->dependencies[d], other);
2287 set_remove(other->dependencies[inverse_table[d]], u);
2290 set_remove(u->dependencies[UNIT_REFERENCES], other);
2295 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2300 r = unit_add_dependency(u, d, other, add_reference);
2304 r = unit_add_dependency(u, e, other, add_reference);
2311 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2315 assert(name || path);
2319 name = basename(path);
2321 if (!unit_name_is_template(name)) {
2327 s = unit_name_replace_instance(name, u->instance);
2329 _cleanup_free_ char *i = NULL;
2331 i = unit_name_to_prefix(u->id);
2335 s = unit_name_replace_instance(name, i);
2345 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2348 _cleanup_free_ char *s = NULL;
2351 assert(name || path);
2353 name = resolve_template(u, name, path, &s);
2357 r = manager_load_unit(u->manager, name, path, NULL, &other);
2361 return unit_add_dependency(u, d, other, add_reference);
2364 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2365 _cleanup_free_ char *s = NULL;
2370 assert(name || path);
2372 name = resolve_template(u, name, path, &s);
2376 r = manager_load_unit(u->manager, name, path, NULL, &other);
2380 return unit_add_two_dependencies(u, d, e, other, add_reference);
2383 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2386 _cleanup_free_ char *s = NULL;
2389 assert(name || path);
2391 name = resolve_template(u, name, path, &s);
2395 r = manager_load_unit(u->manager, name, path, NULL, &other);
2399 return unit_add_dependency(other, d, u, add_reference);
2402 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2405 _cleanup_free_ char *s = NULL;
2408 assert(name || path);
2410 name = resolve_template(u, name, path, &s);
2414 r = manager_load_unit(u->manager, name, path, NULL, &other);
2418 r = unit_add_two_dependencies(other, d, e, u, add_reference);
2425 int set_unit_path(const char *p) {
2426 /* This is mostly for debug purposes */
2427 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2433 char *unit_dbus_path(Unit *u) {
2439 return unit_dbus_path_from_name(u->id);
2442 char *unit_default_cgroup_path(Unit *u) {
2443 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2448 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2449 return strdup(u->manager->cgroup_root);
2451 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2452 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2457 escaped = cg_escape(u->id);
2462 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2464 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2467 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2468 _cleanup_free_ char *b = NULL;
2469 const char *slice_name;
2476 if (UNIT_ISSET(u->slice))
2480 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2482 /* Implicitly place all instantiated units in their
2483 * own per-template slice */
2485 prefix = unit_name_to_prefix(u->id);
2489 /* The prefix is already escaped, but it might include
2490 * "-" which has a special meaning for slice units,
2491 * hence escape it here extra. */
2492 escaped = strreplace(prefix, "-", "\\x2d");
2496 if (u->manager->running_as == SYSTEMD_SYSTEM)
2497 b = strjoin("system-", escaped, ".slice", NULL);
2499 b = strappend(escaped, ".slice");
2506 u->manager->running_as == SYSTEMD_SYSTEM
2507 ? SPECIAL_SYSTEM_SLICE
2508 : SPECIAL_ROOT_SLICE;
2510 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2514 unit_ref_set(&u->slice, slice);
2518 const char *unit_slice_name(Unit *u) {
2521 if (!UNIT_ISSET(u->slice))
2524 return UNIT_DEREF(u->slice)->id;
2527 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2528 _cleanup_free_ char *t = NULL;
2535 t = unit_name_change_suffix(u->id, type);
2539 assert(!unit_has_name(u, t));
2541 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2542 assert(r < 0 || *_found != u);
2546 int unit_watch_bus_name(Unit *u, const char *name) {
2550 /* Watch a specific name on the bus. We only support one unit
2551 * watching each name for now. */
2553 return hashmap_put(u->manager->watch_bus, name, u);
2556 void unit_unwatch_bus_name(Unit *u, const char *name) {
2560 hashmap_remove_value(u->manager->watch_bus, name, u);
2563 bool unit_can_serialize(Unit *u) {
2566 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2569 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2576 if (unit_can_serialize(u)) {
2579 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2583 rt = unit_get_exec_runtime(u);
2585 r = exec_runtime_serialize(rt, u, f, fds);
2591 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2592 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2593 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2594 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2595 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2596 dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2598 if (dual_timestamp_is_set(&u->condition_timestamp))
2599 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2601 if (dual_timestamp_is_set(&u->assert_timestamp))
2602 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2604 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2605 unit_serialize_item_format(u, f, "cpuacct-usage-base", "%" PRIu64, u->cpuacct_usage_base);
2608 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2610 if (serialize_jobs) {
2612 fprintf(f, "job\n");
2613 job_serialize(u->job, f, fds);
2617 fprintf(f, "job\n");
2618 job_serialize(u->nop_job, f, fds);
2627 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2638 va_start(ap, format);
2639 vfprintf(f, format, ap);
2645 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2651 fprintf(f, "%s=%s\n", key, value);
2654 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2655 ExecRuntime **rt = NULL;
2663 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2665 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2668 char line[LINE_MAX], *l, *v;
2671 if (!fgets(line, sizeof(line), f)) {
2684 k = strcspn(l, "=");
2692 if (streq(l, "job")) {
2694 /* new-style serialized job */
2701 r = job_deserialize(j, f, fds);
2707 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2713 r = job_install_deserialized(j);
2715 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2723 type = job_type_from_string(v);
2725 log_debug("Failed to parse job type value %s", v);
2727 u->deserialized_job = type;
2730 } else if (streq(l, "inactive-exit-timestamp")) {
2731 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2733 } else if (streq(l, "active-enter-timestamp")) {
2734 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2736 } else if (streq(l, "active-exit-timestamp")) {
2737 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2739 } else if (streq(l, "inactive-enter-timestamp")) {
2740 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2742 } else if (streq(l, "condition-timestamp")) {
2743 dual_timestamp_deserialize(v, &u->condition_timestamp);
2745 } else if (streq(l, "assert-timestamp")) {
2746 dual_timestamp_deserialize(v, &u->assert_timestamp);
2748 } else if (streq(l, "condition-result")) {
2751 b = parse_boolean(v);
2753 log_debug("Failed to parse condition result value %s", v);
2755 u->condition_result = b;
2759 } else if (streq(l, "assert-result")) {
2762 b = parse_boolean(v);
2764 log_debug("Failed to parse assert result value %s", v);
2766 u->assert_result = b;
2770 } else if (streq(l, "transient")) {
2773 b = parse_boolean(v);
2775 log_debug("Failed to parse transient bool %s", v);
2780 } else if (streq(l, "cpuacct-usage-base")) {
2782 r = safe_atou64(v, &u->cpuacct_usage_base);
2784 log_debug("Failed to parse CPU usage %s", v);
2786 } else if (streq(l, "cgroup")) {
2793 if (u->cgroup_path) {
2796 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2797 log_info("Removing cgroup_path %s from hashmap (%p)", u->cgroup_path, p);
2798 free(u->cgroup_path);
2802 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2807 if (unit_can_serialize(u)) {
2809 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2816 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2823 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2825 _cleanup_free_ char *e = NULL;
2833 /* Adds in links to the device node that this unit is based on */
2835 if (!is_device_path(what))
2838 e = unit_name_from_path(what, ".device");
2842 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2846 r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2851 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2859 static int unit_add_deserialized_job_coldplug(Unit *u) {
2862 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2866 u->deserialized_job = _JOB_TYPE_INVALID;
2871 int unit_coldplug(Unit *u, Hashmap *deferred_work) {
2876 if (UNIT_VTABLE(u)->coldplug)
2877 if ((r = UNIT_VTABLE(u)->coldplug(u, deferred_work)) < 0)
2881 r = job_coldplug(u->job);
2884 } else if (u->deserialized_job >= 0)
2886 hashmap_put(deferred_work, u, &unit_add_deserialized_job_coldplug);
2891 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2892 DISABLE_WARNING_FORMAT_NONLITERAL;
2893 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2894 status, unit_status_msg_format, unit_description(u));
2898 bool unit_need_daemon_reload(Unit *u) {
2899 _cleanup_strv_free_ char **t = NULL;
2902 unsigned loaded_cnt, current_cnt;
2906 if (u->fragment_path) {
2908 if (stat(u->fragment_path, &st) < 0)
2909 /* What, cannot access this anymore? */
2912 if (u->fragment_mtime > 0 &&
2913 timespec_load(&st.st_mtim) != u->fragment_mtime)
2917 if (u->source_path) {
2919 if (stat(u->source_path, &st) < 0)
2922 if (u->source_mtime > 0 &&
2923 timespec_load(&st.st_mtim) != u->source_mtime)
2927 (void) unit_find_dropin_paths(u, &t);
2928 loaded_cnt = strv_length(t);
2929 current_cnt = strv_length(u->dropin_paths);
2931 if (loaded_cnt == current_cnt) {
2932 if (loaded_cnt == 0)
2935 if (strv_overlap(u->dropin_paths, t)) {
2936 STRV_FOREACH(path, u->dropin_paths) {
2938 if (stat(*path, &st) < 0)
2941 if (u->dropin_mtime > 0 &&
2942 timespec_load(&st.st_mtim) > u->dropin_mtime)
2953 void unit_reset_failed(Unit *u) {
2956 if (UNIT_VTABLE(u)->reset_failed)
2957 UNIT_VTABLE(u)->reset_failed(u);
2960 Unit *unit_following(Unit *u) {
2963 if (UNIT_VTABLE(u)->following)
2964 return UNIT_VTABLE(u)->following(u);
2969 bool unit_stop_pending(Unit *u) {
2972 /* This call does check the current state of the unit. It's
2973 * hence useful to be called from state change calls of the
2974 * unit itself, where the state isn't updated yet. This is
2975 * different from unit_inactive_or_pending() which checks both
2976 * the current state and for a queued job. */
2978 return u->job && u->job->type == JOB_STOP;
2981 bool unit_inactive_or_pending(Unit *u) {
2984 /* Returns true if the unit is inactive or going down */
2986 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2989 if (unit_stop_pending(u))
2995 bool unit_active_or_pending(Unit *u) {
2998 /* Returns true if the unit is active or going up */
3000 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
3004 (u->job->type == JOB_START ||
3005 u->job->type == JOB_RELOAD_OR_START ||
3006 u->job->type == JOB_RESTART))
3012 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
3014 assert(w >= 0 && w < _KILL_WHO_MAX);
3016 assert(signo < _NSIG);
3018 if (!UNIT_VTABLE(u)->kill)
3021 return UNIT_VTABLE(u)->kill(u, w, signo, error);
3024 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
3028 pid_set = set_new(NULL);
3032 /* Exclude the main/control pids from being killed via the cgroup */
3034 r = set_put(pid_set, LONG_TO_PTR(main_pid));
3039 if (control_pid > 0) {
3040 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3052 int unit_kill_common(
3058 sd_bus_error *error) {
3062 if (who == KILL_MAIN && main_pid <= 0) {
3064 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3066 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3069 if (who == KILL_CONTROL && control_pid <= 0) {
3070 if (control_pid < 0)
3071 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3073 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3076 if (who == KILL_CONTROL || who == KILL_ALL)
3077 if (control_pid > 0)
3078 if (kill(control_pid, signo) < 0)
3081 if (who == KILL_MAIN || who == KILL_ALL)
3083 if (kill(main_pid, signo) < 0)
3086 if (who == KILL_ALL && u->cgroup_path) {
3087 _cleanup_set_free_ Set *pid_set = NULL;
3090 /* Exclude the main/control pids from being killed via the cgroup */
3091 pid_set = unit_pid_set(main_pid, control_pid);
3095 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3096 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3103 int unit_following_set(Unit *u, Set **s) {
3107 if (UNIT_VTABLE(u)->following_set)
3108 return UNIT_VTABLE(u)->following_set(u, s);
3114 UnitFileState unit_get_unit_file_state(Unit *u) {
3117 if (u->unit_file_state < 0 && u->fragment_path)
3118 u->unit_file_state = unit_file_get_state(
3119 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3120 NULL, basename(u->fragment_path));
3122 return u->unit_file_state;
3125 int unit_get_unit_file_preset(Unit *u) {
3128 if (u->unit_file_preset < 0 && u->fragment_path)
3129 u->unit_file_preset = unit_file_query_preset(
3130 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3131 NULL, basename(u->fragment_path));
3133 return u->unit_file_preset;
3136 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3141 unit_ref_unset(ref);
3144 LIST_PREPEND(refs, u->refs, ref);
3148 void unit_ref_unset(UnitRef *ref) {
3154 LIST_REMOVE(refs, ref->unit->refs, ref);
3158 int unit_patch_contexts(Unit *u) {
3166 /* Patch in the manager defaults into the exec and cgroup
3167 * contexts, _after_ the rest of the settings have been
3170 ec = unit_get_exec_context(u);
3172 /* This only copies in the ones that need memory */
3173 for (i = 0; i < _RLIMIT_MAX; i++)
3174 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3175 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3180 if (u->manager->running_as == SYSTEMD_USER &&
3181 !ec->working_directory) {
3183 r = get_home_dir(&ec->working_directory);
3187 /* Allow user services to run, even if the
3188 * home directory is missing */
3189 ec->working_directory_missing_ok = true;
3192 if (u->manager->running_as == SYSTEMD_USER &&
3193 (ec->syscall_whitelist ||
3194 !set_isempty(ec->syscall_filter) ||
3195 !set_isempty(ec->syscall_archs) ||
3196 ec->address_families_whitelist ||
3197 !set_isempty(ec->address_families)))
3198 ec->no_new_privileges = true;
3200 if (ec->private_devices)
3201 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3204 cc = unit_get_cgroup_context(u);
3208 ec->private_devices &&
3209 cc->device_policy == CGROUP_AUTO)
3210 cc->device_policy = CGROUP_CLOSED;
3216 ExecContext *unit_get_exec_context(Unit *u) {
3223 offset = UNIT_VTABLE(u)->exec_context_offset;
3227 return (ExecContext*) ((uint8_t*) u + offset);
3230 KillContext *unit_get_kill_context(Unit *u) {
3237 offset = UNIT_VTABLE(u)->kill_context_offset;
3241 return (KillContext*) ((uint8_t*) u + offset);
3244 CGroupContext *unit_get_cgroup_context(Unit *u) {
3250 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3254 return (CGroupContext*) ((uint8_t*) u + offset);
3257 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3263 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3267 return *(ExecRuntime**) ((uint8_t*) u + offset);
3270 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3271 if (u->manager->running_as == SYSTEMD_USER) {
3274 if (mode == UNIT_PERSISTENT && !transient)
3275 r = user_config_home(dir);
3277 r = user_runtime_dir(dir);
3284 if (mode == UNIT_PERSISTENT && !transient)
3285 *dir = strdup("/etc/systemd/system");
3287 *dir = strdup("/run/systemd/system");
3294 static int unit_drop_in_file(Unit *u,
3295 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3296 _cleanup_free_ char *dir = NULL;
3301 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3305 return drop_in_file(dir, u->id, 50, name, p, q);
3308 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3310 _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3315 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3318 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3322 r = write_drop_in(dir, u->id, 50, name, data);
3326 r = drop_in_file(dir, u->id, 50, name, &p, &q);
3330 r = strv_extend(&u->dropin_paths, q);
3334 strv_sort(u->dropin_paths);
3335 strv_uniq(u->dropin_paths);
3337 u->dropin_mtime = now(CLOCK_REALTIME);
3342 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3343 _cleanup_free_ char *p = NULL;
3351 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3354 va_start(ap, format);
3355 r = vasprintf(&p, format, ap);
3361 return unit_write_drop_in(u, mode, name, p);
3364 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3365 _cleanup_free_ char *ndata = NULL;
3371 if (!UNIT_VTABLE(u)->private_section)
3374 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3377 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3381 return unit_write_drop_in(u, mode, name, ndata);
3384 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3385 _cleanup_free_ char *p = NULL;
3393 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3396 va_start(ap, format);
3397 r = vasprintf(&p, format, ap);
3403 return unit_write_drop_in_private(u, mode, name, p);
3406 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3407 _cleanup_free_ char *p = NULL, *q = NULL;
3412 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3415 r = unit_drop_in_file(u, mode, name, &p, &q);
3420 r = errno == ENOENT ? 0 : -errno;
3428 int unit_make_transient(Unit *u) {
3433 u->load_state = UNIT_STUB;
3435 u->transient = true;
3437 free(u->fragment_path);
3438 u->fragment_path = NULL;
3440 if (u->manager->running_as == SYSTEMD_USER) {
3441 _cleanup_free_ char *c = NULL;
3443 r = user_runtime_dir(&c);
3449 u->fragment_path = strjoin(c, "/", u->id, NULL);
3450 if (!u->fragment_path)
3455 u->fragment_path = strappend("/run/systemd/system/", u->id);
3456 if (!u->fragment_path)
3459 mkdir_p("/run/systemd/system", 0755);
3462 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3465 int unit_kill_context(
3471 bool main_pid_alien) {
3473 int sig, wait_for_exit = false, r;
3478 if (c->kill_mode == KILL_NONE)
3488 case KILL_TERMINATE:
3489 sig = c->kill_signal;
3492 assert_not_reached("KillOperation unknown");
3496 r = kill_and_sigcont(main_pid, sig);
3498 if (r < 0 && r != -ESRCH) {
3499 _cleanup_free_ char *comm = NULL;
3500 get_process_comm(main_pid, &comm);
3502 log_unit_warning_errno(u->id, r, "Failed to kill main process " PID_FMT " (%s): %m", main_pid, strna(comm));
3504 if (!main_pid_alien)
3505 wait_for_exit = true;
3507 if (c->send_sighup && k != KILL_KILL)
3508 kill(main_pid, SIGHUP);
3512 if (control_pid > 0) {
3513 r = kill_and_sigcont(control_pid, sig);
3515 if (r < 0 && r != -ESRCH) {
3516 _cleanup_free_ char *comm = NULL;
3517 get_process_comm(control_pid, &comm);
3519 log_unit_warning_errno(u->id, r, "Failed to kill control process " PID_FMT " (%s): %m", control_pid, strna(comm));
3521 wait_for_exit = true;
3523 if (c->send_sighup && k != KILL_KILL)
3524 kill(control_pid, SIGHUP);
3528 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3529 _cleanup_set_free_ Set *pid_set = NULL;
3531 /* Exclude the main/control pids from being killed via the cgroup */
3532 pid_set = unit_pid_set(main_pid, control_pid);
3536 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3538 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3539 log_unit_warning_errno(u->id, r, "Failed to kill control group: %m");
3542 /* FIXME: For now, we will not wait for the
3543 * cgroup members to die, simply because
3544 * cgroup notification is unreliable. It
3545 * doesn't work at all in containers, and
3546 * outside of containers it can be confused
3547 * easily by leaving directories in the
3550 /* wait_for_exit = true; */
3552 if (c->send_sighup && k != KILL_KILL) {
3555 pid_set = unit_pid_set(main_pid, control_pid);
3559 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3564 return wait_for_exit;
3567 int unit_require_mounts_for(Unit *u, const char *path) {
3568 char prefix[strlen(path) + 1], *p;
3574 /* Registers a unit for requiring a certain path and all its
3575 * prefixes. We keep a simple array of these paths in the
3576 * unit, since its usually short. However, we build a prefix
3577 * table for all possible prefixes so that new appearing mount
3578 * units can easily determine which units to make themselves a
3581 if (!path_is_absolute(path))
3588 path_kill_slashes(p);
3590 if (!path_is_safe(p)) {
3595 if (strv_contains(u->requires_mounts_for, p)) {
3600 r = strv_consume(&u->requires_mounts_for, p);
3604 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3607 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3611 if (!u->manager->units_requiring_mounts_for) {
3612 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3613 if (!u->manager->units_requiring_mounts_for)
3627 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3643 int unit_setup_exec_runtime(Unit *u) {
3649 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3652 /* Check if there already is an ExecRuntime for this unit? */
3653 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3657 /* Try to get it from somebody else */
3658 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3660 *rt = unit_get_exec_runtime(other);
3662 exec_runtime_ref(*rt);
3667 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3670 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3671 [UNIT_ACTIVE] = "active",
3672 [UNIT_RELOADING] = "reloading",
3673 [UNIT_INACTIVE] = "inactive",
3674 [UNIT_FAILED] = "failed",
3675 [UNIT_ACTIVATING] = "activating",
3676 [UNIT_DEACTIVATING] = "deactivating"
3679 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);