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 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) {
796 timestamp1[FORMAT_TIMESTAMP_MAX],
797 timestamp2[FORMAT_TIMESTAMP_MAX],
798 timestamp3[FORMAT_TIMESTAMP_MAX],
799 timestamp4[FORMAT_TIMESTAMP_MAX],
800 timespan[FORMAT_TIMESPAN_MAX];
802 _cleanup_set_free_ Set *following_set = NULL;
806 assert(u->type >= 0);
808 prefix = strempty(prefix);
809 prefix2 = strappenda(prefix, "\t");
813 "%s\tDescription: %s\n"
815 "%s\tUnit Load State: %s\n"
816 "%s\tUnit Active State: %s\n"
817 "%s\tInactive Exit Timestamp: %s\n"
818 "%s\tActive Enter Timestamp: %s\n"
819 "%s\tActive Exit Timestamp: %s\n"
820 "%s\tInactive Enter Timestamp: %s\n"
821 "%s\tGC Check Good: %s\n"
822 "%s\tNeed Daemon Reload: %s\n"
823 "%s\tTransient: %s\n"
826 "%s\tCGroup realized: %s\n"
827 "%s\tCGroup mask: 0x%x\n"
828 "%s\tCGroup members mask: 0x%x\n",
830 prefix, unit_description(u),
831 prefix, strna(u->instance),
832 prefix, unit_load_state_to_string(u->load_state),
833 prefix, unit_active_state_to_string(unit_active_state(u)),
834 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
835 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
836 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
837 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
838 prefix, yes_no(unit_check_gc(u)),
839 prefix, yes_no(unit_need_daemon_reload(u)),
840 prefix, yes_no(u->transient),
841 prefix, strna(unit_slice_name(u)),
842 prefix, strna(u->cgroup_path),
843 prefix, yes_no(u->cgroup_realized),
844 prefix, u->cgroup_realized_mask,
845 prefix, u->cgroup_members_mask);
847 SET_FOREACH(t, u->names, i)
848 fprintf(f, "%s\tName: %s\n", prefix, t);
850 STRV_FOREACH(j, u->documentation)
851 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
853 following = unit_following(u);
855 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
857 r = unit_following_set(u, &following_set);
861 SET_FOREACH(other, following_set, i)
862 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
865 if (u->fragment_path)
866 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
869 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
871 STRV_FOREACH(j, u->dropin_paths)
872 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
874 if (u->job_timeout > 0)
875 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
877 condition_dump_list(u->conditions, f, prefix);
879 if (dual_timestamp_is_set(&u->condition_timestamp))
881 "%s\tCondition Timestamp: %s\n"
882 "%s\tCondition Result: %s\n",
883 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
884 prefix, yes_no(u->condition_result));
886 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
889 SET_FOREACH(other, u->dependencies[d], i)
890 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
893 if (!strv_isempty(u->requires_mounts_for)) {
895 "%s\tRequiresMountsFor:", prefix);
897 STRV_FOREACH(j, u->requires_mounts_for)
898 fprintf(f, " %s", *j);
903 if (u->load_state == UNIT_LOADED) {
906 "%s\tStopWhenUnneeded: %s\n"
907 "%s\tRefuseManualStart: %s\n"
908 "%s\tRefuseManualStop: %s\n"
909 "%s\tDefaultDependencies: %s\n"
910 "%s\tOnFailureJobMode: %s\n"
911 "%s\tIgnoreOnIsolate: %s\n"
912 "%s\tIgnoreOnSnapshot: %s\n",
913 prefix, yes_no(u->stop_when_unneeded),
914 prefix, yes_no(u->refuse_manual_start),
915 prefix, yes_no(u->refuse_manual_stop),
916 prefix, yes_no(u->default_dependencies),
917 prefix, job_mode_to_string(u->on_failure_job_mode),
918 prefix, yes_no(u->ignore_on_isolate),
919 prefix, yes_no(u->ignore_on_snapshot));
921 if (UNIT_VTABLE(u)->dump)
922 UNIT_VTABLE(u)->dump(u, f, prefix2);
924 } else if (u->load_state == UNIT_MERGED)
926 "%s\tMerged into: %s\n",
927 prefix, u->merged_into->id);
928 else if (u->load_state == UNIT_ERROR)
929 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
933 job_dump(u->job, f, prefix2);
936 job_dump(u->nop_job, f, prefix2);
940 /* Common implementation for multiple backends */
941 int unit_load_fragment_and_dropin(Unit *u) {
946 /* Load a .{service,socket,...} file */
947 r = unit_load_fragment(u);
951 if (u->load_state == UNIT_STUB)
954 /* Load drop-in directory data */
955 r = unit_load_dropin(unit_follow_merge(u));
962 /* Common implementation for multiple backends */
963 int unit_load_fragment_and_dropin_optional(Unit *u) {
968 /* Same as unit_load_fragment_and_dropin(), but whether
969 * something can be loaded or not doesn't matter. */
971 /* Load a .service file */
972 r = unit_load_fragment(u);
976 if (u->load_state == UNIT_STUB)
977 u->load_state = UNIT_LOADED;
979 /* Load drop-in directory data */
980 r = unit_load_dropin(unit_follow_merge(u));
987 int unit_add_default_target_dependency(Unit *u, Unit *target) {
991 if (target->type != UNIT_TARGET)
994 /* Only add the dependency if both units are loaded, so that
995 * that loop check below is reliable */
996 if (u->load_state != UNIT_LOADED ||
997 target->load_state != UNIT_LOADED)
1000 /* If either side wants no automatic dependencies, then let's
1002 if (!u->default_dependencies ||
1003 !target->default_dependencies)
1006 /* Don't create loops */
1007 if (set_get(target->dependencies[UNIT_BEFORE], u))
1010 return unit_add_dependency(target, UNIT_AFTER, u, true);
1013 static int unit_add_target_dependencies(Unit *u) {
1015 static const UnitDependency deps[] = {
1017 UNIT_REQUIRED_BY_OVERRIDABLE,
1029 for (k = 0; k < ELEMENTSOF(deps); k++)
1030 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1031 r = unit_add_default_target_dependency(u, target);
1039 static int unit_add_slice_dependencies(Unit *u) {
1042 if (!unit_get_cgroup_context(u))
1045 if (UNIT_ISSET(u->slice))
1046 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1048 if (streq(u->id, SPECIAL_ROOT_SLICE))
1051 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1054 static int unit_add_mount_dependencies(Unit *u) {
1060 STRV_FOREACH(i, u->requires_mounts_for) {
1061 char prefix[strlen(*i) + 1];
1063 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1066 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1074 if (m->load_state != UNIT_LOADED)
1077 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1081 if (m->fragment_path) {
1082 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1092 static int unit_add_startup_units(Unit *u) {
1096 c = unit_get_cgroup_context(u);
1100 if (c->startup_cpu_shares == (unsigned long) -1 &&
1101 c->startup_blockio_weight == (unsigned long) -1)
1104 r = set_put(u->manager->startup_units, u);
1111 int unit_load(Unit *u) {
1116 if (u->in_load_queue) {
1117 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1118 u->in_load_queue = false;
1121 if (u->type == _UNIT_TYPE_INVALID)
1124 if (u->load_state != UNIT_STUB)
1127 if (UNIT_VTABLE(u)->load) {
1128 r = UNIT_VTABLE(u)->load(u);
1133 if (u->load_state == UNIT_STUB) {
1138 if (u->load_state == UNIT_LOADED) {
1140 r = unit_add_target_dependencies(u);
1144 r = unit_add_slice_dependencies(u);
1148 r = unit_add_mount_dependencies(u);
1152 r = unit_add_startup_units(u);
1156 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1157 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1162 unit_update_cgroup_members_masks(u);
1165 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1167 unit_add_to_dbus_queue(unit_follow_merge(u));
1168 unit_add_to_gc_queue(u);
1173 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1175 unit_add_to_dbus_queue(u);
1176 unit_add_to_gc_queue(u);
1178 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1179 u->id, strerror(-r));
1184 static bool unit_condition_test(Unit *u) {
1187 dual_timestamp_get(&u->condition_timestamp);
1188 u->condition_result = condition_test_list(u->id, u->conditions);
1190 return u->condition_result;
1193 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1194 const UnitStatusMessageFormats *format_table;
1198 assert(t < _JOB_TYPE_MAX);
1200 if (t != JOB_START && t != JOB_STOP)
1203 format_table = &UNIT_VTABLE(u)->status_message_formats;
1207 return format_table->starting_stopping[t == JOB_STOP];
1210 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1215 assert(t < _JOB_TYPE_MAX);
1217 format = unit_get_status_message_format(u, t);
1221 /* Return generic strings */
1223 return "Starting %s.";
1224 else if (t == JOB_STOP)
1225 return "Stopping %s.";
1226 else if (t == JOB_RELOAD)
1227 return "Reloading %s.";
1232 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1237 /* We only print status messages for selected units on
1238 * selected operations. */
1240 format = unit_get_status_message_format(u, t);
1244 DISABLE_WARNING_FORMAT_NONLITERAL;
1245 unit_status_printf(u, "", format);
1249 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1256 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1259 if (log_on_console())
1262 /* We log status messages for all units and all operations. */
1264 format = unit_get_status_message_format_try_harder(u, t);
1268 DISABLE_WARNING_FORMAT_NONLITERAL;
1269 snprintf(buf, sizeof(buf), format, unit_description(u));
1273 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1274 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1275 SD_MESSAGE_UNIT_RELOADING;
1277 log_struct_unit(LOG_INFO,
1285 * -EBADR: This unit type does not support starting.
1286 * -EALREADY: Unit is already started.
1287 * -EAGAIN: An operation is already in progress. Retry later.
1288 * -ECANCELED: Too many requests for now.
1290 int unit_start(Unit *u) {
1291 UnitActiveState state;
1296 if (u->load_state != UNIT_LOADED)
1299 /* If this is already started, then this will succeed. Note
1300 * that this will even succeed if this unit is not startable
1301 * by the user. This is relied on to detect when we need to
1302 * wait for units and when waiting is finished. */
1303 state = unit_active_state(u);
1304 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1307 /* If the conditions failed, don't do anything at all. If we
1308 * already are activating this call might still be useful to
1309 * speed up activation in case there is some hold-off time,
1310 * but we don't want to recheck the condition in that case. */
1311 if (state != UNIT_ACTIVATING &&
1312 !unit_condition_test(u)) {
1313 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1317 /* Forward to the main object, if we aren't it. */
1318 following = unit_following(u);
1320 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1321 u->id, following->id);
1322 return unit_start(following);
1325 unit_status_log_starting_stopping_reloading(u, JOB_START);
1326 unit_status_print_starting_stopping(u, JOB_START);
1328 /* If it is stopped, but we cannot start it, then fail */
1329 if (!UNIT_VTABLE(u)->start)
1332 /* We don't suppress calls to ->start() here when we are
1333 * already starting, to allow this request to be used as a
1334 * "hurry up" call, for example when the unit is in some "auto
1335 * restart" state where it waits for a holdoff timer to elapse
1336 * before it will start again. */
1338 unit_add_to_dbus_queue(u);
1340 return UNIT_VTABLE(u)->start(u);
1343 bool unit_can_start(Unit *u) {
1346 return !!UNIT_VTABLE(u)->start;
1349 bool unit_can_isolate(Unit *u) {
1352 return unit_can_start(u) &&
1357 * -EBADR: This unit type does not support stopping.
1358 * -EALREADY: Unit is already stopped.
1359 * -EAGAIN: An operation is already in progress. Retry later.
1361 int unit_stop(Unit *u) {
1362 UnitActiveState state;
1367 state = unit_active_state(u);
1368 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1371 if ((following = unit_following(u))) {
1372 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1373 u->id, following->id);
1374 return unit_stop(following);
1377 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1378 unit_status_print_starting_stopping(u, JOB_STOP);
1380 if (!UNIT_VTABLE(u)->stop)
1383 unit_add_to_dbus_queue(u);
1385 return UNIT_VTABLE(u)->stop(u);
1389 * -EBADR: This unit type does not support reloading.
1390 * -ENOEXEC: Unit is not started.
1391 * -EAGAIN: An operation is already in progress. Retry later.
1393 int unit_reload(Unit *u) {
1394 UnitActiveState state;
1399 if (u->load_state != UNIT_LOADED)
1402 if (!unit_can_reload(u))
1405 state = unit_active_state(u);
1406 if (state == UNIT_RELOADING)
1409 if (state != UNIT_ACTIVE) {
1410 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1415 following = unit_following(u);
1417 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1418 u->id, following->id);
1419 return unit_reload(following);
1422 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1424 unit_add_to_dbus_queue(u);
1425 return UNIT_VTABLE(u)->reload(u);
1428 bool unit_can_reload(Unit *u) {
1431 if (!UNIT_VTABLE(u)->reload)
1434 if (!UNIT_VTABLE(u)->can_reload)
1437 return UNIT_VTABLE(u)->can_reload(u);
1440 static void unit_check_unneeded(Unit *u) {
1446 /* If this service shall be shut down when unneeded then do
1449 if (!u->stop_when_unneeded)
1452 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1455 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1456 if (unit_active_or_pending(other))
1459 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1460 if (unit_active_or_pending(other))
1463 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1464 if (unit_active_or_pending(other))
1467 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1468 if (unit_active_or_pending(other))
1471 log_info_unit(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
1473 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1474 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1477 static void unit_check_binds_to(Unit *u) {
1487 if (unit_active_state(u) != UNIT_ACTIVE)
1490 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1494 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1503 log_info_unit(u->id, "Unit %s is bound to inactive service. Stopping, too.", u->id);
1505 /* A unit we need to run is gone. Sniff. Let's stop this. */
1506 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1509 static void retroactively_start_dependencies(Unit *u) {
1514 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1516 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1517 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1518 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1519 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1521 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1522 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1523 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1524 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1526 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1527 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1528 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1529 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1531 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1532 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1533 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1534 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1536 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1537 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1538 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1540 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1541 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1542 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1545 static void retroactively_stop_dependencies(Unit *u) {
1550 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1552 /* Pull down units which are bound to us recursively if enabled */
1553 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1554 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1555 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1558 static void check_unneeded_dependencies(Unit *u) {
1563 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1565 /* Garbage collect services that might not be needed anymore, if enabled */
1566 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1567 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1568 unit_check_unneeded(other);
1569 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1570 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1571 unit_check_unneeded(other);
1572 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1573 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1574 unit_check_unneeded(other);
1575 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1576 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1577 unit_check_unneeded(other);
1578 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1579 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1580 unit_check_unneeded(other);
1581 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1582 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1583 unit_check_unneeded(other);
1586 void unit_start_on_failure(Unit *u) {
1592 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1595 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1597 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1600 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1602 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1606 void unit_trigger_notify(Unit *u) {
1612 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1613 if (UNIT_VTABLE(other)->trigger_notify)
1614 UNIT_VTABLE(other)->trigger_notify(other, u);
1617 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1622 assert(os < _UNIT_ACTIVE_STATE_MAX);
1623 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1625 /* Note that this is called for all low-level state changes,
1626 * even if they might map to the same high-level
1627 * UnitActiveState! That means that ns == os is an expected
1628 * behavior here. For example: if a mount point is remounted
1629 * this function will be called too! */
1633 /* Update timestamps for state changes */
1634 if (m->n_reloading <= 0) {
1637 dual_timestamp_get(&ts);
1639 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1640 u->inactive_exit_timestamp = ts;
1641 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1642 u->inactive_enter_timestamp = ts;
1644 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1645 u->active_enter_timestamp = ts;
1646 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1647 u->active_exit_timestamp = ts;
1650 /* Keep track of failed units */
1651 if (ns == UNIT_FAILED)
1652 set_put(u->manager->failed_units, u);
1654 set_remove(u->manager->failed_units, u);
1656 /* Make sure the cgroup is always removed when we become inactive */
1657 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1658 unit_destroy_cgroup(u);
1660 /* Note that this doesn't apply to RemainAfterExit services exiting
1661 * successfully, since there's no change of state in that case. Which is
1662 * why it is handled in service_set_state() */
1663 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1666 ec = unit_get_exec_context(u);
1667 if (ec && exec_context_may_touch_console(ec)) {
1668 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1671 if (m->n_on_console == 0)
1672 /* unset no_console_output flag, since the console is free */
1673 m->no_console_output = false;
1682 if (u->job->state == JOB_WAITING)
1684 /* So we reached a different state for this
1685 * job. Let's see if we can run it now if it
1686 * failed previously due to EAGAIN. */
1687 job_add_to_run_queue(u->job);
1689 /* Let's check whether this state change constitutes a
1690 * finished job, or maybe contradicts a running job and
1691 * hence needs to invalidate jobs. */
1693 switch (u->job->type) {
1696 case JOB_VERIFY_ACTIVE:
1698 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1699 job_finish_and_invalidate(u->job, JOB_DONE, true);
1700 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1703 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1704 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1710 case JOB_RELOAD_OR_START:
1712 if (u->job->state == JOB_RUNNING) {
1713 if (ns == UNIT_ACTIVE)
1714 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1715 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1718 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1719 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1727 case JOB_TRY_RESTART:
1729 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1730 job_finish_and_invalidate(u->job, JOB_DONE, true);
1731 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1733 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1739 assert_not_reached("Job type unknown");
1745 if (m->n_reloading <= 0) {
1747 /* If this state change happened without being
1748 * requested by a job, then let's retroactively start
1749 * or stop dependencies. We skip that step when
1750 * deserializing, since we don't want to create any
1751 * additional jobs just because something is already
1755 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1756 retroactively_start_dependencies(u);
1757 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1758 retroactively_stop_dependencies(u);
1761 /* stop unneeded units regardless if going down was expected or not */
1762 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1763 check_unneeded_dependencies(u);
1765 if (ns != os && ns == UNIT_FAILED) {
1766 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1767 unit_start_on_failure(u);
1771 /* Some names are special */
1772 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1774 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1775 /* The bus might have just become available,
1776 * hence try to connect to it, if we aren't
1780 if (u->type == UNIT_SERVICE &&
1781 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1782 m->n_reloading <= 0) {
1783 /* Write audit record if we have just finished starting up */
1784 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1788 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1789 manager_send_unit_plymouth(m, u);
1793 /* We don't care about D-Bus here, since we'll get an
1794 * asynchronous notification for it anyway. */
1796 if (u->type == UNIT_SERVICE &&
1797 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1798 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1799 m->n_reloading <= 0) {
1801 /* Hmm, if there was no start record written
1802 * write it now, so that we always have a nice
1805 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1807 if (ns == UNIT_INACTIVE)
1808 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1810 /* Write audit record if we have just finished shutting down */
1811 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1813 u->in_audit = false;
1817 manager_recheck_journal(m);
1818 unit_trigger_notify(u);
1820 if (u->manager->n_reloading <= 0) {
1821 /* Maybe we finished startup and are now ready for
1822 * being stopped because unneeded? */
1823 unit_check_unneeded(u);
1825 /* Maybe we finished startup, but something we needed
1826 * has vanished? Let's die then. (This happens when
1827 * something BindsTo= to a Type=oneshot unit, as these
1828 * units go directly from starting to inactive,
1829 * without ever entering started.) */
1830 unit_check_binds_to(u);
1833 unit_add_to_dbus_queue(u);
1834 unit_add_to_gc_queue(u);
1837 int unit_watch_pid(Unit *u, pid_t pid) {
1843 /* Watch a specific PID. We only support one or two units
1844 * watching each PID for now, not more. */
1846 r = set_ensure_allocated(&u->pids, NULL);
1850 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1854 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1856 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
1860 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1863 q = set_put(u->pids, LONG_TO_PTR(pid));
1870 void unit_unwatch_pid(Unit *u, pid_t pid) {
1874 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1875 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1876 set_remove(u->pids, LONG_TO_PTR(pid));
1879 void unit_unwatch_all_pids(Unit *u) {
1882 while (!set_isempty(u->pids))
1883 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1889 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1890 _cleanup_closedir_ DIR *d = NULL;
1891 _cleanup_fclose_ FILE *f = NULL;
1897 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1899 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1903 while ((r = cg_read_pid(f, &pid)) > 0) {
1904 r = unit_watch_pid(u, pid);
1905 if (r < 0 && ret >= 0)
1908 if (r < 0 && ret >= 0)
1911 } else if (ret >= 0)
1914 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1918 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1919 _cleanup_free_ char *p = NULL;
1921 p = strjoin(path, "/", fn, NULL);
1927 r = unit_watch_pids_in_path(u, p);
1928 if (r < 0 && ret >= 0)
1931 if (r < 0 && ret >= 0)
1934 } else if (ret >= 0)
1940 int unit_watch_all_pids(Unit *u) {
1943 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1945 if (!u->cgroup_path)
1948 return unit_watch_pids_in_path(u, u->cgroup_path);
1951 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1957 /* Cleans dead PIDs from our list */
1959 SET_FOREACH(e, u->pids, i) {
1960 pid_t pid = PTR_TO_LONG(e);
1962 if (pid == except1 || pid == except2)
1965 if (!pid_is_unwaited(pid))
1966 unit_unwatch_pid(u, pid);
1970 bool unit_job_is_applicable(Unit *u, JobType j) {
1972 assert(j >= 0 && j < _JOB_TYPE_MAX);
1976 case JOB_VERIFY_ACTIVE:
1983 case JOB_TRY_RESTART:
1984 return unit_can_start(u);
1987 return unit_can_reload(u);
1989 case JOB_RELOAD_OR_START:
1990 return unit_can_reload(u) && unit_can_start(u);
1993 assert_not_reached("Invalid job type");
1997 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2000 switch (dependency) {
2002 case UNIT_REQUIRES_OVERRIDABLE:
2004 case UNIT_REQUISITE:
2005 case UNIT_REQUISITE_OVERRIDABLE:
2008 case UNIT_REQUIRED_BY:
2009 case UNIT_REQUIRED_BY_OVERRIDABLE:
2010 case UNIT_WANTED_BY:
2012 case UNIT_CONSISTS_OF:
2013 case UNIT_REFERENCES:
2014 case UNIT_REFERENCED_BY:
2015 case UNIT_PROPAGATES_RELOAD_TO:
2016 case UNIT_RELOAD_PROPAGATED_FROM:
2017 case UNIT_JOINS_NAMESPACE_OF:
2020 case UNIT_CONFLICTS:
2021 case UNIT_CONFLICTED_BY:
2024 case UNIT_ON_FAILURE:
2026 case UNIT_TRIGGERED_BY:
2027 if (streq_ptr(id, other))
2028 log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
2029 unit_dependency_to_string(dependency), id, other);
2031 log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
2032 unit_dependency_to_string(dependency), id,
2036 case _UNIT_DEPENDENCY_MAX:
2037 case _UNIT_DEPENDENCY_INVALID:
2041 assert_not_reached("Invalid dependency type");
2044 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2046 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2047 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2048 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2049 [UNIT_WANTS] = UNIT_WANTED_BY,
2050 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2051 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2052 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2053 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2054 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2055 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2056 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2057 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2058 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2059 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2060 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2061 [UNIT_BEFORE] = UNIT_AFTER,
2062 [UNIT_AFTER] = UNIT_BEFORE,
2063 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2064 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2065 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2066 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2067 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2068 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2069 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2070 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2072 int r, q = 0, v = 0, w = 0;
2073 Unit *orig_u = u, *orig_other = other;
2076 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2079 u = unit_follow_merge(u);
2080 other = unit_follow_merge(other);
2082 /* We won't allow dependencies on ourselves. We will not
2083 * consider them an error however. */
2085 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2089 r = set_ensure_allocated(&u->dependencies[d], NULL);
2093 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2094 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2099 if (add_reference) {
2100 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2104 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2109 q = set_put(u->dependencies[d], other);
2113 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2114 v = set_put(other->dependencies[inverse_table[d]], u);
2121 if (add_reference) {
2122 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2128 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2133 unit_add_to_dbus_queue(u);
2138 set_remove(u->dependencies[d], other);
2141 set_remove(other->dependencies[inverse_table[d]], u);
2144 set_remove(u->dependencies[UNIT_REFERENCES], other);
2149 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2154 r = unit_add_dependency(u, d, other, add_reference);
2158 r = unit_add_dependency(u, e, other, add_reference);
2165 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2169 assert(name || path);
2173 name = basename(path);
2175 if (!unit_name_is_template(name)) {
2181 s = unit_name_replace_instance(name, u->instance);
2183 _cleanup_free_ char *i = NULL;
2185 i = unit_name_to_prefix(u->id);
2189 s = unit_name_replace_instance(name, i);
2199 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2202 _cleanup_free_ char *s = NULL;
2205 assert(name || path);
2207 name = resolve_template(u, name, path, &s);
2211 r = manager_load_unit(u->manager, name, path, NULL, &other);
2215 return unit_add_dependency(u, d, other, add_reference);
2218 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2219 _cleanup_free_ char *s = NULL;
2224 assert(name || path);
2226 name = resolve_template(u, name, path, &s);
2230 r = manager_load_unit(u->manager, name, path, NULL, &other);
2234 return unit_add_two_dependencies(u, d, e, other, add_reference);
2237 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2240 _cleanup_free_ char *s = NULL;
2243 assert(name || path);
2245 name = resolve_template(u, name, path, &s);
2249 r = manager_load_unit(u->manager, name, path, NULL, &other);
2253 return unit_add_dependency(other, d, u, add_reference);
2256 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2259 _cleanup_free_ char *s = NULL;
2262 assert(name || path);
2264 name = resolve_template(u, name, path, &s);
2268 r = manager_load_unit(u->manager, name, path, NULL, &other);
2272 r = unit_add_two_dependencies(other, d, e, u, add_reference);
2279 int set_unit_path(const char *p) {
2280 /* This is mostly for debug purposes */
2281 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2287 char *unit_dbus_path(Unit *u) {
2293 return unit_dbus_path_from_name(u->id);
2296 char *unit_default_cgroup_path(Unit *u) {
2297 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2302 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2303 return strdup(u->manager->cgroup_root);
2305 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2306 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2311 escaped = cg_escape(u->id);
2316 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2318 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2321 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2322 _cleanup_free_ char *b = NULL;
2323 const char *slice_name;
2330 if (UNIT_ISSET(u->slice))
2334 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2336 /* Implicitly place all instantiated units in their
2337 * own per-template slice */
2339 prefix = unit_name_to_prefix(u->id);
2343 /* The prefix is already escaped, but it might include
2344 * "-" which has a special meaning for slice units,
2345 * hence escape it here extra. */
2346 escaped = strreplace(prefix, "-", "\\x2d");
2350 if (u->manager->running_as == SYSTEMD_SYSTEM)
2351 b = strjoin("system-", escaped, ".slice", NULL);
2353 b = strappend(escaped, ".slice");
2360 u->manager->running_as == SYSTEMD_SYSTEM
2361 ? SPECIAL_SYSTEM_SLICE
2362 : SPECIAL_ROOT_SLICE;
2364 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2368 unit_ref_set(&u->slice, slice);
2372 const char *unit_slice_name(Unit *u) {
2375 if (!UNIT_ISSET(u->slice))
2378 return UNIT_DEREF(u->slice)->id;
2381 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2382 _cleanup_free_ char *t = NULL;
2389 t = unit_name_change_suffix(u->id, type);
2393 assert(!unit_has_name(u, t));
2395 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2396 assert(r < 0 || *_found != u);
2400 int unit_watch_bus_name(Unit *u, const char *name) {
2404 /* Watch a specific name on the bus. We only support one unit
2405 * watching each name for now. */
2407 return hashmap_put(u->manager->watch_bus, name, u);
2410 void unit_unwatch_bus_name(Unit *u, const char *name) {
2414 hashmap_remove_value(u->manager->watch_bus, name, u);
2417 bool unit_can_serialize(Unit *u) {
2420 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2423 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2430 if (unit_can_serialize(u)) {
2433 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2437 rt = unit_get_exec_runtime(u);
2439 r = exec_runtime_serialize(rt, u, f, fds);
2445 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2446 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2447 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2448 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2449 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2451 if (dual_timestamp_is_set(&u->condition_timestamp))
2452 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2454 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2457 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2459 if (serialize_jobs) {
2461 fprintf(f, "job\n");
2462 job_serialize(u->job, f, fds);
2466 fprintf(f, "job\n");
2467 job_serialize(u->nop_job, f, fds);
2476 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2487 va_start(ap, format);
2488 vfprintf(f, format, ap);
2494 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2500 fprintf(f, "%s=%s\n", key, value);
2503 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2504 ExecRuntime **rt = NULL;
2512 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2514 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2517 char line[LINE_MAX], *l, *v;
2520 if (!fgets(line, sizeof(line), f)) {
2533 k = strcspn(l, "=");
2541 if (streq(l, "job")) {
2543 /* new-style serialized job */
2544 Job *j = job_new_raw(u);
2548 r = job_deserialize(j, f, fds);
2554 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2560 r = job_install_deserialized(j);
2562 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2567 if (j->state == JOB_RUNNING)
2568 u->manager->n_running_jobs++;
2571 JobType type = job_type_from_string(v);
2573 log_debug("Failed to parse job type value %s", v);
2575 u->deserialized_job = type;
2578 } else if (streq(l, "inactive-exit-timestamp")) {
2579 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2581 } else if (streq(l, "active-enter-timestamp")) {
2582 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2584 } else if (streq(l, "active-exit-timestamp")) {
2585 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2587 } else if (streq(l, "inactive-enter-timestamp")) {
2588 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2590 } else if (streq(l, "condition-timestamp")) {
2591 dual_timestamp_deserialize(v, &u->condition_timestamp);
2593 } else if (streq(l, "condition-result")) {
2596 b = parse_boolean(v);
2598 log_debug("Failed to parse condition result value %s", v);
2600 u->condition_result = b;
2604 } else if (streq(l, "transient")) {
2607 b = parse_boolean(v);
2609 log_debug("Failed to parse transient bool %s", v);
2614 } else if (streq(l, "cgroup")) {
2621 if (u->cgroup_path) {
2624 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2625 log_info("Removing cgroup_path %s from hashmap (%p)",
2627 free(u->cgroup_path);
2631 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2636 if (unit_can_serialize(u)) {
2638 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2645 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2652 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2654 _cleanup_free_ char *e = NULL;
2662 /* Adds in links to the device node that this unit is based on */
2664 if (!is_device_path(what))
2667 e = unit_name_from_path(what, ".device");
2671 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2676 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2681 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2689 int unit_coldplug(Unit *u) {
2694 if (UNIT_VTABLE(u)->coldplug)
2695 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2699 r = job_coldplug(u->job);
2702 } else if (u->deserialized_job >= 0) {
2704 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2708 u->deserialized_job = _JOB_TYPE_INVALID;
2714 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2715 DISABLE_WARNING_FORMAT_NONLITERAL;
2716 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2720 bool unit_need_daemon_reload(Unit *u) {
2721 _cleanup_strv_free_ char **t = NULL;
2724 unsigned loaded_cnt, current_cnt;
2728 if (u->fragment_path) {
2730 if (stat(u->fragment_path, &st) < 0)
2731 /* What, cannot access this anymore? */
2734 if (u->fragment_mtime > 0 &&
2735 timespec_load(&st.st_mtim) != u->fragment_mtime)
2739 if (u->source_path) {
2741 if (stat(u->source_path, &st) < 0)
2744 if (u->source_mtime > 0 &&
2745 timespec_load(&st.st_mtim) != u->source_mtime)
2749 t = unit_find_dropin_paths(u);
2750 loaded_cnt = strv_length(t);
2751 current_cnt = strv_length(u->dropin_paths);
2753 if (loaded_cnt == current_cnt) {
2754 if (loaded_cnt == 0)
2757 if (strv_overlap(u->dropin_paths, t)) {
2758 STRV_FOREACH(path, u->dropin_paths) {
2760 if (stat(*path, &st) < 0)
2763 if (u->dropin_mtime > 0 &&
2764 timespec_load(&st.st_mtim) > u->dropin_mtime)
2775 void unit_reset_failed(Unit *u) {
2778 if (UNIT_VTABLE(u)->reset_failed)
2779 UNIT_VTABLE(u)->reset_failed(u);
2782 Unit *unit_following(Unit *u) {
2785 if (UNIT_VTABLE(u)->following)
2786 return UNIT_VTABLE(u)->following(u);
2791 bool unit_stop_pending(Unit *u) {
2794 /* This call does check the current state of the unit. It's
2795 * hence useful to be called from state change calls of the
2796 * unit itself, where the state isn't updated yet. This is
2797 * different from unit_inactive_or_pending() which checks both
2798 * the current state and for a queued job. */
2800 return u->job && u->job->type == JOB_STOP;
2803 bool unit_inactive_or_pending(Unit *u) {
2806 /* Returns true if the unit is inactive or going down */
2808 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2811 if (unit_stop_pending(u))
2817 bool unit_active_or_pending(Unit *u) {
2820 /* Returns true if the unit is active or going up */
2822 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2826 (u->job->type == JOB_START ||
2827 u->job->type == JOB_RELOAD_OR_START ||
2828 u->job->type == JOB_RESTART))
2834 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2836 assert(w >= 0 && w < _KILL_WHO_MAX);
2838 assert(signo < _NSIG);
2840 if (!UNIT_VTABLE(u)->kill)
2843 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2846 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2850 pid_set = set_new(NULL);
2854 /* Exclude the main/control pids from being killed via the cgroup */
2856 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2861 if (control_pid > 0) {
2862 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2874 int unit_kill_common(
2880 sd_bus_error *error) {
2884 if (who == KILL_MAIN && main_pid <= 0) {
2886 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2888 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2892 if (who == KILL_CONTROL && control_pid <= 0) {
2893 if (control_pid < 0)
2894 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2896 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2900 if (who == KILL_CONTROL || who == KILL_ALL)
2901 if (control_pid > 0)
2902 if (kill(control_pid, signo) < 0)
2905 if (who == KILL_MAIN || who == KILL_ALL)
2907 if (kill(main_pid, signo) < 0)
2910 if (who == KILL_ALL && u->cgroup_path) {
2911 _cleanup_set_free_ Set *pid_set = NULL;
2914 /* Exclude the main/control pids from being killed via the cgroup */
2915 pid_set = unit_pid_set(main_pid, control_pid);
2919 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2920 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2927 int unit_following_set(Unit *u, Set **s) {
2931 if (UNIT_VTABLE(u)->following_set)
2932 return UNIT_VTABLE(u)->following_set(u, s);
2938 UnitFileState unit_get_unit_file_state(Unit *u) {
2941 if (u->unit_file_state < 0 && u->fragment_path)
2942 u->unit_file_state = unit_file_get_state(
2943 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2944 NULL, basename(u->fragment_path));
2946 return u->unit_file_state;
2949 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2954 unit_ref_unset(ref);
2957 LIST_PREPEND(refs, u->refs, ref);
2961 void unit_ref_unset(UnitRef *ref) {
2967 LIST_REMOVE(refs, ref->unit->refs, ref);
2971 int unit_patch_contexts(Unit *u) {
2979 /* Patch in the manager defaults into the exec and cgroup
2980 * contexts, _after_ the rest of the settings have been
2983 ec = unit_get_exec_context(u);
2985 /* This only copies in the ones that need memory */
2986 for (i = 0; i < _RLIMIT_MAX; i++)
2987 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2988 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2993 if (u->manager->running_as == SYSTEMD_USER &&
2994 !ec->working_directory) {
2996 r = get_home_dir(&ec->working_directory);
3001 if (u->manager->running_as == SYSTEMD_USER &&
3002 (ec->syscall_whitelist ||
3003 !set_isempty(ec->syscall_filter) ||
3004 !set_isempty(ec->syscall_archs) ||
3005 ec->address_families_whitelist ||
3006 !set_isempty(ec->address_families)))
3007 ec->no_new_privileges = true;
3009 if (ec->private_devices)
3010 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3013 cc = unit_get_cgroup_context(u);
3017 ec->private_devices &&
3018 cc->device_policy == CGROUP_AUTO)
3019 cc->device_policy = CGROUP_CLOSED;
3025 ExecContext *unit_get_exec_context(Unit *u) {
3032 offset = UNIT_VTABLE(u)->exec_context_offset;
3036 return (ExecContext*) ((uint8_t*) u + offset);
3039 KillContext *unit_get_kill_context(Unit *u) {
3046 offset = UNIT_VTABLE(u)->kill_context_offset;
3050 return (KillContext*) ((uint8_t*) u + offset);
3053 CGroupContext *unit_get_cgroup_context(Unit *u) {
3059 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3063 return (CGroupContext*) ((uint8_t*) u + offset);
3066 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3072 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3076 return *(ExecRuntime**) ((uint8_t*) u + offset);
3079 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3080 if (u->manager->running_as == SYSTEMD_USER) {
3083 if (mode == UNIT_PERSISTENT && !transient)
3084 r = user_config_home(dir);
3086 r = user_runtime_dir(dir);
3093 if (mode == UNIT_PERSISTENT && !transient)
3094 *dir = strdup("/etc/systemd/system");
3096 *dir = strdup("/run/systemd/system");
3103 static int unit_drop_in_file(Unit *u,
3104 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3105 _cleanup_free_ char *dir = NULL;
3110 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3114 return drop_in_file(dir, u->id, 50, name, p, q);
3117 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3119 _cleanup_free_ char *dir = NULL;
3124 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3127 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3131 return write_drop_in(dir, u->id, 50, name, data);
3134 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3135 _cleanup_free_ char *p = NULL;
3143 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3146 va_start(ap, format);
3147 r = vasprintf(&p, format, ap);
3153 return unit_write_drop_in(u, mode, name, p);
3156 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3157 _cleanup_free_ char *ndata = NULL;
3163 if (!UNIT_VTABLE(u)->private_section)
3166 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3169 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3173 return unit_write_drop_in(u, mode, name, ndata);
3176 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3177 _cleanup_free_ char *p = NULL;
3185 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3188 va_start(ap, format);
3189 r = vasprintf(&p, format, ap);
3195 return unit_write_drop_in_private(u, mode, name, p);
3198 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3199 _cleanup_free_ char *p = NULL, *q = NULL;
3204 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3207 r = unit_drop_in_file(u, mode, name, &p, &q);
3212 r = errno == ENOENT ? 0 : -errno;
3220 int unit_make_transient(Unit *u) {
3225 u->load_state = UNIT_STUB;
3227 u->transient = true;
3229 free(u->fragment_path);
3230 u->fragment_path = NULL;
3232 if (u->manager->running_as == SYSTEMD_USER) {
3233 _cleanup_free_ char *c = NULL;
3235 r = user_runtime_dir(&c);
3241 u->fragment_path = strjoin(c, "/", u->id, NULL);
3242 if (!u->fragment_path)
3247 u->fragment_path = strappend("/run/systemd/system/", u->id);
3248 if (!u->fragment_path)
3251 mkdir_p("/run/systemd/system", 0755);
3254 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3257 int unit_kill_context(
3263 bool main_pid_alien) {
3265 int sig, wait_for_exit = false, r;
3270 if (c->kill_mode == KILL_NONE)
3273 sig = sigkill ? SIGKILL : c->kill_signal;
3276 r = kill_and_sigcont(main_pid, sig);
3278 if (r < 0 && r != -ESRCH) {
3279 _cleanup_free_ char *comm = NULL;
3280 get_process_comm(main_pid, &comm);
3282 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3284 if (!main_pid_alien)
3285 wait_for_exit = true;
3287 if (c->send_sighup && !sigkill)
3288 kill(main_pid, SIGHUP);
3292 if (control_pid > 0) {
3293 r = kill_and_sigcont(control_pid, sig);
3295 if (r < 0 && r != -ESRCH) {
3296 _cleanup_free_ char *comm = NULL;
3297 get_process_comm(control_pid, &comm);
3299 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3301 wait_for_exit = true;
3303 if (c->send_sighup && !sigkill)
3304 kill(control_pid, SIGHUP);
3308 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3309 _cleanup_set_free_ Set *pid_set = NULL;
3311 /* Exclude the main/control pids from being killed via the cgroup */
3312 pid_set = unit_pid_set(main_pid, control_pid);
3316 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3318 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3319 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3322 /* FIXME: For now, we will not wait for the
3323 * cgroup members to die, simply because
3324 * cgroup notification is unreliable. It
3325 * doesn't work at all in containers, and
3326 * outside of containers it can be confused
3327 * easily by leaving directories in the
3330 /* wait_for_exit = true; */
3332 if (c->send_sighup && !sigkill) {
3335 pid_set = unit_pid_set(main_pid, control_pid);
3339 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3344 return wait_for_exit;
3347 int unit_require_mounts_for(Unit *u, const char *path) {
3348 char prefix[strlen(path) + 1], *p;
3354 /* Registers a unit for requiring a certain path and all its
3355 * prefixes. We keep a simple array of these paths in the
3356 * unit, since its usually short. However, we build a prefix
3357 * table for all possible prefixes so that new appearing mount
3358 * units can easily determine which units to make themselves a
3361 if (!path_is_absolute(path))
3368 path_kill_slashes(p);
3370 if (!path_is_safe(p)) {
3375 if (strv_contains(u->requires_mounts_for, p)) {
3380 r = strv_consume(&u->requires_mounts_for, p);
3384 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3387 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3391 if (!u->manager->units_requiring_mounts_for) {
3392 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3393 if (!u->manager->units_requiring_mounts_for)
3407 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3423 int unit_setup_exec_runtime(Unit *u) {
3429 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3432 /* Check if there already is an ExecRuntime for this unit? */
3433 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3437 /* Try to get it from somebody else */
3438 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3440 *rt = unit_get_exec_runtime(other);
3442 exec_runtime_ref(*rt);
3447 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3450 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3451 [UNIT_ACTIVE] = "active",
3452 [UNIT_RELOADING] = "reloading",
3453 [UNIT_INACTIVE] = "inactive",
3454 [UNIT_FAILED] = "failed",
3455 [UNIT_ACTIVATING] = "activating",
3456 [UNIT_DEACTIVATING] = "deactivating"
3459 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);