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"
56 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
57 [UNIT_SERVICE] = &service_vtable,
58 [UNIT_SOCKET] = &socket_vtable,
59 [UNIT_BUSNAME] = &busname_vtable,
60 [UNIT_TARGET] = &target_vtable,
61 [UNIT_SNAPSHOT] = &snapshot_vtable,
62 [UNIT_DEVICE] = &device_vtable,
63 [UNIT_MOUNT] = &mount_vtable,
64 [UNIT_AUTOMOUNT] = &automount_vtable,
65 [UNIT_SWAP] = &swap_vtable,
66 [UNIT_TIMER] = &timer_vtable,
67 [UNIT_PATH] = &path_vtable,
68 [UNIT_SLICE] = &slice_vtable,
69 [UNIT_SCOPE] = &scope_vtable
72 Unit *unit_new(Manager *m, size_t size) {
76 assert(size >= sizeof(Unit));
82 u->names = set_new(string_hash_func, string_compare_func);
89 u->type = _UNIT_TYPE_INVALID;
90 u->deserialized_job = _JOB_TYPE_INVALID;
91 u->default_dependencies = true;
92 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
93 u->on_failure_job_mode = JOB_REPLACE;
98 bool unit_has_name(Unit *u, const char *name) {
102 return !!set_get(u->names, (char*) name);
105 static void unit_init(Unit *u) {
112 assert(u->type >= 0);
114 cc = unit_get_cgroup_context(u);
116 cgroup_context_init(cc);
118 /* Copy in the manager defaults into the cgroup
119 * context, _before_ the rest of the settings have
120 * been initialized */
122 cc->cpu_accounting = u->manager->default_cpu_accounting;
123 cc->blockio_accounting = u->manager->default_blockio_accounting;
124 cc->memory_accounting = u->manager->default_memory_accounting;
127 ec = unit_get_exec_context(u);
129 exec_context_init(ec);
131 kc = unit_get_kill_context(u);
133 kill_context_init(kc);
135 if (UNIT_VTABLE(u)->init)
136 UNIT_VTABLE(u)->init(u);
139 int unit_add_name(Unit *u, const char *text) {
140 _cleanup_free_ char *s = NULL, *i = NULL;
147 if (unit_name_is_template(text)) {
152 s = unit_name_replace_instance(text, u->instance);
158 if (!unit_name_is_valid(s, TEMPLATE_INVALID))
161 assert_se((t = unit_name_to_type(s)) >= 0);
163 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
166 r = unit_name_to_instance(s, &i);
170 if (i && unit_vtable[t]->no_instances)
173 /* Ensure that this unit is either instanced or not instanced,
175 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
178 if (unit_vtable[t]->no_alias &&
179 !set_isempty(u->names) &&
180 !set_get(u->names, s))
183 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
186 r = set_put(u->names, s);
194 r = hashmap_put(u->manager->units, s, u);
196 set_remove(u->names, s);
200 if (u->type == _UNIT_TYPE_INVALID) {
205 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
214 unit_add_to_dbus_queue(u);
218 int unit_choose_id(Unit *u, const char *name) {
219 _cleanup_free_ char *t = NULL;
226 if (unit_name_is_template(name)) {
231 t = unit_name_replace_instance(name, u->instance);
238 /* Selects one of the names of this unit as the id */
239 s = set_get(u->names, (char*) name);
243 r = unit_name_to_instance(s, &i);
252 unit_add_to_dbus_queue(u);
257 int unit_set_description(Unit *u, const char *description) {
262 if (isempty(description))
265 s = strdup(description);
270 free(u->description);
273 unit_add_to_dbus_queue(u);
277 bool unit_check_gc(Unit *u) {
280 if (UNIT_VTABLE(u)->no_gc)
292 if (unit_active_state(u) != UNIT_INACTIVE)
298 if (UNIT_VTABLE(u)->check_gc)
299 if (UNIT_VTABLE(u)->check_gc(u))
305 void unit_add_to_load_queue(Unit *u) {
307 assert(u->type != _UNIT_TYPE_INVALID);
309 if (u->load_state != UNIT_STUB || u->in_load_queue)
312 LIST_PREPEND(load_queue, u->manager->load_queue, u);
313 u->in_load_queue = true;
316 void unit_add_to_cleanup_queue(Unit *u) {
319 if (u->in_cleanup_queue)
322 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
323 u->in_cleanup_queue = true;
326 void unit_add_to_gc_queue(Unit *u) {
329 if (u->in_gc_queue || u->in_cleanup_queue)
332 if (unit_check_gc(u))
335 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
336 u->in_gc_queue = true;
338 u->manager->n_in_gc_queue ++;
341 void unit_add_to_dbus_queue(Unit *u) {
343 assert(u->type != _UNIT_TYPE_INVALID);
345 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
348 /* Shortcut things if nobody cares */
349 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
350 set_isempty(u->manager->private_buses)) {
351 u->sent_dbus_new_signal = true;
355 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
356 u->in_dbus_queue = true;
359 static void bidi_set_free(Unit *u, Set *s) {
365 /* Frees the set and makes sure we are dropped from the
366 * inverse pointers */
368 SET_FOREACH(other, s, i) {
371 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
372 set_remove(other->dependencies[d], u);
374 unit_add_to_gc_queue(other);
380 static void unit_remove_transient(Unit *u) {
388 if (u->fragment_path)
389 unlink(u->fragment_path);
391 STRV_FOREACH(i, u->dropin_paths) {
392 _cleanup_free_ char *p = NULL;
397 r = path_get_parent(*i, &p);
403 static void unit_free_requires_mounts_for(Unit *u) {
406 STRV_FOREACH(j, u->requires_mounts_for) {
407 char s[strlen(*j) + 1];
409 PATH_FOREACH_PREFIX_MORE(s, *j) {
413 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
419 if (set_isempty(x)) {
420 hashmap_remove(u->manager->units_requiring_mounts_for, y);
427 strv_free(u->requires_mounts_for);
428 u->requires_mounts_for = NULL;
431 static void unit_done(Unit *u) {
440 if (UNIT_VTABLE(u)->done)
441 UNIT_VTABLE(u)->done(u);
443 ec = unit_get_exec_context(u);
445 exec_context_done(ec);
447 cc = unit_get_cgroup_context(u);
449 cgroup_context_done(cc);
452 void unit_free(Unit *u) {
459 if (u->manager->n_reloading <= 0)
460 unit_remove_transient(u);
462 bus_unit_send_removed_signal(u);
466 unit_free_requires_mounts_for(u);
468 SET_FOREACH(t, u->names, i)
469 hashmap_remove_value(u->manager->units, t, u);
483 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
484 bidi_set_free(u, u->dependencies[d]);
486 if (u->type != _UNIT_TYPE_INVALID)
487 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
489 if (u->in_load_queue)
490 LIST_REMOVE(load_queue, u->manager->load_queue, u);
492 if (u->in_dbus_queue)
493 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
495 if (u->in_cleanup_queue)
496 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
498 if (u->in_gc_queue) {
499 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
500 u->manager->n_in_gc_queue--;
503 if (u->in_cgroup_queue)
504 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
506 if (u->cgroup_path) {
507 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
508 free(u->cgroup_path);
511 set_remove(u->manager->failed_units, u);
512 set_remove(u->manager->startup_units, u);
514 free(u->description);
515 strv_free(u->documentation);
516 free(u->fragment_path);
517 free(u->source_path);
518 strv_free(u->dropin_paths);
521 set_free_free(u->names);
523 unit_unwatch_all_pids(u);
525 condition_free_list(u->conditions);
527 unit_ref_unset(&u->slice);
530 unit_ref_unset(u->refs);
535 UnitActiveState unit_active_state(Unit *u) {
538 if (u->load_state == UNIT_MERGED)
539 return unit_active_state(unit_follow_merge(u));
541 /* After a reload it might happen that a unit is not correctly
542 * loaded but still has a process around. That's why we won't
543 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
545 return UNIT_VTABLE(u)->active_state(u);
548 const char* unit_sub_state_to_string(Unit *u) {
551 return UNIT_VTABLE(u)->sub_state_to_string(u);
554 static void complete_move(Set **s, Set **other) {
562 set_move(*s, *other);
569 static void merge_names(Unit *u, Unit *other) {
576 complete_move(&u->names, &other->names);
578 set_free_free(other->names);
582 SET_FOREACH(t, u->names, i)
583 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
586 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
593 assert(d < _UNIT_DEPENDENCY_MAX);
595 /* Fix backwards pointers */
596 SET_FOREACH(back, other->dependencies[d], i) {
599 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
600 r = set_remove_and_put(back->dependencies[k], other, u);
602 set_remove(back->dependencies[k], other);
604 assert(r >= 0 || r == -ENOENT);
608 complete_move(&u->dependencies[d], &other->dependencies[d]);
610 set_free(other->dependencies[d]);
611 other->dependencies[d] = NULL;
614 int unit_merge(Unit *u, Unit *other) {
619 assert(u->manager == other->manager);
620 assert(u->type != _UNIT_TYPE_INVALID);
622 other = unit_follow_merge(other);
627 if (u->type != other->type)
630 if (!u->instance != !other->instance)
633 if (other->load_state != UNIT_STUB &&
634 other->load_state != UNIT_NOT_FOUND)
643 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
647 merge_names(u, other);
649 /* Redirect all references */
651 unit_ref_set(other->refs, u);
653 /* Merge dependencies */
654 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
655 merge_dependencies(u, other, d);
657 other->load_state = UNIT_MERGED;
658 other->merged_into = u;
660 /* If there is still some data attached to the other node, we
661 * don't need it anymore, and can free it. */
662 if (other->load_state != UNIT_STUB)
663 if (UNIT_VTABLE(other)->done)
664 UNIT_VTABLE(other)->done(other);
666 unit_add_to_dbus_queue(u);
667 unit_add_to_cleanup_queue(other);
672 int unit_merge_by_name(Unit *u, const char *name) {
675 _cleanup_free_ char *s = NULL;
680 if (unit_name_is_template(name)) {
684 s = unit_name_replace_instance(name, u->instance);
691 other = manager_get_unit(u->manager, name);
693 r = unit_add_name(u, name);
695 r = unit_merge(u, other);
700 Unit* unit_follow_merge(Unit *u) {
703 while (u->load_state == UNIT_MERGED)
704 assert_se(u = u->merged_into);
709 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
715 if (c->working_directory) {
716 r = unit_require_mounts_for(u, c->working_directory);
721 if (c->root_directory) {
722 r = unit_require_mounts_for(u, c->root_directory);
727 if (u->manager->running_as != SYSTEMD_SYSTEM)
730 if (c->private_tmp) {
731 r = unit_require_mounts_for(u, "/tmp");
735 r = unit_require_mounts_for(u, "/var/tmp");
740 if (c->std_output != EXEC_OUTPUT_KMSG &&
741 c->std_output != EXEC_OUTPUT_SYSLOG &&
742 c->std_output != EXEC_OUTPUT_JOURNAL &&
743 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
744 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
745 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
746 c->std_error != EXEC_OUTPUT_KMSG &&
747 c->std_error != EXEC_OUTPUT_SYSLOG &&
748 c->std_error != EXEC_OUTPUT_JOURNAL &&
749 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
750 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
751 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
754 /* If syslog or kernel logging is requested, make sure our own
755 * logging daemon is run first. */
757 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
764 const char *unit_description(Unit *u) {
768 return u->description;
773 void unit_dump(Unit *u, FILE *f, const char *prefix) {
777 _cleanup_free_ char *p2 = NULL;
780 timestamp1[FORMAT_TIMESTAMP_MAX],
781 timestamp2[FORMAT_TIMESTAMP_MAX],
782 timestamp3[FORMAT_TIMESTAMP_MAX],
783 timestamp4[FORMAT_TIMESTAMP_MAX],
784 timespan[FORMAT_TIMESPAN_MAX];
786 _cleanup_set_free_ Set *following_set = NULL;
790 assert(u->type >= 0);
794 p2 = strappend(prefix, "\t");
795 prefix2 = p2 ? p2 : prefix;
799 "%s\tDescription: %s\n"
801 "%s\tUnit Load State: %s\n"
802 "%s\tUnit Active State: %s\n"
803 "%s\tInactive Exit Timestamp: %s\n"
804 "%s\tActive Enter Timestamp: %s\n"
805 "%s\tActive Exit Timestamp: %s\n"
806 "%s\tInactive Enter Timestamp: %s\n"
807 "%s\tGC Check Good: %s\n"
808 "%s\tNeed Daemon Reload: %s\n"
809 "%s\tTransient: %s\n"
812 "%s\tCGroup realized: %s\n"
813 "%s\tCGroup mask: 0x%x\n"
814 "%s\tCGroup members mask: 0x%x\n",
816 prefix, unit_description(u),
817 prefix, strna(u->instance),
818 prefix, unit_load_state_to_string(u->load_state),
819 prefix, unit_active_state_to_string(unit_active_state(u)),
820 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
821 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
822 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
823 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
824 prefix, yes_no(unit_check_gc(u)),
825 prefix, yes_no(unit_need_daemon_reload(u)),
826 prefix, yes_no(u->transient),
827 prefix, strna(unit_slice_name(u)),
828 prefix, strna(u->cgroup_path),
829 prefix, yes_no(u->cgroup_realized),
830 prefix, u->cgroup_realized_mask,
831 prefix, u->cgroup_members_mask);
833 SET_FOREACH(t, u->names, i)
834 fprintf(f, "%s\tName: %s\n", prefix, t);
836 STRV_FOREACH(j, u->documentation)
837 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
839 following = unit_following(u);
841 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
843 r = unit_following_set(u, &following_set);
847 SET_FOREACH(other, following_set, i)
848 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
851 if (u->fragment_path)
852 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
855 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
857 STRV_FOREACH(j, u->dropin_paths)
858 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
860 if (u->job_timeout > 0)
861 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
863 condition_dump_list(u->conditions, f, prefix);
865 if (dual_timestamp_is_set(&u->condition_timestamp))
867 "%s\tCondition Timestamp: %s\n"
868 "%s\tCondition Result: %s\n",
869 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
870 prefix, yes_no(u->condition_result));
872 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
875 SET_FOREACH(other, u->dependencies[d], i)
876 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
879 if (!strv_isempty(u->requires_mounts_for)) {
881 "%s\tRequiresMountsFor:", prefix);
883 STRV_FOREACH(j, u->requires_mounts_for)
884 fprintf(f, " %s", *j);
889 if (u->load_state == UNIT_LOADED) {
892 "%s\tStopWhenUnneeded: %s\n"
893 "%s\tRefuseManualStart: %s\n"
894 "%s\tRefuseManualStop: %s\n"
895 "%s\tDefaultDependencies: %s\n"
896 "%s\tOnFailureJobMode: %s\n"
897 "%s\tIgnoreOnIsolate: %s\n"
898 "%s\tIgnoreOnSnapshot: %s\n",
899 prefix, yes_no(u->stop_when_unneeded),
900 prefix, yes_no(u->refuse_manual_start),
901 prefix, yes_no(u->refuse_manual_stop),
902 prefix, yes_no(u->default_dependencies),
903 prefix, job_mode_to_string(u->on_failure_job_mode),
904 prefix, yes_no(u->ignore_on_isolate),
905 prefix, yes_no(u->ignore_on_snapshot));
907 if (UNIT_VTABLE(u)->dump)
908 UNIT_VTABLE(u)->dump(u, f, prefix2);
910 } else if (u->load_state == UNIT_MERGED)
912 "%s\tMerged into: %s\n",
913 prefix, u->merged_into->id);
914 else if (u->load_state == UNIT_ERROR)
915 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
919 job_dump(u->job, f, prefix2);
922 job_dump(u->nop_job, f, prefix2);
926 /* Common implementation for multiple backends */
927 int unit_load_fragment_and_dropin(Unit *u) {
932 /* Load a .{service,socket,...} file */
933 r = unit_load_fragment(u);
937 if (u->load_state == UNIT_STUB)
940 /* Load drop-in directory data */
941 r = unit_load_dropin(unit_follow_merge(u));
948 /* Common implementation for multiple backends */
949 int unit_load_fragment_and_dropin_optional(Unit *u) {
954 /* Same as unit_load_fragment_and_dropin(), but whether
955 * something can be loaded or not doesn't matter. */
957 /* Load a .service file */
958 r = unit_load_fragment(u);
962 if (u->load_state == UNIT_STUB)
963 u->load_state = UNIT_LOADED;
965 /* Load drop-in directory data */
966 r = unit_load_dropin(unit_follow_merge(u));
973 int unit_add_default_target_dependency(Unit *u, Unit *target) {
977 if (target->type != UNIT_TARGET)
980 /* Only add the dependency if both units are loaded, so that
981 * that loop check below is reliable */
982 if (u->load_state != UNIT_LOADED ||
983 target->load_state != UNIT_LOADED)
986 /* If either side wants no automatic dependencies, then let's
988 if (!u->default_dependencies ||
989 !target->default_dependencies)
992 /* Don't create loops */
993 if (set_get(target->dependencies[UNIT_BEFORE], u))
996 return unit_add_dependency(target, UNIT_AFTER, u, true);
999 static int unit_add_target_dependencies(Unit *u) {
1001 static const UnitDependency deps[] = {
1003 UNIT_REQUIRED_BY_OVERRIDABLE,
1015 for (k = 0; k < ELEMENTSOF(deps); k++)
1016 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1017 r = unit_add_default_target_dependency(u, target);
1025 static int unit_add_slice_dependencies(Unit *u) {
1028 if (!unit_get_cgroup_context(u))
1031 if (UNIT_ISSET(u->slice))
1032 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1034 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1037 static int unit_add_mount_dependencies(Unit *u) {
1043 STRV_FOREACH(i, u->requires_mounts_for) {
1044 char prefix[strlen(*i) + 1];
1046 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1049 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1057 if (m->load_state != UNIT_LOADED)
1060 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1064 if (m->fragment_path) {
1065 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1075 static int unit_add_startup_units(Unit *u) {
1079 c = unit_get_cgroup_context(u);
1083 if (c->startup_cpu_shares == (unsigned long) -1 &&
1084 c->startup_blockio_weight == (unsigned long) -1)
1087 r = set_put(u->manager->startup_units, u);
1094 int unit_load(Unit *u) {
1099 if (u->in_load_queue) {
1100 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1101 u->in_load_queue = false;
1104 if (u->type == _UNIT_TYPE_INVALID)
1107 if (u->load_state != UNIT_STUB)
1110 if (UNIT_VTABLE(u)->load) {
1111 r = UNIT_VTABLE(u)->load(u);
1116 if (u->load_state == UNIT_STUB) {
1121 if (u->load_state == UNIT_LOADED) {
1123 r = unit_add_target_dependencies(u);
1127 r = unit_add_slice_dependencies(u);
1131 r = unit_add_mount_dependencies(u);
1135 r = unit_add_startup_units(u);
1139 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1140 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1145 unit_update_cgroup_members_masks(u);
1148 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1150 unit_add_to_dbus_queue(unit_follow_merge(u));
1151 unit_add_to_gc_queue(u);
1156 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1158 unit_add_to_dbus_queue(u);
1159 unit_add_to_gc_queue(u);
1161 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1162 u->id, strerror(-r));
1167 static bool unit_condition_test(Unit *u) {
1170 dual_timestamp_get(&u->condition_timestamp);
1171 u->condition_result = condition_test_list(u->id, u->conditions);
1173 return u->condition_result;
1176 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1177 const UnitStatusMessageFormats *format_table;
1181 assert(t < _JOB_TYPE_MAX);
1183 if (t != JOB_START && t != JOB_STOP)
1186 format_table = &UNIT_VTABLE(u)->status_message_formats;
1190 return format_table->starting_stopping[t == JOB_STOP];
1193 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1198 assert(t < _JOB_TYPE_MAX);
1200 format = unit_get_status_message_format(u, t);
1204 /* Return generic strings */
1206 return "Starting %s.";
1207 else if (t == JOB_STOP)
1208 return "Stopping %s.";
1209 else if (t == JOB_RELOAD)
1210 return "Reloading %s.";
1215 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1220 /* We only print status messages for selected units on
1221 * selected operations. */
1223 format = unit_get_status_message_format(u, t);
1227 DISABLE_WARNING_FORMAT_NONLITERAL;
1228 unit_status_printf(u, "", format);
1232 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1239 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1242 if (log_on_console())
1245 /* We log status messages for all units and all operations. */
1247 format = unit_get_status_message_format_try_harder(u, t);
1251 DISABLE_WARNING_FORMAT_NONLITERAL;
1252 snprintf(buf, sizeof(buf), format, unit_description(u));
1256 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1257 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1258 SD_MESSAGE_UNIT_RELOADING;
1260 log_struct_unit(LOG_INFO,
1268 * -EBADR: This unit type does not support starting.
1269 * -EALREADY: Unit is already started.
1270 * -EAGAIN: An operation is already in progress. Retry later.
1271 * -ECANCELED: Too many requests for now.
1273 int unit_start(Unit *u) {
1274 UnitActiveState state;
1279 if (u->load_state != UNIT_LOADED)
1282 /* If this is already started, then this will succeed. Note
1283 * that this will even succeed if this unit is not startable
1284 * by the user. This is relied on to detect when we need to
1285 * wait for units and when waiting is finished. */
1286 state = unit_active_state(u);
1287 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1290 /* If the conditions failed, don't do anything at all. If we
1291 * already are activating this call might still be useful to
1292 * speed up activation in case there is some hold-off time,
1293 * but we don't want to recheck the condition in that case. */
1294 if (state != UNIT_ACTIVATING &&
1295 !unit_condition_test(u)) {
1296 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1300 /* Forward to the main object, if we aren't it. */
1301 following = unit_following(u);
1303 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1304 u->id, following->id);
1305 return unit_start(following);
1308 unit_status_log_starting_stopping_reloading(u, JOB_START);
1309 unit_status_print_starting_stopping(u, JOB_START);
1311 /* If it is stopped, but we cannot start it, then fail */
1312 if (!UNIT_VTABLE(u)->start)
1315 /* We don't suppress calls to ->start() here when we are
1316 * already starting, to allow this request to be used as a
1317 * "hurry up" call, for example when the unit is in some "auto
1318 * restart" state where it waits for a holdoff timer to elapse
1319 * before it will start again. */
1321 unit_add_to_dbus_queue(u);
1323 return UNIT_VTABLE(u)->start(u);
1326 bool unit_can_start(Unit *u) {
1329 return !!UNIT_VTABLE(u)->start;
1332 bool unit_can_isolate(Unit *u) {
1335 return unit_can_start(u) &&
1340 * -EBADR: This unit type does not support stopping.
1341 * -EALREADY: Unit is already stopped.
1342 * -EAGAIN: An operation is already in progress. Retry later.
1344 int unit_stop(Unit *u) {
1345 UnitActiveState state;
1350 state = unit_active_state(u);
1351 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1354 if ((following = unit_following(u))) {
1355 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1356 u->id, following->id);
1357 return unit_stop(following);
1360 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1361 unit_status_print_starting_stopping(u, JOB_STOP);
1363 if (!UNIT_VTABLE(u)->stop)
1366 unit_add_to_dbus_queue(u);
1368 return UNIT_VTABLE(u)->stop(u);
1372 * -EBADR: This unit type does not support reloading.
1373 * -ENOEXEC: Unit is not started.
1374 * -EAGAIN: An operation is already in progress. Retry later.
1376 int unit_reload(Unit *u) {
1377 UnitActiveState state;
1382 if (u->load_state != UNIT_LOADED)
1385 if (!unit_can_reload(u))
1388 state = unit_active_state(u);
1389 if (state == UNIT_RELOADING)
1392 if (state != UNIT_ACTIVE) {
1393 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1398 following = unit_following(u);
1400 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1401 u->id, following->id);
1402 return unit_reload(following);
1405 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1407 unit_add_to_dbus_queue(u);
1408 return UNIT_VTABLE(u)->reload(u);
1411 bool unit_can_reload(Unit *u) {
1414 if (!UNIT_VTABLE(u)->reload)
1417 if (!UNIT_VTABLE(u)->can_reload)
1420 return UNIT_VTABLE(u)->can_reload(u);
1423 static void unit_check_unneeded(Unit *u) {
1429 /* If this service shall be shut down when unneeded then do
1432 if (!u->stop_when_unneeded)
1435 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1438 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1439 if (unit_active_or_pending(other))
1442 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1443 if (unit_active_or_pending(other))
1446 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1447 if (unit_active_or_pending(other))
1450 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1451 if (unit_active_or_pending(other))
1454 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1456 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1457 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1460 static void retroactively_start_dependencies(Unit *u) {
1465 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1467 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1468 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1469 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1470 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1472 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1473 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1474 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1475 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1477 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1478 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1479 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1480 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1482 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1483 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1484 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1485 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1487 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1488 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1489 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1491 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1492 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1493 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1496 static void retroactively_stop_dependencies(Unit *u) {
1501 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1503 /* Pull down units which are bound to us recursively if enabled */
1504 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1505 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1506 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1509 static void check_unneeded_dependencies(Unit *u) {
1514 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1516 /* Garbage collect services that might not be needed anymore, if enabled */
1517 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1518 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1519 unit_check_unneeded(other);
1520 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1521 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1522 unit_check_unneeded(other);
1523 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1524 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1525 unit_check_unneeded(other);
1526 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1527 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1528 unit_check_unneeded(other);
1529 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1530 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1531 unit_check_unneeded(other);
1532 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1533 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1534 unit_check_unneeded(other);
1537 void unit_start_on_failure(Unit *u) {
1543 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1546 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1548 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1551 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1553 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1557 void unit_trigger_notify(Unit *u) {
1563 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1564 if (UNIT_VTABLE(other)->trigger_notify)
1565 UNIT_VTABLE(other)->trigger_notify(other, u);
1568 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1573 assert(os < _UNIT_ACTIVE_STATE_MAX);
1574 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1576 /* Note that this is called for all low-level state changes,
1577 * even if they might map to the same high-level
1578 * UnitActiveState! That means that ns == os is an expected
1579 * behavior here. For example: if a mount point is remounted
1580 * this function will be called too! */
1584 /* Update timestamps for state changes */
1585 if (m->n_reloading <= 0) {
1588 dual_timestamp_get(&ts);
1590 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1591 u->inactive_exit_timestamp = ts;
1592 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1593 u->inactive_enter_timestamp = ts;
1595 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1596 u->active_enter_timestamp = ts;
1597 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1598 u->active_exit_timestamp = ts;
1601 /* Keep track of failed units */
1602 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1603 set_put(u->manager->failed_units, u);
1604 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1605 set_remove(u->manager->failed_units, u);
1607 /* Make sure the cgroup is always removed when we become inactive */
1608 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1609 unit_destroy_cgroup(u);
1611 /* Note that this doesn't apply to RemainAfterExit services exiting
1612 * successfully, since there's no change of state in that case. Which is
1613 * why it is handled in service_set_state() */
1614 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1617 ec = unit_get_exec_context(u);
1618 if (ec && exec_context_may_touch_console(ec)) {
1619 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1622 if (m->n_on_console == 0)
1623 /* unset no_console_output flag, since the console is free */
1624 m->no_console_output = false;
1633 if (u->job->state == JOB_WAITING)
1635 /* So we reached a different state for this
1636 * job. Let's see if we can run it now if it
1637 * failed previously due to EAGAIN. */
1638 job_add_to_run_queue(u->job);
1640 /* Let's check whether this state change constitutes a
1641 * finished job, or maybe contradicts a running job and
1642 * hence needs to invalidate jobs. */
1644 switch (u->job->type) {
1647 case JOB_VERIFY_ACTIVE:
1649 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1650 job_finish_and_invalidate(u->job, JOB_DONE, true);
1651 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1654 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1655 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1661 case JOB_RELOAD_OR_START:
1663 if (u->job->state == JOB_RUNNING) {
1664 if (ns == UNIT_ACTIVE)
1665 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1666 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1669 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1670 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1678 case JOB_TRY_RESTART:
1680 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1681 job_finish_and_invalidate(u->job, JOB_DONE, true);
1682 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1684 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1690 assert_not_reached("Job type unknown");
1696 if (m->n_reloading <= 0) {
1698 /* If this state change happened without being
1699 * requested by a job, then let's retroactively start
1700 * or stop dependencies. We skip that step when
1701 * deserializing, since we don't want to create any
1702 * additional jobs just because something is already
1706 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1707 retroactively_start_dependencies(u);
1708 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1709 retroactively_stop_dependencies(u);
1712 /* stop unneeded units regardless if going down was expected or not */
1713 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1714 check_unneeded_dependencies(u);
1716 if (ns != os && ns == UNIT_FAILED) {
1717 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1718 unit_start_on_failure(u);
1722 /* Some names are special */
1723 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1725 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1726 /* The bus might have just become available,
1727 * hence try to connect to it, if we aren't
1731 if (u->type == UNIT_SERVICE &&
1732 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1733 m->n_reloading <= 0) {
1734 /* Write audit record if we have just finished starting up */
1735 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1739 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1740 manager_send_unit_plymouth(m, u);
1744 /* We don't care about D-Bus here, since we'll get an
1745 * asynchronous notification for it anyway. */
1747 if (u->type == UNIT_SERVICE &&
1748 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1749 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1750 m->n_reloading <= 0) {
1752 /* Hmm, if there was no start record written
1753 * write it now, so that we always have a nice
1756 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1758 if (ns == UNIT_INACTIVE)
1759 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1761 /* Write audit record if we have just finished shutting down */
1762 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1764 u->in_audit = false;
1768 manager_recheck_journal(m);
1769 unit_trigger_notify(u);
1771 /* Maybe we finished startup and are now ready for being
1772 * stopped because unneeded? */
1773 if (u->manager->n_reloading <= 0)
1774 unit_check_unneeded(u);
1776 unit_add_to_dbus_queue(u);
1777 unit_add_to_gc_queue(u);
1780 int unit_watch_pid(Unit *u, pid_t pid) {
1786 /* Watch a specific PID. We only support one or two units
1787 * watching each PID for now, not more. */
1789 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1793 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1797 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1799 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1803 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1806 q = set_put(u->pids, LONG_TO_PTR(pid));
1813 void unit_unwatch_pid(Unit *u, pid_t pid) {
1817 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1818 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1819 set_remove(u->pids, LONG_TO_PTR(pid));
1822 void unit_unwatch_all_pids(Unit *u) {
1825 while (!set_isempty(u->pids))
1826 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1832 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1833 _cleanup_closedir_ DIR *d = NULL;
1834 _cleanup_fclose_ FILE *f = NULL;
1840 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1842 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1846 while ((r = cg_read_pid(f, &pid)) > 0) {
1847 r = unit_watch_pid(u, pid);
1848 if (r < 0 && ret >= 0)
1851 if (r < 0 && ret >= 0)
1854 } else if (ret >= 0)
1857 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1861 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1862 _cleanup_free_ char *p = NULL;
1864 p = strjoin(path, "/", fn, NULL);
1870 r = unit_watch_pids_in_path(u, p);
1871 if (r < 0 && ret >= 0)
1874 if (r < 0 && ret >= 0)
1877 } else if (ret >= 0)
1883 int unit_watch_all_pids(Unit *u) {
1886 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1888 if (!u->cgroup_path)
1891 return unit_watch_pids_in_path(u, u->cgroup_path);
1894 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1900 /* Cleans dead PIDs from our list */
1902 SET_FOREACH(e, u->pids, i) {
1903 pid_t pid = PTR_TO_LONG(e);
1905 if (pid == except1 || pid == except2)
1908 if (!pid_is_unwaited(pid))
1909 unit_unwatch_pid(u, pid);
1913 bool unit_job_is_applicable(Unit *u, JobType j) {
1915 assert(j >= 0 && j < _JOB_TYPE_MAX);
1919 case JOB_VERIFY_ACTIVE:
1926 case JOB_TRY_RESTART:
1927 return unit_can_start(u);
1930 return unit_can_reload(u);
1932 case JOB_RELOAD_OR_START:
1933 return unit_can_reload(u) && unit_can_start(u);
1936 assert_not_reached("Invalid job type");
1940 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1942 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1943 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1944 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1945 [UNIT_WANTS] = UNIT_WANTED_BY,
1946 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1947 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1948 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1949 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1950 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1951 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1952 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1953 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1954 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1955 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1956 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1957 [UNIT_BEFORE] = UNIT_AFTER,
1958 [UNIT_AFTER] = UNIT_BEFORE,
1959 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1960 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1961 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1962 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1963 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1964 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1965 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1966 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1968 int r, q = 0, v = 0, w = 0;
1971 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1974 u = unit_follow_merge(u);
1975 other = unit_follow_merge(other);
1977 /* We won't allow dependencies on ourselves. We will not
1978 * consider them an error however. */
1982 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1986 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1987 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1992 if (add_reference) {
1993 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1997 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
2002 q = set_put(u->dependencies[d], other);
2006 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2007 v = set_put(other->dependencies[inverse_table[d]], u);
2014 if (add_reference) {
2015 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2021 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2026 unit_add_to_dbus_queue(u);
2031 set_remove(u->dependencies[d], other);
2034 set_remove(other->dependencies[inverse_table[d]], u);
2037 set_remove(u->dependencies[UNIT_REFERENCES], other);
2042 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2047 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2050 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2056 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2060 assert(name || path);
2064 name = basename(path);
2066 if (!unit_name_is_template(name)) {
2072 s = unit_name_replace_instance(name, u->instance);
2074 _cleanup_free_ char *i = NULL;
2076 i = unit_name_to_prefix(u->id);
2080 s = unit_name_replace_instance(name, i);
2090 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2093 _cleanup_free_ char *s = NULL;
2096 assert(name || path);
2098 name = resolve_template(u, name, path, &s);
2102 r = manager_load_unit(u->manager, name, path, NULL, &other);
2106 return unit_add_dependency(u, d, other, add_reference);
2109 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2112 _cleanup_free_ char *s = NULL;
2115 assert(name || path);
2117 if (!(name = resolve_template(u, name, path, &s)))
2120 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2123 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2128 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2131 _cleanup_free_ char *s = NULL;
2134 assert(name || path);
2136 if (!(name = resolve_template(u, name, path, &s)))
2139 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2142 r = unit_add_dependency(other, d, u, add_reference);
2147 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2150 _cleanup_free_ char *s = NULL;
2153 assert(name || path);
2155 if (!(name = resolve_template(u, name, path, &s)))
2158 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2161 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2167 int set_unit_path(const char *p) {
2168 /* This is mostly for debug purposes */
2169 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2175 char *unit_dbus_path(Unit *u) {
2181 return unit_dbus_path_from_name(u->id);
2184 char *unit_default_cgroup_path(Unit *u) {
2185 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2190 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2191 return strdup(u->manager->cgroup_root);
2193 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2194 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2199 escaped = cg_escape(u->id);
2204 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2206 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2209 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2210 _cleanup_free_ char *b = NULL;
2211 const char *slice_name;
2218 if (UNIT_ISSET(u->slice))
2222 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2224 /* Implicitly place all instantiated units in their
2225 * own per-template slice */
2227 prefix = unit_name_to_prefix(u->id);
2231 /* The prefix is already escaped, but it might include
2232 * "-" which has a special meaning for slice units,
2233 * hence escape it here extra. */
2234 escaped = strreplace(prefix, "-", "\\x2d");
2238 if (u->manager->running_as == SYSTEMD_SYSTEM)
2239 b = strjoin("system-", escaped, ".slice", NULL);
2241 b = strappend(escaped, ".slice");
2248 u->manager->running_as == SYSTEMD_SYSTEM
2249 ? SPECIAL_SYSTEM_SLICE
2250 : SPECIAL_ROOT_SLICE;
2252 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2256 unit_ref_set(&u->slice, slice);
2260 const char *unit_slice_name(Unit *u) {
2263 if (!UNIT_ISSET(u->slice))
2266 return UNIT_DEREF(u->slice)->id;
2269 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2270 _cleanup_free_ char *t = NULL;
2277 t = unit_name_change_suffix(u->id, type);
2281 assert(!unit_has_name(u, t));
2283 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2284 assert(r < 0 || *_found != u);
2288 int unit_watch_bus_name(Unit *u, const char *name) {
2292 /* Watch a specific name on the bus. We only support one unit
2293 * watching each name for now. */
2295 return hashmap_put(u->manager->watch_bus, name, u);
2298 void unit_unwatch_bus_name(Unit *u, const char *name) {
2302 hashmap_remove_value(u->manager->watch_bus, name, u);
2305 bool unit_can_serialize(Unit *u) {
2308 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2311 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2318 if (unit_can_serialize(u)) {
2321 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2325 rt = unit_get_exec_runtime(u);
2327 r = exec_runtime_serialize(rt, u, f, fds);
2333 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2334 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2335 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2336 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2337 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2339 if (dual_timestamp_is_set(&u->condition_timestamp))
2340 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2342 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2345 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2347 if (serialize_jobs) {
2349 fprintf(f, "job\n");
2350 job_serialize(u->job, f, fds);
2354 fprintf(f, "job\n");
2355 job_serialize(u->nop_job, f, fds);
2364 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2375 va_start(ap, format);
2376 vfprintf(f, format, ap);
2382 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2388 fprintf(f, "%s=%s\n", key, value);
2391 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2392 ExecRuntime **rt = NULL;
2400 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2402 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2405 char line[LINE_MAX], *l, *v;
2408 if (!fgets(line, sizeof(line), f)) {
2421 k = strcspn(l, "=");
2429 if (streq(l, "job")) {
2431 /* new-style serialized job */
2432 Job *j = job_new_raw(u);
2436 r = job_deserialize(j, f, fds);
2442 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2448 r = job_install_deserialized(j);
2450 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2455 if (j->state == JOB_RUNNING)
2456 u->manager->n_running_jobs++;
2459 JobType type = job_type_from_string(v);
2461 log_debug("Failed to parse job type value %s", v);
2463 u->deserialized_job = type;
2466 } else if (streq(l, "inactive-exit-timestamp")) {
2467 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2469 } else if (streq(l, "active-enter-timestamp")) {
2470 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2472 } else if (streq(l, "active-exit-timestamp")) {
2473 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2475 } else if (streq(l, "inactive-enter-timestamp")) {
2476 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2478 } else if (streq(l, "condition-timestamp")) {
2479 dual_timestamp_deserialize(v, &u->condition_timestamp);
2481 } else if (streq(l, "condition-result")) {
2484 b = parse_boolean(v);
2486 log_debug("Failed to parse condition result value %s", v);
2488 u->condition_result = b;
2492 } else if (streq(l, "transient")) {
2495 b = parse_boolean(v);
2497 log_debug("Failed to parse transient bool %s", v);
2502 } else if (streq(l, "cgroup")) {
2509 if (u->cgroup_path) {
2512 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2513 log_info("Removing cgroup_path %s from hashmap (%p)",
2515 free(u->cgroup_path);
2519 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2524 if (unit_can_serialize(u)) {
2526 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2533 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2540 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2542 _cleanup_free_ char *e = NULL;
2550 /* Adds in links to the device node that this unit is based on */
2552 if (!is_device_path(what))
2555 e = unit_name_from_path(what, ".device");
2559 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2564 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2569 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2577 int unit_coldplug(Unit *u) {
2582 if (UNIT_VTABLE(u)->coldplug)
2583 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2587 r = job_coldplug(u->job);
2590 } else if (u->deserialized_job >= 0) {
2592 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2596 u->deserialized_job = _JOB_TYPE_INVALID;
2602 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2603 DISABLE_WARNING_FORMAT_NONLITERAL;
2604 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2608 bool unit_need_daemon_reload(Unit *u) {
2609 _cleanup_strv_free_ char **t = NULL;
2612 unsigned loaded_cnt, current_cnt;
2616 if (u->fragment_path) {
2618 if (stat(u->fragment_path, &st) < 0)
2619 /* What, cannot access this anymore? */
2622 if (u->fragment_mtime > 0 &&
2623 timespec_load(&st.st_mtim) != u->fragment_mtime)
2627 if (u->source_path) {
2629 if (stat(u->source_path, &st) < 0)
2632 if (u->source_mtime > 0 &&
2633 timespec_load(&st.st_mtim) != u->source_mtime)
2637 t = unit_find_dropin_paths(u);
2638 loaded_cnt = strv_length(t);
2639 current_cnt = strv_length(u->dropin_paths);
2641 if (loaded_cnt == current_cnt) {
2642 if (loaded_cnt == 0)
2645 if (strv_overlap(u->dropin_paths, t)) {
2646 STRV_FOREACH(path, u->dropin_paths) {
2648 if (stat(*path, &st) < 0)
2651 if (u->dropin_mtime > 0 &&
2652 timespec_load(&st.st_mtim) > u->dropin_mtime)
2663 void unit_reset_failed(Unit *u) {
2666 if (UNIT_VTABLE(u)->reset_failed)
2667 UNIT_VTABLE(u)->reset_failed(u);
2670 Unit *unit_following(Unit *u) {
2673 if (UNIT_VTABLE(u)->following)
2674 return UNIT_VTABLE(u)->following(u);
2679 bool unit_stop_pending(Unit *u) {
2682 /* This call does check the current state of the unit. It's
2683 * hence useful to be called from state change calls of the
2684 * unit itself, where the state isn't updated yet. This is
2685 * different from unit_inactive_or_pending() which checks both
2686 * the current state and for a queued job. */
2688 return u->job && u->job->type == JOB_STOP;
2691 bool unit_inactive_or_pending(Unit *u) {
2694 /* Returns true if the unit is inactive or going down */
2696 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2699 if (unit_stop_pending(u))
2705 bool unit_active_or_pending(Unit *u) {
2708 /* Returns true if the unit is active or going up */
2710 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2714 (u->job->type == JOB_START ||
2715 u->job->type == JOB_RELOAD_OR_START ||
2716 u->job->type == JOB_RESTART))
2722 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2724 assert(w >= 0 && w < _KILL_WHO_MAX);
2726 assert(signo < _NSIG);
2728 if (!UNIT_VTABLE(u)->kill)
2731 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2734 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2738 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2742 /* Exclude the main/control pids from being killed via the cgroup */
2744 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2749 if (control_pid > 0) {
2750 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2762 int unit_kill_common(
2768 sd_bus_error *error) {
2772 if (who == KILL_MAIN && main_pid <= 0) {
2774 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2776 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2780 if (who == KILL_CONTROL && control_pid <= 0) {
2781 if (control_pid < 0)
2782 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2784 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2788 if (who == KILL_CONTROL || who == KILL_ALL)
2789 if (control_pid > 0)
2790 if (kill(control_pid, signo) < 0)
2793 if (who == KILL_MAIN || who == KILL_ALL)
2795 if (kill(main_pid, signo) < 0)
2798 if (who == KILL_ALL && u->cgroup_path) {
2799 _cleanup_set_free_ Set *pid_set = NULL;
2802 /* Exclude the main/control pids from being killed via the cgroup */
2803 pid_set = unit_pid_set(main_pid, control_pid);
2807 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2808 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2815 int unit_following_set(Unit *u, Set **s) {
2819 if (UNIT_VTABLE(u)->following_set)
2820 return UNIT_VTABLE(u)->following_set(u, s);
2826 UnitFileState unit_get_unit_file_state(Unit *u) {
2829 if (u->unit_file_state < 0 && u->fragment_path)
2830 u->unit_file_state = unit_file_get_state(
2831 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2832 NULL, basename(u->fragment_path));
2834 return u->unit_file_state;
2837 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2842 unit_ref_unset(ref);
2845 LIST_PREPEND(refs, u->refs, ref);
2849 void unit_ref_unset(UnitRef *ref) {
2855 LIST_REMOVE(refs, ref->unit->refs, ref);
2859 int unit_patch_contexts(Unit *u) {
2867 /* Patch in the manager defaults into the exec and cgroup
2868 * contexts, _after_ the rest of the settings have been
2871 ec = unit_get_exec_context(u);
2873 /* This only copies in the ones that need memory */
2874 for (i = 0; i < _RLIMIT_MAX; i++)
2875 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2876 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2881 if (u->manager->running_as == SYSTEMD_USER &&
2882 !ec->working_directory) {
2884 r = get_home_dir(&ec->working_directory);
2889 if (u->manager->running_as == SYSTEMD_USER &&
2890 (ec->syscall_whitelist ||
2891 !set_isempty(ec->syscall_filter) ||
2892 !set_isempty(ec->syscall_archs) ||
2893 ec->address_families_whitelist ||
2894 !set_isempty(ec->address_families)))
2895 ec->no_new_privileges = true;
2897 if (ec->private_devices)
2898 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2901 cc = unit_get_cgroup_context(u);
2905 ec->private_devices &&
2906 cc->device_policy == CGROUP_AUTO)
2907 cc->device_policy = CGROUP_CLOSED;
2913 ExecContext *unit_get_exec_context(Unit *u) {
2920 offset = UNIT_VTABLE(u)->exec_context_offset;
2924 return (ExecContext*) ((uint8_t*) u + offset);
2927 KillContext *unit_get_kill_context(Unit *u) {
2934 offset = UNIT_VTABLE(u)->kill_context_offset;
2938 return (KillContext*) ((uint8_t*) u + offset);
2941 CGroupContext *unit_get_cgroup_context(Unit *u) {
2947 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2951 return (CGroupContext*) ((uint8_t*) u + offset);
2954 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2960 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2964 return *(ExecRuntime**) ((uint8_t*) u + offset);
2967 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
2968 if (u->manager->running_as == SYSTEMD_USER) {
2971 r = user_config_home(dir);
2977 if (mode == UNIT_PERSISTENT && !transient)
2978 *dir = strdup("/etc/systemd/system");
2980 *dir = strdup("/run/systemd/system");
2987 static int unit_drop_in_file(Unit *u,
2988 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
2989 _cleanup_free_ char *dir = NULL;
2994 r = unit_drop_in_dir(u, mode, u->transient, &dir);
2998 return drop_in_file(dir, u->id, 50, name, p, q);
3001 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3003 _cleanup_free_ char *dir = NULL;
3008 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3011 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3015 return write_drop_in(dir, u->id, 50, name, data);
3018 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3019 _cleanup_free_ char *p = NULL;
3027 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3030 va_start(ap, format);
3031 r = vasprintf(&p, format, ap);
3037 return unit_write_drop_in(u, mode, name, p);
3040 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3041 _cleanup_free_ char *ndata = NULL;
3047 if (!UNIT_VTABLE(u)->private_section)
3050 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3053 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3057 return unit_write_drop_in(u, mode, name, ndata);
3060 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3061 _cleanup_free_ char *p = NULL;
3069 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3072 va_start(ap, format);
3073 r = vasprintf(&p, format, ap);
3079 return unit_write_drop_in_private(u, mode, name, p);
3082 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3083 _cleanup_free_ char *p = NULL, *q = NULL;
3088 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3091 r = unit_drop_in_file(u, mode, name, &p, &q);
3096 r = errno == ENOENT ? 0 : -errno;
3104 int unit_make_transient(Unit *u) {
3109 u->load_state = UNIT_STUB;
3111 u->transient = true;
3113 free(u->fragment_path);
3114 u->fragment_path = NULL;
3116 if (u->manager->running_as == SYSTEMD_USER) {
3117 _cleanup_free_ char *c = NULL;
3119 r = user_config_home(&c);
3125 u->fragment_path = strjoin(c, "/", u->id, NULL);
3126 if (!u->fragment_path)
3131 u->fragment_path = strappend("/run/systemd/system/", u->id);
3132 if (!u->fragment_path)
3135 mkdir_p("/run/systemd/system", 0755);
3138 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3141 int unit_kill_context(
3147 bool main_pid_alien) {
3149 int sig, wait_for_exit = false, r;
3154 if (c->kill_mode == KILL_NONE)
3157 sig = sigkill ? SIGKILL : c->kill_signal;
3160 r = kill_and_sigcont(main_pid, sig);
3162 if (r < 0 && r != -ESRCH) {
3163 _cleanup_free_ char *comm = NULL;
3164 get_process_comm(main_pid, &comm);
3166 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3168 if (!main_pid_alien)
3169 wait_for_exit = true;
3171 if (c->send_sighup && !sigkill)
3172 kill(main_pid, SIGHUP);
3176 if (control_pid > 0) {
3177 r = kill_and_sigcont(control_pid, sig);
3179 if (r < 0 && r != -ESRCH) {
3180 _cleanup_free_ char *comm = NULL;
3181 get_process_comm(control_pid, &comm);
3183 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3185 wait_for_exit = true;
3187 if (c->send_sighup && !sigkill)
3188 kill(control_pid, SIGHUP);
3192 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3193 _cleanup_set_free_ Set *pid_set = NULL;
3195 /* Exclude the main/control pids from being killed via the cgroup */
3196 pid_set = unit_pid_set(main_pid, control_pid);
3200 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3202 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3203 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3206 /* FIXME: For now, we will not wait for the
3207 * cgroup members to die, simply because
3208 * cgroup notification is unreliable. It
3209 * doesn't work at all in containers, and
3210 * outside of containers it can be confused
3211 * easily by leaving directories in the
3214 /* wait_for_exit = true; */
3216 if (c->send_sighup && !sigkill) {
3219 pid_set = unit_pid_set(main_pid, control_pid);
3223 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3228 return wait_for_exit;
3231 int unit_require_mounts_for(Unit *u, const char *path) {
3232 char prefix[strlen(path) + 1], *p;
3238 /* Registers a unit for requiring a certain path and all its
3239 * prefixes. We keep a simple array of these paths in the
3240 * unit, since its usually short. However, we build a prefix
3241 * table for all possible prefixes so that new appearing mount
3242 * units can easily determine which units to make themselves a
3245 if (!path_is_absolute(path))
3252 path_kill_slashes(p);
3254 if (!path_is_safe(p)) {
3259 if (strv_contains(u->requires_mounts_for, p)) {
3264 r = strv_consume(&u->requires_mounts_for, p);
3268 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3271 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3275 if (!u->manager->units_requiring_mounts_for) {
3276 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3277 if (!u->manager->units_requiring_mounts_for)
3285 x = set_new(NULL, NULL);
3291 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3307 int unit_setup_exec_runtime(Unit *u) {
3313 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3316 /* Check if ther already is an ExecRuntime for this unit? */
3317 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3321 /* Try to get it from somebody else */
3322 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3324 *rt = unit_get_exec_runtime(other);
3326 exec_runtime_ref(*rt);
3331 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3334 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3335 [UNIT_ACTIVE] = "active",
3336 [UNIT_RELOADING] = "reloading",
3337 [UNIT_INACTIVE] = "inactive",
3338 [UNIT_FAILED] = "failed",
3339 [UNIT_ACTIVATING] = "activating",
3340 [UNIT_DEACTIVATING] = "deactivating"
3343 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3345 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3346 [UNIT_REQUIRES] = "Requires",
3347 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3348 [UNIT_REQUISITE] = "Requisite",
3349 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3350 [UNIT_WANTS] = "Wants",
3351 [UNIT_BINDS_TO] = "BindsTo",
3352 [UNIT_PART_OF] = "PartOf",
3353 [UNIT_REQUIRED_BY] = "RequiredBy",
3354 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3355 [UNIT_WANTED_BY] = "WantedBy",
3356 [UNIT_BOUND_BY] = "BoundBy",
3357 [UNIT_CONSISTS_OF] = "ConsistsOf",
3358 [UNIT_CONFLICTS] = "Conflicts",
3359 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3360 [UNIT_BEFORE] = "Before",
3361 [UNIT_AFTER] = "After",
3362 [UNIT_ON_FAILURE] = "OnFailure",
3363 [UNIT_TRIGGERS] = "Triggers",
3364 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3365 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3366 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3367 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3368 [UNIT_REFERENCES] = "References",
3369 [UNIT_REFERENCED_BY] = "ReferencedBy",
3372 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);