1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
33 #include "sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
55 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
56 [UNIT_SERVICE] = &service_vtable,
57 [UNIT_SOCKET] = &socket_vtable,
58 [UNIT_BUSNAME] = &busname_vtable,
59 [UNIT_TARGET] = &target_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_DEVICE] = &device_vtable,
62 [UNIT_MOUNT] = &mount_vtable,
63 [UNIT_AUTOMOUNT] = &automount_vtable,
64 [UNIT_SWAP] = &swap_vtable,
65 [UNIT_TIMER] = &timer_vtable,
66 [UNIT_PATH] = &path_vtable,
67 [UNIT_SLICE] = &slice_vtable,
68 [UNIT_SCOPE] = &scope_vtable
71 Unit *unit_new(Manager *m, size_t size) {
75 assert(size >= sizeof(Unit));
81 u->names = set_new(string_hash_func, string_compare_func);
88 u->type = _UNIT_TYPE_INVALID;
89 u->deserialized_job = _JOB_TYPE_INVALID;
90 u->default_dependencies = true;
91 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 u->on_failure_job_mode = JOB_REPLACE;
97 bool unit_has_name(Unit *u, const char *name) {
101 return !!set_get(u->names, (char*) name);
104 int unit_add_name(Unit *u, const char *text) {
112 if (unit_name_is_template(text)) {
116 s = unit_name_replace_instance(text, u->instance);
123 if (!unit_name_is_valid(s, TEMPLATE_INVALID)) {
128 assert_se((t = unit_name_to_type(s)) >= 0);
130 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
135 r = unit_name_to_instance(s, &i);
139 if (i && unit_vtable[t]->no_instances) {
144 /* Ensure that this unit is either instanced or not instanced,
146 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
151 if (unit_vtable[t]->no_alias &&
152 !set_isempty(u->names) &&
153 !set_get(u->names, s)) {
158 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
163 r = set_put(u->names, s);
170 r = hashmap_put(u->manager->units, s, u);
172 set_remove(u->names, s);
176 if (u->type == _UNIT_TYPE_INVALID) {
182 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
184 if (UNIT_VTABLE(u)->init)
185 UNIT_VTABLE(u)->init(u);
189 unit_add_to_dbus_queue(u);
199 int unit_choose_id(Unit *u, const char *name) {
201 _cleanup_free_ char *t = NULL;
207 if (unit_name_is_template(name)) {
212 t = unit_name_replace_instance(name, u->instance);
219 /* Selects one of the names of this unit as the id */
220 s = set_get(u->names, (char*) name);
225 r = unit_name_to_instance(s, &i);
234 unit_add_to_dbus_queue(u);
239 int unit_set_description(Unit *u, const char *description) {
244 if (isempty(description))
247 s = strdup(description);
252 free(u->description);
255 unit_add_to_dbus_queue(u);
259 bool unit_check_gc(Unit *u) {
262 if (UNIT_VTABLE(u)->no_gc)
274 if (unit_active_state(u) != UNIT_INACTIVE)
280 if (UNIT_VTABLE(u)->check_gc)
281 if (UNIT_VTABLE(u)->check_gc(u))
287 void unit_add_to_load_queue(Unit *u) {
289 assert(u->type != _UNIT_TYPE_INVALID);
291 if (u->load_state != UNIT_STUB || u->in_load_queue)
294 LIST_PREPEND(load_queue, u->manager->load_queue, u);
295 u->in_load_queue = true;
298 void unit_add_to_cleanup_queue(Unit *u) {
301 if (u->in_cleanup_queue)
304 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
305 u->in_cleanup_queue = true;
308 void unit_add_to_gc_queue(Unit *u) {
311 if (u->in_gc_queue || u->in_cleanup_queue)
314 if (unit_check_gc(u))
317 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
318 u->in_gc_queue = true;
320 u->manager->n_in_gc_queue ++;
323 void unit_add_to_dbus_queue(Unit *u) {
325 assert(u->type != _UNIT_TYPE_INVALID);
327 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
330 /* Shortcut things if nobody cares */
331 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
332 set_isempty(u->manager->private_buses)) {
333 u->sent_dbus_new_signal = true;
337 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
338 u->in_dbus_queue = true;
341 static void bidi_set_free(Unit *u, Set *s) {
347 /* Frees the set and makes sure we are dropped from the
348 * inverse pointers */
350 SET_FOREACH(other, s, i) {
353 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
354 set_remove(other->dependencies[d], u);
356 unit_add_to_gc_queue(other);
362 static void unit_remove_transient(Unit *u) {
370 if (u->fragment_path)
371 unlink(u->fragment_path);
373 STRV_FOREACH(i, u->dropin_paths) {
374 _cleanup_free_ char *p = NULL;
379 r = path_get_parent(*i, &p);
385 static void unit_free_requires_mounts_for(Unit *u) {
388 STRV_FOREACH(j, u->requires_mounts_for) {
389 char s[strlen(*j) + 1];
391 PATH_FOREACH_PREFIX_MORE(s, *j) {
395 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
401 if (set_isempty(x)) {
402 hashmap_remove(u->manager->units_requiring_mounts_for, y);
409 strv_free(u->requires_mounts_for);
410 u->requires_mounts_for = NULL;
413 void unit_free(Unit *u) {
420 if (u->manager->n_reloading <= 0)
421 unit_remove_transient(u);
423 bus_unit_send_removed_signal(u);
425 if (u->load_state != UNIT_STUB)
426 if (UNIT_VTABLE(u)->done)
427 UNIT_VTABLE(u)->done(u);
429 unit_free_requires_mounts_for(u);
431 SET_FOREACH(t, u->names, i)
432 hashmap_remove_value(u->manager->units, t, u);
446 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
447 bidi_set_free(u, u->dependencies[d]);
449 if (u->type != _UNIT_TYPE_INVALID)
450 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
452 if (u->in_load_queue)
453 LIST_REMOVE(load_queue, u->manager->load_queue, u);
455 if (u->in_dbus_queue)
456 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
458 if (u->in_cleanup_queue)
459 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
461 if (u->in_gc_queue) {
462 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
463 u->manager->n_in_gc_queue--;
466 if (u->in_cgroup_queue)
467 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
469 if (u->cgroup_path) {
470 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
471 free(u->cgroup_path);
474 set_remove(u->manager->failed_units, u);
476 free(u->description);
477 strv_free(u->documentation);
478 free(u->fragment_path);
479 free(u->source_path);
480 strv_free(u->dropin_paths);
483 set_free_free(u->names);
485 unit_unwatch_all_pids(u);
487 condition_free_list(u->conditions);
489 unit_ref_unset(&u->slice);
492 unit_ref_unset(u->refs);
497 UnitActiveState unit_active_state(Unit *u) {
500 if (u->load_state == UNIT_MERGED)
501 return unit_active_state(unit_follow_merge(u));
503 /* After a reload it might happen that a unit is not correctly
504 * loaded but still has a process around. That's why we won't
505 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
507 return UNIT_VTABLE(u)->active_state(u);
510 const char* unit_sub_state_to_string(Unit *u) {
513 return UNIT_VTABLE(u)->sub_state_to_string(u);
516 static void complete_move(Set **s, Set **other) {
524 set_move(*s, *other);
531 static void merge_names(Unit *u, Unit *other) {
538 complete_move(&u->names, &other->names);
540 set_free_free(other->names);
544 SET_FOREACH(t, u->names, i)
545 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
548 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
555 assert(d < _UNIT_DEPENDENCY_MAX);
557 /* Fix backwards pointers */
558 SET_FOREACH(back, other->dependencies[d], i) {
561 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
562 r = set_remove_and_put(back->dependencies[k], other, u);
564 set_remove(back->dependencies[k], other);
566 assert(r >= 0 || r == -ENOENT);
570 complete_move(&u->dependencies[d], &other->dependencies[d]);
572 set_free(other->dependencies[d]);
573 other->dependencies[d] = NULL;
576 int unit_merge(Unit *u, Unit *other) {
581 assert(u->manager == other->manager);
582 assert(u->type != _UNIT_TYPE_INVALID);
584 other = unit_follow_merge(other);
589 if (u->type != other->type)
592 if (!u->instance != !other->instance)
595 if (other->load_state != UNIT_STUB &&
596 other->load_state != UNIT_NOT_FOUND)
605 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
609 merge_names(u, other);
611 /* Redirect all references */
613 unit_ref_set(other->refs, u);
615 /* Merge dependencies */
616 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
617 merge_dependencies(u, other, d);
619 other->load_state = UNIT_MERGED;
620 other->merged_into = u;
622 /* If there is still some data attached to the other node, we
623 * don't need it anymore, and can free it. */
624 if (other->load_state != UNIT_STUB)
625 if (UNIT_VTABLE(other)->done)
626 UNIT_VTABLE(other)->done(other);
628 unit_add_to_dbus_queue(u);
629 unit_add_to_cleanup_queue(other);
634 int unit_merge_by_name(Unit *u, const char *name) {
637 _cleanup_free_ char *s = NULL;
642 if (unit_name_is_template(name)) {
646 s = unit_name_replace_instance(name, u->instance);
653 other = manager_get_unit(u->manager, name);
655 r = unit_add_name(u, name);
657 r = unit_merge(u, other);
662 Unit* unit_follow_merge(Unit *u) {
665 while (u->load_state == UNIT_MERGED)
666 assert_se(u = u->merged_into);
671 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
677 if (c->working_directory) {
678 r = unit_require_mounts_for(u, c->working_directory);
683 if (c->root_directory) {
684 r = unit_require_mounts_for(u, c->root_directory);
689 if (u->manager->running_as != SYSTEMD_SYSTEM)
692 if (c->private_tmp) {
693 r = unit_require_mounts_for(u, "/tmp");
697 r = unit_require_mounts_for(u, "/var/tmp");
702 if (c->std_output != EXEC_OUTPUT_KMSG &&
703 c->std_output != EXEC_OUTPUT_SYSLOG &&
704 c->std_output != EXEC_OUTPUT_JOURNAL &&
705 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
706 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
707 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
708 c->std_error != EXEC_OUTPUT_KMSG &&
709 c->std_error != EXEC_OUTPUT_SYSLOG &&
710 c->std_error != EXEC_OUTPUT_JOURNAL &&
711 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
712 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
713 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
716 /* If syslog or kernel logging is requested, make sure our own
717 * logging daemon is run first. */
719 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
726 const char *unit_description(Unit *u) {
730 return u->description;
735 void unit_dump(Unit *u, FILE *f, const char *prefix) {
739 _cleanup_free_ char *p2 = NULL;
742 timestamp1[FORMAT_TIMESTAMP_MAX],
743 timestamp2[FORMAT_TIMESTAMP_MAX],
744 timestamp3[FORMAT_TIMESTAMP_MAX],
745 timestamp4[FORMAT_TIMESTAMP_MAX],
746 timespan[FORMAT_TIMESPAN_MAX];
748 _cleanup_set_free_ Set *following_set = NULL;
752 assert(u->type >= 0);
756 p2 = strappend(prefix, "\t");
757 prefix2 = p2 ? p2 : prefix;
761 "%s\tDescription: %s\n"
763 "%s\tUnit Load State: %s\n"
764 "%s\tUnit Active State: %s\n"
765 "%s\tInactive Exit Timestamp: %s\n"
766 "%s\tActive Enter Timestamp: %s\n"
767 "%s\tActive Exit Timestamp: %s\n"
768 "%s\tInactive Enter Timestamp: %s\n"
769 "%s\tGC Check Good: %s\n"
770 "%s\tNeed Daemon Reload: %s\n"
771 "%s\tTransient: %s\n"
774 "%s\tCGroup realized: %s\n"
775 "%s\tCGroup mask: 0x%x\n"
776 "%s\tCGroup members mask: 0x%x\n",
778 prefix, unit_description(u),
779 prefix, strna(u->instance),
780 prefix, unit_load_state_to_string(u->load_state),
781 prefix, unit_active_state_to_string(unit_active_state(u)),
782 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
783 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
784 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
785 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
786 prefix, yes_no(unit_check_gc(u)),
787 prefix, yes_no(unit_need_daemon_reload(u)),
788 prefix, yes_no(u->transient),
789 prefix, strna(unit_slice_name(u)),
790 prefix, strna(u->cgroup_path),
791 prefix, yes_no(u->cgroup_realized),
792 prefix, u->cgroup_realized_mask,
793 prefix, u->cgroup_members_mask);
795 SET_FOREACH(t, u->names, i)
796 fprintf(f, "%s\tName: %s\n", prefix, t);
798 STRV_FOREACH(j, u->documentation)
799 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
801 following = unit_following(u);
803 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
805 r = unit_following_set(u, &following_set);
809 SET_FOREACH(other, following_set, i)
810 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
813 if (u->fragment_path)
814 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
817 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
819 STRV_FOREACH(j, u->dropin_paths)
820 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
822 if (u->job_timeout > 0)
823 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
825 condition_dump_list(u->conditions, f, prefix);
827 if (dual_timestamp_is_set(&u->condition_timestamp))
829 "%s\tCondition Timestamp: %s\n"
830 "%s\tCondition Result: %s\n",
831 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
832 prefix, yes_no(u->condition_result));
834 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
837 SET_FOREACH(other, u->dependencies[d], i)
838 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
841 if (!strv_isempty(u->requires_mounts_for)) {
843 "%s\tRequiresMountsFor:", prefix);
845 STRV_FOREACH(j, u->requires_mounts_for)
846 fprintf(f, " %s", *j);
851 if (u->load_state == UNIT_LOADED) {
854 "%s\tStopWhenUnneeded: %s\n"
855 "%s\tRefuseManualStart: %s\n"
856 "%s\tRefuseManualStop: %s\n"
857 "%s\tDefaultDependencies: %s\n"
858 "%s\tOnFailureJobMode: %s\n"
859 "%s\tIgnoreOnIsolate: %s\n"
860 "%s\tIgnoreOnSnapshot: %s\n",
861 prefix, yes_no(u->stop_when_unneeded),
862 prefix, yes_no(u->refuse_manual_start),
863 prefix, yes_no(u->refuse_manual_stop),
864 prefix, yes_no(u->default_dependencies),
865 prefix, job_mode_to_string(u->on_failure_job_mode),
866 prefix, yes_no(u->ignore_on_isolate),
867 prefix, yes_no(u->ignore_on_snapshot));
869 if (UNIT_VTABLE(u)->dump)
870 UNIT_VTABLE(u)->dump(u, f, prefix2);
872 } else if (u->load_state == UNIT_MERGED)
874 "%s\tMerged into: %s\n",
875 prefix, u->merged_into->id);
876 else if (u->load_state == UNIT_ERROR)
877 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
881 job_dump(u->job, f, prefix2);
884 job_dump(u->nop_job, f, prefix2);
888 /* Common implementation for multiple backends */
889 int unit_load_fragment_and_dropin(Unit *u) {
894 /* Load a .{service,socket,...} file */
895 r = unit_load_fragment(u);
899 if (u->load_state == UNIT_STUB)
902 /* Load drop-in directory data */
903 r = unit_load_dropin(unit_follow_merge(u));
910 /* Common implementation for multiple backends */
911 int unit_load_fragment_and_dropin_optional(Unit *u) {
916 /* Same as unit_load_fragment_and_dropin(), but whether
917 * something can be loaded or not doesn't matter. */
919 /* Load a .service file */
920 r = unit_load_fragment(u);
924 if (u->load_state == UNIT_STUB)
925 u->load_state = UNIT_LOADED;
927 /* Load drop-in directory data */
928 r = unit_load_dropin(unit_follow_merge(u));
935 int unit_add_default_target_dependency(Unit *u, Unit *target) {
939 if (target->type != UNIT_TARGET)
942 /* Only add the dependency if both units are loaded, so that
943 * that loop check below is reliable */
944 if (u->load_state != UNIT_LOADED ||
945 target->load_state != UNIT_LOADED)
948 /* If either side wants no automatic dependencies, then let's
950 if (!u->default_dependencies ||
951 !target->default_dependencies)
954 /* Don't create loops */
955 if (set_get(target->dependencies[UNIT_BEFORE], u))
958 return unit_add_dependency(target, UNIT_AFTER, u, true);
961 static int unit_add_target_dependencies(Unit *u) {
963 static const UnitDependency deps[] = {
965 UNIT_REQUIRED_BY_OVERRIDABLE,
977 for (k = 0; k < ELEMENTSOF(deps); k++)
978 SET_FOREACH(target, u->dependencies[deps[k]], i) {
979 r = unit_add_default_target_dependency(u, target);
987 static int unit_add_slice_dependencies(Unit *u) {
990 if (!unit_get_cgroup_context(u))
993 if (UNIT_ISSET(u->slice))
994 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
996 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
999 static int unit_add_mount_dependencies(Unit *u) {
1005 STRV_FOREACH(i, u->requires_mounts_for) {
1006 char prefix[strlen(*i) + 1];
1008 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1011 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1019 if (m->load_state != UNIT_LOADED)
1022 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1026 if (m->fragment_path) {
1027 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1037 int unit_load(Unit *u) {
1042 if (u->in_load_queue) {
1043 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1044 u->in_load_queue = false;
1047 if (u->type == _UNIT_TYPE_INVALID)
1050 if (u->load_state != UNIT_STUB)
1053 if (UNIT_VTABLE(u)->load) {
1054 r = UNIT_VTABLE(u)->load(u);
1059 if (u->load_state == UNIT_STUB) {
1064 if (u->load_state == UNIT_LOADED) {
1066 r = unit_add_target_dependencies(u);
1070 r = unit_add_slice_dependencies(u);
1074 r = unit_add_mount_dependencies(u);
1078 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1079 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1084 unit_update_cgroup_members_masks(u);
1087 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1089 unit_add_to_dbus_queue(unit_follow_merge(u));
1090 unit_add_to_gc_queue(u);
1095 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1097 unit_add_to_dbus_queue(u);
1098 unit_add_to_gc_queue(u);
1100 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1101 u->id, strerror(-r));
1106 static bool unit_condition_test(Unit *u) {
1109 dual_timestamp_get(&u->condition_timestamp);
1110 u->condition_result = condition_test_list(u->id, u->conditions);
1112 return u->condition_result;
1115 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1116 const UnitStatusMessageFormats *format_table;
1120 assert(t < _JOB_TYPE_MAX);
1122 if (t != JOB_START && t != JOB_STOP)
1125 format_table = &UNIT_VTABLE(u)->status_message_formats;
1129 return format_table->starting_stopping[t == JOB_STOP];
1132 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1137 assert(t < _JOB_TYPE_MAX);
1139 format = unit_get_status_message_format(u, t);
1143 /* Return generic strings */
1145 return "Starting %s.";
1146 else if (t == JOB_STOP)
1147 return "Stopping %s.";
1148 else if (t == JOB_RELOAD)
1149 return "Reloading %s.";
1154 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1159 /* We only print status messages for selected units on
1160 * selected operations. */
1162 format = unit_get_status_message_format(u, t);
1166 DISABLE_WARNING_FORMAT_NONLITERAL;
1167 unit_status_printf(u, "", format);
1171 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1178 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1181 if (log_on_console())
1184 /* We log status messages for all units and all operations. */
1186 format = unit_get_status_message_format_try_harder(u, t);
1190 DISABLE_WARNING_FORMAT_NONLITERAL;
1191 snprintf(buf, sizeof(buf), format, unit_description(u));
1195 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1196 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1197 SD_MESSAGE_UNIT_RELOADING;
1199 log_struct_unit(LOG_INFO,
1207 * -EBADR: This unit type does not support starting.
1208 * -EALREADY: Unit is already started.
1209 * -EAGAIN: An operation is already in progress. Retry later.
1210 * -ECANCELED: Too many requests for now.
1212 int unit_start(Unit *u) {
1213 UnitActiveState state;
1218 if (u->load_state != UNIT_LOADED)
1221 /* If this is already started, then this will succeed. Note
1222 * that this will even succeed if this unit is not startable
1223 * by the user. This is relied on to detect when we need to
1224 * wait for units and when waiting is finished. */
1225 state = unit_active_state(u);
1226 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1229 /* If the conditions failed, don't do anything at all. If we
1230 * already are activating this call might still be useful to
1231 * speed up activation in case there is some hold-off time,
1232 * but we don't want to recheck the condition in that case. */
1233 if (state != UNIT_ACTIVATING &&
1234 !unit_condition_test(u)) {
1235 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1239 /* Forward to the main object, if we aren't it. */
1240 following = unit_following(u);
1242 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1243 u->id, following->id);
1244 return unit_start(following);
1247 unit_status_log_starting_stopping_reloading(u, JOB_START);
1248 unit_status_print_starting_stopping(u, JOB_START);
1250 /* If it is stopped, but we cannot start it, then fail */
1251 if (!UNIT_VTABLE(u)->start)
1254 /* We don't suppress calls to ->start() here when we are
1255 * already starting, to allow this request to be used as a
1256 * "hurry up" call, for example when the unit is in some "auto
1257 * restart" state where it waits for a holdoff timer to elapse
1258 * before it will start again. */
1260 unit_add_to_dbus_queue(u);
1262 return UNIT_VTABLE(u)->start(u);
1265 bool unit_can_start(Unit *u) {
1268 return !!UNIT_VTABLE(u)->start;
1271 bool unit_can_isolate(Unit *u) {
1274 return unit_can_start(u) &&
1279 * -EBADR: This unit type does not support stopping.
1280 * -EALREADY: Unit is already stopped.
1281 * -EAGAIN: An operation is already in progress. Retry later.
1283 int unit_stop(Unit *u) {
1284 UnitActiveState state;
1289 state = unit_active_state(u);
1290 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1293 if ((following = unit_following(u))) {
1294 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1295 u->id, following->id);
1296 return unit_stop(following);
1299 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1300 unit_status_print_starting_stopping(u, JOB_STOP);
1302 if (!UNIT_VTABLE(u)->stop)
1305 unit_add_to_dbus_queue(u);
1307 return UNIT_VTABLE(u)->stop(u);
1311 * -EBADR: This unit type does not support reloading.
1312 * -ENOEXEC: Unit is not started.
1313 * -EAGAIN: An operation is already in progress. Retry later.
1315 int unit_reload(Unit *u) {
1316 UnitActiveState state;
1321 if (u->load_state != UNIT_LOADED)
1324 if (!unit_can_reload(u))
1327 state = unit_active_state(u);
1328 if (state == UNIT_RELOADING)
1331 if (state != UNIT_ACTIVE) {
1332 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1337 following = unit_following(u);
1339 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1340 u->id, following->id);
1341 return unit_reload(following);
1344 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1346 unit_add_to_dbus_queue(u);
1347 return UNIT_VTABLE(u)->reload(u);
1350 bool unit_can_reload(Unit *u) {
1353 if (!UNIT_VTABLE(u)->reload)
1356 if (!UNIT_VTABLE(u)->can_reload)
1359 return UNIT_VTABLE(u)->can_reload(u);
1362 static void unit_check_unneeded(Unit *u) {
1368 /* If this service shall be shut down when unneeded then do
1371 if (!u->stop_when_unneeded)
1374 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1377 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1378 if (unit_active_or_pending(other))
1381 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1382 if (unit_active_or_pending(other))
1385 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1386 if (unit_active_or_pending(other))
1389 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1390 if (unit_active_or_pending(other))
1393 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1395 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1396 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1399 static void retroactively_start_dependencies(Unit *u) {
1404 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1406 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1407 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1408 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1409 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1411 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1412 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1413 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1414 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1416 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1417 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1418 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1419 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1421 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1422 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1423 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1424 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1426 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1427 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1428 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1430 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1431 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1432 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1435 static void retroactively_stop_dependencies(Unit *u) {
1440 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1442 /* Pull down units which are bound to us recursively if enabled */
1443 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1444 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1445 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1448 static void check_unneeded_dependencies(Unit *u) {
1453 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1455 /* Garbage collect services that might not be needed anymore, if enabled */
1456 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1457 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1458 unit_check_unneeded(other);
1459 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1460 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1461 unit_check_unneeded(other);
1462 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1463 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1464 unit_check_unneeded(other);
1465 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1466 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1467 unit_check_unneeded(other);
1468 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1469 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1470 unit_check_unneeded(other);
1471 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1472 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1473 unit_check_unneeded(other);
1476 void unit_start_on_failure(Unit *u) {
1482 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1485 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1487 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1490 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1492 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1496 void unit_trigger_notify(Unit *u) {
1502 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1503 if (UNIT_VTABLE(other)->trigger_notify)
1504 UNIT_VTABLE(other)->trigger_notify(other, u);
1507 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1512 assert(os < _UNIT_ACTIVE_STATE_MAX);
1513 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1515 /* Note that this is called for all low-level state changes,
1516 * even if they might map to the same high-level
1517 * UnitActiveState! That means that ns == os is OK an expected
1518 * behavior here. For example: if a mount point is remounted
1519 * this function will be called too! */
1523 /* Update timestamps for state changes */
1524 if (m->n_reloading <= 0) {
1527 dual_timestamp_get(&ts);
1529 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1530 u->inactive_exit_timestamp = ts;
1531 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1532 u->inactive_enter_timestamp = ts;
1534 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1535 u->active_enter_timestamp = ts;
1536 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1537 u->active_exit_timestamp = ts;
1540 /* Keep track of failed of units */
1541 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1542 set_put(u->manager->failed_units, u);
1543 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1544 set_remove(u->manager->failed_units, u);
1546 /* Make sure the cgroup is always removed when we become inactive */
1547 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1548 unit_destroy_cgroup(u);
1550 /* Note that this doesn't apply to RemainAfterExit services exiting
1551 * successfully, since there's no change of state in that case. Which is
1552 * why it is handled in service_set_state() */
1553 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1556 ec = unit_get_exec_context(u);
1557 if (ec && exec_context_may_touch_console(ec)) {
1558 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1561 if (m->n_on_console == 0)
1562 /* unset no_console_output flag, since the console is free */
1563 m->no_console_output = false;
1572 if (u->job->state == JOB_WAITING)
1574 /* So we reached a different state for this
1575 * job. Let's see if we can run it now if it
1576 * failed previously due to EAGAIN. */
1577 job_add_to_run_queue(u->job);
1579 /* Let's check whether this state change constitutes a
1580 * finished job, or maybe contradicts a running job and
1581 * hence needs to invalidate jobs. */
1583 switch (u->job->type) {
1586 case JOB_VERIFY_ACTIVE:
1588 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1589 job_finish_and_invalidate(u->job, JOB_DONE, true);
1590 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1593 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1594 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1600 case JOB_RELOAD_OR_START:
1602 if (u->job->state == JOB_RUNNING) {
1603 if (ns == UNIT_ACTIVE)
1604 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1605 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1608 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1609 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1617 case JOB_TRY_RESTART:
1619 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1620 job_finish_and_invalidate(u->job, JOB_DONE, true);
1621 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1623 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1629 assert_not_reached("Job type unknown");
1635 if (m->n_reloading <= 0) {
1637 /* If this state change happened without being
1638 * requested by a job, then let's retroactively start
1639 * or stop dependencies. We skip that step when
1640 * deserializing, since we don't want to create any
1641 * additional jobs just because something is already
1645 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1646 retroactively_start_dependencies(u);
1647 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1648 retroactively_stop_dependencies(u);
1651 /* stop unneeded units regardless if going down was expected or not */
1652 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1653 check_unneeded_dependencies(u);
1655 if (ns != os && ns == UNIT_FAILED) {
1656 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1657 unit_start_on_failure(u);
1661 /* Some names are special */
1662 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1664 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1665 /* The bus just might have become available,
1666 * hence try to connect to it, if we aren't
1670 if (u->type == UNIT_SERVICE &&
1671 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1672 m->n_reloading <= 0) {
1673 /* Write audit record if we have just finished starting up */
1674 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1678 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1679 manager_send_unit_plymouth(m, u);
1683 /* We don't care about D-Bus here, since we'll get an
1684 * asynchronous notification for it anyway. */
1686 if (u->type == UNIT_SERVICE &&
1687 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1688 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1689 m->n_reloading <= 0) {
1691 /* Hmm, if there was no start record written
1692 * write it now, so that we always have a nice
1695 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1697 if (ns == UNIT_INACTIVE)
1698 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1700 /* Write audit record if we have just finished shutting down */
1701 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1703 u->in_audit = false;
1707 manager_recheck_journal(m);
1708 unit_trigger_notify(u);
1710 /* Maybe we finished startup and are now ready for being
1711 * stopped because unneeded? */
1712 if (u->manager->n_reloading <= 0)
1713 unit_check_unneeded(u);
1715 unit_add_to_dbus_queue(u);
1716 unit_add_to_gc_queue(u);
1719 int unit_watch_pid(Unit *u, pid_t pid) {
1725 /* Watch a specific PID. We only support one or two units
1726 * watching each PID for now, not more. */
1728 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1732 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1736 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1738 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1742 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1745 q = set_put(u->pids, LONG_TO_PTR(pid));
1752 void unit_unwatch_pid(Unit *u, pid_t pid) {
1756 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1757 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1758 set_remove(u->pids, LONG_TO_PTR(pid));
1761 void unit_unwatch_all_pids(Unit *u) {
1764 while (!set_isempty(u->pids))
1765 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1771 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1772 _cleanup_closedir_ DIR *d = NULL;
1773 _cleanup_fclose_ FILE *f = NULL;
1779 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1781 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1785 while ((r = cg_read_pid(f, &pid)) > 0) {
1786 r = unit_watch_pid(u, pid);
1787 if (r < 0 && ret >= 0)
1790 if (r < 0 && ret >= 0)
1793 } else if (ret >= 0)
1796 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1800 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1801 _cleanup_free_ char *p = NULL;
1803 p = strjoin(path, "/", fn, NULL);
1809 r = unit_watch_pids_in_path(u, p);
1810 if (r < 0 && ret >= 0)
1813 if (r < 0 && ret >= 0)
1816 } else if (ret >= 0)
1822 int unit_watch_all_pids(Unit *u) {
1825 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1827 if (!u->cgroup_path)
1830 return unit_watch_pids_in_path(u, u->cgroup_path);
1833 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1839 /* Cleans dead PIDs from our list */
1841 SET_FOREACH(e, u->pids, i) {
1842 pid_t pid = PTR_TO_LONG(e);
1844 if (pid == except1 || pid == except2)
1847 if (!pid_is_unwaited(pid))
1848 unit_unwatch_pid(u, pid);
1852 bool unit_job_is_applicable(Unit *u, JobType j) {
1854 assert(j >= 0 && j < _JOB_TYPE_MAX);
1858 case JOB_VERIFY_ACTIVE:
1865 case JOB_TRY_RESTART:
1866 return unit_can_start(u);
1869 return unit_can_reload(u);
1871 case JOB_RELOAD_OR_START:
1872 return unit_can_reload(u) && unit_can_start(u);
1875 assert_not_reached("Invalid job type");
1879 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1881 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1882 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1883 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1884 [UNIT_WANTS] = UNIT_WANTED_BY,
1885 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1886 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1887 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1888 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1889 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1890 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1891 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1892 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1893 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1894 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1895 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1896 [UNIT_BEFORE] = UNIT_AFTER,
1897 [UNIT_AFTER] = UNIT_BEFORE,
1898 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1899 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1900 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1901 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1902 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1903 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1904 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1905 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1907 int r, q = 0, v = 0, w = 0;
1910 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1913 u = unit_follow_merge(u);
1914 other = unit_follow_merge(other);
1916 /* We won't allow dependencies on ourselves. We will not
1917 * consider them an error however. */
1921 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1925 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1926 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1931 if (add_reference) {
1932 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1936 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1941 q = set_put(u->dependencies[d], other);
1945 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1946 v = set_put(other->dependencies[inverse_table[d]], u);
1953 if (add_reference) {
1954 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1960 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1965 unit_add_to_dbus_queue(u);
1970 set_remove(u->dependencies[d], other);
1973 set_remove(other->dependencies[inverse_table[d]], u);
1976 set_remove(u->dependencies[UNIT_REFERENCES], other);
1981 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1986 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1989 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1995 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1999 assert(name || path);
2003 name = basename(path);
2005 if (!unit_name_is_template(name)) {
2011 s = unit_name_replace_instance(name, u->instance);
2013 _cleanup_free_ char *i = NULL;
2015 i = unit_name_to_prefix(u->id);
2019 s = unit_name_replace_instance(name, i);
2029 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2032 _cleanup_free_ char *s = NULL;
2035 assert(name || path);
2037 name = resolve_template(u, name, path, &s);
2041 r = manager_load_unit(u->manager, name, path, NULL, &other);
2045 return unit_add_dependency(u, d, other, add_reference);
2048 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2051 _cleanup_free_ char *s = NULL;
2054 assert(name || path);
2056 if (!(name = resolve_template(u, name, path, &s)))
2059 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2062 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2067 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2070 _cleanup_free_ char *s = NULL;
2073 assert(name || path);
2075 if (!(name = resolve_template(u, name, path, &s)))
2078 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2081 r = unit_add_dependency(other, d, u, add_reference);
2086 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2089 _cleanup_free_ char *s = NULL;
2092 assert(name || path);
2094 if (!(name = resolve_template(u, name, path, &s)))
2097 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2100 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2106 int set_unit_path(const char *p) {
2107 _cleanup_free_ char *c = NULL;
2109 /* This is mostly for debug purposes */
2110 c = path_make_absolute_cwd(p);
2111 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2117 char *unit_dbus_path(Unit *u) {
2123 return unit_dbus_path_from_name(u->id);
2126 char *unit_default_cgroup_path(Unit *u) {
2127 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2132 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2133 return strdup(u->manager->cgroup_root);
2135 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2136 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2141 escaped = cg_escape(u->id);
2146 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2148 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2151 int unit_add_default_slice(Unit *u) {
2152 _cleanup_free_ char *b = NULL;
2153 const char *slice_name;
2159 if (UNIT_ISSET(u->slice))
2162 if (!unit_get_cgroup_context(u))
2166 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2168 /* Implicitly place all instantiated units in their
2169 * own per-template slice */
2171 prefix = unit_name_to_prefix(u->id);
2175 /* The prefix is already escaped, but it might include
2176 * "-" which has a special meaning for slice units,
2177 * hence escape it here extra. */
2178 escaped = strreplace(prefix, "-", "\\x2d");
2182 if (u->manager->running_as == SYSTEMD_SYSTEM)
2183 b = strjoin("system-", escaped, ".slice", NULL);
2185 b = strappend(escaped, ".slice");
2192 u->manager->running_as == SYSTEMD_SYSTEM
2193 ? SPECIAL_SYSTEM_SLICE
2194 : SPECIAL_ROOT_SLICE;
2196 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2200 unit_ref_set(&u->slice, slice);
2204 const char *unit_slice_name(Unit *u) {
2207 if (!UNIT_ISSET(u->slice))
2210 return UNIT_DEREF(u->slice)->id;
2213 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2214 _cleanup_free_ char *t = NULL;
2221 t = unit_name_change_suffix(u->id, type);
2225 assert(!unit_has_name(u, t));
2227 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2228 assert(r < 0 || *_found != u);
2232 int unit_watch_bus_name(Unit *u, const char *name) {
2236 /* Watch a specific name on the bus. We only support one unit
2237 * watching each name for now. */
2239 return hashmap_put(u->manager->watch_bus, name, u);
2242 void unit_unwatch_bus_name(Unit *u, const char *name) {
2246 hashmap_remove_value(u->manager->watch_bus, name, u);
2249 bool unit_can_serialize(Unit *u) {
2252 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2255 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2263 if (!unit_can_serialize(u))
2266 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2270 rt = unit_get_exec_runtime(u);
2272 r = exec_runtime_serialize(rt, u, f, fds);
2277 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2278 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2279 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2280 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2281 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2283 if (dual_timestamp_is_set(&u->condition_timestamp))
2284 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2286 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2289 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2291 if (serialize_jobs) {
2293 fprintf(f, "job\n");
2294 job_serialize(u->job, f, fds);
2298 fprintf(f, "job\n");
2299 job_serialize(u->nop_job, f, fds);
2308 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2319 va_start(ap, format);
2320 vfprintf(f, format, ap);
2326 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2332 fprintf(f, "%s=%s\n", key, value);
2335 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2337 ExecRuntime **rt = NULL;
2344 if (!unit_can_serialize(u))
2347 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2349 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2352 char line[LINE_MAX], *l, *v;
2355 if (!fgets(line, sizeof(line), f)) {
2368 k = strcspn(l, "=");
2376 if (streq(l, "job")) {
2378 /* new-style serialized job */
2379 Job *j = job_new_raw(u);
2383 r = job_deserialize(j, f, fds);
2389 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2395 r = job_install_deserialized(j);
2397 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2402 if (j->state == JOB_RUNNING)
2403 u->manager->n_running_jobs++;
2406 JobType type = job_type_from_string(v);
2408 log_debug("Failed to parse job type value %s", v);
2410 u->deserialized_job = type;
2413 } else if (streq(l, "inactive-exit-timestamp")) {
2414 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2416 } else if (streq(l, "active-enter-timestamp")) {
2417 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2419 } else if (streq(l, "active-exit-timestamp")) {
2420 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2422 } else if (streq(l, "inactive-enter-timestamp")) {
2423 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2425 } else if (streq(l, "condition-timestamp")) {
2426 dual_timestamp_deserialize(v, &u->condition_timestamp);
2428 } else if (streq(l, "condition-result")) {
2431 b = parse_boolean(v);
2433 log_debug("Failed to parse condition result value %s", v);
2435 u->condition_result = b;
2439 } else if (streq(l, "transient")) {
2442 b = parse_boolean(v);
2444 log_debug("Failed to parse transient bool %s", v);
2449 } else if (streq(l, "cgroup")) {
2456 free(u->cgroup_path);
2459 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2464 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2471 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2477 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2479 _cleanup_free_ char *e = NULL;
2487 /* Adds in links to the device node that this unit is based on */
2489 if (!is_device_path(what))
2492 e = unit_name_from_path(what, ".device");
2496 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2501 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2506 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2514 int unit_coldplug(Unit *u) {
2519 if (UNIT_VTABLE(u)->coldplug)
2520 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2524 r = job_coldplug(u->job);
2527 } else if (u->deserialized_job >= 0) {
2529 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2533 u->deserialized_job = _JOB_TYPE_INVALID;
2539 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2540 DISABLE_WARNING_FORMAT_NONLITERAL;
2541 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2545 bool unit_need_daemon_reload(Unit *u) {
2546 _cleanup_strv_free_ char **t = NULL;
2549 unsigned loaded_cnt, current_cnt;
2553 if (u->fragment_path) {
2555 if (stat(u->fragment_path, &st) < 0)
2556 /* What, cannot access this anymore? */
2559 if (u->fragment_mtime > 0 &&
2560 timespec_load(&st.st_mtim) != u->fragment_mtime)
2564 if (u->source_path) {
2566 if (stat(u->source_path, &st) < 0)
2569 if (u->source_mtime > 0 &&
2570 timespec_load(&st.st_mtim) != u->source_mtime)
2574 t = unit_find_dropin_paths(u);
2575 loaded_cnt = strv_length(t);
2576 current_cnt = strv_length(u->dropin_paths);
2578 if (loaded_cnt == current_cnt) {
2579 if (loaded_cnt == 0)
2582 if (strv_overlap(u->dropin_paths, t)) {
2583 STRV_FOREACH(path, u->dropin_paths) {
2585 if (stat(*path, &st) < 0)
2588 if (u->dropin_mtime > 0 &&
2589 timespec_load(&st.st_mtim) > u->dropin_mtime)
2600 void unit_reset_failed(Unit *u) {
2603 if (UNIT_VTABLE(u)->reset_failed)
2604 UNIT_VTABLE(u)->reset_failed(u);
2607 Unit *unit_following(Unit *u) {
2610 if (UNIT_VTABLE(u)->following)
2611 return UNIT_VTABLE(u)->following(u);
2616 bool unit_stop_pending(Unit *u) {
2619 /* This call does check the current state of the unit. It's
2620 * hence useful to be called from state change calls of the
2621 * unit itself, where the state isn't updated yet. This is
2622 * different from unit_inactive_or_pending() which checks both
2623 * the current state and for a queued job. */
2625 return u->job && u->job->type == JOB_STOP;
2628 bool unit_inactive_or_pending(Unit *u) {
2631 /* Returns true if the unit is inactive or going down */
2633 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2636 if (unit_stop_pending(u))
2642 bool unit_active_or_pending(Unit *u) {
2645 /* Returns true if the unit is active or going up */
2647 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2651 (u->job->type == JOB_START ||
2652 u->job->type == JOB_RELOAD_OR_START ||
2653 u->job->type == JOB_RESTART))
2659 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2661 assert(w >= 0 && w < _KILL_WHO_MAX);
2663 assert(signo < _NSIG);
2665 if (!UNIT_VTABLE(u)->kill)
2668 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2671 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2675 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2679 /* Exclude the main/control pids from being killed via the cgroup */
2681 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2686 if (control_pid > 0) {
2687 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2699 int unit_kill_common(
2705 sd_bus_error *error) {
2709 if (who == KILL_MAIN && main_pid <= 0) {
2711 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2713 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2717 if (who == KILL_CONTROL && control_pid <= 0) {
2718 if (control_pid < 0)
2719 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2721 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2725 if (who == KILL_CONTROL || who == KILL_ALL)
2726 if (control_pid > 0)
2727 if (kill(control_pid, signo) < 0)
2730 if (who == KILL_MAIN || who == KILL_ALL)
2732 if (kill(main_pid, signo) < 0)
2735 if (who == KILL_ALL && u->cgroup_path) {
2736 _cleanup_set_free_ Set *pid_set = NULL;
2739 /* Exclude the main/control pids from being killed via the cgroup */
2740 pid_set = unit_pid_set(main_pid, control_pid);
2744 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2745 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2752 int unit_following_set(Unit *u, Set **s) {
2756 if (UNIT_VTABLE(u)->following_set)
2757 return UNIT_VTABLE(u)->following_set(u, s);
2763 UnitFileState unit_get_unit_file_state(Unit *u) {
2766 if (u->unit_file_state < 0 && u->fragment_path)
2767 u->unit_file_state = unit_file_get_state(
2768 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2769 NULL, basename(u->fragment_path));
2771 return u->unit_file_state;
2774 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2779 unit_ref_unset(ref);
2782 LIST_PREPEND(refs, u->refs, ref);
2786 void unit_ref_unset(UnitRef *ref) {
2792 LIST_REMOVE(refs, ref->unit->refs, ref);
2796 int unit_cgroup_context_init_defaults(Unit *u, CGroupContext *c) {
2800 /* Copy in the manager defaults into the cgroup context,
2801 * _before_ the rest of the settings have been initialized */
2803 c->cpu_accounting = u->manager->default_cpu_accounting;
2804 c->blockio_accounting = u->manager->default_blockio_accounting;
2805 c->memory_accounting = u->manager->default_memory_accounting;
2810 int unit_exec_context_patch_defaults(Unit *u, ExecContext *c) {
2817 /* Patch in the manager defaults into the exec context,
2818 * _after_ the rest of the settings have been initialized */
2820 /* This only copies in the ones that need memory */
2821 for (i = 0; i < _RLIMIT_MAX; i++)
2822 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2823 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2828 if (u->manager->running_as == SYSTEMD_USER &&
2829 !c->working_directory) {
2831 r = get_home_dir(&c->working_directory);
2836 if (u->manager->running_as == SYSTEMD_USER &&
2837 (c->syscall_whitelist ||
2838 !set_isempty(c->syscall_filter) ||
2839 !set_isempty(c->syscall_archs) ||
2840 c->address_families_whitelist ||
2841 !set_isempty(c->address_families)))
2842 c->no_new_privileges = true;
2844 if (c->private_devices)
2845 c->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2850 ExecContext *unit_get_exec_context(Unit *u) {
2854 offset = UNIT_VTABLE(u)->exec_context_offset;
2858 return (ExecContext*) ((uint8_t*) u + offset);
2861 KillContext *unit_get_kill_context(Unit *u) {
2865 offset = UNIT_VTABLE(u)->kill_context_offset;
2869 return (KillContext*) ((uint8_t*) u + offset);
2872 CGroupContext *unit_get_cgroup_context(Unit *u) {
2875 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2879 return (CGroupContext*) ((uint8_t*) u + offset);
2882 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2885 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2889 return *(ExecRuntime**) ((uint8_t*) u + offset);
2892 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2893 _cleanup_free_ char *b = NULL;
2902 b = xescape(name, "/.");
2906 if (!filename_is_safe(b))
2909 if (u->manager->running_as == SYSTEMD_USER) {
2910 _cleanup_free_ char *c = NULL;
2912 r = user_config_home(&c);
2918 p = strjoin(c, "/", u->id, ".d", NULL);
2919 } else if (mode == UNIT_PERSISTENT && !u->transient)
2920 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2922 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2926 q = strjoin(p, "/90-", b, ".conf", NULL);
2937 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2938 _cleanup_free_ char *p = NULL, *q = NULL;
2945 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2948 r = drop_in_file(u, mode, name, &p, &q);
2953 return write_string_file_atomic_label(q, data);
2956 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2957 _cleanup_free_ char *p = NULL;
2965 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2968 va_start(ap, format);
2969 r = vasprintf(&p, format, ap);
2975 return unit_write_drop_in(u, mode, name, p);
2978 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2979 _cleanup_free_ char *ndata = NULL;
2985 if (!UNIT_VTABLE(u)->private_section)
2988 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2991 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2995 return unit_write_drop_in(u, mode, name, ndata);
2998 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2999 _cleanup_free_ char *p = NULL;
3007 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3010 va_start(ap, format);
3011 r = vasprintf(&p, format, ap);
3017 return unit_write_drop_in_private(u, mode, name, p);
3020 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3021 _cleanup_free_ char *p = NULL, *q = NULL;
3026 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3029 r = drop_in_file(u, mode, name, &p, &q);
3034 r = errno == ENOENT ? 0 : -errno;
3042 int unit_make_transient(Unit *u) {
3047 u->load_state = UNIT_STUB;
3049 u->transient = true;
3051 free(u->fragment_path);
3052 u->fragment_path = NULL;
3054 if (u->manager->running_as == SYSTEMD_USER) {
3055 _cleanup_free_ char *c = NULL;
3057 r = user_config_home(&c);
3063 u->fragment_path = strjoin(c, "/", u->id, NULL);
3064 if (!u->fragment_path)
3069 u->fragment_path = strappend("/run/systemd/system/", u->id);
3070 if (!u->fragment_path)
3073 mkdir_p("/run/systemd/system", 0755);
3076 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3079 int unit_kill_context(
3085 bool main_pid_alien) {
3087 int sig, wait_for_exit = false, r;
3092 if (c->kill_mode == KILL_NONE)
3095 sig = sigkill ? SIGKILL : c->kill_signal;
3098 r = kill_and_sigcont(main_pid, sig);
3100 if (r < 0 && r != -ESRCH) {
3101 _cleanup_free_ char *comm = NULL;
3102 get_process_comm(main_pid, &comm);
3104 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3106 if (!main_pid_alien)
3107 wait_for_exit = true;
3109 if (c->send_sighup && !sigkill)
3110 kill(main_pid, SIGHUP);
3114 if (control_pid > 0) {
3115 r = kill_and_sigcont(control_pid, sig);
3117 if (r < 0 && r != -ESRCH) {
3118 _cleanup_free_ char *comm = NULL;
3119 get_process_comm(control_pid, &comm);
3121 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3123 wait_for_exit = true;
3125 if (c->send_sighup && !sigkill)
3126 kill(control_pid, SIGHUP);
3130 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3131 _cleanup_set_free_ Set *pid_set = NULL;
3133 /* Exclude the main/control pids from being killed via the cgroup */
3134 pid_set = unit_pid_set(main_pid, control_pid);
3138 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3140 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3141 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3144 /* FIXME: For now, we will not wait for the
3145 * cgroup members to die, simply because
3146 * cgroup notification is unreliable. It
3147 * doesn't work at all in containers, and
3148 * outside of containers it can be confused
3149 * easily by leaving directories in the
3152 /* wait_for_exit = true; */
3154 if (c->send_sighup && !sigkill) {
3157 pid_set = unit_pid_set(main_pid, control_pid);
3161 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3166 return wait_for_exit;
3169 int unit_require_mounts_for(Unit *u, const char *path) {
3170 char prefix[strlen(path) + 1], *p;
3176 /* Registers a unit for requiring a certain path and all its
3177 * prefixes. We keep a simple array of these paths in the
3178 * unit, since its usually short. However, we build a prefix
3179 * table for all possible prefixes so that new appearing mount
3180 * units can easily determine which units to make themselves a
3183 if (!path_is_absolute(path))
3190 path_kill_slashes(p);
3192 if (!path_is_safe(p)) {
3197 if (strv_contains(u->requires_mounts_for, p)) {
3202 r = strv_consume(&u->requires_mounts_for, p);
3206 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3209 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3213 if (!u->manager->units_requiring_mounts_for) {
3214 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3215 if (!u->manager->units_requiring_mounts_for)
3223 x = set_new(NULL, NULL);
3229 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3245 int unit_setup_exec_runtime(Unit *u) {
3251 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3254 /* Check if ther already is an ExecRuntime for this unit? */
3255 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3259 /* Try to get it from somebody else */
3260 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3262 *rt = unit_get_exec_runtime(other);
3264 exec_runtime_ref(*rt);
3269 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3272 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3273 [UNIT_ACTIVE] = "active",
3274 [UNIT_RELOADING] = "reloading",
3275 [UNIT_INACTIVE] = "inactive",
3276 [UNIT_FAILED] = "failed",
3277 [UNIT_ACTIVATING] = "activating",
3278 [UNIT_DEACTIVATING] = "deactivating"
3281 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3283 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3284 [UNIT_REQUIRES] = "Requires",
3285 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3286 [UNIT_REQUISITE] = "Requisite",
3287 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3288 [UNIT_WANTS] = "Wants",
3289 [UNIT_BINDS_TO] = "BindsTo",
3290 [UNIT_PART_OF] = "PartOf",
3291 [UNIT_REQUIRED_BY] = "RequiredBy",
3292 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3293 [UNIT_WANTED_BY] = "WantedBy",
3294 [UNIT_BOUND_BY] = "BoundBy",
3295 [UNIT_CONSISTS_OF] = "ConsistsOf",
3296 [UNIT_CONFLICTS] = "Conflicts",
3297 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3298 [UNIT_BEFORE] = "Before",
3299 [UNIT_AFTER] = "After",
3300 [UNIT_ON_FAILURE] = "OnFailure",
3301 [UNIT_TRIGGERS] = "Triggers",
3302 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3303 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3304 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3305 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3306 [UNIT_REFERENCES] = "References",
3307 [UNIT_REFERENCED_BY] = "ReferencedBy",
3310 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);