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>
32 #include "systemd/sd-id128.h"
33 #include "systemd/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"
47 #include "cgroup-attr.h"
50 #include "fileio-label.h"
51 #include "bus-errors.h"
53 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
54 [UNIT_SERVICE] = &service_vtable,
55 [UNIT_TIMER] = &timer_vtable,
56 [UNIT_SOCKET] = &socket_vtable,
57 [UNIT_TARGET] = &target_vtable,
58 [UNIT_DEVICE] = &device_vtable,
59 [UNIT_MOUNT] = &mount_vtable,
60 [UNIT_AUTOMOUNT] = &automount_vtable,
61 [UNIT_SNAPSHOT] = &snapshot_vtable,
62 [UNIT_SWAP] = &swap_vtable,
63 [UNIT_PATH] = &path_vtable
66 Unit *unit_new(Manager *m, size_t size) {
70 assert(size >= sizeof(Unit));
76 u->names = set_new(string_hash_func, string_compare_func);
83 u->type = _UNIT_TYPE_INVALID;
84 u->deserialized_job = _JOB_TYPE_INVALID;
85 u->default_dependencies = true;
86 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
91 bool unit_has_name(Unit *u, const char *name) {
95 return !!set_get(u->names, (char*) name);
98 int unit_add_name(Unit *u, const char *text) {
106 if (unit_name_is_template(text)) {
110 s = unit_name_replace_instance(text, u->instance);
117 if (!unit_name_is_valid(s, false)) {
122 assert_se((t = unit_name_to_type(s)) >= 0);
124 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
129 if ((r = unit_name_to_instance(s, &i)) < 0)
132 if (i && unit_vtable[t]->no_instances) {
137 /* Ensure that this unit is either instanced or not instanced,
139 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
144 if (unit_vtable[t]->no_alias &&
145 !set_isempty(u->names) &&
146 !set_get(u->names, s)) {
151 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
156 if ((r = set_put(u->names, s)) < 0) {
162 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
163 set_remove(u->names, s);
167 if (u->type == _UNIT_TYPE_INVALID) {
173 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
175 if (UNIT_VTABLE(u)->init)
176 UNIT_VTABLE(u)->init(u);
180 unit_add_to_dbus_queue(u);
190 int unit_choose_id(Unit *u, const char *name) {
191 char *s, *t = NULL, *i;
197 if (unit_name_is_template(name)) {
202 if (!(t = unit_name_replace_instance(name, u->instance)))
208 /* Selects one of the names of this unit as the id */
209 s = set_get(u->names, (char*) name);
215 if ((r = unit_name_to_instance(s, &i)) < 0)
223 unit_add_to_dbus_queue(u);
228 int unit_set_description(Unit *u, const char *description) {
233 if (!(s = strdup(description)))
236 free(u->description);
239 unit_add_to_dbus_queue(u);
243 bool unit_check_gc(Unit *u) {
246 if (u->load_state == UNIT_STUB)
249 if (UNIT_VTABLE(u)->no_gc)
261 if (unit_active_state(u) != UNIT_INACTIVE)
267 if (UNIT_VTABLE(u)->check_gc)
268 if (UNIT_VTABLE(u)->check_gc(u))
274 void unit_add_to_load_queue(Unit *u) {
276 assert(u->type != _UNIT_TYPE_INVALID);
278 if (u->load_state != UNIT_STUB || u->in_load_queue)
281 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
282 u->in_load_queue = true;
285 void unit_add_to_cleanup_queue(Unit *u) {
288 if (u->in_cleanup_queue)
291 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
292 u->in_cleanup_queue = true;
295 void unit_add_to_gc_queue(Unit *u) {
298 if (u->in_gc_queue || u->in_cleanup_queue)
301 if (unit_check_gc(u))
304 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
305 u->in_gc_queue = true;
307 u->manager->n_in_gc_queue ++;
309 if (u->manager->gc_queue_timestamp <= 0)
310 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
313 void unit_add_to_dbus_queue(Unit *u) {
315 assert(u->type != _UNIT_TYPE_INVALID);
317 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
320 /* Shortcut things if nobody cares */
321 if (!bus_has_subscriber(u->manager)) {
322 u->sent_dbus_new_signal = true;
326 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
327 u->in_dbus_queue = true;
330 static void bidi_set_free(Unit *u, Set *s) {
336 /* Frees the set and makes sure we are dropped from the
337 * inverse pointers */
339 SET_FOREACH(other, s, i) {
342 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
343 set_remove(other->dependencies[d], u);
345 unit_add_to_gc_queue(other);
351 void unit_free(Unit *u) {
358 bus_unit_send_removed_signal(u);
360 if (u->load_state != UNIT_STUB)
361 if (UNIT_VTABLE(u)->done)
362 UNIT_VTABLE(u)->done(u);
364 SET_FOREACH(t, u->names, i)
365 hashmap_remove_value(u->manager->units, t, u);
379 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
380 bidi_set_free(u, u->dependencies[d]);
382 if (u->requires_mounts_for) {
383 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
384 strv_free(u->requires_mounts_for);
387 if (u->type != _UNIT_TYPE_INVALID)
388 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
390 if (u->in_load_queue)
391 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
393 if (u->in_dbus_queue)
394 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
396 if (u->in_cleanup_queue)
397 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
399 if (u->in_gc_queue) {
400 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
401 u->manager->n_in_gc_queue--;
404 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
405 cgroup_attribute_free_list(u->cgroup_attributes);
407 free(u->description);
408 strv_free(u->documentation);
409 free(u->fragment_path);
410 free(u->source_path);
411 strv_free(u->dropin_paths);
414 set_free_free(u->names);
416 condition_free_list(u->conditions);
419 unit_ref_unset(u->refs);
424 UnitActiveState unit_active_state(Unit *u) {
427 if (u->load_state == UNIT_MERGED)
428 return unit_active_state(unit_follow_merge(u));
430 /* After a reload it might happen that a unit is not correctly
431 * loaded but still has a process around. That's why we won't
432 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
434 return UNIT_VTABLE(u)->active_state(u);
437 const char* unit_sub_state_to_string(Unit *u) {
440 return UNIT_VTABLE(u)->sub_state_to_string(u);
443 static void complete_move(Set **s, Set **other) {
451 set_move(*s, *other);
458 static void merge_names(Unit *u, Unit *other) {
465 complete_move(&u->names, &other->names);
467 set_free_free(other->names);
471 SET_FOREACH(t, u->names, i)
472 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
475 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
482 assert(d < _UNIT_DEPENDENCY_MAX);
484 /* Fix backwards pointers */
485 SET_FOREACH(back, other->dependencies[d], i) {
488 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
489 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
492 set_remove(back->dependencies[k], other);
494 assert(r == -ENOENT);
498 complete_move(&u->dependencies[d], &other->dependencies[d]);
500 set_free(other->dependencies[d]);
501 other->dependencies[d] = NULL;
504 int unit_merge(Unit *u, Unit *other) {
509 assert(u->manager == other->manager);
510 assert(u->type != _UNIT_TYPE_INVALID);
512 other = unit_follow_merge(other);
517 if (u->type != other->type)
520 if (!u->instance != !other->instance)
523 if (other->load_state != UNIT_STUB &&
524 other->load_state != UNIT_ERROR)
533 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
537 merge_names(u, other);
539 /* Redirect all references */
541 unit_ref_set(other->refs, u);
543 /* Merge dependencies */
544 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
545 merge_dependencies(u, other, d);
547 other->load_state = UNIT_MERGED;
548 other->merged_into = u;
550 /* If there is still some data attached to the other node, we
551 * don't need it anymore, and can free it. */
552 if (other->load_state != UNIT_STUB)
553 if (UNIT_VTABLE(other)->done)
554 UNIT_VTABLE(other)->done(other);
556 unit_add_to_dbus_queue(u);
557 unit_add_to_cleanup_queue(other);
562 int unit_merge_by_name(Unit *u, const char *name) {
570 if (unit_name_is_template(name)) {
574 if (!(s = unit_name_replace_instance(name, u->instance)))
580 if (!(other = manager_get_unit(u->manager, name)))
581 r = unit_add_name(u, name);
583 r = unit_merge(u, other);
589 Unit* unit_follow_merge(Unit *u) {
592 while (u->load_state == UNIT_MERGED)
593 assert_se(u = u->merged_into);
598 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
604 if (c->std_output != EXEC_OUTPUT_KMSG &&
605 c->std_output != EXEC_OUTPUT_SYSLOG &&
606 c->std_output != EXEC_OUTPUT_JOURNAL &&
607 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
608 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
609 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
610 c->std_error != EXEC_OUTPUT_KMSG &&
611 c->std_error != EXEC_OUTPUT_SYSLOG &&
612 c->std_error != EXEC_OUTPUT_JOURNAL &&
613 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
614 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
615 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
618 /* If syslog or kernel logging is requested, make sure our own
619 * logging daemon is run first. */
621 if (u->manager->running_as == SYSTEMD_SYSTEM) {
622 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
630 const char *unit_description(Unit *u) {
634 return u->description;
639 void unit_dump(Unit *u, FILE *f, const char *prefix) {
646 timestamp1[FORMAT_TIMESTAMP_MAX],
647 timestamp2[FORMAT_TIMESTAMP_MAX],
648 timestamp3[FORMAT_TIMESTAMP_MAX],
649 timestamp4[FORMAT_TIMESTAMP_MAX],
650 timespan[FORMAT_TIMESPAN_MAX];
654 assert(u->type >= 0);
658 p2 = strappend(prefix, "\t");
659 prefix2 = p2 ? p2 : prefix;
663 "%s\tDescription: %s\n"
665 "%s\tUnit Load State: %s\n"
666 "%s\tUnit Active State: %s\n"
667 "%s\tInactive Exit Timestamp: %s\n"
668 "%s\tActive Enter Timestamp: %s\n"
669 "%s\tActive Exit Timestamp: %s\n"
670 "%s\tInactive Enter Timestamp: %s\n"
671 "%s\tGC Check Good: %s\n"
672 "%s\tNeed Daemon Reload: %s\n",
674 prefix, unit_description(u),
675 prefix, strna(u->instance),
676 prefix, unit_load_state_to_string(u->load_state),
677 prefix, unit_active_state_to_string(unit_active_state(u)),
678 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
679 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
680 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
681 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
682 prefix, yes_no(unit_check_gc(u)),
683 prefix, yes_no(unit_need_daemon_reload(u)));
685 SET_FOREACH(t, u->names, i)
686 fprintf(f, "%s\tName: %s\n", prefix, t);
688 STRV_FOREACH(j, u->documentation)
689 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
691 if ((following = unit_following(u)))
692 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
694 if (u->fragment_path)
695 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
698 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
700 STRV_FOREACH(j, u->dropin_paths)
701 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
703 if (u->job_timeout > 0)
704 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
706 condition_dump_list(u->conditions, f, prefix);
708 if (dual_timestamp_is_set(&u->condition_timestamp))
710 "%s\tCondition Timestamp: %s\n"
711 "%s\tCondition Result: %s\n",
712 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
713 prefix, yes_no(u->condition_result));
715 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
718 SET_FOREACH(other, u->dependencies[d], i)
719 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
722 if (!strv_isempty(u->requires_mounts_for)) {
724 "%s\tRequiresMountsFor:", prefix);
726 STRV_FOREACH(j, u->requires_mounts_for)
727 fprintf(f, " %s", *j);
732 if (u->load_state == UNIT_LOADED) {
737 "%s\tStopWhenUnneeded: %s\n"
738 "%s\tRefuseManualStart: %s\n"
739 "%s\tRefuseManualStop: %s\n"
740 "%s\tDefaultDependencies: %s\n"
741 "%s\tOnFailureIsolate: %s\n"
742 "%s\tIgnoreOnIsolate: %s\n"
743 "%s\tIgnoreOnSnapshot: %s\n",
744 prefix, yes_no(u->stop_when_unneeded),
745 prefix, yes_no(u->refuse_manual_start),
746 prefix, yes_no(u->refuse_manual_stop),
747 prefix, yes_no(u->default_dependencies),
748 prefix, yes_no(u->on_failure_isolate),
749 prefix, yes_no(u->ignore_on_isolate),
750 prefix, yes_no(u->ignore_on_snapshot));
752 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
753 fprintf(f, "%s\tControlGroup: %s:%s\n",
754 prefix, b->controller, b->path);
756 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
757 _cleanup_free_ char *v = NULL;
759 if (a->semantics && a->semantics->map_write)
760 a->semantics->map_write(a->semantics, a->value, &v);
762 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
763 prefix, a->controller, a->name, v ? v : a->value);
766 if (UNIT_VTABLE(u)->dump)
767 UNIT_VTABLE(u)->dump(u, f, prefix2);
769 } else if (u->load_state == UNIT_MERGED)
771 "%s\tMerged into: %s\n",
772 prefix, u->merged_into->id);
773 else if (u->load_state == UNIT_ERROR)
774 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
778 job_dump(u->job, f, prefix2);
781 job_dump(u->nop_job, f, prefix2);
786 /* Common implementation for multiple backends */
787 int unit_load_fragment_and_dropin(Unit *u) {
792 /* Load a .service file */
793 if ((r = unit_load_fragment(u)) < 0)
796 if (u->load_state == UNIT_STUB)
799 /* Load drop-in directory data */
800 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
806 /* Common implementation for multiple backends */
807 int unit_load_fragment_and_dropin_optional(Unit *u) {
812 /* Same as unit_load_fragment_and_dropin(), but whether
813 * something can be loaded or not doesn't matter. */
815 /* Load a .service file */
816 if ((r = unit_load_fragment(u)) < 0)
819 if (u->load_state == UNIT_STUB)
820 u->load_state = UNIT_LOADED;
822 /* Load drop-in directory data */
823 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
829 int unit_add_default_target_dependency(Unit *u, Unit *target) {
833 if (target->type != UNIT_TARGET)
836 /* Only add the dependency if both units are loaded, so that
837 * that loop check below is reliable */
838 if (u->load_state != UNIT_LOADED ||
839 target->load_state != UNIT_LOADED)
842 /* If either side wants no automatic dependencies, then let's
844 if (!u->default_dependencies ||
845 !target->default_dependencies)
848 /* Don't create loops */
849 if (set_get(target->dependencies[UNIT_BEFORE], u))
852 return unit_add_dependency(target, UNIT_AFTER, u, true);
855 static int unit_add_default_dependencies(Unit *u) {
856 static const UnitDependency deps[] = {
858 UNIT_REQUIRED_BY_OVERRIDABLE,
870 for (k = 0; k < ELEMENTSOF(deps); k++)
871 SET_FOREACH(target, u->dependencies[deps[k]], i)
872 if ((r = unit_add_default_target_dependency(u, target)) < 0)
878 int unit_load(Unit *u) {
883 if (u->in_load_queue) {
884 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
885 u->in_load_queue = false;
888 if (u->type == _UNIT_TYPE_INVALID)
891 if (u->load_state != UNIT_STUB)
894 if (UNIT_VTABLE(u)->load)
895 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
898 if (u->load_state == UNIT_STUB) {
903 if (u->load_state == UNIT_LOADED &&
904 u->default_dependencies)
905 if ((r = unit_add_default_dependencies(u)) < 0)
908 if (u->load_state == UNIT_LOADED) {
909 r = unit_add_mount_links(u);
914 if (u->on_failure_isolate &&
915 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
917 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
924 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
926 unit_add_to_dbus_queue(unit_follow_merge(u));
927 unit_add_to_gc_queue(u);
932 u->load_state = UNIT_ERROR;
934 unit_add_to_dbus_queue(u);
935 unit_add_to_gc_queue(u);
937 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
942 bool unit_condition_test(Unit *u) {
945 dual_timestamp_get(&u->condition_timestamp);
946 u->condition_result = condition_test_list(u->conditions);
948 return u->condition_result;
951 static const char* unit_get_status_message_format(Unit *u, JobType t) {
952 const UnitStatusMessageFormats *format_table;
956 assert(t < _JOB_TYPE_MAX);
958 if (t != JOB_START && t != JOB_STOP)
961 format_table = &UNIT_VTABLE(u)->status_message_formats;
965 return format_table->starting_stopping[t == JOB_STOP];
968 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
973 assert(t < _JOB_TYPE_MAX);
975 format = unit_get_status_message_format(u, t);
979 /* Return generic strings */
981 return "Starting %s.";
982 else if (t == JOB_STOP)
983 return "Stopping %s.";
984 else if (t == JOB_RELOAD)
985 return "Reloading %s.";
990 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
995 /* We only print status messages for selected units on
996 * selected operations. */
998 format = unit_get_status_message_format(u, t);
1002 unit_status_printf(u, "", format);
1005 #pragma GCC diagnostic push
1006 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1007 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1014 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1017 if (log_on_console())
1020 /* We log status messages for all units and all operations. */
1022 format = unit_get_status_message_format_try_harder(u, t);
1026 snprintf(buf, sizeof(buf), format, unit_description(u));
1029 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1030 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1031 SD_MESSAGE_UNIT_RELOADING;
1033 log_struct_unit(LOG_INFO,
1039 #pragma GCC diagnostic pop
1042 * -EBADR: This unit type does not support starting.
1043 * -EALREADY: Unit is already started.
1044 * -EAGAIN: An operation is already in progress. Retry later.
1045 * -ECANCELED: Too many requests for now.
1047 int unit_start(Unit *u) {
1048 UnitActiveState state;
1053 if (u->load_state != UNIT_LOADED)
1056 /* If this is already started, then this will succeed. Note
1057 * that this will even succeed if this unit is not startable
1058 * by the user. This is relied on to detect when we need to
1059 * wait for units and when waiting is finished. */
1060 state = unit_active_state(u);
1061 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1064 /* If the conditions failed, don't do anything at all. If we
1065 * already are activating this call might still be useful to
1066 * speed up activation in case there is some hold-off time,
1067 * but we don't want to recheck the condition in that case. */
1068 if (state != UNIT_ACTIVATING &&
1069 !unit_condition_test(u)) {
1070 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1074 /* Forward to the main object, if we aren't it. */
1075 if ((following = unit_following(u))) {
1076 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1077 return unit_start(following);
1080 unit_status_log_starting_stopping_reloading(u, JOB_START);
1081 unit_status_print_starting_stopping(u, JOB_START);
1083 /* If it is stopped, but we cannot start it, then fail */
1084 if (!UNIT_VTABLE(u)->start)
1087 /* We don't suppress calls to ->start() here when we are
1088 * already starting, to allow this request to be used as a
1089 * "hurry up" call, for example when the unit is in some "auto
1090 * restart" state where it waits for a holdoff timer to elapse
1091 * before it will start again. */
1093 unit_add_to_dbus_queue(u);
1095 return UNIT_VTABLE(u)->start(u);
1098 bool unit_can_start(Unit *u) {
1101 return !!UNIT_VTABLE(u)->start;
1104 bool unit_can_isolate(Unit *u) {
1107 return unit_can_start(u) &&
1112 * -EBADR: This unit type does not support stopping.
1113 * -EALREADY: Unit is already stopped.
1114 * -EAGAIN: An operation is already in progress. Retry later.
1116 int unit_stop(Unit *u) {
1117 UnitActiveState state;
1122 state = unit_active_state(u);
1123 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1126 if ((following = unit_following(u))) {
1127 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1128 return unit_stop(following);
1131 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1132 unit_status_print_starting_stopping(u, JOB_STOP);
1134 if (!UNIT_VTABLE(u)->stop)
1137 unit_add_to_dbus_queue(u);
1139 return UNIT_VTABLE(u)->stop(u);
1143 * -EBADR: This unit type does not support reloading.
1144 * -ENOEXEC: Unit is not started.
1145 * -EAGAIN: An operation is already in progress. Retry later.
1147 int unit_reload(Unit *u) {
1148 UnitActiveState state;
1153 if (u->load_state != UNIT_LOADED)
1156 if (!unit_can_reload(u))
1159 state = unit_active_state(u);
1160 if (state == UNIT_RELOADING)
1163 if (state != UNIT_ACTIVE)
1166 if ((following = unit_following(u))) {
1167 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1168 return unit_reload(following);
1171 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1173 unit_add_to_dbus_queue(u);
1174 return UNIT_VTABLE(u)->reload(u);
1177 bool unit_can_reload(Unit *u) {
1180 if (!UNIT_VTABLE(u)->reload)
1183 if (!UNIT_VTABLE(u)->can_reload)
1186 return UNIT_VTABLE(u)->can_reload(u);
1189 static void unit_check_unneeded(Unit *u) {
1195 /* If this service shall be shut down when unneeded then do
1198 if (!u->stop_when_unneeded)
1201 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1204 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1205 if (unit_pending_active(other))
1208 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1209 if (unit_pending_active(other))
1212 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1213 if (unit_pending_active(other))
1216 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1217 if (unit_pending_active(other))
1220 log_info("Service %s is not needed anymore. Stopping.", u->id);
1222 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1223 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1226 static void retroactively_start_dependencies(Unit *u) {
1231 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1233 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1234 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1235 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1236 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1238 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1239 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1240 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1241 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1243 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1244 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1245 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1246 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1248 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1249 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1250 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1251 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1253 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1254 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1255 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1257 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1258 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1259 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1262 static void retroactively_stop_dependencies(Unit *u) {
1267 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1269 /* Pull down units which are bound to us recursively if enabled */
1270 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1271 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1272 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1275 static void check_unneeded_dependencies(Unit *u) {
1280 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1282 /* Garbage collect services that might not be needed anymore, if enabled */
1283 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1284 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1285 unit_check_unneeded(other);
1286 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1287 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1288 unit_check_unneeded(other);
1289 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1290 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1291 unit_check_unneeded(other);
1292 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1293 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1294 unit_check_unneeded(other);
1295 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1296 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1297 unit_check_unneeded(other);
1298 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1299 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1300 unit_check_unneeded(other);
1303 void unit_trigger_on_failure(Unit *u) {
1309 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1312 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1314 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1317 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1318 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1322 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1327 assert(os < _UNIT_ACTIVE_STATE_MAX);
1328 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1330 /* Note that this is called for all low-level state changes,
1331 * even if they might map to the same high-level
1332 * UnitActiveState! That means that ns == os is OK an expected
1333 * behavior here. For example: if a mount point is remounted
1334 * this function will be called too! */
1338 if (m->n_reloading <= 0) {
1341 dual_timestamp_get(&ts);
1343 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1344 u->inactive_exit_timestamp = ts;
1345 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1346 u->inactive_enter_timestamp = ts;
1348 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1349 u->active_enter_timestamp = ts;
1350 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1351 u->active_exit_timestamp = ts;
1353 timer_unit_notify(u, ns);
1354 path_unit_notify(u, ns);
1357 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1358 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1360 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1361 ExecContext *ec = unit_get_exec_context(u);
1362 if (ec && exec_context_may_touch_console(ec)) {
1363 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1373 if (u->job->state == JOB_WAITING)
1375 /* So we reached a different state for this
1376 * job. Let's see if we can run it now if it
1377 * failed previously due to EAGAIN. */
1378 job_add_to_run_queue(u->job);
1380 /* Let's check whether this state change constitutes a
1381 * finished job, or maybe contradicts a running job and
1382 * hence needs to invalidate jobs. */
1384 switch (u->job->type) {
1387 case JOB_VERIFY_ACTIVE:
1389 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1390 job_finish_and_invalidate(u->job, JOB_DONE, true);
1391 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1394 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1395 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1401 case JOB_RELOAD_OR_START:
1403 if (u->job->state == JOB_RUNNING) {
1404 if (ns == UNIT_ACTIVE)
1405 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1406 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1409 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1410 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1418 case JOB_TRY_RESTART:
1420 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1421 job_finish_and_invalidate(u->job, JOB_DONE, true);
1422 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1424 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1430 assert_not_reached("Job type unknown");
1436 if (m->n_reloading <= 0) {
1438 /* If this state change happened without being
1439 * requested by a job, then let's retroactively start
1440 * or stop dependencies. We skip that step when
1441 * deserializing, since we don't want to create any
1442 * additional jobs just because something is already
1446 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1447 retroactively_start_dependencies(u);
1448 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1449 retroactively_stop_dependencies(u);
1452 /* stop unneeded units regardless if going down was expected or not */
1453 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1454 check_unneeded_dependencies(u);
1456 if (ns != os && ns == UNIT_FAILED) {
1457 log_struct_unit(LOG_NOTICE,
1459 "MESSAGE=Unit %s entered failed state", u->id,
1461 unit_trigger_on_failure(u);
1465 /* Some names are special */
1466 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1468 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1469 /* The bus just might have become available,
1470 * hence try to connect to it, if we aren't
1474 if (u->type == UNIT_SERVICE &&
1475 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1476 m->n_reloading <= 0) {
1477 /* Write audit record if we have just finished starting up */
1478 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1482 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1483 manager_send_unit_plymouth(m, u);
1487 /* We don't care about D-Bus here, since we'll get an
1488 * asynchronous notification for it anyway. */
1490 if (u->type == UNIT_SERVICE &&
1491 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1492 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1493 m->n_reloading <= 0) {
1495 /* Hmm, if there was no start record written
1496 * write it now, so that we always have a nice
1499 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1501 if (ns == UNIT_INACTIVE)
1502 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1504 /* Write audit record if we have just finished shutting down */
1505 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1507 u->in_audit = false;
1511 manager_recheck_journal(m);
1513 /* Maybe we finished startup and are now ready for being
1514 * stopped because unneeded? */
1515 if (u->manager->n_reloading <= 0)
1516 unit_check_unneeded(u);
1518 unit_add_to_dbus_queue(u);
1519 unit_add_to_gc_queue(u);
1522 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1523 struct epoll_event ev;
1528 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1534 if (epoll_ctl(u->manager->epoll_fd,
1535 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1547 void unit_unwatch_fd(Unit *u, Watch *w) {
1551 if (w->type == WATCH_INVALID)
1554 assert(w->type == WATCH_FD);
1555 assert(w->data.unit == u);
1556 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1559 w->type = WATCH_INVALID;
1560 w->data.unit = NULL;
1563 int unit_watch_pid(Unit *u, pid_t pid) {
1567 /* Watch a specific PID. We only support one unit watching
1568 * each PID for now. */
1570 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1573 void unit_unwatch_pid(Unit *u, pid_t pid) {
1577 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1580 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1581 struct itimerspec its;
1587 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1589 /* This will try to reuse the old timer if there is one */
1591 if (w->type == WATCH_UNIT_TIMER) {
1592 assert(w->data.unit == u);
1597 } else if (w->type == WATCH_INVALID) {
1600 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1604 assert_not_reached("Invalid watch type");
1609 /* Set absolute time in the past, but not 0, since we
1610 * don't want to disarm the timer */
1611 its.it_value.tv_sec = 0;
1612 its.it_value.tv_nsec = 1;
1614 flags = TFD_TIMER_ABSTIME;
1616 timespec_store(&its.it_value, usec);
1617 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1620 /* This will also flush the elapse counter */
1621 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1624 if (w->type == WATCH_INVALID) {
1625 struct epoll_event ev;
1629 ev.events = EPOLLIN;
1631 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1635 w->type = WATCH_UNIT_TIMER;
1643 close_nointr_nofail(fd);
1648 void unit_unwatch_timer(Unit *u, Watch *w) {
1652 if (w->type == WATCH_INVALID)
1655 assert(w->type == WATCH_UNIT_TIMER);
1656 assert(w->data.unit == u);
1659 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1660 close_nointr_nofail(w->fd);
1663 w->type = WATCH_INVALID;
1664 w->data.unit = NULL;
1667 bool unit_job_is_applicable(Unit *u, JobType j) {
1669 assert(j >= 0 && j < _JOB_TYPE_MAX);
1673 case JOB_VERIFY_ACTIVE:
1680 case JOB_TRY_RESTART:
1681 return unit_can_start(u);
1684 return unit_can_reload(u);
1686 case JOB_RELOAD_OR_START:
1687 return unit_can_reload(u) && unit_can_start(u);
1690 assert_not_reached("Invalid job type");
1694 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1696 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1697 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1698 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1699 [UNIT_WANTS] = UNIT_WANTED_BY,
1700 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1701 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1702 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1703 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1704 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1705 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1706 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1707 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1708 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1709 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1710 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1711 [UNIT_BEFORE] = UNIT_AFTER,
1712 [UNIT_AFTER] = UNIT_BEFORE,
1713 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1714 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1715 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1716 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1717 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1718 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1719 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1721 int r, q = 0, v = 0, w = 0;
1724 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1727 u = unit_follow_merge(u);
1728 other = unit_follow_merge(other);
1730 /* We won't allow dependencies on ourselves. We will not
1731 * consider them an error however. */
1735 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1738 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1739 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1743 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1744 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1747 if ((q = set_put(u->dependencies[d], other)) < 0)
1750 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1751 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1756 if (add_reference) {
1757 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1762 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1766 unit_add_to_dbus_queue(u);
1771 set_remove(u->dependencies[d], other);
1774 set_remove(other->dependencies[inverse_table[d]], u);
1777 set_remove(u->dependencies[UNIT_REFERENCES], other);
1782 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1787 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1790 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1796 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1800 assert(name || path);
1804 name = path_get_file_name(path);
1806 if (!unit_name_is_template(name)) {
1812 s = unit_name_replace_instance(name, u->instance);
1816 i = unit_name_to_prefix(u->id);
1820 s = unit_name_replace_instance(name, i);
1831 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1834 _cleanup_free_ char *s = NULL;
1837 assert(name || path);
1839 name = resolve_template(u, name, path, &s);
1843 r = manager_load_unit(u->manager, name, path, NULL, &other);
1847 return unit_add_dependency(u, d, other, add_reference);
1850 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1856 assert(name || path);
1858 if (!(name = resolve_template(u, name, path, &s)))
1861 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1864 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1871 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1877 assert(name || path);
1879 if (!(name = resolve_template(u, name, path, &s)))
1882 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1885 r = unit_add_dependency(other, d, u, add_reference);
1892 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1898 assert(name || path);
1900 if (!(name = resolve_template(u, name, path, &s)))
1903 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1906 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1914 int set_unit_path(const char *p) {
1915 _cleanup_free_ char *c = NULL;
1917 /* This is mostly for debug purposes */
1918 c = path_make_absolute_cwd(p);
1919 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1925 char *unit_dbus_path(Unit *u) {
1931 return unit_dbus_path_from_name(u->id);
1934 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1942 if (!b->controller) {
1943 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1950 /* Ensure this hasn't been added yet */
1953 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1956 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1957 LIST_PREPEND(CGroupBonding, by_path, l, b);
1959 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1961 LIST_REMOVE(CGroupBonding, by_path, l, b);
1966 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1972 char *unit_default_cgroup_path(Unit *u) {
1976 _cleanup_free_ char *t = NULL;
1978 t = unit_name_template(u->id);
1982 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1984 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1987 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1988 char *controller = NULL, *path = NULL;
1989 CGroupBonding *b = NULL;
1996 r = cg_split_spec(name, &controller, &path);
2001 path = unit_default_cgroup_path(u);
2006 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2010 if (!path || !controller) {
2016 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2018 if (streq(path, b->path)) {
2027 if (overwrite && !b->essential) {
2034 b->realized = false;
2047 b = new0(CGroupBonding, 1);
2053 b->controller = controller;
2056 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2058 r = unit_add_cgroup(u, b);
2075 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2076 CGroupBonding *b = NULL;
2082 controller = SYSTEMD_CGROUP_CONTROLLER;
2084 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2087 b = new0(CGroupBonding, 1);
2091 b->controller = strdup(controller);
2095 b->path = unit_default_cgroup_path(u);
2100 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2102 r = unit_add_cgroup(u, b);
2110 free(b->controller);
2116 int unit_add_default_cgroups(Unit *u) {
2123 /* Adds in the default cgroups, if they weren't specified
2126 if (!u->manager->cgroup_hierarchy)
2129 r = unit_add_one_default_cgroup(u, NULL);
2133 STRV_FOREACH(c, u->manager->default_controllers)
2134 unit_add_one_default_cgroup(u, *c);
2136 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2137 unit_add_one_default_cgroup(u, a->controller);
2142 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2145 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2148 int unit_add_cgroup_attribute(
2150 const CGroupSemantics *semantics,
2151 const char *controller,
2154 CGroupAttribute **ret) {
2156 _cleanup_free_ char *c = NULL;
2164 /* Semantics always take precedence */
2165 if (semantics->name)
2166 name = semantics->name;
2168 if (semantics->controller)
2169 controller = semantics->controller;
2176 r = cg_controller_from_attr(name, &c);
2183 if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2186 if (!filename_is_safe(name))
2189 if (!filename_is_safe(controller))
2192 /* Check if this attribute already exists. Note that we will
2193 * explicitly check for the value here too, as there are
2194 * attributes which accept multiple values. */
2195 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2197 if (streq(value, a->value)) {
2198 /* Exactly the same value is always OK, let's ignore this */
2205 if (semantics && !semantics->multiple) {
2208 /* If this is a single-item entry, we can
2209 * simply patch the existing attribute */
2224 a = new0(CGroupAttribute, 1);
2232 a->controller = strdup(controller);
2234 a->name = strdup(name);
2235 a->value = strdup(value);
2237 if (!a->controller || !a->name || !a->value) {
2238 free(a->controller);
2245 a->semantics = semantics;
2248 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2256 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2264 if (!(t = unit_name_change_suffix(u->id, type)))
2267 assert(!unit_has_name(u, t));
2269 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2272 assert(r < 0 || *_found != u);
2277 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2285 if (!(t = unit_name_change_suffix(u->id, type)))
2288 assert(!unit_has_name(u, t));
2290 found = manager_get_unit(u->manager, t);
2300 int unit_watch_bus_name(Unit *u, const char *name) {
2304 /* Watch a specific name on the bus. We only support one unit
2305 * watching each name for now. */
2307 return hashmap_put(u->manager->watch_bus, name, u);
2310 void unit_unwatch_bus_name(Unit *u, const char *name) {
2314 hashmap_remove_value(u->manager->watch_bus, name, u);
2317 bool unit_can_serialize(Unit *u) {
2320 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2323 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2330 if (!unit_can_serialize(u))
2333 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2337 if (serialize_jobs) {
2339 fprintf(f, "job\n");
2340 job_serialize(u->job, f, fds);
2344 fprintf(f, "job\n");
2345 job_serialize(u->nop_job, f, fds);
2349 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2350 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2351 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2352 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2353 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2355 if (dual_timestamp_is_set(&u->condition_timestamp))
2356 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2363 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2374 va_start(ap, format);
2375 vfprintf(f, format, ap);
2381 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2387 fprintf(f, "%s=%s\n", key, value);
2390 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2397 if (!unit_can_serialize(u))
2401 char line[LINE_MAX], *l, *v;
2404 if (!fgets(line, sizeof(line), f)) {
2417 k = strcspn(l, "=");
2425 if (streq(l, "job")) {
2427 /* new-style serialized job */
2428 Job *j = job_new_raw(u);
2432 r = job_deserialize(j, f, fds);
2438 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2444 r = job_install_deserialized(j);
2446 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2451 if (j->state == JOB_RUNNING)
2452 u->manager->n_running_jobs++;
2455 JobType type = job_type_from_string(v);
2457 log_debug("Failed to parse job type value %s", v);
2459 u->deserialized_job = type;
2462 } else if (streq(l, "inactive-exit-timestamp")) {
2463 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2465 } else if (streq(l, "active-enter-timestamp")) {
2466 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2468 } else if (streq(l, "active-exit-timestamp")) {
2469 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2471 } else if (streq(l, "inactive-enter-timestamp")) {
2472 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2474 } else if (streq(l, "condition-timestamp")) {
2475 dual_timestamp_deserialize(v, &u->condition_timestamp);
2477 } else if (streq(l, "condition-result")) {
2480 if ((b = parse_boolean(v)) < 0)
2481 log_debug("Failed to parse condition result value %s", v);
2483 u->condition_result = b;
2488 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2493 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2503 /* Adds in links to the device node that this unit is based on */
2505 if (!is_device_path(what))
2508 e = unit_name_from_path(what, ".device");
2512 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2517 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2522 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2530 int unit_coldplug(Unit *u) {
2535 if (UNIT_VTABLE(u)->coldplug)
2536 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2540 r = job_coldplug(u->job);
2543 } else if (u->deserialized_job >= 0) {
2545 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2549 u->deserialized_job = _JOB_TYPE_INVALID;
2555 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2556 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2559 bool unit_need_daemon_reload(Unit *u) {
2560 _cleanup_strv_free_ char **t = NULL;
2563 unsigned loaded_cnt, current_cnt;
2567 if (u->fragment_path) {
2569 if (stat(u->fragment_path, &st) < 0)
2570 /* What, cannot access this anymore? */
2573 if (u->fragment_mtime > 0 &&
2574 timespec_load(&st.st_mtim) != u->fragment_mtime)
2578 if (u->source_path) {
2580 if (stat(u->source_path, &st) < 0)
2583 if (u->source_mtime > 0 &&
2584 timespec_load(&st.st_mtim) != u->source_mtime)
2588 t = unit_find_dropin_paths(u);
2589 loaded_cnt = strv_length(t);
2590 current_cnt = strv_length(u->dropin_paths);
2592 if (loaded_cnt == current_cnt) {
2593 if (loaded_cnt == 0)
2596 if (strv_overlap(u->dropin_paths, t)) {
2597 STRV_FOREACH(path, u->dropin_paths) {
2599 if (stat(*path, &st) < 0)
2602 if (u->dropin_mtime > 0 &&
2603 timespec_load(&st.st_mtim) > u->dropin_mtime)
2614 void unit_reset_failed(Unit *u) {
2617 if (UNIT_VTABLE(u)->reset_failed)
2618 UNIT_VTABLE(u)->reset_failed(u);
2621 Unit *unit_following(Unit *u) {
2624 if (UNIT_VTABLE(u)->following)
2625 return UNIT_VTABLE(u)->following(u);
2630 bool unit_pending_inactive(Unit *u) {
2633 /* Returns true if the unit is inactive or going down */
2635 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2638 if (u->job && u->job->type == JOB_STOP)
2644 bool unit_pending_active(Unit *u) {
2647 /* Returns true if the unit is active or going up */
2649 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2653 (u->job->type == JOB_START ||
2654 u->job->type == JOB_RELOAD_OR_START ||
2655 u->job->type == JOB_RESTART))
2661 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2663 assert(w >= 0 && w < _KILL_WHO_MAX);
2665 assert(signo < _NSIG);
2667 if (!UNIT_VTABLE(u)->kill)
2670 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2673 int unit_kill_common(
2683 if (who == KILL_MAIN && main_pid <= 0) {
2685 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2687 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2691 if (who == KILL_CONTROL && control_pid <= 0) {
2692 if (control_pid < 0)
2693 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2695 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2699 if (who == KILL_CONTROL || who == KILL_ALL)
2700 if (control_pid > 0)
2701 if (kill(control_pid, signo) < 0)
2704 if (who == KILL_MAIN || who == KILL_ALL)
2706 if (kill(main_pid, signo) < 0)
2709 if (who == KILL_ALL) {
2710 _cleanup_set_free_ Set *pid_set = NULL;
2713 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2717 /* Exclude the control/main pid from being killed via the cgroup */
2718 if (control_pid > 0) {
2719 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2725 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2730 q = cgroup_bonding_kill_list(u->cgroup_bondings, signo, false, false, pid_set, NULL);
2731 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2738 int unit_following_set(Unit *u, Set **s) {
2742 if (UNIT_VTABLE(u)->following_set)
2743 return UNIT_VTABLE(u)->following_set(u, s);
2749 UnitFileState unit_get_unit_file_state(Unit *u) {
2752 if (u->unit_file_state < 0 && u->fragment_path)
2753 u->unit_file_state = unit_file_get_state(
2754 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2755 NULL, path_get_file_name(u->fragment_path));
2757 return u->unit_file_state;
2760 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2765 unit_ref_unset(ref);
2768 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2772 void unit_ref_unset(UnitRef *ref) {
2778 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2782 int unit_add_one_mount_link(Unit *u, Mount *m) {
2788 if (u->load_state != UNIT_LOADED ||
2789 UNIT(m)->load_state != UNIT_LOADED)
2792 STRV_FOREACH(i, u->requires_mounts_for) {
2797 if (!path_startswith(*i, m->where))
2800 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2806 int unit_add_mount_links(Unit *u) {
2812 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2813 r = unit_add_one_mount_link(u, MOUNT(other));
2821 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2828 /* This only copies in the ones that need memory */
2830 for (i = 0; i < RLIMIT_NLIMITS; i++)
2831 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2832 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2837 if (u->manager->running_as == SYSTEMD_USER &&
2838 !c->working_directory) {
2840 r = get_home_dir(&c->working_directory);
2848 ExecContext *unit_get_exec_context(Unit *u) {
2852 offset = UNIT_VTABLE(u)->exec_context_offset;
2856 return (ExecContext*) ((uint8_t*) u + offset);
2859 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2868 if (u->manager->running_as == SYSTEMD_USER && runtime)
2871 if (!filename_is_safe(name))
2874 if (u->manager->running_as == SYSTEMD_USER) {
2875 _cleanup_free_ char *c = NULL;
2877 r = user_config_home(&c);
2883 p = strjoin(c, "/", u->id, ".d", NULL);
2885 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2887 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2891 q = strjoin(p, "/50-", name, ".conf", NULL);
2902 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2903 _cleanup_free_ char *p = NULL, *q = NULL;
2908 r = drop_in_file(u, runtime, name, &p, &q);
2913 return write_string_file_atomic_label(q, data);
2916 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2917 _cleanup_free_ char *p = NULL, *q = NULL;
2922 r = drop_in_file(u, runtime, name, &p, &q);
2932 int unit_kill_context(
2938 bool main_pid_alien) {
2940 int sig, wait_for_exit = 0, r;
2945 if (c->kill_mode == KILL_NONE)
2948 sig = sigkill ? SIGKILL : c->kill_signal;
2951 r = kill_and_sigcont(main_pid, sig);
2953 if (r < 0 && r != -ESRCH) {
2954 _cleanup_free_ char *comm = NULL;
2955 get_process_comm(main_pid, &comm);
2957 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2958 (long) main_pid, strna(comm), strerror(-r));
2960 wait_for_exit = !main_pid_alien;
2963 if (control_pid > 0) {
2964 r = kill_and_sigcont(control_pid, sig);
2966 if (r < 0 && r != -ESRCH) {
2967 _cleanup_free_ char *comm = NULL;
2968 get_process_comm(control_pid, &comm);
2970 log_warning_unit(u->id,
2971 "Failed to kill control process %li (%s): %s",
2972 (long) control_pid, strna(comm), strerror(-r));
2974 wait_for_exit = true;
2977 if (c->kill_mode == KILL_CONTROL_GROUP) {
2978 _cleanup_set_free_ Set *pid_set = NULL;
2980 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2984 /* Exclude the main/control pids from being killed via the cgroup */
2986 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2991 if (control_pid > 0) {
2992 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2997 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2999 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3000 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3002 wait_for_exit = true;
3005 return wait_for_exit;
3008 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3009 [UNIT_ACTIVE] = "active",
3010 [UNIT_RELOADING] = "reloading",
3011 [UNIT_INACTIVE] = "inactive",
3012 [UNIT_FAILED] = "failed",
3013 [UNIT_ACTIVATING] = "activating",
3014 [UNIT_DEACTIVATING] = "deactivating"
3017 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3019 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3020 [UNIT_REQUIRES] = "Requires",
3021 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3022 [UNIT_REQUISITE] = "Requisite",
3023 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3024 [UNIT_WANTS] = "Wants",
3025 [UNIT_BINDS_TO] = "BindsTo",
3026 [UNIT_PART_OF] = "PartOf",
3027 [UNIT_REQUIRED_BY] = "RequiredBy",
3028 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3029 [UNIT_WANTED_BY] = "WantedBy",
3030 [UNIT_BOUND_BY] = "BoundBy",
3031 [UNIT_CONSISTS_OF] = "ConsistsOf",
3032 [UNIT_CONFLICTS] = "Conflicts",
3033 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3034 [UNIT_BEFORE] = "Before",
3035 [UNIT_AFTER] = "After",
3036 [UNIT_ON_FAILURE] = "OnFailure",
3037 [UNIT_TRIGGERS] = "Triggers",
3038 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3039 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3040 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3041 [UNIT_REFERENCES] = "References",
3042 [UNIT_REFERENCED_BY] = "ReferencedBy",
3045 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);