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 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency);
74 Unit *unit_new(Manager *m, size_t size) {
78 assert(size >= sizeof(Unit));
84 u->names = set_new(&string_hash_ops);
91 u->type = _UNIT_TYPE_INVALID;
92 u->deserialized_job = _JOB_TYPE_INVALID;
93 u->default_dependencies = true;
94 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
95 u->on_failure_job_mode = JOB_REPLACE;
100 bool unit_has_name(Unit *u, const char *name) {
104 return !!set_get(u->names, (char*) name);
107 static void unit_init(Unit *u) {
114 assert(u->type >= 0);
116 cc = unit_get_cgroup_context(u);
118 cgroup_context_init(cc);
120 /* Copy in the manager defaults into the cgroup
121 * context, _before_ the rest of the settings have
122 * been initialized */
124 cc->cpu_accounting = u->manager->default_cpu_accounting;
125 cc->blockio_accounting = u->manager->default_blockio_accounting;
126 cc->memory_accounting = u->manager->default_memory_accounting;
129 ec = unit_get_exec_context(u);
131 exec_context_init(ec);
133 kc = unit_get_kill_context(u);
135 kill_context_init(kc);
137 if (UNIT_VTABLE(u)->init)
138 UNIT_VTABLE(u)->init(u);
141 int unit_add_name(Unit *u, const char *text) {
142 _cleanup_free_ char *s = NULL, *i = NULL;
149 if (unit_name_is_template(text)) {
154 s = unit_name_replace_instance(text, u->instance);
160 if (!unit_name_is_valid(s, TEMPLATE_INVALID))
163 assert_se((t = unit_name_to_type(s)) >= 0);
165 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
168 r = unit_name_to_instance(s, &i);
172 if (i && unit_vtable[t]->no_instances)
175 /* Ensure that this unit is either instanced or not instanced,
177 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
180 if (unit_vtable[t]->no_alias &&
181 !set_isempty(u->names) &&
182 !set_get(u->names, s))
185 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
188 r = set_put(u->names, s);
196 r = hashmap_put(u->manager->units, s, u);
198 set_remove(u->names, s);
202 if (u->type == _UNIT_TYPE_INVALID) {
207 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
216 unit_add_to_dbus_queue(u);
220 int unit_choose_id(Unit *u, const char *name) {
221 _cleanup_free_ char *t = NULL;
228 if (unit_name_is_template(name)) {
233 t = unit_name_replace_instance(name, u->instance);
240 /* Selects one of the names of this unit as the id */
241 s = set_get(u->names, (char*) name);
245 r = unit_name_to_instance(s, &i);
254 unit_add_to_dbus_queue(u);
259 int unit_set_description(Unit *u, const char *description) {
264 if (isempty(description))
267 s = strdup(description);
272 free(u->description);
275 unit_add_to_dbus_queue(u);
279 bool unit_check_gc(Unit *u) {
282 if (UNIT_VTABLE(u)->no_gc)
294 if (unit_active_state(u) != UNIT_INACTIVE)
300 if (UNIT_VTABLE(u)->check_gc)
301 if (UNIT_VTABLE(u)->check_gc(u))
307 void unit_add_to_load_queue(Unit *u) {
309 assert(u->type != _UNIT_TYPE_INVALID);
311 if (u->load_state != UNIT_STUB || u->in_load_queue)
314 LIST_PREPEND(load_queue, u->manager->load_queue, u);
315 u->in_load_queue = true;
318 void unit_add_to_cleanup_queue(Unit *u) {
321 if (u->in_cleanup_queue)
324 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
325 u->in_cleanup_queue = true;
328 void unit_add_to_gc_queue(Unit *u) {
331 if (u->in_gc_queue || u->in_cleanup_queue)
334 if (unit_check_gc(u))
337 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
338 u->in_gc_queue = true;
340 u->manager->n_in_gc_queue ++;
343 void unit_add_to_dbus_queue(Unit *u) {
345 assert(u->type != _UNIT_TYPE_INVALID);
347 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
350 /* Shortcut things if nobody cares */
351 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
352 set_isempty(u->manager->private_buses)) {
353 u->sent_dbus_new_signal = true;
357 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
358 u->in_dbus_queue = true;
361 static void bidi_set_free(Unit *u, Set *s) {
367 /* Frees the set and makes sure we are dropped from the
368 * inverse pointers */
370 SET_FOREACH(other, s, i) {
373 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
374 set_remove(other->dependencies[d], u);
376 unit_add_to_gc_queue(other);
382 static void unit_remove_transient(Unit *u) {
390 if (u->fragment_path)
391 unlink(u->fragment_path);
393 STRV_FOREACH(i, u->dropin_paths) {
394 _cleanup_free_ char *p = NULL;
399 r = path_get_parent(*i, &p);
405 static void unit_free_requires_mounts_for(Unit *u) {
408 STRV_FOREACH(j, u->requires_mounts_for) {
409 char s[strlen(*j) + 1];
411 PATH_FOREACH_PREFIX_MORE(s, *j) {
415 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
421 if (set_isempty(x)) {
422 hashmap_remove(u->manager->units_requiring_mounts_for, y);
429 strv_free(u->requires_mounts_for);
430 u->requires_mounts_for = NULL;
433 static void unit_done(Unit *u) {
442 if (UNIT_VTABLE(u)->done)
443 UNIT_VTABLE(u)->done(u);
445 ec = unit_get_exec_context(u);
447 exec_context_done(ec);
449 cc = unit_get_cgroup_context(u);
451 cgroup_context_done(cc);
454 void unit_free(Unit *u) {
461 if (u->manager->n_reloading <= 0)
462 unit_remove_transient(u);
464 bus_unit_send_removed_signal(u);
468 unit_free_requires_mounts_for(u);
470 SET_FOREACH(t, u->names, i)
471 hashmap_remove_value(u->manager->units, t, u);
485 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
486 bidi_set_free(u, u->dependencies[d]);
488 if (u->type != _UNIT_TYPE_INVALID)
489 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
491 if (u->in_load_queue)
492 LIST_REMOVE(load_queue, u->manager->load_queue, u);
494 if (u->in_dbus_queue)
495 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
497 if (u->in_cleanup_queue)
498 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
500 if (u->in_gc_queue) {
501 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
502 u->manager->n_in_gc_queue--;
505 if (u->in_cgroup_queue)
506 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
508 if (u->cgroup_path) {
509 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
510 free(u->cgroup_path);
513 set_remove(u->manager->failed_units, u);
514 set_remove(u->manager->startup_units, u);
516 free(u->description);
517 strv_free(u->documentation);
518 free(u->fragment_path);
519 free(u->source_path);
520 strv_free(u->dropin_paths);
523 free(u->job_timeout_reboot_arg);
525 set_free_free(u->names);
527 unit_unwatch_all_pids(u);
529 condition_free_list(u->conditions);
531 unit_ref_unset(&u->slice);
534 unit_ref_unset(u->refs);
539 UnitActiveState unit_active_state(Unit *u) {
542 if (u->load_state == UNIT_MERGED)
543 return unit_active_state(unit_follow_merge(u));
545 /* After a reload it might happen that a unit is not correctly
546 * loaded but still has a process around. That's why we won't
547 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
549 return UNIT_VTABLE(u)->active_state(u);
552 const char* unit_sub_state_to_string(Unit *u) {
555 return UNIT_VTABLE(u)->sub_state_to_string(u);
558 static int complete_move(Set **s, Set **other) {
568 r = set_move(*s, *other);
579 static int merge_names(Unit *u, Unit *other) {
587 r = complete_move(&u->names, &other->names);
591 set_free_free(other->names);
595 SET_FOREACH(t, u->names, i)
596 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
601 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
606 assert(d < _UNIT_DEPENDENCY_MAX);
609 * If u does not have this dependency set allocated, there is no need
610 * to reserve anything. In that case other's set will be transfered
611 * as a whole to u by complete_move().
613 if (!u->dependencies[d])
616 /* merge_dependencies() will skip a u-on-u dependency */
617 n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
619 return set_reserve(u->dependencies[d], n_reserve);
622 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
629 assert(d < _UNIT_DEPENDENCY_MAX);
631 /* Fix backwards pointers */
632 SET_FOREACH(back, other->dependencies[d], i) {
635 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
636 /* Do not add dependencies between u and itself */
638 if (set_remove(back->dependencies[k], other))
639 maybe_warn_about_dependency(u->id, other_id, k);
641 r = set_remove_and_put(back->dependencies[k], other, u);
643 set_remove(back->dependencies[k], other);
645 assert(r >= 0 || r == -ENOENT);
650 /* Also do not move dependencies on u to itself */
651 back = set_remove(other->dependencies[d], u);
653 maybe_warn_about_dependency(u->id, other_id, d);
655 /* The move cannot fail. The caller must have performed a reservation. */
656 assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
658 set_free(other->dependencies[d]);
659 other->dependencies[d] = NULL;
662 int unit_merge(Unit *u, Unit *other) {
664 const char *other_id = NULL;
669 assert(u->manager == other->manager);
670 assert(u->type != _UNIT_TYPE_INVALID);
672 other = unit_follow_merge(other);
677 if (u->type != other->type)
680 if (!u->instance != !other->instance)
683 if (other->load_state != UNIT_STUB &&
684 other->load_state != UNIT_NOT_FOUND)
693 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
697 other_id = strdupa(other->id);
699 /* Make reservations to ensure merge_dependencies() won't fail */
700 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
701 r = reserve_dependencies(u, other, d);
703 * We don't rollback reservations if we fail. We don't have
704 * a way to undo reservations. A reservation is not a leak.
711 r = merge_names(u, other);
715 /* Redirect all references */
717 unit_ref_set(other->refs, u);
719 /* Merge dependencies */
720 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
721 merge_dependencies(u, other, other_id, d);
723 other->load_state = UNIT_MERGED;
724 other->merged_into = u;
726 /* If there is still some data attached to the other node, we
727 * don't need it anymore, and can free it. */
728 if (other->load_state != UNIT_STUB)
729 if (UNIT_VTABLE(other)->done)
730 UNIT_VTABLE(other)->done(other);
732 unit_add_to_dbus_queue(u);
733 unit_add_to_cleanup_queue(other);
738 int unit_merge_by_name(Unit *u, const char *name) {
741 _cleanup_free_ char *s = NULL;
746 if (unit_name_is_template(name)) {
750 s = unit_name_replace_instance(name, u->instance);
757 other = manager_get_unit(u->manager, name);
759 r = unit_add_name(u, name);
761 r = unit_merge(u, other);
766 Unit* unit_follow_merge(Unit *u) {
769 while (u->load_state == UNIT_MERGED)
770 assert_se(u = u->merged_into);
775 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
781 if (c->working_directory) {
782 r = unit_require_mounts_for(u, c->working_directory);
787 if (c->root_directory) {
788 r = unit_require_mounts_for(u, c->root_directory);
793 if (u->manager->running_as != SYSTEMD_SYSTEM)
796 if (c->private_tmp) {
797 r = unit_require_mounts_for(u, "/tmp");
801 r = unit_require_mounts_for(u, "/var/tmp");
806 if (c->std_output != EXEC_OUTPUT_KMSG &&
807 c->std_output != EXEC_OUTPUT_SYSLOG &&
808 c->std_output != EXEC_OUTPUT_JOURNAL &&
809 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
810 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
811 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
812 c->std_error != EXEC_OUTPUT_KMSG &&
813 c->std_error != EXEC_OUTPUT_SYSLOG &&
814 c->std_error != EXEC_OUTPUT_JOURNAL &&
815 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
816 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
817 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
820 /* If syslog or kernel logging is requested, make sure our own
821 * logging daemon is run first. */
823 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
830 const char *unit_description(Unit *u) {
834 return u->description;
839 void unit_dump(Unit *u, FILE *f, const char *prefix) {
845 timestamp1[FORMAT_TIMESTAMP_MAX],
846 timestamp2[FORMAT_TIMESTAMP_MAX],
847 timestamp3[FORMAT_TIMESTAMP_MAX],
848 timestamp4[FORMAT_TIMESTAMP_MAX],
849 timespan[FORMAT_TIMESPAN_MAX];
851 _cleanup_set_free_ Set *following_set = NULL;
855 assert(u->type >= 0);
857 prefix = strempty(prefix);
858 prefix2 = strappenda(prefix, "\t");
862 "%s\tDescription: %s\n"
864 "%s\tUnit Load State: %s\n"
865 "%s\tUnit Active State: %s\n"
866 "%s\tInactive Exit Timestamp: %s\n"
867 "%s\tActive Enter Timestamp: %s\n"
868 "%s\tActive Exit Timestamp: %s\n"
869 "%s\tInactive Enter Timestamp: %s\n"
870 "%s\tGC Check Good: %s\n"
871 "%s\tNeed Daemon Reload: %s\n"
872 "%s\tTransient: %s\n"
875 "%s\tCGroup realized: %s\n"
876 "%s\tCGroup mask: 0x%x\n"
877 "%s\tCGroup members mask: 0x%x\n",
879 prefix, unit_description(u),
880 prefix, strna(u->instance),
881 prefix, unit_load_state_to_string(u->load_state),
882 prefix, unit_active_state_to_string(unit_active_state(u)),
883 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
884 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
885 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
886 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
887 prefix, yes_no(unit_check_gc(u)),
888 prefix, yes_no(unit_need_daemon_reload(u)),
889 prefix, yes_no(u->transient),
890 prefix, strna(unit_slice_name(u)),
891 prefix, strna(u->cgroup_path),
892 prefix, yes_no(u->cgroup_realized),
893 prefix, u->cgroup_realized_mask,
894 prefix, u->cgroup_members_mask);
896 SET_FOREACH(t, u->names, i)
897 fprintf(f, "%s\tName: %s\n", prefix, t);
899 STRV_FOREACH(j, u->documentation)
900 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
902 following = unit_following(u);
904 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
906 r = unit_following_set(u, &following_set);
910 SET_FOREACH(other, following_set, i)
911 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
914 if (u->fragment_path)
915 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
918 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
920 STRV_FOREACH(j, u->dropin_paths)
921 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
923 if (u->job_timeout > 0)
924 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
926 if (u->job_timeout_action != FAILURE_ACTION_NONE)
927 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
929 if (u->job_timeout_reboot_arg)
930 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
932 condition_dump_list(u->conditions, f, prefix);
934 if (dual_timestamp_is_set(&u->condition_timestamp))
936 "%s\tCondition Timestamp: %s\n"
937 "%s\tCondition Result: %s\n",
938 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
939 prefix, yes_no(u->condition_result));
941 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
944 SET_FOREACH(other, u->dependencies[d], i)
945 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
948 if (!strv_isempty(u->requires_mounts_for)) {
950 "%s\tRequiresMountsFor:", prefix);
952 STRV_FOREACH(j, u->requires_mounts_for)
953 fprintf(f, " %s", *j);
958 if (u->load_state == UNIT_LOADED) {
961 "%s\tStopWhenUnneeded: %s\n"
962 "%s\tRefuseManualStart: %s\n"
963 "%s\tRefuseManualStop: %s\n"
964 "%s\tDefaultDependencies: %s\n"
965 "%s\tOnFailureJobMode: %s\n"
966 "%s\tIgnoreOnIsolate: %s\n"
967 "%s\tIgnoreOnSnapshot: %s\n",
968 prefix, yes_no(u->stop_when_unneeded),
969 prefix, yes_no(u->refuse_manual_start),
970 prefix, yes_no(u->refuse_manual_stop),
971 prefix, yes_no(u->default_dependencies),
972 prefix, job_mode_to_string(u->on_failure_job_mode),
973 prefix, yes_no(u->ignore_on_isolate),
974 prefix, yes_no(u->ignore_on_snapshot));
976 if (UNIT_VTABLE(u)->dump)
977 UNIT_VTABLE(u)->dump(u, f, prefix2);
979 } else if (u->load_state == UNIT_MERGED)
981 "%s\tMerged into: %s\n",
982 prefix, u->merged_into->id);
983 else if (u->load_state == UNIT_ERROR)
984 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
988 job_dump(u->job, f, prefix2);
991 job_dump(u->nop_job, f, prefix2);
995 /* Common implementation for multiple backends */
996 int unit_load_fragment_and_dropin(Unit *u) {
1001 /* Load a .{service,socket,...} file */
1002 r = unit_load_fragment(u);
1006 if (u->load_state == UNIT_STUB)
1009 /* Load drop-in directory data */
1010 r = unit_load_dropin(unit_follow_merge(u));
1017 /* Common implementation for multiple backends */
1018 int unit_load_fragment_and_dropin_optional(Unit *u) {
1023 /* Same as unit_load_fragment_and_dropin(), but whether
1024 * something can be loaded or not doesn't matter. */
1026 /* Load a .service file */
1027 r = unit_load_fragment(u);
1031 if (u->load_state == UNIT_STUB)
1032 u->load_state = UNIT_LOADED;
1034 /* Load drop-in directory data */
1035 r = unit_load_dropin(unit_follow_merge(u));
1042 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1046 if (target->type != UNIT_TARGET)
1049 /* Only add the dependency if both units are loaded, so that
1050 * that loop check below is reliable */
1051 if (u->load_state != UNIT_LOADED ||
1052 target->load_state != UNIT_LOADED)
1055 /* If either side wants no automatic dependencies, then let's
1057 if (!u->default_dependencies ||
1058 !target->default_dependencies)
1061 /* Don't create loops */
1062 if (set_get(target->dependencies[UNIT_BEFORE], u))
1065 return unit_add_dependency(target, UNIT_AFTER, u, true);
1068 static int unit_add_target_dependencies(Unit *u) {
1070 static const UnitDependency deps[] = {
1072 UNIT_REQUIRED_BY_OVERRIDABLE,
1084 for (k = 0; k < ELEMENTSOF(deps); k++)
1085 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1086 r = unit_add_default_target_dependency(u, target);
1094 static int unit_add_slice_dependencies(Unit *u) {
1097 if (!unit_get_cgroup_context(u))
1100 if (UNIT_ISSET(u->slice))
1101 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1103 if (streq(u->id, SPECIAL_ROOT_SLICE))
1106 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1109 static int unit_add_mount_dependencies(Unit *u) {
1115 STRV_FOREACH(i, u->requires_mounts_for) {
1116 char prefix[strlen(*i) + 1];
1118 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1121 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1129 if (m->load_state != UNIT_LOADED)
1132 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1136 if (m->fragment_path) {
1137 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1147 static int unit_add_startup_units(Unit *u) {
1151 c = unit_get_cgroup_context(u);
1155 if (c->startup_cpu_shares == (unsigned long) -1 &&
1156 c->startup_blockio_weight == (unsigned long) -1)
1159 r = set_put(u->manager->startup_units, u);
1166 int unit_load(Unit *u) {
1171 if (u->in_load_queue) {
1172 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1173 u->in_load_queue = false;
1176 if (u->type == _UNIT_TYPE_INVALID)
1179 if (u->load_state != UNIT_STUB)
1182 if (UNIT_VTABLE(u)->load) {
1183 r = UNIT_VTABLE(u)->load(u);
1188 if (u->load_state == UNIT_STUB) {
1193 if (u->load_state == UNIT_LOADED) {
1195 r = unit_add_target_dependencies(u);
1199 r = unit_add_slice_dependencies(u);
1203 r = unit_add_mount_dependencies(u);
1207 r = unit_add_startup_units(u);
1211 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1212 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1217 unit_update_cgroup_members_masks(u);
1220 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1222 unit_add_to_dbus_queue(unit_follow_merge(u));
1223 unit_add_to_gc_queue(u);
1228 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1230 unit_add_to_dbus_queue(u);
1231 unit_add_to_gc_queue(u);
1233 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1234 u->id, strerror(-r));
1239 static bool unit_condition_test(Unit *u) {
1242 dual_timestamp_get(&u->condition_timestamp);
1243 u->condition_result = condition_test_list(u->id, u->conditions);
1245 return u->condition_result;
1248 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1249 const UnitStatusMessageFormats *format_table;
1253 assert(t < _JOB_TYPE_MAX);
1255 if (t != JOB_START && t != JOB_STOP)
1258 format_table = &UNIT_VTABLE(u)->status_message_formats;
1262 return format_table->starting_stopping[t == JOB_STOP];
1265 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1270 assert(t < _JOB_TYPE_MAX);
1272 format = unit_get_status_message_format(u, t);
1276 /* Return generic strings */
1278 return "Starting %s.";
1279 else if (t == JOB_STOP)
1280 return "Stopping %s.";
1281 else if (t == JOB_RELOAD)
1282 return "Reloading %s.";
1287 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1292 /* We only print status messages for selected units on
1293 * selected operations. */
1295 format = unit_get_status_message_format(u, t);
1299 DISABLE_WARNING_FORMAT_NONLITERAL;
1300 unit_status_printf(u, "", format);
1304 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1311 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1314 if (log_on_console())
1317 /* We log status messages for all units and all operations. */
1319 format = unit_get_status_message_format_try_harder(u, t);
1323 DISABLE_WARNING_FORMAT_NONLITERAL;
1324 snprintf(buf, sizeof(buf), format, unit_description(u));
1328 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1329 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1330 SD_MESSAGE_UNIT_RELOADING;
1332 log_struct_unit(LOG_INFO,
1340 * -EBADR: This unit type does not support starting.
1341 * -EALREADY: Unit is already started.
1342 * -EAGAIN: An operation is already in progress. Retry later.
1343 * -ECANCELED: Too many requests for now.
1345 int unit_start(Unit *u) {
1346 UnitActiveState state;
1351 if (u->load_state != UNIT_LOADED)
1354 /* If this is already started, then this will succeed. Note
1355 * that this will even succeed if this unit is not startable
1356 * by the user. This is relied on to detect when we need to
1357 * wait for units and when waiting is finished. */
1358 state = unit_active_state(u);
1359 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1362 /* If the conditions failed, don't do anything at all. If we
1363 * already are activating this call might still be useful to
1364 * speed up activation in case there is some hold-off time,
1365 * but we don't want to recheck the condition in that case. */
1366 if (state != UNIT_ACTIVATING &&
1367 !unit_condition_test(u)) {
1368 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1372 /* Forward to the main object, if we aren't it. */
1373 following = unit_following(u);
1375 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1376 u->id, following->id);
1377 return unit_start(following);
1380 unit_status_log_starting_stopping_reloading(u, JOB_START);
1381 unit_status_print_starting_stopping(u, JOB_START);
1383 /* If it is stopped, but we cannot start it, then fail */
1384 if (!UNIT_VTABLE(u)->start)
1387 /* We don't suppress calls to ->start() here when we are
1388 * already starting, to allow this request to be used as a
1389 * "hurry up" call, for example when the unit is in some "auto
1390 * restart" state where it waits for a holdoff timer to elapse
1391 * before it will start again. */
1393 unit_add_to_dbus_queue(u);
1395 return UNIT_VTABLE(u)->start(u);
1398 bool unit_can_start(Unit *u) {
1401 return !!UNIT_VTABLE(u)->start;
1404 bool unit_can_isolate(Unit *u) {
1407 return unit_can_start(u) &&
1412 * -EBADR: This unit type does not support stopping.
1413 * -EALREADY: Unit is already stopped.
1414 * -EAGAIN: An operation is already in progress. Retry later.
1416 int unit_stop(Unit *u) {
1417 UnitActiveState state;
1422 state = unit_active_state(u);
1423 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1426 if ((following = unit_following(u))) {
1427 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1428 u->id, following->id);
1429 return unit_stop(following);
1432 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1433 unit_status_print_starting_stopping(u, JOB_STOP);
1435 if (!UNIT_VTABLE(u)->stop)
1438 unit_add_to_dbus_queue(u);
1440 return UNIT_VTABLE(u)->stop(u);
1444 * -EBADR: This unit type does not support reloading.
1445 * -ENOEXEC: Unit is not started.
1446 * -EAGAIN: An operation is already in progress. Retry later.
1448 int unit_reload(Unit *u) {
1449 UnitActiveState state;
1454 if (u->load_state != UNIT_LOADED)
1457 if (!unit_can_reload(u))
1460 state = unit_active_state(u);
1461 if (state == UNIT_RELOADING)
1464 if (state != UNIT_ACTIVE) {
1465 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1470 following = unit_following(u);
1472 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1473 u->id, following->id);
1474 return unit_reload(following);
1477 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1479 unit_add_to_dbus_queue(u);
1480 return UNIT_VTABLE(u)->reload(u);
1483 bool unit_can_reload(Unit *u) {
1486 if (!UNIT_VTABLE(u)->reload)
1489 if (!UNIT_VTABLE(u)->can_reload)
1492 return UNIT_VTABLE(u)->can_reload(u);
1495 static void unit_check_unneeded(Unit *u) {
1501 /* If this service shall be shut down when unneeded then do
1504 if (!u->stop_when_unneeded)
1507 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1510 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1511 if (unit_active_or_pending(other))
1514 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1515 if (unit_active_or_pending(other))
1518 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1519 if (unit_active_or_pending(other))
1522 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1523 if (unit_active_or_pending(other))
1526 log_info_unit(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
1528 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1529 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1532 static void unit_check_binds_to(Unit *u) {
1542 if (unit_active_state(u) != UNIT_ACTIVE)
1545 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1549 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1558 log_info_unit(u->id, "Unit %s is bound to inactive service. Stopping, too.", u->id);
1560 /* A unit we need to run is gone. Sniff. Let's stop this. */
1561 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1564 static void retroactively_start_dependencies(Unit *u) {
1569 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1571 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1572 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1573 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1574 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1576 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1577 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1578 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1579 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1581 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1582 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1583 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1584 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1586 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1587 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1588 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1589 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1591 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1592 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1593 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1595 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1596 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1597 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1600 static void retroactively_stop_dependencies(Unit *u) {
1605 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1607 /* Pull down units which are bound to us recursively if enabled */
1608 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1609 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1610 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1613 static void check_unneeded_dependencies(Unit *u) {
1618 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1620 /* Garbage collect services that might not be needed anymore, if enabled */
1621 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1622 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1623 unit_check_unneeded(other);
1624 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1625 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1626 unit_check_unneeded(other);
1627 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1628 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1629 unit_check_unneeded(other);
1630 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1631 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1632 unit_check_unneeded(other);
1633 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1634 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1635 unit_check_unneeded(other);
1636 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1637 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1638 unit_check_unneeded(other);
1641 void unit_start_on_failure(Unit *u) {
1647 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1650 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1652 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1655 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1657 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1661 void unit_trigger_notify(Unit *u) {
1667 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1668 if (UNIT_VTABLE(other)->trigger_notify)
1669 UNIT_VTABLE(other)->trigger_notify(other, u);
1672 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1677 assert(os < _UNIT_ACTIVE_STATE_MAX);
1678 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1680 /* Note that this is called for all low-level state changes,
1681 * even if they might map to the same high-level
1682 * UnitActiveState! That means that ns == os is an expected
1683 * behavior here. For example: if a mount point is remounted
1684 * this function will be called too! */
1688 /* Update timestamps for state changes */
1689 if (m->n_reloading <= 0) {
1692 dual_timestamp_get(&ts);
1694 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1695 u->inactive_exit_timestamp = ts;
1696 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1697 u->inactive_enter_timestamp = ts;
1699 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1700 u->active_enter_timestamp = ts;
1701 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1702 u->active_exit_timestamp = ts;
1705 /* Keep track of failed units */
1706 if (ns == UNIT_FAILED)
1707 set_put(u->manager->failed_units, u);
1709 set_remove(u->manager->failed_units, u);
1711 /* Make sure the cgroup is always removed when we become inactive */
1712 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1713 unit_destroy_cgroup(u);
1715 /* Note that this doesn't apply to RemainAfterExit services exiting
1716 * successfully, since there's no change of state in that case. Which is
1717 * why it is handled in service_set_state() */
1718 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1721 ec = unit_get_exec_context(u);
1722 if (ec && exec_context_may_touch_console(ec)) {
1723 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1726 if (m->n_on_console == 0)
1727 /* unset no_console_output flag, since the console is free */
1728 m->no_console_output = false;
1737 if (u->job->state == JOB_WAITING)
1739 /* So we reached a different state for this
1740 * job. Let's see if we can run it now if it
1741 * failed previously due to EAGAIN. */
1742 job_add_to_run_queue(u->job);
1744 /* Let's check whether this state change constitutes a
1745 * finished job, or maybe contradicts a running job and
1746 * hence needs to invalidate jobs. */
1748 switch (u->job->type) {
1751 case JOB_VERIFY_ACTIVE:
1753 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1754 job_finish_and_invalidate(u->job, JOB_DONE, true);
1755 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1758 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1759 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1765 case JOB_RELOAD_OR_START:
1767 if (u->job->state == JOB_RUNNING) {
1768 if (ns == UNIT_ACTIVE)
1769 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1770 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1773 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1774 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1782 case JOB_TRY_RESTART:
1784 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1785 job_finish_and_invalidate(u->job, JOB_DONE, true);
1786 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1788 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1794 assert_not_reached("Job type unknown");
1800 if (m->n_reloading <= 0) {
1802 /* If this state change happened without being
1803 * requested by a job, then let's retroactively start
1804 * or stop dependencies. We skip that step when
1805 * deserializing, since we don't want to create any
1806 * additional jobs just because something is already
1810 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1811 retroactively_start_dependencies(u);
1812 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1813 retroactively_stop_dependencies(u);
1816 /* stop unneeded units regardless if going down was expected or not */
1817 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1818 check_unneeded_dependencies(u);
1820 if (ns != os && ns == UNIT_FAILED) {
1821 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1822 unit_start_on_failure(u);
1826 /* Some names are special */
1827 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1829 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1830 /* The bus might have just become available,
1831 * hence try to connect to it, if we aren't
1835 if (u->type == UNIT_SERVICE &&
1836 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1837 m->n_reloading <= 0) {
1838 /* Write audit record if we have just finished starting up */
1839 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1843 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1844 manager_send_unit_plymouth(m, u);
1848 /* We don't care about D-Bus here, since we'll get an
1849 * asynchronous notification for it anyway. */
1851 if (u->type == UNIT_SERVICE &&
1852 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1853 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1854 m->n_reloading <= 0) {
1856 /* Hmm, if there was no start record written
1857 * write it now, so that we always have a nice
1860 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1862 if (ns == UNIT_INACTIVE)
1863 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1865 /* Write audit record if we have just finished shutting down */
1866 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1868 u->in_audit = false;
1872 manager_recheck_journal(m);
1873 unit_trigger_notify(u);
1875 if (u->manager->n_reloading <= 0) {
1876 /* Maybe we finished startup and are now ready for
1877 * being stopped because unneeded? */
1878 unit_check_unneeded(u);
1880 /* Maybe we finished startup, but something we needed
1881 * has vanished? Let's die then. (This happens when
1882 * something BindsTo= to a Type=oneshot unit, as these
1883 * units go directly from starting to inactive,
1884 * without ever entering started.) */
1885 unit_check_binds_to(u);
1888 unit_add_to_dbus_queue(u);
1889 unit_add_to_gc_queue(u);
1892 int unit_watch_pid(Unit *u, pid_t pid) {
1898 /* Watch a specific PID. We only support one or two units
1899 * watching each PID for now, not more. */
1901 r = set_ensure_allocated(&u->pids, NULL);
1905 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1909 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1911 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
1915 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1918 q = set_put(u->pids, LONG_TO_PTR(pid));
1925 void unit_unwatch_pid(Unit *u, pid_t pid) {
1929 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1930 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1931 set_remove(u->pids, LONG_TO_PTR(pid));
1934 void unit_unwatch_all_pids(Unit *u) {
1937 while (!set_isempty(u->pids))
1938 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1944 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1945 _cleanup_closedir_ DIR *d = NULL;
1946 _cleanup_fclose_ FILE *f = NULL;
1952 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1954 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1958 while ((r = cg_read_pid(f, &pid)) > 0) {
1959 r = unit_watch_pid(u, pid);
1960 if (r < 0 && ret >= 0)
1963 if (r < 0 && ret >= 0)
1966 } else if (ret >= 0)
1969 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1973 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1974 _cleanup_free_ char *p = NULL;
1976 p = strjoin(path, "/", fn, NULL);
1982 r = unit_watch_pids_in_path(u, p);
1983 if (r < 0 && ret >= 0)
1986 if (r < 0 && ret >= 0)
1989 } else if (ret >= 0)
1995 int unit_watch_all_pids(Unit *u) {
1998 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2000 if (!u->cgroup_path)
2003 return unit_watch_pids_in_path(u, u->cgroup_path);
2006 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2012 /* Cleans dead PIDs from our list */
2014 SET_FOREACH(e, u->pids, i) {
2015 pid_t pid = PTR_TO_LONG(e);
2017 if (pid == except1 || pid == except2)
2020 if (!pid_is_unwaited(pid))
2021 unit_unwatch_pid(u, pid);
2025 bool unit_job_is_applicable(Unit *u, JobType j) {
2027 assert(j >= 0 && j < _JOB_TYPE_MAX);
2031 case JOB_VERIFY_ACTIVE:
2038 case JOB_TRY_RESTART:
2039 return unit_can_start(u);
2042 return unit_can_reload(u);
2044 case JOB_RELOAD_OR_START:
2045 return unit_can_reload(u) && unit_can_start(u);
2048 assert_not_reached("Invalid job type");
2052 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2055 switch (dependency) {
2057 case UNIT_REQUIRES_OVERRIDABLE:
2059 case UNIT_REQUISITE:
2060 case UNIT_REQUISITE_OVERRIDABLE:
2063 case UNIT_REQUIRED_BY:
2064 case UNIT_REQUIRED_BY_OVERRIDABLE:
2065 case UNIT_WANTED_BY:
2067 case UNIT_CONSISTS_OF:
2068 case UNIT_REFERENCES:
2069 case UNIT_REFERENCED_BY:
2070 case UNIT_PROPAGATES_RELOAD_TO:
2071 case UNIT_RELOAD_PROPAGATED_FROM:
2072 case UNIT_JOINS_NAMESPACE_OF:
2075 case UNIT_CONFLICTS:
2076 case UNIT_CONFLICTED_BY:
2079 case UNIT_ON_FAILURE:
2081 case UNIT_TRIGGERED_BY:
2082 if (streq_ptr(id, other))
2083 log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
2084 unit_dependency_to_string(dependency), id, other);
2086 log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
2087 unit_dependency_to_string(dependency), id,
2091 case _UNIT_DEPENDENCY_MAX:
2092 case _UNIT_DEPENDENCY_INVALID:
2096 assert_not_reached("Invalid dependency type");
2099 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2101 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2102 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2103 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2104 [UNIT_WANTS] = UNIT_WANTED_BY,
2105 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2106 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2107 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2108 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2109 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2110 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2111 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2112 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2113 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2114 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2115 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2116 [UNIT_BEFORE] = UNIT_AFTER,
2117 [UNIT_AFTER] = UNIT_BEFORE,
2118 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2119 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2120 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2121 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2122 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2123 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2124 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2125 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2127 int r, q = 0, v = 0, w = 0;
2128 Unit *orig_u = u, *orig_other = other;
2131 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2134 u = unit_follow_merge(u);
2135 other = unit_follow_merge(other);
2137 /* We won't allow dependencies on ourselves. We will not
2138 * consider them an error however. */
2140 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2144 r = set_ensure_allocated(&u->dependencies[d], NULL);
2148 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2149 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2154 if (add_reference) {
2155 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2159 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2164 q = set_put(u->dependencies[d], other);
2168 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2169 v = set_put(other->dependencies[inverse_table[d]], u);
2176 if (add_reference) {
2177 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2183 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2188 unit_add_to_dbus_queue(u);
2193 set_remove(u->dependencies[d], other);
2196 set_remove(other->dependencies[inverse_table[d]], u);
2199 set_remove(u->dependencies[UNIT_REFERENCES], other);
2204 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2209 r = unit_add_dependency(u, d, other, add_reference);
2213 r = unit_add_dependency(u, e, other, add_reference);
2220 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2224 assert(name || path);
2228 name = basename(path);
2230 if (!unit_name_is_template(name)) {
2236 s = unit_name_replace_instance(name, u->instance);
2238 _cleanup_free_ char *i = NULL;
2240 i = unit_name_to_prefix(u->id);
2244 s = unit_name_replace_instance(name, i);
2254 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2257 _cleanup_free_ char *s = NULL;
2260 assert(name || path);
2262 name = resolve_template(u, name, path, &s);
2266 r = manager_load_unit(u->manager, name, path, NULL, &other);
2270 return unit_add_dependency(u, d, other, add_reference);
2273 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2274 _cleanup_free_ char *s = NULL;
2279 assert(name || path);
2281 name = resolve_template(u, name, path, &s);
2285 r = manager_load_unit(u->manager, name, path, NULL, &other);
2289 return unit_add_two_dependencies(u, d, e, other, add_reference);
2292 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2295 _cleanup_free_ char *s = NULL;
2298 assert(name || path);
2300 name = resolve_template(u, name, path, &s);
2304 r = manager_load_unit(u->manager, name, path, NULL, &other);
2308 return unit_add_dependency(other, d, u, add_reference);
2311 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2314 _cleanup_free_ char *s = NULL;
2317 assert(name || path);
2319 name = resolve_template(u, name, path, &s);
2323 r = manager_load_unit(u->manager, name, path, NULL, &other);
2327 r = unit_add_two_dependencies(other, d, e, u, add_reference);
2334 int set_unit_path(const char *p) {
2335 /* This is mostly for debug purposes */
2336 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2342 char *unit_dbus_path(Unit *u) {
2348 return unit_dbus_path_from_name(u->id);
2351 char *unit_default_cgroup_path(Unit *u) {
2352 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2357 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2358 return strdup(u->manager->cgroup_root);
2360 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2361 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2366 escaped = cg_escape(u->id);
2371 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2373 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2376 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2377 _cleanup_free_ char *b = NULL;
2378 const char *slice_name;
2385 if (UNIT_ISSET(u->slice))
2389 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2391 /* Implicitly place all instantiated units in their
2392 * own per-template slice */
2394 prefix = unit_name_to_prefix(u->id);
2398 /* The prefix is already escaped, but it might include
2399 * "-" which has a special meaning for slice units,
2400 * hence escape it here extra. */
2401 escaped = strreplace(prefix, "-", "\\x2d");
2405 if (u->manager->running_as == SYSTEMD_SYSTEM)
2406 b = strjoin("system-", escaped, ".slice", NULL);
2408 b = strappend(escaped, ".slice");
2415 u->manager->running_as == SYSTEMD_SYSTEM
2416 ? SPECIAL_SYSTEM_SLICE
2417 : SPECIAL_ROOT_SLICE;
2419 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2423 unit_ref_set(&u->slice, slice);
2427 const char *unit_slice_name(Unit *u) {
2430 if (!UNIT_ISSET(u->slice))
2433 return UNIT_DEREF(u->slice)->id;
2436 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2437 _cleanup_free_ char *t = NULL;
2444 t = unit_name_change_suffix(u->id, type);
2448 assert(!unit_has_name(u, t));
2450 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2451 assert(r < 0 || *_found != u);
2455 int unit_watch_bus_name(Unit *u, const char *name) {
2459 /* Watch a specific name on the bus. We only support one unit
2460 * watching each name for now. */
2462 return hashmap_put(u->manager->watch_bus, name, u);
2465 void unit_unwatch_bus_name(Unit *u, const char *name) {
2469 hashmap_remove_value(u->manager->watch_bus, name, u);
2472 bool unit_can_serialize(Unit *u) {
2475 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2478 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2485 if (unit_can_serialize(u)) {
2488 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2492 rt = unit_get_exec_runtime(u);
2494 r = exec_runtime_serialize(rt, u, f, fds);
2500 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2501 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2502 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2503 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2504 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2506 if (dual_timestamp_is_set(&u->condition_timestamp))
2507 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2509 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2512 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2514 if (serialize_jobs) {
2516 fprintf(f, "job\n");
2517 job_serialize(u->job, f, fds);
2521 fprintf(f, "job\n");
2522 job_serialize(u->nop_job, f, fds);
2531 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2542 va_start(ap, format);
2543 vfprintf(f, format, ap);
2549 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2555 fprintf(f, "%s=%s\n", key, value);
2558 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2559 ExecRuntime **rt = NULL;
2567 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2569 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2572 char line[LINE_MAX], *l, *v;
2575 if (!fgets(line, sizeof(line), f)) {
2588 k = strcspn(l, "=");
2596 if (streq(l, "job")) {
2598 /* new-style serialized job */
2599 Job *j = job_new_raw(u);
2603 r = job_deserialize(j, f, fds);
2609 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2615 r = job_install_deserialized(j);
2617 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2622 if (j->state == JOB_RUNNING)
2623 u->manager->n_running_jobs++;
2626 JobType type = job_type_from_string(v);
2628 log_debug("Failed to parse job type value %s", v);
2630 u->deserialized_job = type;
2633 } else if (streq(l, "inactive-exit-timestamp")) {
2634 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2636 } else if (streq(l, "active-enter-timestamp")) {
2637 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2639 } else if (streq(l, "active-exit-timestamp")) {
2640 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2642 } else if (streq(l, "inactive-enter-timestamp")) {
2643 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2645 } else if (streq(l, "condition-timestamp")) {
2646 dual_timestamp_deserialize(v, &u->condition_timestamp);
2648 } else if (streq(l, "condition-result")) {
2651 b = parse_boolean(v);
2653 log_debug("Failed to parse condition result value %s", v);
2655 u->condition_result = b;
2659 } else if (streq(l, "transient")) {
2662 b = parse_boolean(v);
2664 log_debug("Failed to parse transient bool %s", v);
2669 } else if (streq(l, "cgroup")) {
2676 if (u->cgroup_path) {
2679 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2680 log_info("Removing cgroup_path %s from hashmap (%p)",
2682 free(u->cgroup_path);
2686 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2691 if (unit_can_serialize(u)) {
2693 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2700 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2707 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2709 _cleanup_free_ char *e = NULL;
2717 /* Adds in links to the device node that this unit is based on */
2719 if (!is_device_path(what))
2722 e = unit_name_from_path(what, ".device");
2726 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2731 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2736 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2744 int unit_coldplug(Unit *u) {
2749 if (UNIT_VTABLE(u)->coldplug)
2750 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2754 r = job_coldplug(u->job);
2757 } else if (u->deserialized_job >= 0) {
2759 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2763 u->deserialized_job = _JOB_TYPE_INVALID;
2769 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2770 DISABLE_WARNING_FORMAT_NONLITERAL;
2771 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2772 status, unit_status_msg_format, unit_description(u));
2776 bool unit_need_daemon_reload(Unit *u) {
2777 _cleanup_strv_free_ char **t = NULL;
2780 unsigned loaded_cnt, current_cnt;
2784 if (u->fragment_path) {
2786 if (stat(u->fragment_path, &st) < 0)
2787 /* What, cannot access this anymore? */
2790 if (u->fragment_mtime > 0 &&
2791 timespec_load(&st.st_mtim) != u->fragment_mtime)
2795 if (u->source_path) {
2797 if (stat(u->source_path, &st) < 0)
2800 if (u->source_mtime > 0 &&
2801 timespec_load(&st.st_mtim) != u->source_mtime)
2805 t = unit_find_dropin_paths(u);
2806 loaded_cnt = strv_length(t);
2807 current_cnt = strv_length(u->dropin_paths);
2809 if (loaded_cnt == current_cnt) {
2810 if (loaded_cnt == 0)
2813 if (strv_overlap(u->dropin_paths, t)) {
2814 STRV_FOREACH(path, u->dropin_paths) {
2816 if (stat(*path, &st) < 0)
2819 if (u->dropin_mtime > 0 &&
2820 timespec_load(&st.st_mtim) > u->dropin_mtime)
2831 void unit_reset_failed(Unit *u) {
2834 if (UNIT_VTABLE(u)->reset_failed)
2835 UNIT_VTABLE(u)->reset_failed(u);
2838 Unit *unit_following(Unit *u) {
2841 if (UNIT_VTABLE(u)->following)
2842 return UNIT_VTABLE(u)->following(u);
2847 bool unit_stop_pending(Unit *u) {
2850 /* This call does check the current state of the unit. It's
2851 * hence useful to be called from state change calls of the
2852 * unit itself, where the state isn't updated yet. This is
2853 * different from unit_inactive_or_pending() which checks both
2854 * the current state and for a queued job. */
2856 return u->job && u->job->type == JOB_STOP;
2859 bool unit_inactive_or_pending(Unit *u) {
2862 /* Returns true if the unit is inactive or going down */
2864 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2867 if (unit_stop_pending(u))
2873 bool unit_active_or_pending(Unit *u) {
2876 /* Returns true if the unit is active or going up */
2878 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2882 (u->job->type == JOB_START ||
2883 u->job->type == JOB_RELOAD_OR_START ||
2884 u->job->type == JOB_RESTART))
2890 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2892 assert(w >= 0 && w < _KILL_WHO_MAX);
2894 assert(signo < _NSIG);
2896 if (!UNIT_VTABLE(u)->kill)
2899 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2902 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2906 pid_set = set_new(NULL);
2910 /* Exclude the main/control pids from being killed via the cgroup */
2912 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2917 if (control_pid > 0) {
2918 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2930 int unit_kill_common(
2936 sd_bus_error *error) {
2940 if (who == KILL_MAIN && main_pid <= 0) {
2942 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2944 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2948 if (who == KILL_CONTROL && control_pid <= 0) {
2949 if (control_pid < 0)
2950 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2952 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2956 if (who == KILL_CONTROL || who == KILL_ALL)
2957 if (control_pid > 0)
2958 if (kill(control_pid, signo) < 0)
2961 if (who == KILL_MAIN || who == KILL_ALL)
2963 if (kill(main_pid, signo) < 0)
2966 if (who == KILL_ALL && u->cgroup_path) {
2967 _cleanup_set_free_ Set *pid_set = NULL;
2970 /* Exclude the main/control pids from being killed via the cgroup */
2971 pid_set = unit_pid_set(main_pid, control_pid);
2975 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2976 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2983 int unit_following_set(Unit *u, Set **s) {
2987 if (UNIT_VTABLE(u)->following_set)
2988 return UNIT_VTABLE(u)->following_set(u, s);
2994 UnitFileState unit_get_unit_file_state(Unit *u) {
2997 if (u->unit_file_state < 0 && u->fragment_path)
2998 u->unit_file_state = unit_file_get_state(
2999 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3000 NULL, basename(u->fragment_path));
3002 return u->unit_file_state;
3005 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3010 unit_ref_unset(ref);
3013 LIST_PREPEND(refs, u->refs, ref);
3017 void unit_ref_unset(UnitRef *ref) {
3023 LIST_REMOVE(refs, ref->unit->refs, ref);
3027 int unit_patch_contexts(Unit *u) {
3035 /* Patch in the manager defaults into the exec and cgroup
3036 * contexts, _after_ the rest of the settings have been
3039 ec = unit_get_exec_context(u);
3041 /* This only copies in the ones that need memory */
3042 for (i = 0; i < _RLIMIT_MAX; i++)
3043 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3044 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3049 if (u->manager->running_as == SYSTEMD_USER &&
3050 !ec->working_directory) {
3052 r = get_home_dir(&ec->working_directory);
3057 if (u->manager->running_as == SYSTEMD_USER &&
3058 (ec->syscall_whitelist ||
3059 !set_isempty(ec->syscall_filter) ||
3060 !set_isempty(ec->syscall_archs) ||
3061 ec->address_families_whitelist ||
3062 !set_isempty(ec->address_families)))
3063 ec->no_new_privileges = true;
3065 if (ec->private_devices)
3066 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3069 cc = unit_get_cgroup_context(u);
3073 ec->private_devices &&
3074 cc->device_policy == CGROUP_AUTO)
3075 cc->device_policy = CGROUP_CLOSED;
3081 ExecContext *unit_get_exec_context(Unit *u) {
3088 offset = UNIT_VTABLE(u)->exec_context_offset;
3092 return (ExecContext*) ((uint8_t*) u + offset);
3095 KillContext *unit_get_kill_context(Unit *u) {
3102 offset = UNIT_VTABLE(u)->kill_context_offset;
3106 return (KillContext*) ((uint8_t*) u + offset);
3109 CGroupContext *unit_get_cgroup_context(Unit *u) {
3115 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3119 return (CGroupContext*) ((uint8_t*) u + offset);
3122 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3128 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3132 return *(ExecRuntime**) ((uint8_t*) u + offset);
3135 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3136 if (u->manager->running_as == SYSTEMD_USER) {
3139 if (mode == UNIT_PERSISTENT && !transient)
3140 r = user_config_home(dir);
3142 r = user_runtime_dir(dir);
3149 if (mode == UNIT_PERSISTENT && !transient)
3150 *dir = strdup("/etc/systemd/system");
3152 *dir = strdup("/run/systemd/system");
3159 static int unit_drop_in_file(Unit *u,
3160 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3161 _cleanup_free_ char *dir = NULL;
3166 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3170 return drop_in_file(dir, u->id, 50, name, p, q);
3173 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3175 _cleanup_free_ char *dir = NULL;
3180 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3183 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3187 return write_drop_in(dir, u->id, 50, name, data);
3190 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3191 _cleanup_free_ char *p = NULL;
3199 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3202 va_start(ap, format);
3203 r = vasprintf(&p, format, ap);
3209 return unit_write_drop_in(u, mode, name, p);
3212 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3213 _cleanup_free_ char *ndata = NULL;
3219 if (!UNIT_VTABLE(u)->private_section)
3222 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3225 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3229 return unit_write_drop_in(u, mode, name, ndata);
3232 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3233 _cleanup_free_ char *p = NULL;
3241 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3244 va_start(ap, format);
3245 r = vasprintf(&p, format, ap);
3251 return unit_write_drop_in_private(u, mode, name, p);
3254 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3255 _cleanup_free_ char *p = NULL, *q = NULL;
3260 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3263 r = unit_drop_in_file(u, mode, name, &p, &q);
3268 r = errno == ENOENT ? 0 : -errno;
3276 int unit_make_transient(Unit *u) {
3281 u->load_state = UNIT_STUB;
3283 u->transient = true;
3285 free(u->fragment_path);
3286 u->fragment_path = NULL;
3288 if (u->manager->running_as == SYSTEMD_USER) {
3289 _cleanup_free_ char *c = NULL;
3291 r = user_runtime_dir(&c);
3297 u->fragment_path = strjoin(c, "/", u->id, NULL);
3298 if (!u->fragment_path)
3303 u->fragment_path = strappend("/run/systemd/system/", u->id);
3304 if (!u->fragment_path)
3307 mkdir_p("/run/systemd/system", 0755);
3310 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3313 int unit_kill_context(
3319 bool main_pid_alien) {
3321 int sig, wait_for_exit = false, r;
3326 if (c->kill_mode == KILL_NONE)
3336 case KILL_TERMINATE:
3337 sig = c->kill_signal;
3340 assert_not_reached("KillOperation unknown");
3344 r = kill_and_sigcont(main_pid, sig);
3346 if (r < 0 && r != -ESRCH) {
3347 _cleanup_free_ char *comm = NULL;
3348 get_process_comm(main_pid, &comm);
3350 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3352 if (!main_pid_alien)
3353 wait_for_exit = true;
3355 if (c->send_sighup && k != KILL_KILL)
3356 kill(main_pid, SIGHUP);
3360 if (control_pid > 0) {
3361 r = kill_and_sigcont(control_pid, sig);
3363 if (r < 0 && r != -ESRCH) {
3364 _cleanup_free_ char *comm = NULL;
3365 get_process_comm(control_pid, &comm);
3367 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3369 wait_for_exit = true;
3371 if (c->send_sighup && k != KILL_KILL)
3372 kill(control_pid, SIGHUP);
3376 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3377 _cleanup_set_free_ Set *pid_set = NULL;
3379 /* Exclude the main/control pids from being killed via the cgroup */
3380 pid_set = unit_pid_set(main_pid, control_pid);
3384 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3386 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3387 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3390 /* FIXME: For now, we will not wait for the
3391 * cgroup members to die, simply because
3392 * cgroup notification is unreliable. It
3393 * doesn't work at all in containers, and
3394 * outside of containers it can be confused
3395 * easily by leaving directories in the
3398 /* wait_for_exit = true; */
3400 if (c->send_sighup && k != KILL_KILL) {
3403 pid_set = unit_pid_set(main_pid, control_pid);
3407 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3412 return wait_for_exit;
3415 int unit_require_mounts_for(Unit *u, const char *path) {
3416 char prefix[strlen(path) + 1], *p;
3422 /* Registers a unit for requiring a certain path and all its
3423 * prefixes. We keep a simple array of these paths in the
3424 * unit, since its usually short. However, we build a prefix
3425 * table for all possible prefixes so that new appearing mount
3426 * units can easily determine which units to make themselves a
3429 if (!path_is_absolute(path))
3436 path_kill_slashes(p);
3438 if (!path_is_safe(p)) {
3443 if (strv_contains(u->requires_mounts_for, p)) {
3448 r = strv_consume(&u->requires_mounts_for, p);
3452 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3455 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3459 if (!u->manager->units_requiring_mounts_for) {
3460 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3461 if (!u->manager->units_requiring_mounts_for)
3475 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3491 int unit_setup_exec_runtime(Unit *u) {
3497 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3500 /* Check if there already is an ExecRuntime for this unit? */
3501 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3505 /* Try to get it from somebody else */
3506 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3508 *rt = unit_get_exec_runtime(other);
3510 exec_runtime_ref(*rt);
3515 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3518 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3519 [UNIT_ACTIVE] = "active",
3520 [UNIT_RELOADING] = "reloading",
3521 [UNIT_INACTIVE] = "inactive",
3522 [UNIT_FAILED] = "failed",
3523 [UNIT_ACTIVATING] = "activating",
3524 [UNIT_DEACTIVATING] = "deactivating"
3527 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);