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, "Unit %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 unit_check_binds_to(Unit *u) {
1490 if (unit_active_state(u) != UNIT_ACTIVE)
1493 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1497 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1506 log_info_unit(u->id, "Unit %s is bound to inactive service. Stopping, too.", u->id);
1508 /* A unit we need to run is gone. Sniff. Let's stop this. */
1509 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1512 static void retroactively_start_dependencies(Unit *u) {
1517 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1519 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1520 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1521 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1522 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1524 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1525 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1526 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1527 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1529 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1530 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1531 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1532 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1534 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1535 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1536 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1537 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1539 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1540 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1541 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1543 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1544 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1545 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1548 static void retroactively_stop_dependencies(Unit *u) {
1553 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1555 /* Pull down units which are bound to us recursively if enabled */
1556 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1557 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1558 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1561 static void check_unneeded_dependencies(Unit *u) {
1566 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1568 /* Garbage collect services that might not be needed anymore, if enabled */
1569 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1570 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1571 unit_check_unneeded(other);
1572 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1573 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1574 unit_check_unneeded(other);
1575 SET_FOREACH(other, u->dependencies[UNIT_WANTS], 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], i)
1579 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1580 unit_check_unneeded(other);
1581 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1582 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1583 unit_check_unneeded(other);
1584 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1585 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1586 unit_check_unneeded(other);
1589 void unit_start_on_failure(Unit *u) {
1595 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1598 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1600 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1603 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1605 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1609 void unit_trigger_notify(Unit *u) {
1615 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1616 if (UNIT_VTABLE(other)->trigger_notify)
1617 UNIT_VTABLE(other)->trigger_notify(other, u);
1620 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1625 assert(os < _UNIT_ACTIVE_STATE_MAX);
1626 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1628 /* Note that this is called for all low-level state changes,
1629 * even if they might map to the same high-level
1630 * UnitActiveState! That means that ns == os is an expected
1631 * behavior here. For example: if a mount point is remounted
1632 * this function will be called too! */
1636 /* Update timestamps for state changes */
1637 if (m->n_reloading <= 0) {
1640 dual_timestamp_get(&ts);
1642 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1643 u->inactive_exit_timestamp = ts;
1644 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1645 u->inactive_enter_timestamp = ts;
1647 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1648 u->active_enter_timestamp = ts;
1649 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1650 u->active_exit_timestamp = ts;
1653 /* Keep track of failed units */
1654 if (ns == UNIT_FAILED)
1655 set_put(u->manager->failed_units, u);
1657 set_remove(u->manager->failed_units, u);
1659 /* Make sure the cgroup is always removed when we become inactive */
1660 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1661 unit_destroy_cgroup(u);
1663 /* Note that this doesn't apply to RemainAfterExit services exiting
1664 * successfully, since there's no change of state in that case. Which is
1665 * why it is handled in service_set_state() */
1666 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1669 ec = unit_get_exec_context(u);
1670 if (ec && exec_context_may_touch_console(ec)) {
1671 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1674 if (m->n_on_console == 0)
1675 /* unset no_console_output flag, since the console is free */
1676 m->no_console_output = false;
1685 if (u->job->state == JOB_WAITING)
1687 /* So we reached a different state for this
1688 * job. Let's see if we can run it now if it
1689 * failed previously due to EAGAIN. */
1690 job_add_to_run_queue(u->job);
1692 /* Let's check whether this state change constitutes a
1693 * finished job, or maybe contradicts a running job and
1694 * hence needs to invalidate jobs. */
1696 switch (u->job->type) {
1699 case JOB_VERIFY_ACTIVE:
1701 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1702 job_finish_and_invalidate(u->job, JOB_DONE, true);
1703 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1706 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1707 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1713 case JOB_RELOAD_OR_START:
1715 if (u->job->state == JOB_RUNNING) {
1716 if (ns == UNIT_ACTIVE)
1717 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1718 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1721 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1722 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1730 case JOB_TRY_RESTART:
1732 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1733 job_finish_and_invalidate(u->job, JOB_DONE, true);
1734 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1736 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1742 assert_not_reached("Job type unknown");
1748 if (m->n_reloading <= 0) {
1750 /* If this state change happened without being
1751 * requested by a job, then let's retroactively start
1752 * or stop dependencies. We skip that step when
1753 * deserializing, since we don't want to create any
1754 * additional jobs just because something is already
1758 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1759 retroactively_start_dependencies(u);
1760 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1761 retroactively_stop_dependencies(u);
1764 /* stop unneeded units regardless if going down was expected or not */
1765 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1766 check_unneeded_dependencies(u);
1768 if (ns != os && ns == UNIT_FAILED) {
1769 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1770 unit_start_on_failure(u);
1774 /* Some names are special */
1775 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1777 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1778 /* The bus might have just become available,
1779 * hence try to connect to it, if we aren't
1783 if (u->type == UNIT_SERVICE &&
1784 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1785 m->n_reloading <= 0) {
1786 /* Write audit record if we have just finished starting up */
1787 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1791 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1792 manager_send_unit_plymouth(m, u);
1796 /* We don't care about D-Bus here, since we'll get an
1797 * asynchronous notification for it anyway. */
1799 if (u->type == UNIT_SERVICE &&
1800 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1801 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1802 m->n_reloading <= 0) {
1804 /* Hmm, if there was no start record written
1805 * write it now, so that we always have a nice
1808 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1810 if (ns == UNIT_INACTIVE)
1811 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1813 /* Write audit record if we have just finished shutting down */
1814 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1816 u->in_audit = false;
1820 manager_recheck_journal(m);
1821 unit_trigger_notify(u);
1823 if (u->manager->n_reloading <= 0) {
1824 /* Maybe we finished startup and are now ready for
1825 * being stopped because unneeded? */
1826 unit_check_unneeded(u);
1828 /* Maybe we finished startup, but something we needed
1829 * has vanished? Let's die then. (This happens when
1830 * something BindsTo= to a Type=oneshot unit, as these
1831 * units go directly from starting to inactive,
1832 * without ever entering started.) */
1833 unit_check_binds_to(u);
1836 unit_add_to_dbus_queue(u);
1837 unit_add_to_gc_queue(u);
1840 int unit_watch_pid(Unit *u, pid_t pid) {
1846 /* Watch a specific PID. We only support one or two units
1847 * watching each PID for now, not more. */
1849 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1853 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1857 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1859 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1863 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1866 q = set_put(u->pids, LONG_TO_PTR(pid));
1873 void unit_unwatch_pid(Unit *u, pid_t pid) {
1877 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1878 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1879 set_remove(u->pids, LONG_TO_PTR(pid));
1882 void unit_unwatch_all_pids(Unit *u) {
1885 while (!set_isempty(u->pids))
1886 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1892 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1893 _cleanup_closedir_ DIR *d = NULL;
1894 _cleanup_fclose_ FILE *f = NULL;
1900 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1902 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1906 while ((r = cg_read_pid(f, &pid)) > 0) {
1907 r = unit_watch_pid(u, pid);
1908 if (r < 0 && ret >= 0)
1911 if (r < 0 && ret >= 0)
1914 } else if (ret >= 0)
1917 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1921 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1922 _cleanup_free_ char *p = NULL;
1924 p = strjoin(path, "/", fn, NULL);
1930 r = unit_watch_pids_in_path(u, p);
1931 if (r < 0 && ret >= 0)
1934 if (r < 0 && ret >= 0)
1937 } else if (ret >= 0)
1943 int unit_watch_all_pids(Unit *u) {
1946 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1948 if (!u->cgroup_path)
1951 return unit_watch_pids_in_path(u, u->cgroup_path);
1954 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1960 /* Cleans dead PIDs from our list */
1962 SET_FOREACH(e, u->pids, i) {
1963 pid_t pid = PTR_TO_LONG(e);
1965 if (pid == except1 || pid == except2)
1968 if (!pid_is_unwaited(pid))
1969 unit_unwatch_pid(u, pid);
1973 bool unit_job_is_applicable(Unit *u, JobType j) {
1975 assert(j >= 0 && j < _JOB_TYPE_MAX);
1979 case JOB_VERIFY_ACTIVE:
1986 case JOB_TRY_RESTART:
1987 return unit_can_start(u);
1990 return unit_can_reload(u);
1992 case JOB_RELOAD_OR_START:
1993 return unit_can_reload(u) && unit_can_start(u);
1996 assert_not_reached("Invalid job type");
2000 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2003 switch (dependency) {
2005 case UNIT_REQUIRES_OVERRIDABLE:
2007 case UNIT_REQUISITE:
2008 case UNIT_REQUISITE_OVERRIDABLE:
2011 case UNIT_REQUIRED_BY:
2012 case UNIT_REQUIRED_BY_OVERRIDABLE:
2013 case UNIT_WANTED_BY:
2015 case UNIT_CONSISTS_OF:
2016 case UNIT_REFERENCES:
2017 case UNIT_REFERENCED_BY:
2018 case UNIT_PROPAGATES_RELOAD_TO:
2019 case UNIT_RELOAD_PROPAGATED_FROM:
2020 case UNIT_JOINS_NAMESPACE_OF:
2023 case UNIT_CONFLICTS:
2024 case UNIT_CONFLICTED_BY:
2027 case UNIT_ON_FAILURE:
2029 case UNIT_TRIGGERED_BY:
2030 if (streq_ptr(id, other))
2031 log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
2032 unit_dependency_to_string(dependency), id, other);
2034 log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
2035 unit_dependency_to_string(dependency), id,
2039 case _UNIT_DEPENDENCY_MAX:
2040 case _UNIT_DEPENDENCY_INVALID:
2044 assert_not_reached("Invalid dependency type");
2047 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2049 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2050 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2051 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2052 [UNIT_WANTS] = UNIT_WANTED_BY,
2053 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2054 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2055 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2056 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2057 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2058 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2059 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2060 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2061 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2062 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2063 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2064 [UNIT_BEFORE] = UNIT_AFTER,
2065 [UNIT_AFTER] = UNIT_BEFORE,
2066 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2067 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2068 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2069 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2070 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2071 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2072 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2073 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2075 int r, q = 0, v = 0, w = 0;
2076 Unit *orig_u = u, *orig_other = other;
2079 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2082 u = unit_follow_merge(u);
2083 other = unit_follow_merge(other);
2085 /* We won't allow dependencies on ourselves. We will not
2086 * consider them an error however. */
2088 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2092 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
2096 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2097 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
2102 if (add_reference) {
2103 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
2107 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
2112 q = set_put(u->dependencies[d], other);
2116 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2117 v = set_put(other->dependencies[inverse_table[d]], u);
2124 if (add_reference) {
2125 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2131 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2136 unit_add_to_dbus_queue(u);
2141 set_remove(u->dependencies[d], other);
2144 set_remove(other->dependencies[inverse_table[d]], u);
2147 set_remove(u->dependencies[UNIT_REFERENCES], other);
2152 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2157 r = unit_add_dependency(u, d, other, add_reference);
2161 r = unit_add_dependency(u, e, other, add_reference);
2168 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2172 assert(name || path);
2176 name = basename(path);
2178 if (!unit_name_is_template(name)) {
2184 s = unit_name_replace_instance(name, u->instance);
2186 _cleanup_free_ char *i = NULL;
2188 i = unit_name_to_prefix(u->id);
2192 s = unit_name_replace_instance(name, i);
2202 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2205 _cleanup_free_ char *s = NULL;
2208 assert(name || path);
2210 name = resolve_template(u, name, path, &s);
2214 r = manager_load_unit(u->manager, name, path, NULL, &other);
2218 return unit_add_dependency(u, d, other, add_reference);
2221 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2222 _cleanup_free_ char *s = NULL;
2227 assert(name || path);
2229 name = resolve_template(u, name, path, &s);
2233 r = manager_load_unit(u->manager, name, path, NULL, &other);
2237 return unit_add_two_dependencies(u, d, e, other, add_reference);
2240 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2243 _cleanup_free_ char *s = NULL;
2246 assert(name || path);
2248 name = resolve_template(u, name, path, &s);
2252 r = manager_load_unit(u->manager, name, path, NULL, &other);
2256 return unit_add_dependency(other, d, u, add_reference);
2259 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2262 _cleanup_free_ char *s = NULL;
2265 assert(name || path);
2267 name = resolve_template(u, name, path, &s);
2271 r = manager_load_unit(u->manager, name, path, NULL, &other);
2275 r = unit_add_two_dependencies(other, d, e, u, add_reference);
2282 int set_unit_path(const char *p) {
2283 /* This is mostly for debug purposes */
2284 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2290 char *unit_dbus_path(Unit *u) {
2296 return unit_dbus_path_from_name(u->id);
2299 char *unit_default_cgroup_path(Unit *u) {
2300 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2305 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2306 return strdup(u->manager->cgroup_root);
2308 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2309 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2314 escaped = cg_escape(u->id);
2319 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2321 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2324 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2325 _cleanup_free_ char *b = NULL;
2326 const char *slice_name;
2333 if (UNIT_ISSET(u->slice))
2337 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2339 /* Implicitly place all instantiated units in their
2340 * own per-template slice */
2342 prefix = unit_name_to_prefix(u->id);
2346 /* The prefix is already escaped, but it might include
2347 * "-" which has a special meaning for slice units,
2348 * hence escape it here extra. */
2349 escaped = strreplace(prefix, "-", "\\x2d");
2353 if (u->manager->running_as == SYSTEMD_SYSTEM)
2354 b = strjoin("system-", escaped, ".slice", NULL);
2356 b = strappend(escaped, ".slice");
2363 u->manager->running_as == SYSTEMD_SYSTEM
2364 ? SPECIAL_SYSTEM_SLICE
2365 : SPECIAL_ROOT_SLICE;
2367 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2371 unit_ref_set(&u->slice, slice);
2375 const char *unit_slice_name(Unit *u) {
2378 if (!UNIT_ISSET(u->slice))
2381 return UNIT_DEREF(u->slice)->id;
2384 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2385 _cleanup_free_ char *t = NULL;
2392 t = unit_name_change_suffix(u->id, type);
2396 assert(!unit_has_name(u, t));
2398 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2399 assert(r < 0 || *_found != u);
2403 int unit_watch_bus_name(Unit *u, const char *name) {
2407 /* Watch a specific name on the bus. We only support one unit
2408 * watching each name for now. */
2410 return hashmap_put(u->manager->watch_bus, name, u);
2413 void unit_unwatch_bus_name(Unit *u, const char *name) {
2417 hashmap_remove_value(u->manager->watch_bus, name, u);
2420 bool unit_can_serialize(Unit *u) {
2423 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2426 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2433 if (unit_can_serialize(u)) {
2436 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2440 rt = unit_get_exec_runtime(u);
2442 r = exec_runtime_serialize(rt, u, f, fds);
2448 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2449 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2450 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2451 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2452 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2454 if (dual_timestamp_is_set(&u->condition_timestamp))
2455 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2457 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2460 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2462 if (serialize_jobs) {
2464 fprintf(f, "job\n");
2465 job_serialize(u->job, f, fds);
2469 fprintf(f, "job\n");
2470 job_serialize(u->nop_job, f, fds);
2479 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2490 va_start(ap, format);
2491 vfprintf(f, format, ap);
2497 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2503 fprintf(f, "%s=%s\n", key, value);
2506 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2507 ExecRuntime **rt = NULL;
2515 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2517 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2520 char line[LINE_MAX], *l, *v;
2523 if (!fgets(line, sizeof(line), f)) {
2536 k = strcspn(l, "=");
2544 if (streq(l, "job")) {
2546 /* new-style serialized job */
2547 Job *j = job_new_raw(u);
2551 r = job_deserialize(j, f, fds);
2557 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2563 r = job_install_deserialized(j);
2565 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2570 if (j->state == JOB_RUNNING)
2571 u->manager->n_running_jobs++;
2574 JobType type = job_type_from_string(v);
2576 log_debug("Failed to parse job type value %s", v);
2578 u->deserialized_job = type;
2581 } else if (streq(l, "inactive-exit-timestamp")) {
2582 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2584 } else if (streq(l, "active-enter-timestamp")) {
2585 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2587 } else if (streq(l, "active-exit-timestamp")) {
2588 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2590 } else if (streq(l, "inactive-enter-timestamp")) {
2591 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2593 } else if (streq(l, "condition-timestamp")) {
2594 dual_timestamp_deserialize(v, &u->condition_timestamp);
2596 } else if (streq(l, "condition-result")) {
2599 b = parse_boolean(v);
2601 log_debug("Failed to parse condition result value %s", v);
2603 u->condition_result = b;
2607 } else if (streq(l, "transient")) {
2610 b = parse_boolean(v);
2612 log_debug("Failed to parse transient bool %s", v);
2617 } else if (streq(l, "cgroup")) {
2624 if (u->cgroup_path) {
2627 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2628 log_info("Removing cgroup_path %s from hashmap (%p)",
2630 free(u->cgroup_path);
2634 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2639 if (unit_can_serialize(u)) {
2641 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2648 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2655 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2657 _cleanup_free_ char *e = NULL;
2665 /* Adds in links to the device node that this unit is based on */
2667 if (!is_device_path(what))
2670 e = unit_name_from_path(what, ".device");
2674 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2679 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2684 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2692 int unit_coldplug(Unit *u) {
2697 if (UNIT_VTABLE(u)->coldplug)
2698 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2702 r = job_coldplug(u->job);
2705 } else if (u->deserialized_job >= 0) {
2707 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2711 u->deserialized_job = _JOB_TYPE_INVALID;
2717 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2718 DISABLE_WARNING_FORMAT_NONLITERAL;
2719 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2723 bool unit_need_daemon_reload(Unit *u) {
2724 _cleanup_strv_free_ char **t = NULL;
2727 unsigned loaded_cnt, current_cnt;
2731 if (u->fragment_path) {
2733 if (stat(u->fragment_path, &st) < 0)
2734 /* What, cannot access this anymore? */
2737 if (u->fragment_mtime > 0 &&
2738 timespec_load(&st.st_mtim) != u->fragment_mtime)
2742 if (u->source_path) {
2744 if (stat(u->source_path, &st) < 0)
2747 if (u->source_mtime > 0 &&
2748 timespec_load(&st.st_mtim) != u->source_mtime)
2752 t = unit_find_dropin_paths(u);
2753 loaded_cnt = strv_length(t);
2754 current_cnt = strv_length(u->dropin_paths);
2756 if (loaded_cnt == current_cnt) {
2757 if (loaded_cnt == 0)
2760 if (strv_overlap(u->dropin_paths, t)) {
2761 STRV_FOREACH(path, u->dropin_paths) {
2763 if (stat(*path, &st) < 0)
2766 if (u->dropin_mtime > 0 &&
2767 timespec_load(&st.st_mtim) > u->dropin_mtime)
2778 void unit_reset_failed(Unit *u) {
2781 if (UNIT_VTABLE(u)->reset_failed)
2782 UNIT_VTABLE(u)->reset_failed(u);
2785 Unit *unit_following(Unit *u) {
2788 if (UNIT_VTABLE(u)->following)
2789 return UNIT_VTABLE(u)->following(u);
2794 bool unit_stop_pending(Unit *u) {
2797 /* This call does check the current state of the unit. It's
2798 * hence useful to be called from state change calls of the
2799 * unit itself, where the state isn't updated yet. This is
2800 * different from unit_inactive_or_pending() which checks both
2801 * the current state and for a queued job. */
2803 return u->job && u->job->type == JOB_STOP;
2806 bool unit_inactive_or_pending(Unit *u) {
2809 /* Returns true if the unit is inactive or going down */
2811 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2814 if (unit_stop_pending(u))
2820 bool unit_active_or_pending(Unit *u) {
2823 /* Returns true if the unit is active or going up */
2825 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2829 (u->job->type == JOB_START ||
2830 u->job->type == JOB_RELOAD_OR_START ||
2831 u->job->type == JOB_RESTART))
2837 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2839 assert(w >= 0 && w < _KILL_WHO_MAX);
2841 assert(signo < _NSIG);
2843 if (!UNIT_VTABLE(u)->kill)
2846 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2849 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2853 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2857 /* Exclude the main/control pids from being killed via the cgroup */
2859 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2864 if (control_pid > 0) {
2865 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2877 int unit_kill_common(
2883 sd_bus_error *error) {
2887 if (who == KILL_MAIN && main_pid <= 0) {
2889 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2891 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2895 if (who == KILL_CONTROL && control_pid <= 0) {
2896 if (control_pid < 0)
2897 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2899 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2903 if (who == KILL_CONTROL || who == KILL_ALL)
2904 if (control_pid > 0)
2905 if (kill(control_pid, signo) < 0)
2908 if (who == KILL_MAIN || who == KILL_ALL)
2910 if (kill(main_pid, signo) < 0)
2913 if (who == KILL_ALL && u->cgroup_path) {
2914 _cleanup_set_free_ Set *pid_set = NULL;
2917 /* Exclude the main/control pids from being killed via the cgroup */
2918 pid_set = unit_pid_set(main_pid, control_pid);
2922 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2923 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2930 int unit_following_set(Unit *u, Set **s) {
2934 if (UNIT_VTABLE(u)->following_set)
2935 return UNIT_VTABLE(u)->following_set(u, s);
2941 UnitFileState unit_get_unit_file_state(Unit *u) {
2944 if (u->unit_file_state < 0 && u->fragment_path)
2945 u->unit_file_state = unit_file_get_state(
2946 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2947 NULL, basename(u->fragment_path));
2949 return u->unit_file_state;
2952 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2957 unit_ref_unset(ref);
2960 LIST_PREPEND(refs, u->refs, ref);
2964 void unit_ref_unset(UnitRef *ref) {
2970 LIST_REMOVE(refs, ref->unit->refs, ref);
2974 int unit_patch_contexts(Unit *u) {
2982 /* Patch in the manager defaults into the exec and cgroup
2983 * contexts, _after_ the rest of the settings have been
2986 ec = unit_get_exec_context(u);
2988 /* This only copies in the ones that need memory */
2989 for (i = 0; i < _RLIMIT_MAX; i++)
2990 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2991 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2996 if (u->manager->running_as == SYSTEMD_USER &&
2997 !ec->working_directory) {
2999 r = get_home_dir(&ec->working_directory);
3004 if (u->manager->running_as == SYSTEMD_USER &&
3005 (ec->syscall_whitelist ||
3006 !set_isempty(ec->syscall_filter) ||
3007 !set_isempty(ec->syscall_archs) ||
3008 ec->address_families_whitelist ||
3009 !set_isempty(ec->address_families)))
3010 ec->no_new_privileges = true;
3012 if (ec->private_devices)
3013 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3016 cc = unit_get_cgroup_context(u);
3020 ec->private_devices &&
3021 cc->device_policy == CGROUP_AUTO)
3022 cc->device_policy = CGROUP_CLOSED;
3028 ExecContext *unit_get_exec_context(Unit *u) {
3035 offset = UNIT_VTABLE(u)->exec_context_offset;
3039 return (ExecContext*) ((uint8_t*) u + offset);
3042 KillContext *unit_get_kill_context(Unit *u) {
3049 offset = UNIT_VTABLE(u)->kill_context_offset;
3053 return (KillContext*) ((uint8_t*) u + offset);
3056 CGroupContext *unit_get_cgroup_context(Unit *u) {
3062 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3066 return (CGroupContext*) ((uint8_t*) u + offset);
3069 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3075 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3079 return *(ExecRuntime**) ((uint8_t*) u + offset);
3082 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3083 if (u->manager->running_as == SYSTEMD_USER) {
3086 r = user_config_home(dir);
3092 if (mode == UNIT_PERSISTENT && !transient)
3093 *dir = strdup("/etc/systemd/system");
3095 *dir = strdup("/run/systemd/system");
3102 static int unit_drop_in_file(Unit *u,
3103 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3104 _cleanup_free_ char *dir = NULL;
3109 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3113 return drop_in_file(dir, u->id, 50, name, p, q);
3116 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3118 _cleanup_free_ char *dir = NULL;
3123 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3126 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3130 return write_drop_in(dir, u->id, 50, name, data);
3133 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3134 _cleanup_free_ char *p = NULL;
3142 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3145 va_start(ap, format);
3146 r = vasprintf(&p, format, ap);
3152 return unit_write_drop_in(u, mode, name, p);
3155 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3156 _cleanup_free_ char *ndata = NULL;
3162 if (!UNIT_VTABLE(u)->private_section)
3165 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3168 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3172 return unit_write_drop_in(u, mode, name, ndata);
3175 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3176 _cleanup_free_ char *p = NULL;
3184 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3187 va_start(ap, format);
3188 r = vasprintf(&p, format, ap);
3194 return unit_write_drop_in_private(u, mode, name, p);
3197 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3198 _cleanup_free_ char *p = NULL, *q = NULL;
3203 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3206 r = unit_drop_in_file(u, mode, name, &p, &q);
3211 r = errno == ENOENT ? 0 : -errno;
3219 int unit_make_transient(Unit *u) {
3224 u->load_state = UNIT_STUB;
3226 u->transient = true;
3228 free(u->fragment_path);
3229 u->fragment_path = NULL;
3231 if (u->manager->running_as == SYSTEMD_USER) {
3232 _cleanup_free_ char *c = NULL;
3234 r = user_config_home(&c);
3240 u->fragment_path = strjoin(c, "/", u->id, NULL);
3241 if (!u->fragment_path)
3246 u->fragment_path = strappend("/run/systemd/system/", u->id);
3247 if (!u->fragment_path)
3250 mkdir_p("/run/systemd/system", 0755);
3253 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3256 int unit_kill_context(
3262 bool main_pid_alien) {
3264 int sig, wait_for_exit = false, r;
3269 if (c->kill_mode == KILL_NONE)
3272 sig = sigkill ? SIGKILL : c->kill_signal;
3275 r = kill_and_sigcont(main_pid, sig);
3277 if (r < 0 && r != -ESRCH) {
3278 _cleanup_free_ char *comm = NULL;
3279 get_process_comm(main_pid, &comm);
3281 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3283 if (!main_pid_alien)
3284 wait_for_exit = true;
3286 if (c->send_sighup && !sigkill)
3287 kill(main_pid, SIGHUP);
3291 if (control_pid > 0) {
3292 r = kill_and_sigcont(control_pid, sig);
3294 if (r < 0 && r != -ESRCH) {
3295 _cleanup_free_ char *comm = NULL;
3296 get_process_comm(control_pid, &comm);
3298 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3300 wait_for_exit = true;
3302 if (c->send_sighup && !sigkill)
3303 kill(control_pid, SIGHUP);
3307 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3308 _cleanup_set_free_ Set *pid_set = NULL;
3310 /* Exclude the main/control pids from being killed via the cgroup */
3311 pid_set = unit_pid_set(main_pid, control_pid);
3315 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3317 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3318 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3321 /* FIXME: For now, we will not wait for the
3322 * cgroup members to die, simply because
3323 * cgroup notification is unreliable. It
3324 * doesn't work at all in containers, and
3325 * outside of containers it can be confused
3326 * easily by leaving directories in the
3329 /* wait_for_exit = true; */
3331 if (c->send_sighup && !sigkill) {
3334 pid_set = unit_pid_set(main_pid, control_pid);
3338 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3343 return wait_for_exit;
3346 int unit_require_mounts_for(Unit *u, const char *path) {
3347 char prefix[strlen(path) + 1], *p;
3353 /* Registers a unit for requiring a certain path and all its
3354 * prefixes. We keep a simple array of these paths in the
3355 * unit, since its usually short. However, we build a prefix
3356 * table for all possible prefixes so that new appearing mount
3357 * units can easily determine which units to make themselves a
3360 if (!path_is_absolute(path))
3367 path_kill_slashes(p);
3369 if (!path_is_safe(p)) {
3374 if (strv_contains(u->requires_mounts_for, p)) {
3379 r = strv_consume(&u->requires_mounts_for, p);
3383 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3386 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3390 if (!u->manager->units_requiring_mounts_for) {
3391 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3392 if (!u->manager->units_requiring_mounts_for)
3400 x = set_new(NULL, NULL);
3406 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3422 int unit_setup_exec_runtime(Unit *u) {
3428 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3431 /* Check if ther already is an ExecRuntime for this unit? */
3432 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3436 /* Try to get it from somebody else */
3437 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3439 *rt = unit_get_exec_runtime(other);
3441 exec_runtime_ref(*rt);
3446 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3449 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3450 [UNIT_ACTIVE] = "active",
3451 [UNIT_RELOADING] = "reloading",
3452 [UNIT_INACTIVE] = "inactive",
3453 [UNIT_FAILED] = "failed",
3454 [UNIT_ACTIVATING] = "activating",
3455 [UNIT_DEACTIVATING] = "deactivating"
3458 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3460 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3461 [UNIT_REQUIRES] = "Requires",
3462 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3463 [UNIT_REQUISITE] = "Requisite",
3464 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3465 [UNIT_WANTS] = "Wants",
3466 [UNIT_BINDS_TO] = "BindsTo",
3467 [UNIT_PART_OF] = "PartOf",
3468 [UNIT_REQUIRED_BY] = "RequiredBy",
3469 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3470 [UNIT_WANTED_BY] = "WantedBy",
3471 [UNIT_BOUND_BY] = "BoundBy",
3472 [UNIT_CONSISTS_OF] = "ConsistsOf",
3473 [UNIT_CONFLICTS] = "Conflicts",
3474 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3475 [UNIT_BEFORE] = "Before",
3476 [UNIT_AFTER] = "After",
3477 [UNIT_ON_FAILURE] = "OnFailure",
3478 [UNIT_TRIGGERS] = "Triggers",
3479 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3480 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3481 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3482 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3483 [UNIT_REFERENCES] = "References",
3484 [UNIT_REFERENCED_BY] = "ReferencedBy",
3487 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);