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_func, string_compare_func);
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 set_free_free(u->names);
525 unit_unwatch_all_pids(u);
527 condition_free_list(u->conditions);
529 unit_ref_unset(&u->slice);
532 unit_ref_unset(u->refs);
537 UnitActiveState unit_active_state(Unit *u) {
540 if (u->load_state == UNIT_MERGED)
541 return unit_active_state(unit_follow_merge(u));
543 /* After a reload it might happen that a unit is not correctly
544 * loaded but still has a process around. That's why we won't
545 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
547 return UNIT_VTABLE(u)->active_state(u);
550 const char* unit_sub_state_to_string(Unit *u) {
553 return UNIT_VTABLE(u)->sub_state_to_string(u);
556 static void complete_move(Set **s, Set **other) {
564 set_move(*s, *other);
571 static void merge_names(Unit *u, Unit *other) {
578 complete_move(&u->names, &other->names);
580 set_free_free(other->names);
584 SET_FOREACH(t, u->names, i)
585 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
588 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
595 assert(d < _UNIT_DEPENDENCY_MAX);
597 /* Fix backwards pointers */
598 SET_FOREACH(back, other->dependencies[d], i) {
601 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
602 /* Do not add dependencies between u and itself */
604 if (set_remove(back->dependencies[k], other))
605 maybe_warn_about_dependency(u->id, other_id, k);
607 r = set_remove_and_put(back->dependencies[k], other, u);
609 set_remove(back->dependencies[k], other);
611 assert(r >= 0 || r == -ENOENT);
616 /* Also do not move dependencies on u to itself */
617 back = set_remove(other->dependencies[d], u);
619 maybe_warn_about_dependency(u->id, other_id, d);
621 complete_move(&u->dependencies[d], &other->dependencies[d]);
623 set_free(other->dependencies[d]);
624 other->dependencies[d] = NULL;
627 int unit_merge(Unit *u, Unit *other) {
629 const char *other_id = NULL;
633 assert(u->manager == other->manager);
634 assert(u->type != _UNIT_TYPE_INVALID);
636 other = unit_follow_merge(other);
641 if (u->type != other->type)
644 if (!u->instance != !other->instance)
647 if (other->load_state != UNIT_STUB &&
648 other->load_state != UNIT_NOT_FOUND)
657 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
661 other_id = strdupa(other->id);
664 merge_names(u, other);
666 /* Redirect all references */
668 unit_ref_set(other->refs, u);
670 /* Merge dependencies */
671 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
672 merge_dependencies(u, other, other_id, d);
674 other->load_state = UNIT_MERGED;
675 other->merged_into = u;
677 /* If there is still some data attached to the other node, we
678 * don't need it anymore, and can free it. */
679 if (other->load_state != UNIT_STUB)
680 if (UNIT_VTABLE(other)->done)
681 UNIT_VTABLE(other)->done(other);
683 unit_add_to_dbus_queue(u);
684 unit_add_to_cleanup_queue(other);
689 int unit_merge_by_name(Unit *u, const char *name) {
692 _cleanup_free_ char *s = NULL;
697 if (unit_name_is_template(name)) {
701 s = unit_name_replace_instance(name, u->instance);
708 other = manager_get_unit(u->manager, name);
710 r = unit_add_name(u, name);
712 r = unit_merge(u, other);
717 Unit* unit_follow_merge(Unit *u) {
720 while (u->load_state == UNIT_MERGED)
721 assert_se(u = u->merged_into);
726 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
732 if (c->working_directory) {
733 r = unit_require_mounts_for(u, c->working_directory);
738 if (c->root_directory) {
739 r = unit_require_mounts_for(u, c->root_directory);
744 if (u->manager->running_as != SYSTEMD_SYSTEM)
747 if (c->private_tmp) {
748 r = unit_require_mounts_for(u, "/tmp");
752 r = unit_require_mounts_for(u, "/var/tmp");
757 if (c->std_output != EXEC_OUTPUT_KMSG &&
758 c->std_output != EXEC_OUTPUT_SYSLOG &&
759 c->std_output != EXEC_OUTPUT_JOURNAL &&
760 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
761 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
762 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
763 c->std_error != EXEC_OUTPUT_KMSG &&
764 c->std_error != EXEC_OUTPUT_SYSLOG &&
765 c->std_error != EXEC_OUTPUT_JOURNAL &&
766 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
767 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
768 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
771 /* If syslog or kernel logging is requested, make sure our own
772 * logging daemon is run first. */
774 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
781 const char *unit_description(Unit *u) {
785 return u->description;
790 void unit_dump(Unit *u, FILE *f, const char *prefix) {
794 _cleanup_free_ char *p2 = NULL;
797 timestamp1[FORMAT_TIMESTAMP_MAX],
798 timestamp2[FORMAT_TIMESTAMP_MAX],
799 timestamp3[FORMAT_TIMESTAMP_MAX],
800 timestamp4[FORMAT_TIMESTAMP_MAX],
801 timespan[FORMAT_TIMESPAN_MAX];
803 _cleanup_set_free_ Set *following_set = NULL;
807 assert(u->type >= 0);
811 p2 = strappend(prefix, "\t");
812 prefix2 = p2 ? p2 : prefix;
816 "%s\tDescription: %s\n"
818 "%s\tUnit Load State: %s\n"
819 "%s\tUnit Active State: %s\n"
820 "%s\tInactive Exit Timestamp: %s\n"
821 "%s\tActive Enter Timestamp: %s\n"
822 "%s\tActive Exit Timestamp: %s\n"
823 "%s\tInactive Enter Timestamp: %s\n"
824 "%s\tGC Check Good: %s\n"
825 "%s\tNeed Daemon Reload: %s\n"
826 "%s\tTransient: %s\n"
829 "%s\tCGroup realized: %s\n"
830 "%s\tCGroup mask: 0x%x\n"
831 "%s\tCGroup members mask: 0x%x\n",
833 prefix, unit_description(u),
834 prefix, strna(u->instance),
835 prefix, unit_load_state_to_string(u->load_state),
836 prefix, unit_active_state_to_string(unit_active_state(u)),
837 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
838 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
839 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
840 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
841 prefix, yes_no(unit_check_gc(u)),
842 prefix, yes_no(unit_need_daemon_reload(u)),
843 prefix, yes_no(u->transient),
844 prefix, strna(unit_slice_name(u)),
845 prefix, strna(u->cgroup_path),
846 prefix, yes_no(u->cgroup_realized),
847 prefix, u->cgroup_realized_mask,
848 prefix, u->cgroup_members_mask);
850 SET_FOREACH(t, u->names, i)
851 fprintf(f, "%s\tName: %s\n", prefix, t);
853 STRV_FOREACH(j, u->documentation)
854 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
856 following = unit_following(u);
858 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
860 r = unit_following_set(u, &following_set);
864 SET_FOREACH(other, following_set, i)
865 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
868 if (u->fragment_path)
869 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
872 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
874 STRV_FOREACH(j, u->dropin_paths)
875 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
877 if (u->job_timeout > 0)
878 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
880 condition_dump_list(u->conditions, f, prefix);
882 if (dual_timestamp_is_set(&u->condition_timestamp))
884 "%s\tCondition Timestamp: %s\n"
885 "%s\tCondition Result: %s\n",
886 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
887 prefix, yes_no(u->condition_result));
889 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
892 SET_FOREACH(other, u->dependencies[d], i)
893 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
896 if (!strv_isempty(u->requires_mounts_for)) {
898 "%s\tRequiresMountsFor:", prefix);
900 STRV_FOREACH(j, u->requires_mounts_for)
901 fprintf(f, " %s", *j);
906 if (u->load_state == UNIT_LOADED) {
909 "%s\tStopWhenUnneeded: %s\n"
910 "%s\tRefuseManualStart: %s\n"
911 "%s\tRefuseManualStop: %s\n"
912 "%s\tDefaultDependencies: %s\n"
913 "%s\tOnFailureJobMode: %s\n"
914 "%s\tIgnoreOnIsolate: %s\n"
915 "%s\tIgnoreOnSnapshot: %s\n",
916 prefix, yes_no(u->stop_when_unneeded),
917 prefix, yes_no(u->refuse_manual_start),
918 prefix, yes_no(u->refuse_manual_stop),
919 prefix, yes_no(u->default_dependencies),
920 prefix, job_mode_to_string(u->on_failure_job_mode),
921 prefix, yes_no(u->ignore_on_isolate),
922 prefix, yes_no(u->ignore_on_snapshot));
924 if (UNIT_VTABLE(u)->dump)
925 UNIT_VTABLE(u)->dump(u, f, prefix2);
927 } else if (u->load_state == UNIT_MERGED)
929 "%s\tMerged into: %s\n",
930 prefix, u->merged_into->id);
931 else if (u->load_state == UNIT_ERROR)
932 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
936 job_dump(u->job, f, prefix2);
939 job_dump(u->nop_job, f, prefix2);
943 /* Common implementation for multiple backends */
944 int unit_load_fragment_and_dropin(Unit *u) {
949 /* Load a .{service,socket,...} file */
950 r = unit_load_fragment(u);
954 if (u->load_state == UNIT_STUB)
957 /* Load drop-in directory data */
958 r = unit_load_dropin(unit_follow_merge(u));
965 /* Common implementation for multiple backends */
966 int unit_load_fragment_and_dropin_optional(Unit *u) {
971 /* Same as unit_load_fragment_and_dropin(), but whether
972 * something can be loaded or not doesn't matter. */
974 /* Load a .service file */
975 r = unit_load_fragment(u);
979 if (u->load_state == UNIT_STUB)
980 u->load_state = UNIT_LOADED;
982 /* Load drop-in directory data */
983 r = unit_load_dropin(unit_follow_merge(u));
990 int unit_add_default_target_dependency(Unit *u, Unit *target) {
994 if (target->type != UNIT_TARGET)
997 /* Only add the dependency if both units are loaded, so that
998 * that loop check below is reliable */
999 if (u->load_state != UNIT_LOADED ||
1000 target->load_state != UNIT_LOADED)
1003 /* If either side wants no automatic dependencies, then let's
1005 if (!u->default_dependencies ||
1006 !target->default_dependencies)
1009 /* Don't create loops */
1010 if (set_get(target->dependencies[UNIT_BEFORE], u))
1013 return unit_add_dependency(target, UNIT_AFTER, u, true);
1016 static int unit_add_target_dependencies(Unit *u) {
1018 static const UnitDependency deps[] = {
1020 UNIT_REQUIRED_BY_OVERRIDABLE,
1032 for (k = 0; k < ELEMENTSOF(deps); k++)
1033 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1034 r = unit_add_default_target_dependency(u, target);
1042 static int unit_add_slice_dependencies(Unit *u) {
1045 if (!unit_get_cgroup_context(u))
1048 if (UNIT_ISSET(u->slice))
1049 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1051 if (streq(u->id, SPECIAL_ROOT_SLICE))
1054 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1057 static int unit_add_mount_dependencies(Unit *u) {
1063 STRV_FOREACH(i, u->requires_mounts_for) {
1064 char prefix[strlen(*i) + 1];
1066 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1069 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1077 if (m->load_state != UNIT_LOADED)
1080 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1084 if (m->fragment_path) {
1085 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1095 static int unit_add_startup_units(Unit *u) {
1099 c = unit_get_cgroup_context(u);
1103 if (c->startup_cpu_shares == (unsigned long) -1 &&
1104 c->startup_blockio_weight == (unsigned long) -1)
1107 r = set_put(u->manager->startup_units, u);
1114 int unit_load(Unit *u) {
1119 if (u->in_load_queue) {
1120 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1121 u->in_load_queue = false;
1124 if (u->type == _UNIT_TYPE_INVALID)
1127 if (u->load_state != UNIT_STUB)
1130 if (UNIT_VTABLE(u)->load) {
1131 r = UNIT_VTABLE(u)->load(u);
1136 if (u->load_state == UNIT_STUB) {
1141 if (u->load_state == UNIT_LOADED) {
1143 r = unit_add_target_dependencies(u);
1147 r = unit_add_slice_dependencies(u);
1151 r = unit_add_mount_dependencies(u);
1155 r = unit_add_startup_units(u);
1159 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1160 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1165 unit_update_cgroup_members_masks(u);
1168 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1170 unit_add_to_dbus_queue(unit_follow_merge(u));
1171 unit_add_to_gc_queue(u);
1176 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1178 unit_add_to_dbus_queue(u);
1179 unit_add_to_gc_queue(u);
1181 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1182 u->id, strerror(-r));
1187 static bool unit_condition_test(Unit *u) {
1190 dual_timestamp_get(&u->condition_timestamp);
1191 u->condition_result = condition_test_list(u->id, u->conditions);
1193 return u->condition_result;
1196 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1197 const UnitStatusMessageFormats *format_table;
1201 assert(t < _JOB_TYPE_MAX);
1203 if (t != JOB_START && t != JOB_STOP)
1206 format_table = &UNIT_VTABLE(u)->status_message_formats;
1210 return format_table->starting_stopping[t == JOB_STOP];
1213 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1218 assert(t < _JOB_TYPE_MAX);
1220 format = unit_get_status_message_format(u, t);
1224 /* Return generic strings */
1226 return "Starting %s.";
1227 else if (t == JOB_STOP)
1228 return "Stopping %s.";
1229 else if (t == JOB_RELOAD)
1230 return "Reloading %s.";
1235 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1240 /* We only print status messages for selected units on
1241 * selected operations. */
1243 format = unit_get_status_message_format(u, t);
1247 DISABLE_WARNING_FORMAT_NONLITERAL;
1248 unit_status_printf(u, "", format);
1252 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1259 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1262 if (log_on_console())
1265 /* We log status messages for all units and all operations. */
1267 format = unit_get_status_message_format_try_harder(u, t);
1271 DISABLE_WARNING_FORMAT_NONLITERAL;
1272 snprintf(buf, sizeof(buf), format, unit_description(u));
1276 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1277 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1278 SD_MESSAGE_UNIT_RELOADING;
1280 log_struct_unit(LOG_INFO,
1288 * -EBADR: This unit type does not support starting.
1289 * -EALREADY: Unit is already started.
1290 * -EAGAIN: An operation is already in progress. Retry later.
1291 * -ECANCELED: Too many requests for now.
1293 int unit_start(Unit *u) {
1294 UnitActiveState state;
1299 if (u->load_state != UNIT_LOADED)
1302 /* If this is already started, then this will succeed. Note
1303 * that this will even succeed if this unit is not startable
1304 * by the user. This is relied on to detect when we need to
1305 * wait for units and when waiting is finished. */
1306 state = unit_active_state(u);
1307 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1310 /* If the conditions failed, don't do anything at all. If we
1311 * already are activating this call might still be useful to
1312 * speed up activation in case there is some hold-off time,
1313 * but we don't want to recheck the condition in that case. */
1314 if (state != UNIT_ACTIVATING &&
1315 !unit_condition_test(u)) {
1316 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1320 /* Forward to the main object, if we aren't it. */
1321 following = unit_following(u);
1323 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1324 u->id, following->id);
1325 return unit_start(following);
1328 unit_status_log_starting_stopping_reloading(u, JOB_START);
1329 unit_status_print_starting_stopping(u, JOB_START);
1331 /* If it is stopped, but we cannot start it, then fail */
1332 if (!UNIT_VTABLE(u)->start)
1335 /* We don't suppress calls to ->start() here when we are
1336 * already starting, to allow this request to be used as a
1337 * "hurry up" call, for example when the unit is in some "auto
1338 * restart" state where it waits for a holdoff timer to elapse
1339 * before it will start again. */
1341 unit_add_to_dbus_queue(u);
1343 return UNIT_VTABLE(u)->start(u);
1346 bool unit_can_start(Unit *u) {
1349 return !!UNIT_VTABLE(u)->start;
1352 bool unit_can_isolate(Unit *u) {
1355 return unit_can_start(u) &&
1360 * -EBADR: This unit type does not support stopping.
1361 * -EALREADY: Unit is already stopped.
1362 * -EAGAIN: An operation is already in progress. Retry later.
1364 int unit_stop(Unit *u) {
1365 UnitActiveState state;
1370 state = unit_active_state(u);
1371 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1374 if ((following = unit_following(u))) {
1375 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1376 u->id, following->id);
1377 return unit_stop(following);
1380 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1381 unit_status_print_starting_stopping(u, JOB_STOP);
1383 if (!UNIT_VTABLE(u)->stop)
1386 unit_add_to_dbus_queue(u);
1388 return UNIT_VTABLE(u)->stop(u);
1392 * -EBADR: This unit type does not support reloading.
1393 * -ENOEXEC: Unit is not started.
1394 * -EAGAIN: An operation is already in progress. Retry later.
1396 int unit_reload(Unit *u) {
1397 UnitActiveState state;
1402 if (u->load_state != UNIT_LOADED)
1405 if (!unit_can_reload(u))
1408 state = unit_active_state(u);
1409 if (state == UNIT_RELOADING)
1412 if (state != UNIT_ACTIVE) {
1413 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1418 following = unit_following(u);
1420 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1421 u->id, following->id);
1422 return unit_reload(following);
1425 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1427 unit_add_to_dbus_queue(u);
1428 return UNIT_VTABLE(u)->reload(u);
1431 bool unit_can_reload(Unit *u) {
1434 if (!UNIT_VTABLE(u)->reload)
1437 if (!UNIT_VTABLE(u)->can_reload)
1440 return UNIT_VTABLE(u)->can_reload(u);
1443 static void unit_check_unneeded(Unit *u) {
1449 /* If this service shall be shut down when unneeded then do
1452 if (!u->stop_when_unneeded)
1455 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1458 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1459 if (unit_active_or_pending(other))
1462 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1463 if (unit_active_or_pending(other))
1466 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1467 if (unit_active_or_pending(other))
1470 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1471 if (unit_active_or_pending(other))
1474 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1476 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1477 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1480 static void retroactively_start_dependencies(Unit *u) {
1485 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1487 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1488 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1489 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1490 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1492 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1493 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1494 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1495 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1497 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1498 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1499 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1500 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1502 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1503 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1504 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1505 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1507 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1508 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1509 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1511 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1512 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1513 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1516 static void retroactively_stop_dependencies(Unit *u) {
1521 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1523 /* Pull down units which are bound to us recursively if enabled */
1524 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1525 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1526 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1529 static void check_unneeded_dependencies(Unit *u) {
1534 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1536 /* Garbage collect services that might not be needed anymore, if enabled */
1537 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1538 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1539 unit_check_unneeded(other);
1540 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1541 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1542 unit_check_unneeded(other);
1543 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1544 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1545 unit_check_unneeded(other);
1546 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1547 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1548 unit_check_unneeded(other);
1549 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1550 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1551 unit_check_unneeded(other);
1552 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1553 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1554 unit_check_unneeded(other);
1557 void unit_start_on_failure(Unit *u) {
1563 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1566 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1568 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1571 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1573 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1577 void unit_trigger_notify(Unit *u) {
1583 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1584 if (UNIT_VTABLE(other)->trigger_notify)
1585 UNIT_VTABLE(other)->trigger_notify(other, u);
1588 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1593 assert(os < _UNIT_ACTIVE_STATE_MAX);
1594 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1596 /* Note that this is called for all low-level state changes,
1597 * even if they might map to the same high-level
1598 * UnitActiveState! That means that ns == os is an expected
1599 * behavior here. For example: if a mount point is remounted
1600 * this function will be called too! */
1604 /* Update timestamps for state changes */
1605 if (m->n_reloading <= 0) {
1608 dual_timestamp_get(&ts);
1610 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1611 u->inactive_exit_timestamp = ts;
1612 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1613 u->inactive_enter_timestamp = ts;
1615 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1616 u->active_enter_timestamp = ts;
1617 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1618 u->active_exit_timestamp = ts;
1621 /* Keep track of failed units */
1622 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1623 set_put(u->manager->failed_units, u);
1624 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1625 set_remove(u->manager->failed_units, u);
1627 /* Make sure the cgroup is always removed when we become inactive */
1628 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1629 unit_destroy_cgroup(u);
1631 /* Note that this doesn't apply to RemainAfterExit services exiting
1632 * successfully, since there's no change of state in that case. Which is
1633 * why it is handled in service_set_state() */
1634 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1637 ec = unit_get_exec_context(u);
1638 if (ec && exec_context_may_touch_console(ec)) {
1639 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1642 if (m->n_on_console == 0)
1643 /* unset no_console_output flag, since the console is free */
1644 m->no_console_output = false;
1653 if (u->job->state == JOB_WAITING)
1655 /* So we reached a different state for this
1656 * job. Let's see if we can run it now if it
1657 * failed previously due to EAGAIN. */
1658 job_add_to_run_queue(u->job);
1660 /* Let's check whether this state change constitutes a
1661 * finished job, or maybe contradicts a running job and
1662 * hence needs to invalidate jobs. */
1664 switch (u->job->type) {
1667 case JOB_VERIFY_ACTIVE:
1669 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1670 job_finish_and_invalidate(u->job, JOB_DONE, true);
1671 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1674 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1675 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1681 case JOB_RELOAD_OR_START:
1683 if (u->job->state == JOB_RUNNING) {
1684 if (ns == UNIT_ACTIVE)
1685 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1686 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1689 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1690 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1698 case JOB_TRY_RESTART:
1700 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1701 job_finish_and_invalidate(u->job, JOB_DONE, true);
1702 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1704 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1710 assert_not_reached("Job type unknown");
1716 if (m->n_reloading <= 0) {
1718 /* If this state change happened without being
1719 * requested by a job, then let's retroactively start
1720 * or stop dependencies. We skip that step when
1721 * deserializing, since we don't want to create any
1722 * additional jobs just because something is already
1726 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1727 retroactively_start_dependencies(u);
1728 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1729 retroactively_stop_dependencies(u);
1732 /* stop unneeded units regardless if going down was expected or not */
1733 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1734 check_unneeded_dependencies(u);
1736 if (ns != os && ns == UNIT_FAILED) {
1737 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1738 unit_start_on_failure(u);
1742 /* Some names are special */
1743 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1745 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1746 /* The bus might have just become available,
1747 * hence try to connect to it, if we aren't
1751 if (u->type == UNIT_SERVICE &&
1752 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1753 m->n_reloading <= 0) {
1754 /* Write audit record if we have just finished starting up */
1755 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1759 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1760 manager_send_unit_plymouth(m, u);
1764 /* We don't care about D-Bus here, since we'll get an
1765 * asynchronous notification for it anyway. */
1767 if (u->type == UNIT_SERVICE &&
1768 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1769 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1770 m->n_reloading <= 0) {
1772 /* Hmm, if there was no start record written
1773 * write it now, so that we always have a nice
1776 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1778 if (ns == UNIT_INACTIVE)
1779 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1781 /* Write audit record if we have just finished shutting down */
1782 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1784 u->in_audit = false;
1788 manager_recheck_journal(m);
1789 unit_trigger_notify(u);
1791 /* Maybe we finished startup and are now ready for being
1792 * stopped because unneeded? */
1793 if (u->manager->n_reloading <= 0)
1794 unit_check_unneeded(u);
1796 unit_add_to_dbus_queue(u);
1797 unit_add_to_gc_queue(u);
1800 int unit_watch_pid(Unit *u, pid_t pid) {
1806 /* Watch a specific PID. We only support one or two units
1807 * watching each PID for now, not more. */
1809 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1813 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1817 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1819 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1823 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1826 q = set_put(u->pids, LONG_TO_PTR(pid));
1833 void unit_unwatch_pid(Unit *u, pid_t pid) {
1837 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1838 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1839 set_remove(u->pids, LONG_TO_PTR(pid));
1842 void unit_unwatch_all_pids(Unit *u) {
1845 while (!set_isempty(u->pids))
1846 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1852 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1853 _cleanup_closedir_ DIR *d = NULL;
1854 _cleanup_fclose_ FILE *f = NULL;
1860 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1862 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1866 while ((r = cg_read_pid(f, &pid)) > 0) {
1867 r = unit_watch_pid(u, pid);
1868 if (r < 0 && ret >= 0)
1871 if (r < 0 && ret >= 0)
1874 } else if (ret >= 0)
1877 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1881 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1882 _cleanup_free_ char *p = NULL;
1884 p = strjoin(path, "/", fn, NULL);
1890 r = unit_watch_pids_in_path(u, p);
1891 if (r < 0 && ret >= 0)
1894 if (r < 0 && ret >= 0)
1897 } else if (ret >= 0)
1903 int unit_watch_all_pids(Unit *u) {
1906 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1908 if (!u->cgroup_path)
1911 return unit_watch_pids_in_path(u, u->cgroup_path);
1914 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1920 /* Cleans dead PIDs from our list */
1922 SET_FOREACH(e, u->pids, i) {
1923 pid_t pid = PTR_TO_LONG(e);
1925 if (pid == except1 || pid == except2)
1928 if (!pid_is_unwaited(pid))
1929 unit_unwatch_pid(u, pid);
1933 bool unit_job_is_applicable(Unit *u, JobType j) {
1935 assert(j >= 0 && j < _JOB_TYPE_MAX);
1939 case JOB_VERIFY_ACTIVE:
1946 case JOB_TRY_RESTART:
1947 return unit_can_start(u);
1950 return unit_can_reload(u);
1952 case JOB_RELOAD_OR_START:
1953 return unit_can_reload(u) && unit_can_start(u);
1956 assert_not_reached("Invalid job type");
1960 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
1961 switch (dependency) {
1963 case UNIT_REQUIRES_OVERRIDABLE:
1965 case UNIT_REQUISITE:
1966 case UNIT_REQUISITE_OVERRIDABLE:
1969 case UNIT_REQUIRED_BY:
1970 case UNIT_REQUIRED_BY_OVERRIDABLE:
1971 case UNIT_WANTED_BY:
1973 case UNIT_CONSISTS_OF:
1974 case UNIT_REFERENCES:
1975 case UNIT_REFERENCED_BY:
1976 case UNIT_PROPAGATES_RELOAD_TO:
1977 case UNIT_RELOAD_PROPAGATED_FROM:
1978 case UNIT_JOINS_NAMESPACE_OF:
1981 case UNIT_CONFLICTS:
1982 case UNIT_CONFLICTED_BY:
1985 case UNIT_ON_FAILURE:
1987 case UNIT_TRIGGERED_BY:
1988 if (streq_ptr(id, other))
1989 log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
1990 unit_dependency_to_string(dependency), id, other);
1992 log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
1993 unit_dependency_to_string(dependency), id,
1997 case _UNIT_DEPENDENCY_MAX:
1998 case _UNIT_DEPENDENCY_INVALID:
2001 assert_not_reached("Invalid dependency type");
2004 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2006 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2007 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2008 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2009 [UNIT_WANTS] = UNIT_WANTED_BY,
2010 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2011 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2012 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2013 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2014 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2015 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2016 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2017 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2018 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2019 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2020 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2021 [UNIT_BEFORE] = UNIT_AFTER,
2022 [UNIT_AFTER] = UNIT_BEFORE,
2023 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2024 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2025 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2026 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2027 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2028 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2029 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2030 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2032 int r, q = 0, v = 0, w = 0;
2033 Unit *orig_u = u, *orig_other = other;
2036 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2039 u = unit_follow_merge(u);
2040 other = unit_follow_merge(other);
2042 /* We won't allow dependencies on ourselves. We will not
2043 * consider them an error however. */
2045 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2049 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
2053 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2054 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
2059 if (add_reference) {
2060 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
2064 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
2069 q = set_put(u->dependencies[d], other);
2073 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2074 v = set_put(other->dependencies[inverse_table[d]], u);
2081 if (add_reference) {
2082 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2088 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2093 unit_add_to_dbus_queue(u);
2098 set_remove(u->dependencies[d], other);
2101 set_remove(other->dependencies[inverse_table[d]], u);
2104 set_remove(u->dependencies[UNIT_REFERENCES], other);
2109 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2114 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2117 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2123 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2127 assert(name || path);
2131 name = basename(path);
2133 if (!unit_name_is_template(name)) {
2139 s = unit_name_replace_instance(name, u->instance);
2141 _cleanup_free_ char *i = NULL;
2143 i = unit_name_to_prefix(u->id);
2147 s = unit_name_replace_instance(name, i);
2157 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2160 _cleanup_free_ char *s = NULL;
2163 assert(name || path);
2165 name = resolve_template(u, name, path, &s);
2169 r = manager_load_unit(u->manager, name, path, NULL, &other);
2173 return unit_add_dependency(u, d, other, add_reference);
2176 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2179 _cleanup_free_ char *s = NULL;
2182 assert(name || path);
2184 if (!(name = resolve_template(u, name, path, &s)))
2187 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2190 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2195 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2198 _cleanup_free_ char *s = NULL;
2201 assert(name || path);
2203 if (!(name = resolve_template(u, name, path, &s)))
2206 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2209 r = unit_add_dependency(other, d, u, add_reference);
2214 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2217 _cleanup_free_ char *s = NULL;
2220 assert(name || path);
2222 if (!(name = resolve_template(u, name, path, &s)))
2225 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2228 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2234 int set_unit_path(const char *p) {
2235 /* This is mostly for debug purposes */
2236 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2242 char *unit_dbus_path(Unit *u) {
2248 return unit_dbus_path_from_name(u->id);
2251 char *unit_default_cgroup_path(Unit *u) {
2252 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2257 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2258 return strdup(u->manager->cgroup_root);
2260 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2261 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2266 escaped = cg_escape(u->id);
2271 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2273 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2276 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2277 _cleanup_free_ char *b = NULL;
2278 const char *slice_name;
2285 if (UNIT_ISSET(u->slice))
2289 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2291 /* Implicitly place all instantiated units in their
2292 * own per-template slice */
2294 prefix = unit_name_to_prefix(u->id);
2298 /* The prefix is already escaped, but it might include
2299 * "-" which has a special meaning for slice units,
2300 * hence escape it here extra. */
2301 escaped = strreplace(prefix, "-", "\\x2d");
2305 if (u->manager->running_as == SYSTEMD_SYSTEM)
2306 b = strjoin("system-", escaped, ".slice", NULL);
2308 b = strappend(escaped, ".slice");
2315 u->manager->running_as == SYSTEMD_SYSTEM
2316 ? SPECIAL_SYSTEM_SLICE
2317 : SPECIAL_ROOT_SLICE;
2319 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2323 unit_ref_set(&u->slice, slice);
2327 const char *unit_slice_name(Unit *u) {
2330 if (!UNIT_ISSET(u->slice))
2333 return UNIT_DEREF(u->slice)->id;
2336 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2337 _cleanup_free_ char *t = NULL;
2344 t = unit_name_change_suffix(u->id, type);
2348 assert(!unit_has_name(u, t));
2350 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2351 assert(r < 0 || *_found != u);
2355 int unit_watch_bus_name(Unit *u, const char *name) {
2359 /* Watch a specific name on the bus. We only support one unit
2360 * watching each name for now. */
2362 return hashmap_put(u->manager->watch_bus, name, u);
2365 void unit_unwatch_bus_name(Unit *u, const char *name) {
2369 hashmap_remove_value(u->manager->watch_bus, name, u);
2372 bool unit_can_serialize(Unit *u) {
2375 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2378 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2385 if (unit_can_serialize(u)) {
2388 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2392 rt = unit_get_exec_runtime(u);
2394 r = exec_runtime_serialize(rt, u, f, fds);
2400 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2401 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2402 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2403 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2404 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2406 if (dual_timestamp_is_set(&u->condition_timestamp))
2407 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2409 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2412 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2414 if (serialize_jobs) {
2416 fprintf(f, "job\n");
2417 job_serialize(u->job, f, fds);
2421 fprintf(f, "job\n");
2422 job_serialize(u->nop_job, f, fds);
2431 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2442 va_start(ap, format);
2443 vfprintf(f, format, ap);
2449 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2455 fprintf(f, "%s=%s\n", key, value);
2458 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2459 ExecRuntime **rt = NULL;
2467 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2469 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2472 char line[LINE_MAX], *l, *v;
2475 if (!fgets(line, sizeof(line), f)) {
2488 k = strcspn(l, "=");
2496 if (streq(l, "job")) {
2498 /* new-style serialized job */
2499 Job *j = job_new_raw(u);
2503 r = job_deserialize(j, f, fds);
2509 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2515 r = job_install_deserialized(j);
2517 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2522 if (j->state == JOB_RUNNING)
2523 u->manager->n_running_jobs++;
2526 JobType type = job_type_from_string(v);
2528 log_debug("Failed to parse job type value %s", v);
2530 u->deserialized_job = type;
2533 } else if (streq(l, "inactive-exit-timestamp")) {
2534 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2536 } else if (streq(l, "active-enter-timestamp")) {
2537 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2539 } else if (streq(l, "active-exit-timestamp")) {
2540 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2542 } else if (streq(l, "inactive-enter-timestamp")) {
2543 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2545 } else if (streq(l, "condition-timestamp")) {
2546 dual_timestamp_deserialize(v, &u->condition_timestamp);
2548 } else if (streq(l, "condition-result")) {
2551 b = parse_boolean(v);
2553 log_debug("Failed to parse condition result value %s", v);
2555 u->condition_result = b;
2559 } else if (streq(l, "transient")) {
2562 b = parse_boolean(v);
2564 log_debug("Failed to parse transient bool %s", v);
2569 } else if (streq(l, "cgroup")) {
2576 if (u->cgroup_path) {
2579 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2580 log_info("Removing cgroup_path %s from hashmap (%p)",
2582 free(u->cgroup_path);
2586 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2591 if (unit_can_serialize(u)) {
2593 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2600 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2607 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2609 _cleanup_free_ char *e = NULL;
2617 /* Adds in links to the device node that this unit is based on */
2619 if (!is_device_path(what))
2622 e = unit_name_from_path(what, ".device");
2626 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2631 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2636 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2644 int unit_coldplug(Unit *u) {
2649 if (UNIT_VTABLE(u)->coldplug)
2650 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2654 r = job_coldplug(u->job);
2657 } else if (u->deserialized_job >= 0) {
2659 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2663 u->deserialized_job = _JOB_TYPE_INVALID;
2669 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2670 DISABLE_WARNING_FORMAT_NONLITERAL;
2671 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2675 bool unit_need_daemon_reload(Unit *u) {
2676 _cleanup_strv_free_ char **t = NULL;
2679 unsigned loaded_cnt, current_cnt;
2683 if (u->fragment_path) {
2685 if (stat(u->fragment_path, &st) < 0)
2686 /* What, cannot access this anymore? */
2689 if (u->fragment_mtime > 0 &&
2690 timespec_load(&st.st_mtim) != u->fragment_mtime)
2694 if (u->source_path) {
2696 if (stat(u->source_path, &st) < 0)
2699 if (u->source_mtime > 0 &&
2700 timespec_load(&st.st_mtim) != u->source_mtime)
2704 t = unit_find_dropin_paths(u);
2705 loaded_cnt = strv_length(t);
2706 current_cnt = strv_length(u->dropin_paths);
2708 if (loaded_cnt == current_cnt) {
2709 if (loaded_cnt == 0)
2712 if (strv_overlap(u->dropin_paths, t)) {
2713 STRV_FOREACH(path, u->dropin_paths) {
2715 if (stat(*path, &st) < 0)
2718 if (u->dropin_mtime > 0 &&
2719 timespec_load(&st.st_mtim) > u->dropin_mtime)
2730 void unit_reset_failed(Unit *u) {
2733 if (UNIT_VTABLE(u)->reset_failed)
2734 UNIT_VTABLE(u)->reset_failed(u);
2737 Unit *unit_following(Unit *u) {
2740 if (UNIT_VTABLE(u)->following)
2741 return UNIT_VTABLE(u)->following(u);
2746 bool unit_stop_pending(Unit *u) {
2749 /* This call does check the current state of the unit. It's
2750 * hence useful to be called from state change calls of the
2751 * unit itself, where the state isn't updated yet. This is
2752 * different from unit_inactive_or_pending() which checks both
2753 * the current state and for a queued job. */
2755 return u->job && u->job->type == JOB_STOP;
2758 bool unit_inactive_or_pending(Unit *u) {
2761 /* Returns true if the unit is inactive or going down */
2763 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2766 if (unit_stop_pending(u))
2772 bool unit_active_or_pending(Unit *u) {
2775 /* Returns true if the unit is active or going up */
2777 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2781 (u->job->type == JOB_START ||
2782 u->job->type == JOB_RELOAD_OR_START ||
2783 u->job->type == JOB_RESTART))
2789 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2791 assert(w >= 0 && w < _KILL_WHO_MAX);
2793 assert(signo < _NSIG);
2795 if (!UNIT_VTABLE(u)->kill)
2798 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2801 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2805 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2809 /* Exclude the main/control pids from being killed via the cgroup */
2811 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2816 if (control_pid > 0) {
2817 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2829 int unit_kill_common(
2835 sd_bus_error *error) {
2839 if (who == KILL_MAIN && main_pid <= 0) {
2841 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2843 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2847 if (who == KILL_CONTROL && control_pid <= 0) {
2848 if (control_pid < 0)
2849 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2851 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2855 if (who == KILL_CONTROL || who == KILL_ALL)
2856 if (control_pid > 0)
2857 if (kill(control_pid, signo) < 0)
2860 if (who == KILL_MAIN || who == KILL_ALL)
2862 if (kill(main_pid, signo) < 0)
2865 if (who == KILL_ALL && u->cgroup_path) {
2866 _cleanup_set_free_ Set *pid_set = NULL;
2869 /* Exclude the main/control pids from being killed via the cgroup */
2870 pid_set = unit_pid_set(main_pid, control_pid);
2874 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2875 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2882 int unit_following_set(Unit *u, Set **s) {
2886 if (UNIT_VTABLE(u)->following_set)
2887 return UNIT_VTABLE(u)->following_set(u, s);
2893 UnitFileState unit_get_unit_file_state(Unit *u) {
2896 if (u->unit_file_state < 0 && u->fragment_path)
2897 u->unit_file_state = unit_file_get_state(
2898 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2899 NULL, basename(u->fragment_path));
2901 return u->unit_file_state;
2904 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2909 unit_ref_unset(ref);
2912 LIST_PREPEND(refs, u->refs, ref);
2916 void unit_ref_unset(UnitRef *ref) {
2922 LIST_REMOVE(refs, ref->unit->refs, ref);
2926 int unit_patch_contexts(Unit *u) {
2934 /* Patch in the manager defaults into the exec and cgroup
2935 * contexts, _after_ the rest of the settings have been
2938 ec = unit_get_exec_context(u);
2940 /* This only copies in the ones that need memory */
2941 for (i = 0; i < _RLIMIT_MAX; i++)
2942 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2943 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2948 if (u->manager->running_as == SYSTEMD_USER &&
2949 !ec->working_directory) {
2951 r = get_home_dir(&ec->working_directory);
2956 if (u->manager->running_as == SYSTEMD_USER &&
2957 (ec->syscall_whitelist ||
2958 !set_isempty(ec->syscall_filter) ||
2959 !set_isempty(ec->syscall_archs) ||
2960 ec->address_families_whitelist ||
2961 !set_isempty(ec->address_families)))
2962 ec->no_new_privileges = true;
2964 if (ec->private_devices)
2965 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2968 cc = unit_get_cgroup_context(u);
2972 ec->private_devices &&
2973 cc->device_policy == CGROUP_AUTO)
2974 cc->device_policy = CGROUP_CLOSED;
2980 ExecContext *unit_get_exec_context(Unit *u) {
2987 offset = UNIT_VTABLE(u)->exec_context_offset;
2991 return (ExecContext*) ((uint8_t*) u + offset);
2994 KillContext *unit_get_kill_context(Unit *u) {
3001 offset = UNIT_VTABLE(u)->kill_context_offset;
3005 return (KillContext*) ((uint8_t*) u + offset);
3008 CGroupContext *unit_get_cgroup_context(Unit *u) {
3014 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3018 return (CGroupContext*) ((uint8_t*) u + offset);
3021 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3027 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3031 return *(ExecRuntime**) ((uint8_t*) u + offset);
3034 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3035 if (u->manager->running_as == SYSTEMD_USER) {
3038 r = user_config_home(dir);
3044 if (mode == UNIT_PERSISTENT && !transient)
3045 *dir = strdup("/etc/systemd/system");
3047 *dir = strdup("/run/systemd/system");
3054 static int unit_drop_in_file(Unit *u,
3055 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3056 _cleanup_free_ char *dir = NULL;
3061 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3065 return drop_in_file(dir, u->id, 50, name, p, q);
3068 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3070 _cleanup_free_ char *dir = NULL;
3075 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3078 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3082 return write_drop_in(dir, u->id, 50, name, data);
3085 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3086 _cleanup_free_ char *p = NULL;
3094 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3097 va_start(ap, format);
3098 r = vasprintf(&p, format, ap);
3104 return unit_write_drop_in(u, mode, name, p);
3107 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3108 _cleanup_free_ char *ndata = NULL;
3114 if (!UNIT_VTABLE(u)->private_section)
3117 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3120 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3124 return unit_write_drop_in(u, mode, name, ndata);
3127 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3128 _cleanup_free_ char *p = NULL;
3136 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3139 va_start(ap, format);
3140 r = vasprintf(&p, format, ap);
3146 return unit_write_drop_in_private(u, mode, name, p);
3149 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3150 _cleanup_free_ char *p = NULL, *q = NULL;
3155 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3158 r = unit_drop_in_file(u, mode, name, &p, &q);
3163 r = errno == ENOENT ? 0 : -errno;
3171 int unit_make_transient(Unit *u) {
3176 u->load_state = UNIT_STUB;
3178 u->transient = true;
3180 free(u->fragment_path);
3181 u->fragment_path = NULL;
3183 if (u->manager->running_as == SYSTEMD_USER) {
3184 _cleanup_free_ char *c = NULL;
3186 r = user_config_home(&c);
3192 u->fragment_path = strjoin(c, "/", u->id, NULL);
3193 if (!u->fragment_path)
3198 u->fragment_path = strappend("/run/systemd/system/", u->id);
3199 if (!u->fragment_path)
3202 mkdir_p("/run/systemd/system", 0755);
3205 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3208 int unit_kill_context(
3214 bool main_pid_alien) {
3216 int sig, wait_for_exit = false, r;
3221 if (c->kill_mode == KILL_NONE)
3224 sig = sigkill ? SIGKILL : c->kill_signal;
3227 r = kill_and_sigcont(main_pid, sig);
3229 if (r < 0 && r != -ESRCH) {
3230 _cleanup_free_ char *comm = NULL;
3231 get_process_comm(main_pid, &comm);
3233 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3235 if (!main_pid_alien)
3236 wait_for_exit = true;
3238 if (c->send_sighup && !sigkill)
3239 kill(main_pid, SIGHUP);
3243 if (control_pid > 0) {
3244 r = kill_and_sigcont(control_pid, sig);
3246 if (r < 0 && r != -ESRCH) {
3247 _cleanup_free_ char *comm = NULL;
3248 get_process_comm(control_pid, &comm);
3250 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3252 wait_for_exit = true;
3254 if (c->send_sighup && !sigkill)
3255 kill(control_pid, SIGHUP);
3259 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3260 _cleanup_set_free_ Set *pid_set = NULL;
3262 /* Exclude the main/control pids from being killed via the cgroup */
3263 pid_set = unit_pid_set(main_pid, control_pid);
3267 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3269 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3270 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3273 /* FIXME: For now, we will not wait for the
3274 * cgroup members to die, simply because
3275 * cgroup notification is unreliable. It
3276 * doesn't work at all in containers, and
3277 * outside of containers it can be confused
3278 * easily by leaving directories in the
3281 /* wait_for_exit = true; */
3283 if (c->send_sighup && !sigkill) {
3286 pid_set = unit_pid_set(main_pid, control_pid);
3290 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3295 return wait_for_exit;
3298 int unit_require_mounts_for(Unit *u, const char *path) {
3299 char prefix[strlen(path) + 1], *p;
3305 /* Registers a unit for requiring a certain path and all its
3306 * prefixes. We keep a simple array of these paths in the
3307 * unit, since its usually short. However, we build a prefix
3308 * table for all possible prefixes so that new appearing mount
3309 * units can easily determine which units to make themselves a
3312 if (!path_is_absolute(path))
3319 path_kill_slashes(p);
3321 if (!path_is_safe(p)) {
3326 if (strv_contains(u->requires_mounts_for, p)) {
3331 r = strv_consume(&u->requires_mounts_for, p);
3335 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3338 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3342 if (!u->manager->units_requiring_mounts_for) {
3343 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3344 if (!u->manager->units_requiring_mounts_for)
3352 x = set_new(NULL, NULL);
3358 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3374 int unit_setup_exec_runtime(Unit *u) {
3380 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3383 /* Check if ther already is an ExecRuntime for this unit? */
3384 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3388 /* Try to get it from somebody else */
3389 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3391 *rt = unit_get_exec_runtime(other);
3393 exec_runtime_ref(*rt);
3398 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3401 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3402 [UNIT_ACTIVE] = "active",
3403 [UNIT_RELOADING] = "reloading",
3404 [UNIT_INACTIVE] = "inactive",
3405 [UNIT_FAILED] = "failed",
3406 [UNIT_ACTIVATING] = "activating",
3407 [UNIT_DEACTIVATING] = "deactivating"
3410 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3412 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3413 [UNIT_REQUIRES] = "Requires",
3414 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3415 [UNIT_REQUISITE] = "Requisite",
3416 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3417 [UNIT_WANTS] = "Wants",
3418 [UNIT_BINDS_TO] = "BindsTo",
3419 [UNIT_PART_OF] = "PartOf",
3420 [UNIT_REQUIRED_BY] = "RequiredBy",
3421 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3422 [UNIT_WANTED_BY] = "WantedBy",
3423 [UNIT_BOUND_BY] = "BoundBy",
3424 [UNIT_CONSISTS_OF] = "ConsistsOf",
3425 [UNIT_CONFLICTS] = "Conflicts",
3426 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3427 [UNIT_BEFORE] = "Before",
3428 [UNIT_AFTER] = "After",
3429 [UNIT_ON_FAILURE] = "OnFailure",
3430 [UNIT_TRIGGERS] = "Triggers",
3431 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3432 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3433 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3434 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3435 [UNIT_REFERENCES] = "References",
3436 [UNIT_REFERENCED_BY] = "ReferencedBy",
3439 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);