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);
530 condition_free_list(u->asserts);
532 unit_ref_unset(&u->slice);
535 unit_ref_unset(u->refs);
540 UnitActiveState unit_active_state(Unit *u) {
543 if (u->load_state == UNIT_MERGED)
544 return unit_active_state(unit_follow_merge(u));
546 /* After a reload it might happen that a unit is not correctly
547 * loaded but still has a process around. That's why we won't
548 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
550 return UNIT_VTABLE(u)->active_state(u);
553 const char* unit_sub_state_to_string(Unit *u) {
556 return UNIT_VTABLE(u)->sub_state_to_string(u);
559 static int complete_move(Set **s, Set **other) {
569 r = set_move(*s, *other);
580 static int merge_names(Unit *u, Unit *other) {
588 r = complete_move(&u->names, &other->names);
592 set_free_free(other->names);
596 SET_FOREACH(t, u->names, i)
597 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
602 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
607 assert(d < _UNIT_DEPENDENCY_MAX);
610 * If u does not have this dependency set allocated, there is no need
611 * to reserve anything. In that case other's set will be transfered
612 * as a whole to u by complete_move().
614 if (!u->dependencies[d])
617 /* merge_dependencies() will skip a u-on-u dependency */
618 n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
620 return set_reserve(u->dependencies[d], n_reserve);
623 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
630 assert(d < _UNIT_DEPENDENCY_MAX);
632 /* Fix backwards pointers */
633 SET_FOREACH(back, other->dependencies[d], i) {
636 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
637 /* Do not add dependencies between u and itself */
639 if (set_remove(back->dependencies[k], other))
640 maybe_warn_about_dependency(u->id, other_id, k);
642 r = set_remove_and_put(back->dependencies[k], other, u);
644 set_remove(back->dependencies[k], other);
646 assert(r >= 0 || r == -ENOENT);
651 /* Also do not move dependencies on u to itself */
652 back = set_remove(other->dependencies[d], u);
654 maybe_warn_about_dependency(u->id, other_id, d);
656 /* The move cannot fail. The caller must have performed a reservation. */
657 assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
659 set_free(other->dependencies[d]);
660 other->dependencies[d] = NULL;
663 int unit_merge(Unit *u, Unit *other) {
665 const char *other_id = NULL;
670 assert(u->manager == other->manager);
671 assert(u->type != _UNIT_TYPE_INVALID);
673 other = unit_follow_merge(other);
678 if (u->type != other->type)
681 if (!u->instance != !other->instance)
684 if (other->load_state != UNIT_STUB &&
685 other->load_state != UNIT_NOT_FOUND)
694 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
698 other_id = strdupa(other->id);
700 /* Make reservations to ensure merge_dependencies() won't fail */
701 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
702 r = reserve_dependencies(u, other, d);
704 * We don't rollback reservations if we fail. We don't have
705 * a way to undo reservations. A reservation is not a leak.
712 r = merge_names(u, other);
716 /* Redirect all references */
718 unit_ref_set(other->refs, u);
720 /* Merge dependencies */
721 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
722 merge_dependencies(u, other, other_id, d);
724 other->load_state = UNIT_MERGED;
725 other->merged_into = u;
727 /* If there is still some data attached to the other node, we
728 * don't need it anymore, and can free it. */
729 if (other->load_state != UNIT_STUB)
730 if (UNIT_VTABLE(other)->done)
731 UNIT_VTABLE(other)->done(other);
733 unit_add_to_dbus_queue(u);
734 unit_add_to_cleanup_queue(other);
739 int unit_merge_by_name(Unit *u, const char *name) {
742 _cleanup_free_ char *s = NULL;
747 if (unit_name_is_template(name)) {
751 s = unit_name_replace_instance(name, u->instance);
758 other = manager_get_unit(u->manager, name);
760 r = unit_add_name(u, name);
762 r = unit_merge(u, other);
767 Unit* unit_follow_merge(Unit *u) {
770 while (u->load_state == UNIT_MERGED)
771 assert_se(u = u->merged_into);
776 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
782 if (c->working_directory) {
783 r = unit_require_mounts_for(u, c->working_directory);
788 if (c->root_directory) {
789 r = unit_require_mounts_for(u, c->root_directory);
794 if (u->manager->running_as != SYSTEMD_SYSTEM)
797 if (c->private_tmp) {
798 r = unit_require_mounts_for(u, "/tmp");
802 r = unit_require_mounts_for(u, "/var/tmp");
807 if (c->std_output != EXEC_OUTPUT_KMSG &&
808 c->std_output != EXEC_OUTPUT_SYSLOG &&
809 c->std_output != EXEC_OUTPUT_JOURNAL &&
810 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
811 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
812 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
813 c->std_error != EXEC_OUTPUT_KMSG &&
814 c->std_error != EXEC_OUTPUT_SYSLOG &&
815 c->std_error != EXEC_OUTPUT_JOURNAL &&
816 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
817 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
818 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
821 /* If syslog or kernel logging is requested, make sure our own
822 * logging daemon is run first. */
824 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
831 const char *unit_description(Unit *u) {
835 return u->description;
840 void unit_dump(Unit *u, FILE *f, const char *prefix) {
846 timestamp1[FORMAT_TIMESTAMP_MAX],
847 timestamp2[FORMAT_TIMESTAMP_MAX],
848 timestamp3[FORMAT_TIMESTAMP_MAX],
849 timestamp4[FORMAT_TIMESTAMP_MAX],
850 timespan[FORMAT_TIMESPAN_MAX];
852 _cleanup_set_free_ Set *following_set = NULL;
856 assert(u->type >= 0);
858 prefix = strempty(prefix);
859 prefix2 = strappenda(prefix, "\t");
863 "%s\tDescription: %s\n"
865 "%s\tUnit Load State: %s\n"
866 "%s\tUnit Active State: %s\n"
867 "%s\tInactive Exit Timestamp: %s\n"
868 "%s\tActive Enter Timestamp: %s\n"
869 "%s\tActive Exit Timestamp: %s\n"
870 "%s\tInactive Enter Timestamp: %s\n"
871 "%s\tGC Check Good: %s\n"
872 "%s\tNeed Daemon Reload: %s\n"
873 "%s\tTransient: %s\n"
876 "%s\tCGroup realized: %s\n"
877 "%s\tCGroup mask: 0x%x\n"
878 "%s\tCGroup members mask: 0x%x\n",
880 prefix, unit_description(u),
881 prefix, strna(u->instance),
882 prefix, unit_load_state_to_string(u->load_state),
883 prefix, unit_active_state_to_string(unit_active_state(u)),
884 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
885 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
886 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
887 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
888 prefix, yes_no(unit_check_gc(u)),
889 prefix, yes_no(unit_need_daemon_reload(u)),
890 prefix, yes_no(u->transient),
891 prefix, strna(unit_slice_name(u)),
892 prefix, strna(u->cgroup_path),
893 prefix, yes_no(u->cgroup_realized),
894 prefix, u->cgroup_realized_mask,
895 prefix, u->cgroup_members_mask);
897 SET_FOREACH(t, u->names, i)
898 fprintf(f, "%s\tName: %s\n", prefix, t);
900 STRV_FOREACH(j, u->documentation)
901 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
903 following = unit_following(u);
905 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
907 r = unit_following_set(u, &following_set);
911 SET_FOREACH(other, following_set, i)
912 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
915 if (u->fragment_path)
916 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
919 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
921 STRV_FOREACH(j, u->dropin_paths)
922 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
924 if (u->job_timeout > 0)
925 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
927 if (u->job_timeout_action != FAILURE_ACTION_NONE)
928 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
930 if (u->job_timeout_reboot_arg)
931 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
933 condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
934 condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
936 if (dual_timestamp_is_set(&u->condition_timestamp))
938 "%s\tCondition Timestamp: %s\n"
939 "%s\tCondition Result: %s\n",
940 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
941 prefix, yes_no(u->condition_result));
943 if (dual_timestamp_is_set(&u->assert_timestamp))
945 "%s\tAssert Timestamp: %s\n"
946 "%s\tAssert Result: %s\n",
947 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),
948 prefix, yes_no(u->assert_result));
950 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
953 SET_FOREACH(other, u->dependencies[d], i)
954 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
957 if (!strv_isempty(u->requires_mounts_for)) {
959 "%s\tRequiresMountsFor:", prefix);
961 STRV_FOREACH(j, u->requires_mounts_for)
962 fprintf(f, " %s", *j);
967 if (u->load_state == UNIT_LOADED) {
970 "%s\tStopWhenUnneeded: %s\n"
971 "%s\tRefuseManualStart: %s\n"
972 "%s\tRefuseManualStop: %s\n"
973 "%s\tDefaultDependencies: %s\n"
974 "%s\tOnFailureJobMode: %s\n"
975 "%s\tIgnoreOnIsolate: %s\n"
976 "%s\tIgnoreOnSnapshot: %s\n",
977 prefix, yes_no(u->stop_when_unneeded),
978 prefix, yes_no(u->refuse_manual_start),
979 prefix, yes_no(u->refuse_manual_stop),
980 prefix, yes_no(u->default_dependencies),
981 prefix, job_mode_to_string(u->on_failure_job_mode),
982 prefix, yes_no(u->ignore_on_isolate),
983 prefix, yes_no(u->ignore_on_snapshot));
985 if (UNIT_VTABLE(u)->dump)
986 UNIT_VTABLE(u)->dump(u, f, prefix2);
988 } else if (u->load_state == UNIT_MERGED)
990 "%s\tMerged into: %s\n",
991 prefix, u->merged_into->id);
992 else if (u->load_state == UNIT_ERROR)
993 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
997 job_dump(u->job, f, prefix2);
1000 job_dump(u->nop_job, f, prefix2);
1004 /* Common implementation for multiple backends */
1005 int unit_load_fragment_and_dropin(Unit *u) {
1010 /* Load a .{service,socket,...} file */
1011 r = unit_load_fragment(u);
1015 if (u->load_state == UNIT_STUB)
1018 /* Load drop-in directory data */
1019 r = unit_load_dropin(unit_follow_merge(u));
1026 /* Common implementation for multiple backends */
1027 int unit_load_fragment_and_dropin_optional(Unit *u) {
1032 /* Same as unit_load_fragment_and_dropin(), but whether
1033 * something can be loaded or not doesn't matter. */
1035 /* Load a .service file */
1036 r = unit_load_fragment(u);
1040 if (u->load_state == UNIT_STUB)
1041 u->load_state = UNIT_LOADED;
1043 /* Load drop-in directory data */
1044 r = unit_load_dropin(unit_follow_merge(u));
1051 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1055 if (target->type != UNIT_TARGET)
1058 /* Only add the dependency if both units are loaded, so that
1059 * that loop check below is reliable */
1060 if (u->load_state != UNIT_LOADED ||
1061 target->load_state != UNIT_LOADED)
1064 /* If either side wants no automatic dependencies, then let's
1066 if (!u->default_dependencies ||
1067 !target->default_dependencies)
1070 /* Don't create loops */
1071 if (set_get(target->dependencies[UNIT_BEFORE], u))
1074 return unit_add_dependency(target, UNIT_AFTER, u, true);
1077 static int unit_add_target_dependencies(Unit *u) {
1079 static const UnitDependency deps[] = {
1081 UNIT_REQUIRED_BY_OVERRIDABLE,
1093 for (k = 0; k < ELEMENTSOF(deps); k++)
1094 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1095 r = unit_add_default_target_dependency(u, target);
1103 static int unit_add_slice_dependencies(Unit *u) {
1106 if (!unit_get_cgroup_context(u))
1109 if (UNIT_ISSET(u->slice))
1110 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1112 if (streq(u->id, SPECIAL_ROOT_SLICE))
1115 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1118 static int unit_add_mount_dependencies(Unit *u) {
1124 STRV_FOREACH(i, u->requires_mounts_for) {
1125 char prefix[strlen(*i) + 1];
1127 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1130 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1138 if (m->load_state != UNIT_LOADED)
1141 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1145 if (m->fragment_path) {
1146 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1156 static int unit_add_startup_units(Unit *u) {
1160 c = unit_get_cgroup_context(u);
1164 if (c->startup_cpu_shares == (unsigned long) -1 &&
1165 c->startup_blockio_weight == (unsigned long) -1)
1168 r = set_put(u->manager->startup_units, u);
1175 int unit_load(Unit *u) {
1180 if (u->in_load_queue) {
1181 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1182 u->in_load_queue = false;
1185 if (u->type == _UNIT_TYPE_INVALID)
1188 if (u->load_state != UNIT_STUB)
1191 if (UNIT_VTABLE(u)->load) {
1192 r = UNIT_VTABLE(u)->load(u);
1197 if (u->load_state == UNIT_STUB) {
1202 if (u->load_state == UNIT_LOADED) {
1204 r = unit_add_target_dependencies(u);
1208 r = unit_add_slice_dependencies(u);
1212 r = unit_add_mount_dependencies(u);
1216 r = unit_add_startup_units(u);
1220 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1221 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1226 unit_update_cgroup_members_masks(u);
1229 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1231 unit_add_to_dbus_queue(unit_follow_merge(u));
1232 unit_add_to_gc_queue(u);
1237 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1239 unit_add_to_dbus_queue(u);
1240 unit_add_to_gc_queue(u);
1242 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1243 u->id, strerror(-r));
1248 static bool unit_condition_test(Unit *u) {
1251 dual_timestamp_get(&u->condition_timestamp);
1252 u->condition_result = condition_test_list(u->id, u->conditions, condition_type_to_string);
1254 return u->condition_result;
1257 static bool unit_assert_test(Unit *u) {
1260 dual_timestamp_get(&u->assert_timestamp);
1261 u->assert_result = condition_test_list(u->id, u->asserts, assert_type_to_string);
1263 return u->assert_result;
1266 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1267 const UnitStatusMessageFormats *format_table;
1271 assert(t < _JOB_TYPE_MAX);
1273 if (t != JOB_START && t != JOB_STOP)
1276 format_table = &UNIT_VTABLE(u)->status_message_formats;
1280 return format_table->starting_stopping[t == JOB_STOP];
1283 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1288 assert(t < _JOB_TYPE_MAX);
1290 format = unit_get_status_message_format(u, t);
1294 /* Return generic strings */
1296 return "Starting %s.";
1297 else if (t == JOB_STOP)
1298 return "Stopping %s.";
1299 else if (t == JOB_RELOAD)
1300 return "Reloading %s.";
1305 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1310 /* We only print status messages for selected units on
1311 * selected operations. */
1313 format = unit_get_status_message_format(u, t);
1317 DISABLE_WARNING_FORMAT_NONLITERAL;
1318 unit_status_printf(u, "", format);
1322 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1329 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1332 if (log_on_console())
1335 /* We log status messages for all units and all operations. */
1337 format = unit_get_status_message_format_try_harder(u, t);
1341 DISABLE_WARNING_FORMAT_NONLITERAL;
1342 snprintf(buf, sizeof(buf), format, unit_description(u));
1346 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1347 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1348 SD_MESSAGE_UNIT_RELOADING;
1350 log_struct_unit(LOG_INFO,
1358 * -EBADR: This unit type does not support starting.
1359 * -EALREADY: Unit is already started.
1360 * -EAGAIN: An operation is already in progress. Retry later.
1361 * -ECANCELED: Too many requests for now.
1362 * -EPROTO: Assert failed
1364 int unit_start(Unit *u) {
1365 UnitActiveState state;
1370 if (u->load_state != UNIT_LOADED)
1373 /* If this is already started, then this will succeed. Note
1374 * that this will even succeed if this unit is not startable
1375 * by the user. This is relied on to detect when we need to
1376 * wait for units and when waiting is finished. */
1377 state = unit_active_state(u);
1378 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1381 /* If the conditions failed, don't do anything at all. If we
1382 * already are activating this call might still be useful to
1383 * speed up activation in case there is some hold-off time,
1384 * but we don't want to recheck the condition in that case. */
1385 if (state != UNIT_ACTIVATING &&
1386 !unit_condition_test(u)) {
1387 log_debug_unit(u->id, "Starting of %s requested but condition failed. Not starting unit.", u->id);
1391 /* If the asserts failed, fail the entire job */
1392 if (state != UNIT_ACTIVATING &&
1393 !unit_assert_test(u)) {
1394 log_debug_unit(u->id, "Starting of %s requested but asserts failed.", u->id);
1398 /* Forward to the main object, if we aren't it. */
1399 following = unit_following(u);
1401 log_debug_unit(u->id, "Redirecting start request from %s to %s.", u->id, following->id);
1402 return unit_start(following);
1405 unit_status_log_starting_stopping_reloading(u, JOB_START);
1406 unit_status_print_starting_stopping(u, JOB_START);
1408 /* If it is stopped, but we cannot start it, then fail */
1409 if (!UNIT_VTABLE(u)->start)
1412 /* We don't suppress calls to ->start() here when we are
1413 * already starting, to allow this request to be used as a
1414 * "hurry up" call, for example when the unit is in some "auto
1415 * restart" state where it waits for a holdoff timer to elapse
1416 * before it will start again. */
1418 unit_add_to_dbus_queue(u);
1420 return UNIT_VTABLE(u)->start(u);
1423 bool unit_can_start(Unit *u) {
1426 return !!UNIT_VTABLE(u)->start;
1429 bool unit_can_isolate(Unit *u) {
1432 return unit_can_start(u) &&
1437 * -EBADR: This unit type does not support stopping.
1438 * -EALREADY: Unit is already stopped.
1439 * -EAGAIN: An operation is already in progress. Retry later.
1441 int unit_stop(Unit *u) {
1442 UnitActiveState state;
1447 state = unit_active_state(u);
1448 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1451 if ((following = unit_following(u))) {
1452 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1453 u->id, following->id);
1454 return unit_stop(following);
1457 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1458 unit_status_print_starting_stopping(u, JOB_STOP);
1460 if (!UNIT_VTABLE(u)->stop)
1463 unit_add_to_dbus_queue(u);
1465 return UNIT_VTABLE(u)->stop(u);
1469 * -EBADR: This unit type does not support reloading.
1470 * -ENOEXEC: Unit is not started.
1471 * -EAGAIN: An operation is already in progress. Retry later.
1473 int unit_reload(Unit *u) {
1474 UnitActiveState state;
1479 if (u->load_state != UNIT_LOADED)
1482 if (!unit_can_reload(u))
1485 state = unit_active_state(u);
1486 if (state == UNIT_RELOADING)
1489 if (state != UNIT_ACTIVE) {
1490 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1495 following = unit_following(u);
1497 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1498 u->id, following->id);
1499 return unit_reload(following);
1502 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1504 unit_add_to_dbus_queue(u);
1505 return UNIT_VTABLE(u)->reload(u);
1508 bool unit_can_reload(Unit *u) {
1511 if (!UNIT_VTABLE(u)->reload)
1514 if (!UNIT_VTABLE(u)->can_reload)
1517 return UNIT_VTABLE(u)->can_reload(u);
1520 static void unit_check_unneeded(Unit *u) {
1526 /* If this service shall be shut down when unneeded then do
1529 if (!u->stop_when_unneeded)
1532 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1535 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1536 if (unit_active_or_pending(other))
1539 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1540 if (unit_active_or_pending(other))
1543 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1544 if (unit_active_or_pending(other))
1547 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1548 if (unit_active_or_pending(other))
1551 log_info_unit(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
1553 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1554 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1557 static void unit_check_binds_to(Unit *u) {
1567 if (unit_active_state(u) != UNIT_ACTIVE)
1570 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1574 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1583 log_info_unit(u->id, "Unit %s is bound to inactive service. Stopping, too.", u->id);
1585 /* A unit we need to run is gone. Sniff. Let's stop this. */
1586 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1589 static void retroactively_start_dependencies(Unit *u) {
1594 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1596 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1597 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1598 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1599 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1601 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1602 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1603 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1604 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1606 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1607 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1608 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1609 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1611 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1612 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1613 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1614 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1616 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1617 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1618 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1620 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1621 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1622 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1625 static void retroactively_stop_dependencies(Unit *u) {
1630 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1632 /* Pull down units which are bound to us recursively if enabled */
1633 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1634 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1635 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1638 static void check_unneeded_dependencies(Unit *u) {
1643 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1645 /* Garbage collect services that might not be needed anymore, if enabled */
1646 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1647 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1648 unit_check_unneeded(other);
1649 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1650 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1651 unit_check_unneeded(other);
1652 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1653 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1654 unit_check_unneeded(other);
1655 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1656 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1657 unit_check_unneeded(other);
1658 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1659 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1660 unit_check_unneeded(other);
1661 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1662 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1663 unit_check_unneeded(other);
1666 void unit_start_on_failure(Unit *u) {
1672 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1675 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1677 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1680 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1682 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1686 void unit_trigger_notify(Unit *u) {
1692 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1693 if (UNIT_VTABLE(other)->trigger_notify)
1694 UNIT_VTABLE(other)->trigger_notify(other, u);
1697 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1702 assert(os < _UNIT_ACTIVE_STATE_MAX);
1703 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1705 /* Note that this is called for all low-level state changes,
1706 * even if they might map to the same high-level
1707 * UnitActiveState! That means that ns == os is an expected
1708 * behavior here. For example: if a mount point is remounted
1709 * this function will be called too! */
1713 /* Update timestamps for state changes */
1714 if (m->n_reloading <= 0) {
1717 dual_timestamp_get(&ts);
1719 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1720 u->inactive_exit_timestamp = ts;
1721 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1722 u->inactive_enter_timestamp = ts;
1724 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1725 u->active_enter_timestamp = ts;
1726 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1727 u->active_exit_timestamp = ts;
1730 /* Keep track of failed units */
1731 if (ns == UNIT_FAILED)
1732 set_put(u->manager->failed_units, u);
1734 set_remove(u->manager->failed_units, u);
1736 /* Make sure the cgroup is always removed when we become inactive */
1737 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1738 unit_destroy_cgroup(u);
1740 /* Note that this doesn't apply to RemainAfterExit services exiting
1741 * successfully, since there's no change of state in that case. Which is
1742 * why it is handled in service_set_state() */
1743 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1746 ec = unit_get_exec_context(u);
1747 if (ec && exec_context_may_touch_console(ec)) {
1748 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1751 if (m->n_on_console == 0)
1752 /* unset no_console_output flag, since the console is free */
1753 m->no_console_output = false;
1762 if (u->job->state == JOB_WAITING)
1764 /* So we reached a different state for this
1765 * job. Let's see if we can run it now if it
1766 * failed previously due to EAGAIN. */
1767 job_add_to_run_queue(u->job);
1769 /* Let's check whether this state change constitutes a
1770 * finished job, or maybe contradicts a running job and
1771 * hence needs to invalidate jobs. */
1773 switch (u->job->type) {
1776 case JOB_VERIFY_ACTIVE:
1778 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1779 job_finish_and_invalidate(u->job, JOB_DONE, true);
1780 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1783 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1784 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1790 case JOB_RELOAD_OR_START:
1792 if (u->job->state == JOB_RUNNING) {
1793 if (ns == UNIT_ACTIVE)
1794 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1795 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1798 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1799 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1807 case JOB_TRY_RESTART:
1809 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1810 job_finish_and_invalidate(u->job, JOB_DONE, true);
1811 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1813 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1819 assert_not_reached("Job type unknown");
1825 if (m->n_reloading <= 0) {
1827 /* If this state change happened without being
1828 * requested by a job, then let's retroactively start
1829 * or stop dependencies. We skip that step when
1830 * deserializing, since we don't want to create any
1831 * additional jobs just because something is already
1835 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1836 retroactively_start_dependencies(u);
1837 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1838 retroactively_stop_dependencies(u);
1841 /* stop unneeded units regardless if going down was expected or not */
1842 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1843 check_unneeded_dependencies(u);
1845 if (ns != os && ns == UNIT_FAILED) {
1846 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1847 unit_start_on_failure(u);
1851 /* Some names are special */
1852 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1854 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1855 /* The bus might have just become available,
1856 * hence try to connect to it, if we aren't
1860 if (u->type == UNIT_SERVICE &&
1861 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1862 m->n_reloading <= 0) {
1863 /* Write audit record if we have just finished starting up */
1864 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1868 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1869 manager_send_unit_plymouth(m, u);
1873 /* We don't care about D-Bus here, since we'll get an
1874 * asynchronous notification for it anyway. */
1876 if (u->type == UNIT_SERVICE &&
1877 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1878 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1879 m->n_reloading <= 0) {
1881 /* Hmm, if there was no start record written
1882 * write it now, so that we always have a nice
1885 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1887 if (ns == UNIT_INACTIVE)
1888 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1890 /* Write audit record if we have just finished shutting down */
1891 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1893 u->in_audit = false;
1897 manager_recheck_journal(m);
1898 unit_trigger_notify(u);
1900 if (u->manager->n_reloading <= 0) {
1901 /* Maybe we finished startup and are now ready for
1902 * being stopped because unneeded? */
1903 unit_check_unneeded(u);
1905 /* Maybe we finished startup, but something we needed
1906 * has vanished? Let's die then. (This happens when
1907 * something BindsTo= to a Type=oneshot unit, as these
1908 * units go directly from starting to inactive,
1909 * without ever entering started.) */
1910 unit_check_binds_to(u);
1913 unit_add_to_dbus_queue(u);
1914 unit_add_to_gc_queue(u);
1917 int unit_watch_pid(Unit *u, pid_t pid) {
1923 /* Watch a specific PID. We only support one or two units
1924 * watching each PID for now, not more. */
1926 r = set_ensure_allocated(&u->pids, NULL);
1930 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1934 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1936 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
1940 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1943 q = set_put(u->pids, LONG_TO_PTR(pid));
1950 void unit_unwatch_pid(Unit *u, pid_t pid) {
1954 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1955 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1956 set_remove(u->pids, LONG_TO_PTR(pid));
1959 void unit_unwatch_all_pids(Unit *u) {
1962 while (!set_isempty(u->pids))
1963 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1969 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1970 _cleanup_closedir_ DIR *d = NULL;
1971 _cleanup_fclose_ FILE *f = NULL;
1977 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1979 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1983 while ((r = cg_read_pid(f, &pid)) > 0) {
1984 r = unit_watch_pid(u, pid);
1985 if (r < 0 && ret >= 0)
1988 if (r < 0 && ret >= 0)
1991 } else if (ret >= 0)
1994 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1998 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1999 _cleanup_free_ char *p = NULL;
2001 p = strjoin(path, "/", fn, NULL);
2007 r = unit_watch_pids_in_path(u, p);
2008 if (r < 0 && ret >= 0)
2011 if (r < 0 && ret >= 0)
2014 } else if (ret >= 0)
2020 int unit_watch_all_pids(Unit *u) {
2023 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2025 if (!u->cgroup_path)
2028 return unit_watch_pids_in_path(u, u->cgroup_path);
2031 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2037 /* Cleans dead PIDs from our list */
2039 SET_FOREACH(e, u->pids, i) {
2040 pid_t pid = PTR_TO_LONG(e);
2042 if (pid == except1 || pid == except2)
2045 if (!pid_is_unwaited(pid))
2046 unit_unwatch_pid(u, pid);
2050 bool unit_job_is_applicable(Unit *u, JobType j) {
2052 assert(j >= 0 && j < _JOB_TYPE_MAX);
2056 case JOB_VERIFY_ACTIVE:
2063 case JOB_TRY_RESTART:
2064 return unit_can_start(u);
2067 return unit_can_reload(u);
2069 case JOB_RELOAD_OR_START:
2070 return unit_can_reload(u) && unit_can_start(u);
2073 assert_not_reached("Invalid job type");
2077 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2080 switch (dependency) {
2082 case UNIT_REQUIRES_OVERRIDABLE:
2084 case UNIT_REQUISITE:
2085 case UNIT_REQUISITE_OVERRIDABLE:
2088 case UNIT_REQUIRED_BY:
2089 case UNIT_REQUIRED_BY_OVERRIDABLE:
2090 case UNIT_WANTED_BY:
2092 case UNIT_CONSISTS_OF:
2093 case UNIT_REFERENCES:
2094 case UNIT_REFERENCED_BY:
2095 case UNIT_PROPAGATES_RELOAD_TO:
2096 case UNIT_RELOAD_PROPAGATED_FROM:
2097 case UNIT_JOINS_NAMESPACE_OF:
2100 case UNIT_CONFLICTS:
2101 case UNIT_CONFLICTED_BY:
2104 case UNIT_ON_FAILURE:
2106 case UNIT_TRIGGERED_BY:
2107 if (streq_ptr(id, other))
2108 log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
2109 unit_dependency_to_string(dependency), id, other);
2111 log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
2112 unit_dependency_to_string(dependency), id,
2116 case _UNIT_DEPENDENCY_MAX:
2117 case _UNIT_DEPENDENCY_INVALID:
2121 assert_not_reached("Invalid dependency type");
2124 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2126 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2127 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2128 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2129 [UNIT_WANTS] = UNIT_WANTED_BY,
2130 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2131 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2132 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2133 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2134 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2135 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2136 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2137 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2138 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2139 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2140 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2141 [UNIT_BEFORE] = UNIT_AFTER,
2142 [UNIT_AFTER] = UNIT_BEFORE,
2143 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2144 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2145 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2146 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2147 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2148 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2149 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2150 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2152 int r, q = 0, v = 0, w = 0;
2153 Unit *orig_u = u, *orig_other = other;
2156 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2159 u = unit_follow_merge(u);
2160 other = unit_follow_merge(other);
2162 /* We won't allow dependencies on ourselves. We will not
2163 * consider them an error however. */
2165 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2169 r = set_ensure_allocated(&u->dependencies[d], NULL);
2173 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2174 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2179 if (add_reference) {
2180 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2184 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2189 q = set_put(u->dependencies[d], other);
2193 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2194 v = set_put(other->dependencies[inverse_table[d]], u);
2201 if (add_reference) {
2202 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2208 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2213 unit_add_to_dbus_queue(u);
2218 set_remove(u->dependencies[d], other);
2221 set_remove(other->dependencies[inverse_table[d]], u);
2224 set_remove(u->dependencies[UNIT_REFERENCES], other);
2229 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2234 r = unit_add_dependency(u, d, other, add_reference);
2238 r = unit_add_dependency(u, e, other, add_reference);
2245 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2249 assert(name || path);
2253 name = basename(path);
2255 if (!unit_name_is_template(name)) {
2261 s = unit_name_replace_instance(name, u->instance);
2263 _cleanup_free_ char *i = NULL;
2265 i = unit_name_to_prefix(u->id);
2269 s = unit_name_replace_instance(name, i);
2279 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2282 _cleanup_free_ char *s = NULL;
2285 assert(name || path);
2287 name = resolve_template(u, name, path, &s);
2291 r = manager_load_unit(u->manager, name, path, NULL, &other);
2295 return unit_add_dependency(u, d, other, add_reference);
2298 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2299 _cleanup_free_ char *s = NULL;
2304 assert(name || path);
2306 name = resolve_template(u, name, path, &s);
2310 r = manager_load_unit(u->manager, name, path, NULL, &other);
2314 return unit_add_two_dependencies(u, d, e, other, add_reference);
2317 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2320 _cleanup_free_ char *s = NULL;
2323 assert(name || path);
2325 name = resolve_template(u, name, path, &s);
2329 r = manager_load_unit(u->manager, name, path, NULL, &other);
2333 return unit_add_dependency(other, d, u, add_reference);
2336 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2339 _cleanup_free_ char *s = NULL;
2342 assert(name || path);
2344 name = resolve_template(u, name, path, &s);
2348 r = manager_load_unit(u->manager, name, path, NULL, &other);
2352 r = unit_add_two_dependencies(other, d, e, u, add_reference);
2359 int set_unit_path(const char *p) {
2360 /* This is mostly for debug purposes */
2361 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2367 char *unit_dbus_path(Unit *u) {
2373 return unit_dbus_path_from_name(u->id);
2376 char *unit_default_cgroup_path(Unit *u) {
2377 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2382 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2383 return strdup(u->manager->cgroup_root);
2385 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2386 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2391 escaped = cg_escape(u->id);
2396 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2398 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2401 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2402 _cleanup_free_ char *b = NULL;
2403 const char *slice_name;
2410 if (UNIT_ISSET(u->slice))
2414 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2416 /* Implicitly place all instantiated units in their
2417 * own per-template slice */
2419 prefix = unit_name_to_prefix(u->id);
2423 /* The prefix is already escaped, but it might include
2424 * "-" which has a special meaning for slice units,
2425 * hence escape it here extra. */
2426 escaped = strreplace(prefix, "-", "\\x2d");
2430 if (u->manager->running_as == SYSTEMD_SYSTEM)
2431 b = strjoin("system-", escaped, ".slice", NULL);
2433 b = strappend(escaped, ".slice");
2440 u->manager->running_as == SYSTEMD_SYSTEM
2441 ? SPECIAL_SYSTEM_SLICE
2442 : SPECIAL_ROOT_SLICE;
2444 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2448 unit_ref_set(&u->slice, slice);
2452 const char *unit_slice_name(Unit *u) {
2455 if (!UNIT_ISSET(u->slice))
2458 return UNIT_DEREF(u->slice)->id;
2461 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2462 _cleanup_free_ char *t = NULL;
2469 t = unit_name_change_suffix(u->id, type);
2473 assert(!unit_has_name(u, t));
2475 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2476 assert(r < 0 || *_found != u);
2480 int unit_watch_bus_name(Unit *u, const char *name) {
2484 /* Watch a specific name on the bus. We only support one unit
2485 * watching each name for now. */
2487 return hashmap_put(u->manager->watch_bus, name, u);
2490 void unit_unwatch_bus_name(Unit *u, const char *name) {
2494 hashmap_remove_value(u->manager->watch_bus, name, u);
2497 bool unit_can_serialize(Unit *u) {
2500 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2503 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2510 if (unit_can_serialize(u)) {
2513 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2517 rt = unit_get_exec_runtime(u);
2519 r = exec_runtime_serialize(rt, u, f, fds);
2525 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2526 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2527 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2528 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2529 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2530 dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2532 if (dual_timestamp_is_set(&u->condition_timestamp))
2533 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2535 if (dual_timestamp_is_set(&u->assert_timestamp))
2536 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2538 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2541 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2543 if (serialize_jobs) {
2545 fprintf(f, "job\n");
2546 job_serialize(u->job, f, fds);
2550 fprintf(f, "job\n");
2551 job_serialize(u->nop_job, f, fds);
2560 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2571 va_start(ap, format);
2572 vfprintf(f, format, ap);
2578 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2584 fprintf(f, "%s=%s\n", key, value);
2587 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2588 ExecRuntime **rt = NULL;
2596 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2598 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2601 char line[LINE_MAX], *l, *v;
2604 if (!fgets(line, sizeof(line), f)) {
2617 k = strcspn(l, "=");
2625 if (streq(l, "job")) {
2627 /* new-style serialized job */
2628 Job *j = job_new_raw(u);
2632 r = job_deserialize(j, f, fds);
2638 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2644 r = job_install_deserialized(j);
2646 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2651 if (j->state == JOB_RUNNING)
2652 u->manager->n_running_jobs++;
2655 JobType type = job_type_from_string(v);
2657 log_debug("Failed to parse job type value %s", v);
2659 u->deserialized_job = type;
2662 } else if (streq(l, "inactive-exit-timestamp")) {
2663 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2665 } else if (streq(l, "active-enter-timestamp")) {
2666 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2668 } else if (streq(l, "active-exit-timestamp")) {
2669 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2671 } else if (streq(l, "inactive-enter-timestamp")) {
2672 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2674 } else if (streq(l, "condition-timestamp")) {
2675 dual_timestamp_deserialize(v, &u->condition_timestamp);
2677 } else if (streq(l, "assert-timestamp")) {
2678 dual_timestamp_deserialize(v, &u->assert_timestamp);
2680 } else if (streq(l, "condition-result")) {
2683 b = parse_boolean(v);
2685 log_debug("Failed to parse condition result value %s", v);
2687 u->condition_result = b;
2691 } else if (streq(l, "assert-result")) {
2694 b = parse_boolean(v);
2696 log_debug("Failed to parse assert result value %s", v);
2698 u->assert_result = b;
2702 } else if (streq(l, "transient")) {
2705 b = parse_boolean(v);
2707 log_debug("Failed to parse transient bool %s", v);
2712 } else if (streq(l, "cgroup")) {
2719 if (u->cgroup_path) {
2722 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2723 log_info("Removing cgroup_path %s from hashmap (%p)",
2725 free(u->cgroup_path);
2729 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2734 if (unit_can_serialize(u)) {
2736 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2743 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2750 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2752 _cleanup_free_ char *e = NULL;
2760 /* Adds in links to the device node that this unit is based on */
2762 if (!is_device_path(what))
2765 e = unit_name_from_path(what, ".device");
2769 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2774 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2779 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2787 int unit_coldplug(Unit *u) {
2792 if (UNIT_VTABLE(u)->coldplug)
2793 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2797 r = job_coldplug(u->job);
2800 } else if (u->deserialized_job >= 0) {
2802 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2806 u->deserialized_job = _JOB_TYPE_INVALID;
2812 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2813 DISABLE_WARNING_FORMAT_NONLITERAL;
2814 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2815 status, unit_status_msg_format, unit_description(u));
2819 bool unit_need_daemon_reload(Unit *u) {
2820 _cleanup_strv_free_ char **t = NULL;
2823 unsigned loaded_cnt, current_cnt;
2827 if (u->fragment_path) {
2829 if (stat(u->fragment_path, &st) < 0)
2830 /* What, cannot access this anymore? */
2833 if (u->fragment_mtime > 0 &&
2834 timespec_load(&st.st_mtim) != u->fragment_mtime)
2838 if (u->source_path) {
2840 if (stat(u->source_path, &st) < 0)
2843 if (u->source_mtime > 0 &&
2844 timespec_load(&st.st_mtim) != u->source_mtime)
2848 t = unit_find_dropin_paths(u);
2849 loaded_cnt = strv_length(t);
2850 current_cnt = strv_length(u->dropin_paths);
2852 if (loaded_cnt == current_cnt) {
2853 if (loaded_cnt == 0)
2856 if (strv_overlap(u->dropin_paths, t)) {
2857 STRV_FOREACH(path, u->dropin_paths) {
2859 if (stat(*path, &st) < 0)
2862 if (u->dropin_mtime > 0 &&
2863 timespec_load(&st.st_mtim) > u->dropin_mtime)
2874 void unit_reset_failed(Unit *u) {
2877 if (UNIT_VTABLE(u)->reset_failed)
2878 UNIT_VTABLE(u)->reset_failed(u);
2881 Unit *unit_following(Unit *u) {
2884 if (UNIT_VTABLE(u)->following)
2885 return UNIT_VTABLE(u)->following(u);
2890 bool unit_stop_pending(Unit *u) {
2893 /* This call does check the current state of the unit. It's
2894 * hence useful to be called from state change calls of the
2895 * unit itself, where the state isn't updated yet. This is
2896 * different from unit_inactive_or_pending() which checks both
2897 * the current state and for a queued job. */
2899 return u->job && u->job->type == JOB_STOP;
2902 bool unit_inactive_or_pending(Unit *u) {
2905 /* Returns true if the unit is inactive or going down */
2907 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2910 if (unit_stop_pending(u))
2916 bool unit_active_or_pending(Unit *u) {
2919 /* Returns true if the unit is active or going up */
2921 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2925 (u->job->type == JOB_START ||
2926 u->job->type == JOB_RELOAD_OR_START ||
2927 u->job->type == JOB_RESTART))
2933 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2935 assert(w >= 0 && w < _KILL_WHO_MAX);
2937 assert(signo < _NSIG);
2939 if (!UNIT_VTABLE(u)->kill)
2942 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2945 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2949 pid_set = set_new(NULL);
2953 /* Exclude the main/control pids from being killed via the cgroup */
2955 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2960 if (control_pid > 0) {
2961 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2973 int unit_kill_common(
2979 sd_bus_error *error) {
2983 if (who == KILL_MAIN && main_pid <= 0) {
2985 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2987 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2990 if (who == KILL_CONTROL && control_pid <= 0) {
2991 if (control_pid < 0)
2992 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2994 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2997 if (who == KILL_CONTROL || who == KILL_ALL)
2998 if (control_pid > 0)
2999 if (kill(control_pid, signo) < 0)
3002 if (who == KILL_MAIN || who == KILL_ALL)
3004 if (kill(main_pid, signo) < 0)
3007 if (who == KILL_ALL && u->cgroup_path) {
3008 _cleanup_set_free_ Set *pid_set = NULL;
3011 /* Exclude the main/control pids from being killed via the cgroup */
3012 pid_set = unit_pid_set(main_pid, control_pid);
3016 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3017 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3024 int unit_following_set(Unit *u, Set **s) {
3028 if (UNIT_VTABLE(u)->following_set)
3029 return UNIT_VTABLE(u)->following_set(u, s);
3035 UnitFileState unit_get_unit_file_state(Unit *u) {
3038 if (u->unit_file_state < 0 && u->fragment_path)
3039 u->unit_file_state = unit_file_get_state(
3040 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3041 NULL, basename(u->fragment_path));
3043 return u->unit_file_state;
3046 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3051 unit_ref_unset(ref);
3054 LIST_PREPEND(refs, u->refs, ref);
3058 void unit_ref_unset(UnitRef *ref) {
3064 LIST_REMOVE(refs, ref->unit->refs, ref);
3068 int unit_patch_contexts(Unit *u) {
3076 /* Patch in the manager defaults into the exec and cgroup
3077 * contexts, _after_ the rest of the settings have been
3080 ec = unit_get_exec_context(u);
3082 /* This only copies in the ones that need memory */
3083 for (i = 0; i < _RLIMIT_MAX; i++)
3084 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3085 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3090 if (u->manager->running_as == SYSTEMD_USER &&
3091 !ec->working_directory) {
3093 r = get_home_dir(&ec->working_directory);
3098 if (u->manager->running_as == SYSTEMD_USER &&
3099 (ec->syscall_whitelist ||
3100 !set_isempty(ec->syscall_filter) ||
3101 !set_isempty(ec->syscall_archs) ||
3102 ec->address_families_whitelist ||
3103 !set_isempty(ec->address_families)))
3104 ec->no_new_privileges = true;
3106 if (ec->private_devices)
3107 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3110 cc = unit_get_cgroup_context(u);
3114 ec->private_devices &&
3115 cc->device_policy == CGROUP_AUTO)
3116 cc->device_policy = CGROUP_CLOSED;
3122 ExecContext *unit_get_exec_context(Unit *u) {
3129 offset = UNIT_VTABLE(u)->exec_context_offset;
3133 return (ExecContext*) ((uint8_t*) u + offset);
3136 KillContext *unit_get_kill_context(Unit *u) {
3143 offset = UNIT_VTABLE(u)->kill_context_offset;
3147 return (KillContext*) ((uint8_t*) u + offset);
3150 CGroupContext *unit_get_cgroup_context(Unit *u) {
3156 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3160 return (CGroupContext*) ((uint8_t*) u + offset);
3163 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3169 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3173 return *(ExecRuntime**) ((uint8_t*) u + offset);
3176 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3177 if (u->manager->running_as == SYSTEMD_USER) {
3180 if (mode == UNIT_PERSISTENT && !transient)
3181 r = user_config_home(dir);
3183 r = user_runtime_dir(dir);
3190 if (mode == UNIT_PERSISTENT && !transient)
3191 *dir = strdup("/etc/systemd/system");
3193 *dir = strdup("/run/systemd/system");
3200 static int unit_drop_in_file(Unit *u,
3201 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3202 _cleanup_free_ char *dir = NULL;
3207 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3211 return drop_in_file(dir, u->id, 50, name, p, q);
3214 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3216 _cleanup_free_ char *dir = NULL;
3221 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3224 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3228 return write_drop_in(dir, u->id, 50, name, data);
3231 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3232 _cleanup_free_ char *p = NULL;
3240 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3243 va_start(ap, format);
3244 r = vasprintf(&p, format, ap);
3250 return unit_write_drop_in(u, mode, name, p);
3253 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3254 _cleanup_free_ char *ndata = NULL;
3260 if (!UNIT_VTABLE(u)->private_section)
3263 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3266 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3270 return unit_write_drop_in(u, mode, name, ndata);
3273 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3274 _cleanup_free_ char *p = NULL;
3282 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3285 va_start(ap, format);
3286 r = vasprintf(&p, format, ap);
3292 return unit_write_drop_in_private(u, mode, name, p);
3295 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3296 _cleanup_free_ char *p = NULL, *q = NULL;
3301 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3304 r = unit_drop_in_file(u, mode, name, &p, &q);
3309 r = errno == ENOENT ? 0 : -errno;
3317 int unit_make_transient(Unit *u) {
3322 u->load_state = UNIT_STUB;
3324 u->transient = true;
3326 free(u->fragment_path);
3327 u->fragment_path = NULL;
3329 if (u->manager->running_as == SYSTEMD_USER) {
3330 _cleanup_free_ char *c = NULL;
3332 r = user_runtime_dir(&c);
3338 u->fragment_path = strjoin(c, "/", u->id, NULL);
3339 if (!u->fragment_path)
3344 u->fragment_path = strappend("/run/systemd/system/", u->id);
3345 if (!u->fragment_path)
3348 mkdir_p("/run/systemd/system", 0755);
3351 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3354 int unit_kill_context(
3360 bool main_pid_alien) {
3362 int sig, wait_for_exit = false, r;
3367 if (c->kill_mode == KILL_NONE)
3377 case KILL_TERMINATE:
3378 sig = c->kill_signal;
3381 assert_not_reached("KillOperation unknown");
3385 r = kill_and_sigcont(main_pid, sig);
3387 if (r < 0 && r != -ESRCH) {
3388 _cleanup_free_ char *comm = NULL;
3389 get_process_comm(main_pid, &comm);
3391 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3393 if (!main_pid_alien)
3394 wait_for_exit = true;
3396 if (c->send_sighup && k != KILL_KILL)
3397 kill(main_pid, SIGHUP);
3401 if (control_pid > 0) {
3402 r = kill_and_sigcont(control_pid, sig);
3404 if (r < 0 && r != -ESRCH) {
3405 _cleanup_free_ char *comm = NULL;
3406 get_process_comm(control_pid, &comm);
3408 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3410 wait_for_exit = true;
3412 if (c->send_sighup && k != KILL_KILL)
3413 kill(control_pid, SIGHUP);
3417 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3418 _cleanup_set_free_ Set *pid_set = NULL;
3420 /* Exclude the main/control pids from being killed via the cgroup */
3421 pid_set = unit_pid_set(main_pid, control_pid);
3425 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3427 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3428 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3431 /* FIXME: For now, we will not wait for the
3432 * cgroup members to die, simply because
3433 * cgroup notification is unreliable. It
3434 * doesn't work at all in containers, and
3435 * outside of containers it can be confused
3436 * easily by leaving directories in the
3439 /* wait_for_exit = true; */
3441 if (c->send_sighup && k != KILL_KILL) {
3444 pid_set = unit_pid_set(main_pid, control_pid);
3448 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3453 return wait_for_exit;
3456 int unit_require_mounts_for(Unit *u, const char *path) {
3457 char prefix[strlen(path) + 1], *p;
3463 /* Registers a unit for requiring a certain path and all its
3464 * prefixes. We keep a simple array of these paths in the
3465 * unit, since its usually short. However, we build a prefix
3466 * table for all possible prefixes so that new appearing mount
3467 * units can easily determine which units to make themselves a
3470 if (!path_is_absolute(path))
3477 path_kill_slashes(p);
3479 if (!path_is_safe(p)) {
3484 if (strv_contains(u->requires_mounts_for, p)) {
3489 r = strv_consume(&u->requires_mounts_for, p);
3493 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3496 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3500 if (!u->manager->units_requiring_mounts_for) {
3501 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3502 if (!u->manager->units_requiring_mounts_for)
3516 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3532 int unit_setup_exec_runtime(Unit *u) {
3538 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3541 /* Check if there already is an ExecRuntime for this unit? */
3542 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3546 /* Try to get it from somebody else */
3547 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3549 *rt = unit_get_exec_runtime(other);
3551 exec_runtime_ref(*rt);
3556 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3559 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3560 [UNIT_ACTIVE] = "active",
3561 [UNIT_RELOADING] = "reloading",
3562 [UNIT_INACTIVE] = "inactive",
3563 [UNIT_FAILED] = "failed",
3564 [UNIT_ACTIVATING] = "activating",
3565 [UNIT_DEACTIVATING] = "deactivating"
3568 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);