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);
413 set_free_free(u->names);
415 condition_free_list(u->conditions);
418 unit_ref_unset(u->refs);
423 UnitActiveState unit_active_state(Unit *u) {
426 if (u->load_state == UNIT_MERGED)
427 return unit_active_state(unit_follow_merge(u));
429 /* After a reload it might happen that a unit is not correctly
430 * loaded but still has a process around. That's why we won't
431 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
433 return UNIT_VTABLE(u)->active_state(u);
436 const char* unit_sub_state_to_string(Unit *u) {
439 return UNIT_VTABLE(u)->sub_state_to_string(u);
442 static void complete_move(Set **s, Set **other) {
450 set_move(*s, *other);
457 static void merge_names(Unit *u, Unit *other) {
464 complete_move(&u->names, &other->names);
466 set_free_free(other->names);
470 SET_FOREACH(t, u->names, i)
471 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
474 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
481 assert(d < _UNIT_DEPENDENCY_MAX);
483 /* Fix backwards pointers */
484 SET_FOREACH(back, other->dependencies[d], i) {
487 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
488 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
491 set_remove(back->dependencies[k], other);
493 assert(r == -ENOENT);
497 complete_move(&u->dependencies[d], &other->dependencies[d]);
499 set_free(other->dependencies[d]);
500 other->dependencies[d] = NULL;
503 int unit_merge(Unit *u, Unit *other) {
508 assert(u->manager == other->manager);
509 assert(u->type != _UNIT_TYPE_INVALID);
511 other = unit_follow_merge(other);
516 if (u->type != other->type)
519 if (!u->instance != !other->instance)
522 if (other->load_state != UNIT_STUB &&
523 other->load_state != UNIT_ERROR)
532 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
536 merge_names(u, other);
538 /* Redirect all references */
540 unit_ref_set(other->refs, u);
542 /* Merge dependencies */
543 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
544 merge_dependencies(u, other, d);
546 other->load_state = UNIT_MERGED;
547 other->merged_into = u;
549 /* If there is still some data attached to the other node, we
550 * don't need it anymore, and can free it. */
551 if (other->load_state != UNIT_STUB)
552 if (UNIT_VTABLE(other)->done)
553 UNIT_VTABLE(other)->done(other);
555 unit_add_to_dbus_queue(u);
556 unit_add_to_cleanup_queue(other);
561 int unit_merge_by_name(Unit *u, const char *name) {
569 if (unit_name_is_template(name)) {
573 if (!(s = unit_name_replace_instance(name, u->instance)))
579 if (!(other = manager_get_unit(u->manager, name)))
580 r = unit_add_name(u, name);
582 r = unit_merge(u, other);
588 Unit* unit_follow_merge(Unit *u) {
591 while (u->load_state == UNIT_MERGED)
592 assert_se(u = u->merged_into);
597 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
603 if (c->std_output != EXEC_OUTPUT_KMSG &&
604 c->std_output != EXEC_OUTPUT_SYSLOG &&
605 c->std_output != EXEC_OUTPUT_JOURNAL &&
606 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
607 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
608 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
609 c->std_error != EXEC_OUTPUT_KMSG &&
610 c->std_error != EXEC_OUTPUT_SYSLOG &&
611 c->std_error != EXEC_OUTPUT_JOURNAL &&
612 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
613 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
614 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
617 /* If syslog or kernel logging is requested, make sure our own
618 * logging daemon is run first. */
620 if (u->manager->running_as == SYSTEMD_SYSTEM) {
621 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
629 const char *unit_description(Unit *u) {
633 return u->description;
638 void unit_dump(Unit *u, FILE *f, const char *prefix) {
645 timestamp1[FORMAT_TIMESTAMP_MAX],
646 timestamp2[FORMAT_TIMESTAMP_MAX],
647 timestamp3[FORMAT_TIMESTAMP_MAX],
648 timestamp4[FORMAT_TIMESTAMP_MAX],
649 timespan[FORMAT_TIMESPAN_MAX];
653 assert(u->type >= 0);
657 p2 = strappend(prefix, "\t");
658 prefix2 = p2 ? p2 : prefix;
662 "%s\tDescription: %s\n"
664 "%s\tUnit Load State: %s\n"
665 "%s\tUnit Active State: %s\n"
666 "%s\tInactive Exit Timestamp: %s\n"
667 "%s\tActive Enter Timestamp: %s\n"
668 "%s\tActive Exit Timestamp: %s\n"
669 "%s\tInactive Enter Timestamp: %s\n"
670 "%s\tGC Check Good: %s\n"
671 "%s\tNeed Daemon Reload: %s\n",
673 prefix, unit_description(u),
674 prefix, strna(u->instance),
675 prefix, unit_load_state_to_string(u->load_state),
676 prefix, unit_active_state_to_string(unit_active_state(u)),
677 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
678 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
679 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
680 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
681 prefix, yes_no(unit_check_gc(u)),
682 prefix, yes_no(unit_need_daemon_reload(u)));
684 SET_FOREACH(t, u->names, i)
685 fprintf(f, "%s\tName: %s\n", prefix, t);
687 STRV_FOREACH(j, u->documentation)
688 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
690 if ((following = unit_following(u)))
691 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
693 if (u->fragment_path)
694 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
697 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
699 if (u->job_timeout > 0)
700 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
702 condition_dump_list(u->conditions, f, prefix);
704 if (dual_timestamp_is_set(&u->condition_timestamp))
706 "%s\tCondition Timestamp: %s\n"
707 "%s\tCondition Result: %s\n",
708 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
709 prefix, yes_no(u->condition_result));
711 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
714 SET_FOREACH(other, u->dependencies[d], i)
715 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
718 if (!strv_isempty(u->requires_mounts_for)) {
720 "%s\tRequiresMountsFor:", prefix);
722 STRV_FOREACH(j, u->requires_mounts_for)
723 fprintf(f, " %s", *j);
728 if (u->load_state == UNIT_LOADED) {
733 "%s\tStopWhenUnneeded: %s\n"
734 "%s\tRefuseManualStart: %s\n"
735 "%s\tRefuseManualStop: %s\n"
736 "%s\tDefaultDependencies: %s\n"
737 "%s\tOnFailureIsolate: %s\n"
738 "%s\tIgnoreOnIsolate: %s\n"
739 "%s\tIgnoreOnSnapshot: %s\n",
740 prefix, yes_no(u->stop_when_unneeded),
741 prefix, yes_no(u->refuse_manual_start),
742 prefix, yes_no(u->refuse_manual_stop),
743 prefix, yes_no(u->default_dependencies),
744 prefix, yes_no(u->on_failure_isolate),
745 prefix, yes_no(u->ignore_on_isolate),
746 prefix, yes_no(u->ignore_on_snapshot));
748 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
749 fprintf(f, "%s\tControlGroup: %s:%s\n",
750 prefix, b->controller, b->path);
752 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
753 _cleanup_free_ char *v = NULL;
755 if (a->semantics && a->semantics->map_write)
756 a->semantics->map_write(a->semantics, a->value, &v);
758 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
759 prefix, a->controller, a->name, v ? v : a->value);
762 if (UNIT_VTABLE(u)->dump)
763 UNIT_VTABLE(u)->dump(u, f, prefix2);
765 } else if (u->load_state == UNIT_MERGED)
767 "%s\tMerged into: %s\n",
768 prefix, u->merged_into->id);
769 else if (u->load_state == UNIT_ERROR)
770 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
774 job_dump(u->job, f, prefix2);
777 job_dump(u->nop_job, f, prefix2);
782 /* Common implementation for multiple backends */
783 int unit_load_fragment_and_dropin(Unit *u) {
788 /* Load a .service file */
789 if ((r = unit_load_fragment(u)) < 0)
792 if (u->load_state == UNIT_STUB)
795 /* Load drop-in directory data */
796 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
802 /* Common implementation for multiple backends */
803 int unit_load_fragment_and_dropin_optional(Unit *u) {
808 /* Same as unit_load_fragment_and_dropin(), but whether
809 * something can be loaded or not doesn't matter. */
811 /* Load a .service file */
812 if ((r = unit_load_fragment(u)) < 0)
815 if (u->load_state == UNIT_STUB)
816 u->load_state = UNIT_LOADED;
818 /* Load drop-in directory data */
819 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
825 int unit_add_default_target_dependency(Unit *u, Unit *target) {
829 if (target->type != UNIT_TARGET)
832 /* Only add the dependency if both units are loaded, so that
833 * that loop check below is reliable */
834 if (u->load_state != UNIT_LOADED ||
835 target->load_state != UNIT_LOADED)
838 /* If either side wants no automatic dependencies, then let's
840 if (!u->default_dependencies ||
841 !target->default_dependencies)
844 /* Don't create loops */
845 if (set_get(target->dependencies[UNIT_BEFORE], u))
848 return unit_add_dependency(target, UNIT_AFTER, u, true);
851 static int unit_add_default_dependencies(Unit *u) {
852 static const UnitDependency deps[] = {
854 UNIT_REQUIRED_BY_OVERRIDABLE,
866 for (k = 0; k < ELEMENTSOF(deps); k++)
867 SET_FOREACH(target, u->dependencies[deps[k]], i)
868 if ((r = unit_add_default_target_dependency(u, target)) < 0)
874 int unit_load(Unit *u) {
879 if (u->in_load_queue) {
880 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
881 u->in_load_queue = false;
884 if (u->type == _UNIT_TYPE_INVALID)
887 if (u->load_state != UNIT_STUB)
890 if (UNIT_VTABLE(u)->load)
891 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
894 if (u->load_state == UNIT_STUB) {
899 if (u->load_state == UNIT_LOADED &&
900 u->default_dependencies)
901 if ((r = unit_add_default_dependencies(u)) < 0)
904 if (u->load_state == UNIT_LOADED) {
905 r = unit_add_mount_links(u);
910 if (u->on_failure_isolate &&
911 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
913 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
920 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
922 unit_add_to_dbus_queue(unit_follow_merge(u));
923 unit_add_to_gc_queue(u);
928 u->load_state = UNIT_ERROR;
930 unit_add_to_dbus_queue(u);
931 unit_add_to_gc_queue(u);
933 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
938 bool unit_condition_test(Unit *u) {
941 dual_timestamp_get(&u->condition_timestamp);
942 u->condition_result = condition_test_list(u->conditions);
944 return u->condition_result;
947 static const char* unit_get_status_message_format(Unit *u, JobType t) {
948 const UnitStatusMessageFormats *format_table;
952 assert(t < _JOB_TYPE_MAX);
954 if (t != JOB_START && t != JOB_STOP)
957 format_table = &UNIT_VTABLE(u)->status_message_formats;
961 return format_table->starting_stopping[t == JOB_STOP];
964 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
969 assert(t < _JOB_TYPE_MAX);
971 format = unit_get_status_message_format(u, t);
975 /* Return generic strings */
977 return "Starting %s.";
978 else if (t == JOB_STOP)
979 return "Stopping %s.";
980 else if (t == JOB_RELOAD)
981 return "Reloading %s.";
986 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
991 /* We only print status messages for selected units on
992 * selected operations. */
994 format = unit_get_status_message_format(u, t);
998 unit_status_printf(u, "", format);
1001 #pragma GCC diagnostic push
1002 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1003 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1010 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1013 if (log_on_console())
1016 /* We log status messages for all units and all operations. */
1018 format = unit_get_status_message_format_try_harder(u, t);
1022 snprintf(buf, sizeof(buf), format, unit_description(u));
1025 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1026 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1027 SD_MESSAGE_UNIT_RELOADING;
1029 log_struct_unit(LOG_INFO,
1035 #pragma GCC diagnostic pop
1038 * -EBADR: This unit type does not support starting.
1039 * -EALREADY: Unit is already started.
1040 * -EAGAIN: An operation is already in progress. Retry later.
1041 * -ECANCELED: Too many requests for now.
1043 int unit_start(Unit *u) {
1044 UnitActiveState state;
1049 if (u->load_state != UNIT_LOADED)
1052 /* If this is already started, then this will succeed. Note
1053 * that this will even succeed if this unit is not startable
1054 * by the user. This is relied on to detect when we need to
1055 * wait for units and when waiting is finished. */
1056 state = unit_active_state(u);
1057 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1060 /* If the conditions failed, don't do anything at all. If we
1061 * already are activating this call might still be useful to
1062 * speed up activation in case there is some hold-off time,
1063 * but we don't want to recheck the condition in that case. */
1064 if (state != UNIT_ACTIVATING &&
1065 !unit_condition_test(u)) {
1066 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1070 /* Forward to the main object, if we aren't it. */
1071 if ((following = unit_following(u))) {
1072 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1073 return unit_start(following);
1076 unit_status_log_starting_stopping_reloading(u, JOB_START);
1077 unit_status_print_starting_stopping(u, JOB_START);
1079 /* If it is stopped, but we cannot start it, then fail */
1080 if (!UNIT_VTABLE(u)->start)
1083 /* We don't suppress calls to ->start() here when we are
1084 * already starting, to allow this request to be used as a
1085 * "hurry up" call, for example when the unit is in some "auto
1086 * restart" state where it waits for a holdoff timer to elapse
1087 * before it will start again. */
1089 unit_add_to_dbus_queue(u);
1091 return UNIT_VTABLE(u)->start(u);
1094 bool unit_can_start(Unit *u) {
1097 return !!UNIT_VTABLE(u)->start;
1100 bool unit_can_isolate(Unit *u) {
1103 return unit_can_start(u) &&
1108 * -EBADR: This unit type does not support stopping.
1109 * -EALREADY: Unit is already stopped.
1110 * -EAGAIN: An operation is already in progress. Retry later.
1112 int unit_stop(Unit *u) {
1113 UnitActiveState state;
1118 state = unit_active_state(u);
1119 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1122 if ((following = unit_following(u))) {
1123 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1124 return unit_stop(following);
1127 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1128 unit_status_print_starting_stopping(u, JOB_STOP);
1130 if (!UNIT_VTABLE(u)->stop)
1133 unit_add_to_dbus_queue(u);
1135 return UNIT_VTABLE(u)->stop(u);
1139 * -EBADR: This unit type does not support reloading.
1140 * -ENOEXEC: Unit is not started.
1141 * -EAGAIN: An operation is already in progress. Retry later.
1143 int unit_reload(Unit *u) {
1144 UnitActiveState state;
1149 if (u->load_state != UNIT_LOADED)
1152 if (!unit_can_reload(u))
1155 state = unit_active_state(u);
1156 if (state == UNIT_RELOADING)
1159 if (state != UNIT_ACTIVE)
1162 if ((following = unit_following(u))) {
1163 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1164 return unit_reload(following);
1167 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1169 unit_add_to_dbus_queue(u);
1170 return UNIT_VTABLE(u)->reload(u);
1173 bool unit_can_reload(Unit *u) {
1176 if (!UNIT_VTABLE(u)->reload)
1179 if (!UNIT_VTABLE(u)->can_reload)
1182 return UNIT_VTABLE(u)->can_reload(u);
1185 static void unit_check_unneeded(Unit *u) {
1191 /* If this service shall be shut down when unneeded then do
1194 if (!u->stop_when_unneeded)
1197 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1200 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1201 if (unit_pending_active(other))
1204 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1205 if (unit_pending_active(other))
1208 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1209 if (unit_pending_active(other))
1212 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1213 if (unit_pending_active(other))
1216 log_info("Service %s is not needed anymore. Stopping.", u->id);
1218 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1219 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1222 static void retroactively_start_dependencies(Unit *u) {
1227 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1229 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1230 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1231 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1232 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1234 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1235 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1236 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1237 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1239 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1240 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1241 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1242 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1244 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1245 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1246 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1247 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1249 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1250 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1251 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1252 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1254 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1255 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1256 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1258 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1259 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1260 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1263 static void retroactively_stop_dependencies(Unit *u) {
1268 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1270 /* Pull down units which are bound to us recursively if enabled */
1271 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1272 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1273 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1276 static void check_unneeded_dependencies(Unit *u) {
1281 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1283 /* Garbage collect services that might not be needed anymore, if enabled */
1284 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1285 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1286 unit_check_unneeded(other);
1287 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1288 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1289 unit_check_unneeded(other);
1290 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1291 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1292 unit_check_unneeded(other);
1293 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1294 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1295 unit_check_unneeded(other);
1296 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1297 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1298 unit_check_unneeded(other);
1299 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1300 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1301 unit_check_unneeded(other);
1304 void unit_trigger_on_failure(Unit *u) {
1310 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1313 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1315 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1318 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1319 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1323 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1328 assert(os < _UNIT_ACTIVE_STATE_MAX);
1329 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1331 /* Note that this is called for all low-level state changes,
1332 * even if they might map to the same high-level
1333 * UnitActiveState! That means that ns == os is OK an expected
1334 * behavior here. For example: if a mount point is remounted
1335 * this function will be called too! */
1339 if (m->n_reloading <= 0) {
1342 dual_timestamp_get(&ts);
1344 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1345 u->inactive_exit_timestamp = ts;
1346 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1347 u->inactive_enter_timestamp = ts;
1349 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1350 u->active_enter_timestamp = ts;
1351 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1352 u->active_exit_timestamp = ts;
1354 timer_unit_notify(u, ns);
1355 path_unit_notify(u, ns);
1358 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1359 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1361 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1362 ExecContext *ec = unit_get_exec_context(u);
1363 if (ec && exec_context_may_touch_console(ec)) {
1364 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1374 if (u->job->state == JOB_WAITING)
1376 /* So we reached a different state for this
1377 * job. Let's see if we can run it now if it
1378 * failed previously due to EAGAIN. */
1379 job_add_to_run_queue(u->job);
1381 /* Let's check whether this state change constitutes a
1382 * finished job, or maybe contradicts a running job and
1383 * hence needs to invalidate jobs. */
1385 switch (u->job->type) {
1388 case JOB_VERIFY_ACTIVE:
1390 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1391 job_finish_and_invalidate(u->job, JOB_DONE, true);
1392 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1395 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1396 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1402 case JOB_RELOAD_OR_START:
1404 if (u->job->state == JOB_RUNNING) {
1405 if (ns == UNIT_ACTIVE)
1406 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1407 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1410 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1411 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1419 case JOB_TRY_RESTART:
1421 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1422 job_finish_and_invalidate(u->job, JOB_DONE, true);
1423 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1425 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1431 assert_not_reached("Job type unknown");
1437 if (m->n_reloading <= 0) {
1439 /* If this state change happened without being
1440 * requested by a job, then let's retroactively start
1441 * or stop dependencies. We skip that step when
1442 * deserializing, since we don't want to create any
1443 * additional jobs just because something is already
1447 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1448 retroactively_start_dependencies(u);
1449 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1450 retroactively_stop_dependencies(u);
1453 /* stop unneeded units regardless if going down was expected or not */
1454 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1455 check_unneeded_dependencies(u);
1457 if (ns != os && ns == UNIT_FAILED) {
1458 log_struct_unit(LOG_NOTICE,
1460 "MESSAGE=Unit %s entered failed state", u->id,
1462 unit_trigger_on_failure(u);
1466 /* Some names are special */
1467 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1469 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1470 /* The bus just might have become available,
1471 * hence try to connect to it, if we aren't
1475 if (u->type == UNIT_SERVICE &&
1476 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1477 m->n_reloading <= 0) {
1478 /* Write audit record if we have just finished starting up */
1479 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1483 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1484 manager_send_unit_plymouth(m, u);
1488 /* We don't care about D-Bus here, since we'll get an
1489 * asynchronous notification for it anyway. */
1491 if (u->type == UNIT_SERVICE &&
1492 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1493 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1494 m->n_reloading <= 0) {
1496 /* Hmm, if there was no start record written
1497 * write it now, so that we always have a nice
1500 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1502 if (ns == UNIT_INACTIVE)
1503 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1505 /* Write audit record if we have just finished shutting down */
1506 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1508 u->in_audit = false;
1512 manager_recheck_journal(m);
1514 /* Maybe we finished startup and are now ready for being
1515 * stopped because unneeded? */
1516 if (u->manager->n_reloading <= 0)
1517 unit_check_unneeded(u);
1519 unit_add_to_dbus_queue(u);
1520 unit_add_to_gc_queue(u);
1523 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1524 struct epoll_event ev;
1529 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1535 if (epoll_ctl(u->manager->epoll_fd,
1536 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1548 void unit_unwatch_fd(Unit *u, Watch *w) {
1552 if (w->type == WATCH_INVALID)
1555 assert(w->type == WATCH_FD);
1556 assert(w->data.unit == u);
1557 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1560 w->type = WATCH_INVALID;
1561 w->data.unit = NULL;
1564 int unit_watch_pid(Unit *u, pid_t pid) {
1568 /* Watch a specific PID. We only support one unit watching
1569 * each PID for now. */
1571 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1574 void unit_unwatch_pid(Unit *u, pid_t pid) {
1578 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1581 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1582 struct itimerspec its;
1588 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1590 /* This will try to reuse the old timer if there is one */
1592 if (w->type == WATCH_UNIT_TIMER) {
1593 assert(w->data.unit == u);
1598 } else if (w->type == WATCH_INVALID) {
1601 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1605 assert_not_reached("Invalid watch type");
1610 /* Set absolute time in the past, but not 0, since we
1611 * don't want to disarm the timer */
1612 its.it_value.tv_sec = 0;
1613 its.it_value.tv_nsec = 1;
1615 flags = TFD_TIMER_ABSTIME;
1617 timespec_store(&its.it_value, usec);
1618 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1621 /* This will also flush the elapse counter */
1622 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1625 if (w->type == WATCH_INVALID) {
1626 struct epoll_event ev;
1630 ev.events = EPOLLIN;
1632 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1636 w->type = WATCH_UNIT_TIMER;
1644 close_nointr_nofail(fd);
1649 void unit_unwatch_timer(Unit *u, Watch *w) {
1653 if (w->type == WATCH_INVALID)
1656 assert(w->type == WATCH_UNIT_TIMER);
1657 assert(w->data.unit == u);
1660 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1661 close_nointr_nofail(w->fd);
1664 w->type = WATCH_INVALID;
1665 w->data.unit = NULL;
1668 bool unit_job_is_applicable(Unit *u, JobType j) {
1670 assert(j >= 0 && j < _JOB_TYPE_MAX);
1674 case JOB_VERIFY_ACTIVE:
1681 case JOB_TRY_RESTART:
1682 return unit_can_start(u);
1685 return unit_can_reload(u);
1687 case JOB_RELOAD_OR_START:
1688 return unit_can_reload(u) && unit_can_start(u);
1691 assert_not_reached("Invalid job type");
1695 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1697 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1698 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1699 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1700 [UNIT_WANTS] = UNIT_WANTED_BY,
1701 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1702 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1703 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1704 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1705 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1706 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1707 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1708 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1709 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1710 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1711 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1712 [UNIT_BEFORE] = UNIT_AFTER,
1713 [UNIT_AFTER] = UNIT_BEFORE,
1714 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1715 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1716 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1717 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1718 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1719 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1720 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1722 int r, q = 0, v = 0, w = 0;
1725 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1728 u = unit_follow_merge(u);
1729 other = unit_follow_merge(other);
1731 /* We won't allow dependencies on ourselves. We will not
1732 * consider them an error however. */
1736 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1739 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1740 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1744 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1745 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1748 if ((q = set_put(u->dependencies[d], other)) < 0)
1751 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1752 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1757 if (add_reference) {
1758 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1763 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1767 unit_add_to_dbus_queue(u);
1772 set_remove(u->dependencies[d], other);
1775 set_remove(other->dependencies[inverse_table[d]], u);
1778 set_remove(u->dependencies[UNIT_REFERENCES], other);
1783 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1788 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1791 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1797 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1801 assert(name || path);
1805 name = path_get_file_name(path);
1807 if (!unit_name_is_template(name)) {
1813 s = unit_name_replace_instance(name, u->instance);
1817 i = unit_name_to_prefix(u->id);
1821 s = unit_name_replace_instance(name, i);
1832 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1835 _cleanup_free_ char *s = NULL;
1838 assert(name || path);
1840 name = resolve_template(u, name, path, &s);
1844 r = manager_load_unit(u->manager, name, path, NULL, &other);
1848 return unit_add_dependency(u, d, other, add_reference);
1851 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1857 assert(name || path);
1859 if (!(name = resolve_template(u, name, path, &s)))
1862 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1865 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1872 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1878 assert(name || path);
1880 if (!(name = resolve_template(u, name, path, &s)))
1883 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1886 r = unit_add_dependency(other, d, u, add_reference);
1893 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1899 assert(name || path);
1901 if (!(name = resolve_template(u, name, path, &s)))
1904 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1907 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1915 int set_unit_path(const char *p) {
1916 _cleanup_free_ char *c = NULL;
1918 /* This is mostly for debug purposes */
1919 c = path_make_absolute_cwd(p);
1920 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1926 char *unit_dbus_path(Unit *u) {
1932 return unit_dbus_path_from_name(u->id);
1935 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1943 if (!b->controller) {
1944 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1951 /* Ensure this hasn't been added yet */
1954 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1957 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1958 LIST_PREPEND(CGroupBonding, by_path, l, b);
1960 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1962 LIST_REMOVE(CGroupBonding, by_path, l, b);
1967 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1973 char *unit_default_cgroup_path(Unit *u) {
1977 _cleanup_free_ char *t = NULL;
1979 t = unit_name_template(u->id);
1983 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1985 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1988 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1989 char *controller = NULL, *path = NULL;
1990 CGroupBonding *b = NULL;
1997 r = cg_split_spec(name, &controller, &path);
2002 path = unit_default_cgroup_path(u);
2007 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2011 if (!path || !controller) {
2017 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2019 if (streq(path, b->path)) {
2028 if (overwrite && !b->essential) {
2035 b->realized = false;
2048 b = new0(CGroupBonding, 1);
2054 b->controller = controller;
2057 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2059 r = unit_add_cgroup(u, b);
2076 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2077 CGroupBonding *b = NULL;
2083 controller = SYSTEMD_CGROUP_CONTROLLER;
2085 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2088 b = new0(CGroupBonding, 1);
2092 b->controller = strdup(controller);
2096 b->path = unit_default_cgroup_path(u);
2101 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2103 r = unit_add_cgroup(u, b);
2111 free(b->controller);
2117 int unit_add_default_cgroups(Unit *u) {
2124 /* Adds in the default cgroups, if they weren't specified
2127 if (!u->manager->cgroup_hierarchy)
2130 r = unit_add_one_default_cgroup(u, NULL);
2134 STRV_FOREACH(c, u->manager->default_controllers)
2135 unit_add_one_default_cgroup(u, *c);
2137 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2138 unit_add_one_default_cgroup(u, a->controller);
2143 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2146 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2149 int unit_add_cgroup_attribute(
2151 const CGroupSemantics *semantics,
2152 const char *controller,
2155 CGroupAttribute **ret) {
2157 _cleanup_free_ char *c = NULL;
2165 /* Semantics always take precedence */
2166 if (semantics->name)
2167 name = semantics->name;
2169 if (semantics->controller)
2170 controller = semantics->controller;
2177 r = cg_controller_from_attr(name, &c);
2184 if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2187 if (!filename_is_safe(name))
2190 if (!filename_is_safe(controller))
2193 /* Check if this attribute already exists. Note that we will
2194 * explicitly check for the value here too, as there are
2195 * attributes which accept multiple values. */
2196 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2198 if (streq(value, a->value)) {
2199 /* Exactly the same value is always OK, let's ignore this */
2206 if (semantics && !semantics->multiple) {
2209 /* If this is a single-item entry, we can
2210 * simply patch the existing attribute */
2225 a = new0(CGroupAttribute, 1);
2233 a->controller = strdup(controller);
2235 a->name = strdup(name);
2236 a->value = strdup(value);
2238 if (!a->controller || !a->name || !a->value) {
2239 free(a->controller);
2246 a->semantics = semantics;
2249 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2257 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2265 if (!(t = unit_name_change_suffix(u->id, type)))
2268 assert(!unit_has_name(u, t));
2270 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2273 assert(r < 0 || *_found != u);
2278 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2286 if (!(t = unit_name_change_suffix(u->id, type)))
2289 assert(!unit_has_name(u, t));
2291 found = manager_get_unit(u->manager, t);
2301 int unit_watch_bus_name(Unit *u, const char *name) {
2305 /* Watch a specific name on the bus. We only support one unit
2306 * watching each name for now. */
2308 return hashmap_put(u->manager->watch_bus, name, u);
2311 void unit_unwatch_bus_name(Unit *u, const char *name) {
2315 hashmap_remove_value(u->manager->watch_bus, name, u);
2318 bool unit_can_serialize(Unit *u) {
2321 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2324 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2331 if (!unit_can_serialize(u))
2334 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2338 if (serialize_jobs) {
2340 fprintf(f, "job\n");
2341 job_serialize(u->job, f, fds);
2345 fprintf(f, "job\n");
2346 job_serialize(u->nop_job, f, fds);
2350 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2351 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2352 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2353 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2354 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2356 if (dual_timestamp_is_set(&u->condition_timestamp))
2357 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2364 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2375 va_start(ap, format);
2376 vfprintf(f, format, ap);
2382 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2388 fprintf(f, "%s=%s\n", key, value);
2391 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2398 if (!unit_can_serialize(u))
2402 char line[LINE_MAX], *l, *v;
2405 if (!fgets(line, sizeof(line), f)) {
2418 k = strcspn(l, "=");
2426 if (streq(l, "job")) {
2428 /* new-style serialized job */
2429 Job *j = job_new_raw(u);
2433 r = job_deserialize(j, f, fds);
2439 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2445 r = job_install_deserialized(j);
2447 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2452 if (j->state == JOB_RUNNING)
2453 u->manager->n_running_jobs++;
2456 JobType type = job_type_from_string(v);
2458 log_debug("Failed to parse job type value %s", v);
2460 u->deserialized_job = type;
2463 } else if (streq(l, "inactive-exit-timestamp")) {
2464 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2466 } else if (streq(l, "active-enter-timestamp")) {
2467 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2469 } else if (streq(l, "active-exit-timestamp")) {
2470 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2472 } else if (streq(l, "inactive-enter-timestamp")) {
2473 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2475 } else if (streq(l, "condition-timestamp")) {
2476 dual_timestamp_deserialize(v, &u->condition_timestamp);
2478 } else if (streq(l, "condition-result")) {
2481 if ((b = parse_boolean(v)) < 0)
2482 log_debug("Failed to parse condition result value %s", v);
2484 u->condition_result = b;
2489 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2494 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2504 /* Adds in links to the device node that this unit is based on */
2506 if (!is_device_path(what))
2509 e = unit_name_from_path(what, ".device");
2513 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2518 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2523 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2531 int unit_coldplug(Unit *u) {
2536 if (UNIT_VTABLE(u)->coldplug)
2537 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2541 r = job_coldplug(u->job);
2544 } else if (u->deserialized_job >= 0) {
2546 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2550 u->deserialized_job = _JOB_TYPE_INVALID;
2556 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2557 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2560 bool unit_need_daemon_reload(Unit *u) {
2565 if (u->fragment_path) {
2567 if (stat(u->fragment_path, &st) < 0)
2568 /* What, cannot access this anymore? */
2571 if (u->fragment_mtime > 0 &&
2572 timespec_load(&st.st_mtim) != u->fragment_mtime)
2576 if (u->source_path) {
2578 if (stat(u->source_path, &st) < 0)
2581 if (u->source_mtime > 0 &&
2582 timespec_load(&st.st_mtim) != u->source_mtime)
2589 void unit_reset_failed(Unit *u) {
2592 if (UNIT_VTABLE(u)->reset_failed)
2593 UNIT_VTABLE(u)->reset_failed(u);
2596 Unit *unit_following(Unit *u) {
2599 if (UNIT_VTABLE(u)->following)
2600 return UNIT_VTABLE(u)->following(u);
2605 bool unit_pending_inactive(Unit *u) {
2608 /* Returns true if the unit is inactive or going down */
2610 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2613 if (u->job && u->job->type == JOB_STOP)
2619 bool unit_pending_active(Unit *u) {
2622 /* Returns true if the unit is active or going up */
2624 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2628 (u->job->type == JOB_START ||
2629 u->job->type == JOB_RELOAD_OR_START ||
2630 u->job->type == JOB_RESTART))
2636 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2638 assert(w >= 0 && w < _KILL_WHO_MAX);
2640 assert(signo < _NSIG);
2642 if (!UNIT_VTABLE(u)->kill)
2645 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2648 int unit_kill_common(Unit *u, KillWho who, int signo, pid_t main_pid, pid_t control_pid, DBusError *error) {
2651 if (who == KILL_MAIN && main_pid <= 0) {
2653 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2655 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2659 if (who == KILL_CONTROL && control_pid <= 0) {
2660 if (control_pid < 0)
2661 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2663 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2667 if (who == KILL_CONTROL || who == KILL_ALL)
2668 if (control_pid > 0)
2669 if (kill(control_pid, signo) < 0)
2672 if (who == KILL_MAIN || who == KILL_ALL)
2674 if (kill(main_pid, signo) < 0)
2677 if (who == KILL_ALL) {
2678 _cleanup_set_free_ Set *pid_set = NULL;
2681 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2685 /* Exclude the control/main pid from being killed via the cgroup */
2686 if (control_pid > 0) {
2687 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2693 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2698 q = cgroup_bonding_kill_list(u->cgroup_bondings, signo, false, false, pid_set, NULL);
2699 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2706 int unit_following_set(Unit *u, Set **s) {
2710 if (UNIT_VTABLE(u)->following_set)
2711 return UNIT_VTABLE(u)->following_set(u, s);
2717 UnitFileState unit_get_unit_file_state(Unit *u) {
2720 if (u->unit_file_state < 0 && u->fragment_path)
2721 u->unit_file_state = unit_file_get_state(
2722 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2723 NULL, path_get_file_name(u->fragment_path));
2725 return u->unit_file_state;
2728 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2733 unit_ref_unset(ref);
2736 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2740 void unit_ref_unset(UnitRef *ref) {
2746 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2750 int unit_add_one_mount_link(Unit *u, Mount *m) {
2756 if (u->load_state != UNIT_LOADED ||
2757 UNIT(m)->load_state != UNIT_LOADED)
2760 STRV_FOREACH(i, u->requires_mounts_for) {
2765 if (!path_startswith(*i, m->where))
2768 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2774 int unit_add_mount_links(Unit *u) {
2780 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2781 r = unit_add_one_mount_link(u, MOUNT(other));
2789 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2796 /* This only copies in the ones that need memory */
2798 for (i = 0; i < RLIMIT_NLIMITS; i++)
2799 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2800 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2805 if (u->manager->running_as == SYSTEMD_USER &&
2806 !c->working_directory) {
2808 r = get_home_dir(&c->working_directory);
2816 ExecContext *unit_get_exec_context(Unit *u) {
2820 offset = UNIT_VTABLE(u)->exec_context_offset;
2824 return (ExecContext*) ((uint8_t*) u + offset);
2827 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2836 if (u->manager->running_as == SYSTEMD_USER && runtime)
2839 if (!filename_is_safe(name))
2842 if (u->manager->running_as == SYSTEMD_USER) {
2843 _cleanup_free_ char *c = NULL;
2845 r = user_config_home(&c);
2851 p = strjoin(c, "/", u->id, ".d", NULL);
2853 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2855 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2859 q = strjoin(p, "/50-", name, ".conf", NULL);
2870 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2871 _cleanup_free_ char *p = NULL, *q = NULL;
2876 r = drop_in_file(u, runtime, name, &p, &q);
2881 return write_one_line_file_atomic_label(q, data);
2884 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2885 _cleanup_free_ char *p = NULL, *q = NULL;
2890 r = drop_in_file(u, runtime, name, &p, &q);
2900 int unit_kill_context(
2906 bool main_pid_alien) {
2908 int sig, wait_for_exit = 0, r;
2913 if (c->kill_mode == KILL_NONE)
2916 sig = sigkill ? SIGKILL : c->kill_signal;
2919 r = kill_and_sigcont(main_pid, sig);
2921 if (r < 0 && r != -ESRCH) {
2922 _cleanup_free_ char *comm = NULL;
2923 get_process_comm(main_pid, &comm);
2925 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2926 (long) main_pid, strna(comm), strerror(-r));
2928 wait_for_exit = !main_pid_alien;
2931 if (control_pid > 0) {
2932 r = kill_and_sigcont(control_pid, sig);
2934 if (r < 0 && r != -ESRCH) {
2935 _cleanup_free_ char *comm = NULL;
2936 get_process_comm(control_pid, &comm);
2938 log_warning_unit(u->id,
2939 "Failed to kill control process %li (%s): %s",
2940 (long) control_pid, strna(comm), strerror(-r));
2942 wait_for_exit = true;
2945 if (c->kill_mode == KILL_CONTROL_GROUP) {
2946 _cleanup_set_free_ Set *pid_set = NULL;
2948 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2952 /* Exclude the main/control pids from being killed via the cgroup */
2954 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2959 if (control_pid > 0) {
2960 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2965 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2967 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2968 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2970 wait_for_exit = true;
2973 return wait_for_exit;
2976 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2977 [UNIT_ACTIVE] = "active",
2978 [UNIT_RELOADING] = "reloading",
2979 [UNIT_INACTIVE] = "inactive",
2980 [UNIT_FAILED] = "failed",
2981 [UNIT_ACTIVATING] = "activating",
2982 [UNIT_DEACTIVATING] = "deactivating"
2985 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2987 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2988 [UNIT_REQUIRES] = "Requires",
2989 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2990 [UNIT_REQUISITE] = "Requisite",
2991 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2992 [UNIT_WANTS] = "Wants",
2993 [UNIT_BINDS_TO] = "BindsTo",
2994 [UNIT_PART_OF] = "PartOf",
2995 [UNIT_REQUIRED_BY] = "RequiredBy",
2996 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2997 [UNIT_WANTED_BY] = "WantedBy",
2998 [UNIT_BOUND_BY] = "BoundBy",
2999 [UNIT_CONSISTS_OF] = "ConsistsOf",
3000 [UNIT_CONFLICTS] = "Conflicts",
3001 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3002 [UNIT_BEFORE] = "Before",
3003 [UNIT_AFTER] = "After",
3004 [UNIT_ON_FAILURE] = "OnFailure",
3005 [UNIT_TRIGGERS] = "Triggers",
3006 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3007 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3008 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3009 [UNIT_REFERENCES] = "References",
3010 [UNIT_REFERENCED_BY] = "ReferencedBy",
3013 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);