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"
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_TIMER] = &timer_vtable,
55 [UNIT_SOCKET] = &socket_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_DEVICE] = &device_vtable,
58 [UNIT_MOUNT] = &mount_vtable,
59 [UNIT_AUTOMOUNT] = &automount_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_PATH] = &path_vtable
65 Unit *unit_new(Manager *m, size_t size) {
69 assert(size >= sizeof(Unit));
75 u->names = set_new(string_hash_func, string_compare_func);
82 u->type = _UNIT_TYPE_INVALID;
83 u->deserialized_job = _JOB_TYPE_INVALID;
84 u->default_dependencies = true;
85 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
90 bool unit_has_name(Unit *u, const char *name) {
94 return !!set_get(u->names, (char*) name);
97 int unit_add_name(Unit *u, const char *text) {
105 if (unit_name_is_template(text)) {
109 s = unit_name_replace_instance(text, u->instance);
116 if (!unit_name_is_valid(s, false)) {
121 assert_se((t = unit_name_to_type(s)) >= 0);
123 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
128 if ((r = unit_name_to_instance(s, &i)) < 0)
131 if (i && unit_vtable[t]->no_instances) {
136 /* Ensure that this unit is either instanced or not instanced,
138 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
143 if (unit_vtable[t]->no_alias &&
144 !set_isempty(u->names) &&
145 !set_get(u->names, s)) {
150 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
155 if ((r = set_put(u->names, s)) < 0) {
161 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
162 set_remove(u->names, s);
166 if (u->type == _UNIT_TYPE_INVALID) {
172 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
174 if (UNIT_VTABLE(u)->init)
175 UNIT_VTABLE(u)->init(u);
179 unit_add_to_dbus_queue(u);
189 int unit_choose_id(Unit *u, const char *name) {
190 char *s, *t = NULL, *i;
196 if (unit_name_is_template(name)) {
201 if (!(t = unit_name_replace_instance(name, u->instance)))
207 /* Selects one of the names of this unit as the id */
208 s = set_get(u->names, (char*) name);
214 if ((r = unit_name_to_instance(s, &i)) < 0)
222 unit_add_to_dbus_queue(u);
227 int unit_set_description(Unit *u, const char *description) {
232 if (!(s = strdup(description)))
235 free(u->description);
238 unit_add_to_dbus_queue(u);
242 bool unit_check_gc(Unit *u) {
245 if (u->load_state == UNIT_STUB)
248 if (UNIT_VTABLE(u)->no_gc)
260 if (unit_active_state(u) != UNIT_INACTIVE)
266 if (UNIT_VTABLE(u)->check_gc)
267 if (UNIT_VTABLE(u)->check_gc(u))
273 void unit_add_to_load_queue(Unit *u) {
275 assert(u->type != _UNIT_TYPE_INVALID);
277 if (u->load_state != UNIT_STUB || u->in_load_queue)
280 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
281 u->in_load_queue = true;
284 void unit_add_to_cleanup_queue(Unit *u) {
287 if (u->in_cleanup_queue)
290 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
291 u->in_cleanup_queue = true;
294 void unit_add_to_gc_queue(Unit *u) {
297 if (u->in_gc_queue || u->in_cleanup_queue)
300 if (unit_check_gc(u))
303 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
304 u->in_gc_queue = true;
306 u->manager->n_in_gc_queue ++;
308 if (u->manager->gc_queue_timestamp <= 0)
309 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
312 void unit_add_to_dbus_queue(Unit *u) {
314 assert(u->type != _UNIT_TYPE_INVALID);
316 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
319 /* Shortcut things if nobody cares */
320 if (!bus_has_subscriber(u->manager)) {
321 u->sent_dbus_new_signal = true;
325 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
326 u->in_dbus_queue = true;
329 static void bidi_set_free(Unit *u, Set *s) {
335 /* Frees the set and makes sure we are dropped from the
336 * inverse pointers */
338 SET_FOREACH(other, s, i) {
341 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
342 set_remove(other->dependencies[d], u);
344 unit_add_to_gc_queue(other);
350 void unit_free(Unit *u) {
357 bus_unit_send_removed_signal(u);
359 if (u->load_state != UNIT_STUB)
360 if (UNIT_VTABLE(u)->done)
361 UNIT_VTABLE(u)->done(u);
363 SET_FOREACH(t, u->names, i)
364 hashmap_remove_value(u->manager->units, t, u);
378 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
379 bidi_set_free(u, u->dependencies[d]);
381 if (u->requires_mounts_for) {
382 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
383 strv_free(u->requires_mounts_for);
386 if (u->type != _UNIT_TYPE_INVALID)
387 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
389 if (u->in_load_queue)
390 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
392 if (u->in_dbus_queue)
393 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
395 if (u->in_cleanup_queue)
396 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
398 if (u->in_gc_queue) {
399 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
400 u->manager->n_in_gc_queue--;
403 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
404 cgroup_attribute_free_list(u->cgroup_attributes);
406 free(u->description);
407 strv_free(u->documentation);
408 free(u->fragment_path);
409 free(u->source_path);
412 set_free_free(u->names);
414 condition_free_list(u->conditions);
417 unit_ref_unset(u->refs);
422 UnitActiveState unit_active_state(Unit *u) {
425 if (u->load_state == UNIT_MERGED)
426 return unit_active_state(unit_follow_merge(u));
428 /* After a reload it might happen that a unit is not correctly
429 * loaded but still has a process around. That's why we won't
430 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
432 return UNIT_VTABLE(u)->active_state(u);
435 const char* unit_sub_state_to_string(Unit *u) {
438 return UNIT_VTABLE(u)->sub_state_to_string(u);
441 static void complete_move(Set **s, Set **other) {
449 set_move(*s, *other);
456 static void merge_names(Unit *u, Unit *other) {
463 complete_move(&u->names, &other->names);
465 set_free_free(other->names);
469 SET_FOREACH(t, u->names, i)
470 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
473 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
480 assert(d < _UNIT_DEPENDENCY_MAX);
482 /* Fix backwards pointers */
483 SET_FOREACH(back, other->dependencies[d], i) {
486 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
487 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
490 set_remove(back->dependencies[k], other);
492 assert(r == -ENOENT);
496 complete_move(&u->dependencies[d], &other->dependencies[d]);
498 set_free(other->dependencies[d]);
499 other->dependencies[d] = NULL;
502 int unit_merge(Unit *u, Unit *other) {
507 assert(u->manager == other->manager);
508 assert(u->type != _UNIT_TYPE_INVALID);
510 other = unit_follow_merge(other);
515 if (u->type != other->type)
518 if (!u->instance != !other->instance)
521 if (other->load_state != UNIT_STUB &&
522 other->load_state != UNIT_ERROR)
531 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
535 merge_names(u, other);
537 /* Redirect all references */
539 unit_ref_set(other->refs, u);
541 /* Merge dependencies */
542 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
543 merge_dependencies(u, other, d);
545 other->load_state = UNIT_MERGED;
546 other->merged_into = u;
548 /* If there is still some data attached to the other node, we
549 * don't need it anymore, and can free it. */
550 if (other->load_state != UNIT_STUB)
551 if (UNIT_VTABLE(other)->done)
552 UNIT_VTABLE(other)->done(other);
554 unit_add_to_dbus_queue(u);
555 unit_add_to_cleanup_queue(other);
560 int unit_merge_by_name(Unit *u, const char *name) {
568 if (unit_name_is_template(name)) {
572 if (!(s = unit_name_replace_instance(name, u->instance)))
578 if (!(other = manager_get_unit(u->manager, name)))
579 r = unit_add_name(u, name);
581 r = unit_merge(u, other);
587 Unit* unit_follow_merge(Unit *u) {
590 while (u->load_state == UNIT_MERGED)
591 assert_se(u = u->merged_into);
596 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
602 if (c->std_output != EXEC_OUTPUT_KMSG &&
603 c->std_output != EXEC_OUTPUT_SYSLOG &&
604 c->std_output != EXEC_OUTPUT_JOURNAL &&
605 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
606 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
607 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
608 c->std_error != EXEC_OUTPUT_KMSG &&
609 c->std_error != EXEC_OUTPUT_SYSLOG &&
610 c->std_error != EXEC_OUTPUT_JOURNAL &&
611 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
612 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
613 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
616 /* If syslog or kernel logging is requested, make sure our own
617 * logging daemon is run first. */
619 if (u->manager->running_as == SYSTEMD_SYSTEM) {
620 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
628 const char *unit_description(Unit *u) {
632 return u->description;
637 void unit_dump(Unit *u, FILE *f, const char *prefix) {
644 timestamp1[FORMAT_TIMESTAMP_MAX],
645 timestamp2[FORMAT_TIMESTAMP_MAX],
646 timestamp3[FORMAT_TIMESTAMP_MAX],
647 timestamp4[FORMAT_TIMESTAMP_MAX],
648 timespan[FORMAT_TIMESPAN_MAX];
652 assert(u->type >= 0);
656 p2 = strappend(prefix, "\t");
657 prefix2 = p2 ? p2 : prefix;
661 "%s\tDescription: %s\n"
663 "%s\tUnit Load State: %s\n"
664 "%s\tUnit Active State: %s\n"
665 "%s\tInactive Exit Timestamp: %s\n"
666 "%s\tActive Enter Timestamp: %s\n"
667 "%s\tActive Exit Timestamp: %s\n"
668 "%s\tInactive Enter Timestamp: %s\n"
669 "%s\tGC Check Good: %s\n"
670 "%s\tNeed Daemon Reload: %s\n",
672 prefix, unit_description(u),
673 prefix, strna(u->instance),
674 prefix, unit_load_state_to_string(u->load_state),
675 prefix, unit_active_state_to_string(unit_active_state(u)),
676 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
677 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
678 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
679 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
680 prefix, yes_no(unit_check_gc(u)),
681 prefix, yes_no(unit_need_daemon_reload(u)));
683 SET_FOREACH(t, u->names, i)
684 fprintf(f, "%s\tName: %s\n", prefix, t);
686 STRV_FOREACH(j, u->documentation)
687 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
689 if ((following = unit_following(u)))
690 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
692 if (u->fragment_path)
693 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
696 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
698 if (u->job_timeout > 0)
699 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
701 condition_dump_list(u->conditions, f, prefix);
703 if (dual_timestamp_is_set(&u->condition_timestamp))
705 "%s\tCondition Timestamp: %s\n"
706 "%s\tCondition Result: %s\n",
707 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
708 prefix, yes_no(u->condition_result));
710 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
713 SET_FOREACH(other, u->dependencies[d], i)
714 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
717 if (!strv_isempty(u->requires_mounts_for)) {
719 "%s\tRequiresMountsFor:", prefix);
721 STRV_FOREACH(j, u->requires_mounts_for)
722 fprintf(f, " %s", *j);
727 if (u->load_state == UNIT_LOADED) {
732 "%s\tStopWhenUnneeded: %s\n"
733 "%s\tRefuseManualStart: %s\n"
734 "%s\tRefuseManualStop: %s\n"
735 "%s\tDefaultDependencies: %s\n"
736 "%s\tOnFailureIsolate: %s\n"
737 "%s\tIgnoreOnIsolate: %s\n"
738 "%s\tIgnoreOnSnapshot: %s\n",
739 prefix, yes_no(u->stop_when_unneeded),
740 prefix, yes_no(u->refuse_manual_start),
741 prefix, yes_no(u->refuse_manual_stop),
742 prefix, yes_no(u->default_dependencies),
743 prefix, yes_no(u->on_failure_isolate),
744 prefix, yes_no(u->ignore_on_isolate),
745 prefix, yes_no(u->ignore_on_snapshot));
747 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
748 fprintf(f, "%s\tControlGroup: %s:%s\n",
749 prefix, b->controller, b->path);
751 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
755 a->map_callback(a->controller, a->name, a->value, &v);
757 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
758 prefix, a->controller, a->name, v ? v : a->value);
763 if (UNIT_VTABLE(u)->dump)
764 UNIT_VTABLE(u)->dump(u, f, prefix2);
766 } else if (u->load_state == UNIT_MERGED)
768 "%s\tMerged into: %s\n",
769 prefix, u->merged_into->id);
770 else if (u->load_state == UNIT_ERROR)
771 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
775 job_dump(u->job, f, prefix2);
778 job_dump(u->nop_job, f, prefix2);
783 /* Common implementation for multiple backends */
784 int unit_load_fragment_and_dropin(Unit *u) {
789 /* Load a .service file */
790 if ((r = unit_load_fragment(u)) < 0)
793 if (u->load_state == UNIT_STUB)
796 /* Load drop-in directory data */
797 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
803 /* Common implementation for multiple backends */
804 int unit_load_fragment_and_dropin_optional(Unit *u) {
809 /* Same as unit_load_fragment_and_dropin(), but whether
810 * something can be loaded or not doesn't matter. */
812 /* Load a .service file */
813 if ((r = unit_load_fragment(u)) < 0)
816 if (u->load_state == UNIT_STUB)
817 u->load_state = UNIT_LOADED;
819 /* Load drop-in directory data */
820 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
826 int unit_add_default_target_dependency(Unit *u, Unit *target) {
830 if (target->type != UNIT_TARGET)
833 /* Only add the dependency if both units are loaded, so that
834 * that loop check below is reliable */
835 if (u->load_state != UNIT_LOADED ||
836 target->load_state != UNIT_LOADED)
839 /* If either side wants no automatic dependencies, then let's
841 if (!u->default_dependencies ||
842 !target->default_dependencies)
845 /* Don't create loops */
846 if (set_get(target->dependencies[UNIT_BEFORE], u))
849 return unit_add_dependency(target, UNIT_AFTER, u, true);
852 static int unit_add_default_dependencies(Unit *u) {
853 static const UnitDependency deps[] = {
855 UNIT_REQUIRED_BY_OVERRIDABLE,
867 for (k = 0; k < ELEMENTSOF(deps); k++)
868 SET_FOREACH(target, u->dependencies[deps[k]], i)
869 if ((r = unit_add_default_target_dependency(u, target)) < 0)
875 int unit_load(Unit *u) {
880 if (u->in_load_queue) {
881 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
882 u->in_load_queue = false;
885 if (u->type == _UNIT_TYPE_INVALID)
888 if (u->load_state != UNIT_STUB)
891 if (UNIT_VTABLE(u)->load)
892 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
895 if (u->load_state == UNIT_STUB) {
900 if (u->load_state == UNIT_LOADED &&
901 u->default_dependencies)
902 if ((r = unit_add_default_dependencies(u)) < 0)
905 if (u->load_state == UNIT_LOADED) {
906 r = unit_add_mount_links(u);
911 if (u->on_failure_isolate &&
912 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
914 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
921 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
923 unit_add_to_dbus_queue(unit_follow_merge(u));
924 unit_add_to_gc_queue(u);
929 u->load_state = UNIT_ERROR;
931 unit_add_to_dbus_queue(u);
932 unit_add_to_gc_queue(u);
934 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
939 bool unit_condition_test(Unit *u) {
942 dual_timestamp_get(&u->condition_timestamp);
943 u->condition_result = condition_test_list(u->conditions);
945 return u->condition_result;
948 static const char* unit_get_status_message_format(Unit *u, JobType t) {
949 const UnitStatusMessageFormats *format_table;
953 assert(t < _JOB_TYPE_MAX);
955 if (t != JOB_START && t != JOB_STOP)
958 format_table = &UNIT_VTABLE(u)->status_message_formats;
962 return format_table->starting_stopping[t == JOB_STOP];
965 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
970 assert(t < _JOB_TYPE_MAX);
972 format = unit_get_status_message_format(u, t);
976 /* Return generic strings */
978 return "Starting %s.";
979 else if (t == JOB_STOP)
980 return "Stopping %s.";
981 else if (t == JOB_RELOAD)
982 return "Reloading %s.";
987 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
992 /* We only print status messages for selected units on
993 * selected operations. */
995 format = unit_get_status_message_format(u, t);
999 unit_status_printf(u, "", format, unit_description(u));
1002 #pragma GCC diagnostic push
1003 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1004 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1011 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1014 if (log_on_console())
1017 /* We log status messages for all units and all operations. */
1019 format = unit_get_status_message_format_try_harder(u, t);
1023 snprintf(buf, sizeof(buf), format, unit_description(u));
1026 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1027 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1028 SD_MESSAGE_UNIT_RELOADING;
1030 log_struct_unit(LOG_INFO,
1036 #pragma GCC diagnostic pop
1039 * -EBADR: This unit type does not support starting.
1040 * -EALREADY: Unit is already started.
1041 * -EAGAIN: An operation is already in progress. Retry later.
1042 * -ECANCELED: Too many requests for now.
1044 int unit_start(Unit *u) {
1045 UnitActiveState state;
1050 if (u->load_state != UNIT_LOADED)
1053 /* If this is already started, then this will succeed. Note
1054 * that this will even succeed if this unit is not startable
1055 * by the user. This is relied on to detect when we need to
1056 * wait for units and when waiting is finished. */
1057 state = unit_active_state(u);
1058 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1061 /* If the conditions failed, don't do anything at all. If we
1062 * already are activating this call might still be useful to
1063 * speed up activation in case there is some hold-off time,
1064 * but we don't want to recheck the condition in that case. */
1065 if (state != UNIT_ACTIVATING &&
1066 !unit_condition_test(u)) {
1067 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1071 /* Forward to the main object, if we aren't it. */
1072 if ((following = unit_following(u))) {
1073 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1074 return unit_start(following);
1077 unit_status_log_starting_stopping_reloading(u, JOB_START);
1078 unit_status_print_starting_stopping(u, JOB_START);
1080 /* If it is stopped, but we cannot start it, then fail */
1081 if (!UNIT_VTABLE(u)->start)
1084 /* We don't suppress calls to ->start() here when we are
1085 * already starting, to allow this request to be used as a
1086 * "hurry up" call, for example when the unit is in some "auto
1087 * restart" state where it waits for a holdoff timer to elapse
1088 * before it will start again. */
1090 unit_add_to_dbus_queue(u);
1092 return UNIT_VTABLE(u)->start(u);
1095 bool unit_can_start(Unit *u) {
1098 return !!UNIT_VTABLE(u)->start;
1101 bool unit_can_isolate(Unit *u) {
1104 return unit_can_start(u) &&
1109 * -EBADR: This unit type does not support stopping.
1110 * -EALREADY: Unit is already stopped.
1111 * -EAGAIN: An operation is already in progress. Retry later.
1113 int unit_stop(Unit *u) {
1114 UnitActiveState state;
1119 state = unit_active_state(u);
1120 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1123 if ((following = unit_following(u))) {
1124 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1125 return unit_stop(following);
1128 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1129 unit_status_print_starting_stopping(u, JOB_STOP);
1131 if (!UNIT_VTABLE(u)->stop)
1134 unit_add_to_dbus_queue(u);
1136 return UNIT_VTABLE(u)->stop(u);
1140 * -EBADR: This unit type does not support reloading.
1141 * -ENOEXEC: Unit is not started.
1142 * -EAGAIN: An operation is already in progress. Retry later.
1144 int unit_reload(Unit *u) {
1145 UnitActiveState state;
1150 if (u->load_state != UNIT_LOADED)
1153 if (!unit_can_reload(u))
1156 state = unit_active_state(u);
1157 if (state == UNIT_RELOADING)
1160 if (state != UNIT_ACTIVE)
1163 if ((following = unit_following(u))) {
1164 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1165 return unit_reload(following);
1168 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1170 unit_add_to_dbus_queue(u);
1171 return UNIT_VTABLE(u)->reload(u);
1174 bool unit_can_reload(Unit *u) {
1177 if (!UNIT_VTABLE(u)->reload)
1180 if (!UNIT_VTABLE(u)->can_reload)
1183 return UNIT_VTABLE(u)->can_reload(u);
1186 static void unit_check_unneeded(Unit *u) {
1192 /* If this service shall be shut down when unneeded then do
1195 if (!u->stop_when_unneeded)
1198 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1201 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1202 if (unit_pending_active(other))
1205 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1206 if (unit_pending_active(other))
1209 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1210 if (unit_pending_active(other))
1213 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1214 if (unit_pending_active(other))
1217 log_info("Service %s is not needed anymore. Stopping.", u->id);
1219 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1220 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1223 static void retroactively_start_dependencies(Unit *u) {
1228 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1230 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1231 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1232 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1233 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1235 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1236 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1237 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1238 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1240 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1241 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1242 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1243 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1245 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1246 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1247 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1248 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1250 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1251 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1252 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1253 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1255 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1256 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1257 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1259 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1260 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1261 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1264 static void retroactively_stop_dependencies(Unit *u) {
1269 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1271 /* Pull down units which are bound to us recursively if enabled */
1272 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1273 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1274 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1277 static void check_unneeded_dependencies(Unit *u) {
1282 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1284 /* Garbage collect services that might not be needed anymore, if enabled */
1285 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1286 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1287 unit_check_unneeded(other);
1288 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1289 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1290 unit_check_unneeded(other);
1291 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1292 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1293 unit_check_unneeded(other);
1294 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1295 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1296 unit_check_unneeded(other);
1297 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1298 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1299 unit_check_unneeded(other);
1300 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1301 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1302 unit_check_unneeded(other);
1305 void unit_trigger_on_failure(Unit *u) {
1311 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1314 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1316 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1319 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1320 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1324 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! */
1337 if (u->manager->n_reloading <= 0) {
1340 dual_timestamp_get(&ts);
1342 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1343 u->inactive_exit_timestamp = ts;
1344 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1345 u->inactive_enter_timestamp = ts;
1347 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1348 u->active_enter_timestamp = ts;
1349 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1350 u->active_exit_timestamp = ts;
1352 timer_unit_notify(u, ns);
1353 path_unit_notify(u, ns);
1356 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1357 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1362 if (u->job->state == JOB_WAITING)
1364 /* So we reached a different state for this
1365 * job. Let's see if we can run it now if it
1366 * failed previously due to EAGAIN. */
1367 job_add_to_run_queue(u->job);
1369 /* Let's check whether this state change constitutes a
1370 * finished job, or maybe contradicts a running job and
1371 * hence needs to invalidate jobs. */
1373 switch (u->job->type) {
1376 case JOB_VERIFY_ACTIVE:
1378 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1379 job_finish_and_invalidate(u->job, JOB_DONE, true);
1380 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1383 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1384 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1390 case JOB_RELOAD_OR_START:
1392 if (u->job->state == JOB_RUNNING) {
1393 if (ns == UNIT_ACTIVE)
1394 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1395 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1398 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1399 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1407 case JOB_TRY_RESTART:
1409 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1410 job_finish_and_invalidate(u->job, JOB_DONE, true);
1411 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1413 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1419 assert_not_reached("Job type unknown");
1425 if (u->manager->n_reloading <= 0) {
1427 /* If this state change happened without being
1428 * requested by a job, then let's retroactively start
1429 * or stop dependencies. We skip that step when
1430 * deserializing, since we don't want to create any
1431 * additional jobs just because something is already
1435 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1436 retroactively_start_dependencies(u);
1437 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1438 retroactively_stop_dependencies(u);
1441 /* stop unneeded units regardless if going down was expected or not */
1442 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1443 check_unneeded_dependencies(u);
1445 if (ns != os && ns == UNIT_FAILED) {
1446 log_struct_unit(LOG_NOTICE,
1448 "MESSAGE=Unit %s entered failed state", u->id,
1450 unit_trigger_on_failure(u);
1454 /* Some names are special */
1455 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1457 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1458 /* The bus just might have become available,
1459 * hence try to connect to it, if we aren't
1461 bus_init(u->manager, true);
1463 if (u->type == UNIT_SERVICE &&
1464 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1465 u->manager->n_reloading <= 0) {
1466 /* Write audit record if we have just finished starting up */
1467 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1471 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1472 manager_send_unit_plymouth(u->manager, u);
1476 /* We don't care about D-Bus here, since we'll get an
1477 * asynchronous notification for it anyway. */
1479 if (u->type == UNIT_SERVICE &&
1480 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1481 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1482 u->manager->n_reloading <= 0) {
1484 /* Hmm, if there was no start record written
1485 * write it now, so that we always have a nice
1488 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1490 if (ns == UNIT_INACTIVE)
1491 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1493 /* Write audit record if we have just finished shutting down */
1494 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1496 u->in_audit = false;
1500 manager_recheck_journal(u->manager);
1502 /* Maybe we finished startup and are now ready for being
1503 * stopped because unneeded? */
1504 unit_check_unneeded(u);
1506 unit_add_to_dbus_queue(u);
1507 unit_add_to_gc_queue(u);
1510 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1511 struct epoll_event ev;
1516 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1522 if (epoll_ctl(u->manager->epoll_fd,
1523 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1535 void unit_unwatch_fd(Unit *u, Watch *w) {
1539 if (w->type == WATCH_INVALID)
1542 assert(w->type == WATCH_FD);
1543 assert(w->data.unit == u);
1544 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1547 w->type = WATCH_INVALID;
1548 w->data.unit = NULL;
1551 int unit_watch_pid(Unit *u, pid_t pid) {
1555 /* Watch a specific PID. We only support one unit watching
1556 * each PID for now. */
1558 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1561 void unit_unwatch_pid(Unit *u, pid_t pid) {
1565 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1568 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1569 struct itimerspec its;
1575 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1577 /* This will try to reuse the old timer if there is one */
1579 if (w->type == WATCH_UNIT_TIMER) {
1580 assert(w->data.unit == u);
1585 } else if (w->type == WATCH_INVALID) {
1588 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1592 assert_not_reached("Invalid watch type");
1597 /* Set absolute time in the past, but not 0, since we
1598 * don't want to disarm the timer */
1599 its.it_value.tv_sec = 0;
1600 its.it_value.tv_nsec = 1;
1602 flags = TFD_TIMER_ABSTIME;
1604 timespec_store(&its.it_value, usec);
1605 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1608 /* This will also flush the elapse counter */
1609 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1612 if (w->type == WATCH_INVALID) {
1613 struct epoll_event ev;
1617 ev.events = EPOLLIN;
1619 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1623 w->type = WATCH_UNIT_TIMER;
1631 close_nointr_nofail(fd);
1636 void unit_unwatch_timer(Unit *u, Watch *w) {
1640 if (w->type == WATCH_INVALID)
1643 assert(w->type == WATCH_UNIT_TIMER);
1644 assert(w->data.unit == u);
1647 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1648 close_nointr_nofail(w->fd);
1651 w->type = WATCH_INVALID;
1652 w->data.unit = NULL;
1655 bool unit_job_is_applicable(Unit *u, JobType j) {
1657 assert(j >= 0 && j < _JOB_TYPE_MAX);
1661 case JOB_VERIFY_ACTIVE:
1668 case JOB_TRY_RESTART:
1669 return unit_can_start(u);
1672 return unit_can_reload(u);
1674 case JOB_RELOAD_OR_START:
1675 return unit_can_reload(u) && unit_can_start(u);
1678 assert_not_reached("Invalid job type");
1682 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1684 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1685 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1686 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1687 [UNIT_WANTS] = UNIT_WANTED_BY,
1688 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1689 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1690 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1691 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1692 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1693 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1694 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1695 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1696 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1697 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1698 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1699 [UNIT_BEFORE] = UNIT_AFTER,
1700 [UNIT_AFTER] = UNIT_BEFORE,
1701 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1702 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1703 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1704 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1705 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1706 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1707 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1709 int r, q = 0, v = 0, w = 0;
1712 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1715 u = unit_follow_merge(u);
1716 other = unit_follow_merge(other);
1718 /* We won't allow dependencies on ourselves. We will not
1719 * consider them an error however. */
1723 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1726 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1727 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1731 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1732 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1735 if ((q = set_put(u->dependencies[d], other)) < 0)
1738 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1739 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1744 if (add_reference) {
1745 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1750 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1754 unit_add_to_dbus_queue(u);
1759 set_remove(u->dependencies[d], other);
1762 set_remove(other->dependencies[inverse_table[d]], u);
1765 set_remove(u->dependencies[UNIT_REFERENCES], other);
1770 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1775 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1778 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1784 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1788 assert(name || path);
1792 name = path_get_file_name(path);
1794 if (!unit_name_is_template(name)) {
1800 s = unit_name_replace_instance(name, u->instance);
1804 i = unit_name_to_prefix(u->id);
1808 s = unit_name_replace_instance(name, i);
1819 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1822 _cleanup_free_ char *s = NULL;
1825 assert(name || path);
1827 name = resolve_template(u, name, path, &s);
1831 r = manager_load_unit(u->manager, name, path, NULL, &other);
1835 return unit_add_dependency(u, d, other, add_reference);
1838 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1844 assert(name || path);
1846 if (!(name = resolve_template(u, name, path, &s)))
1849 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1852 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1859 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1865 assert(name || path);
1867 if (!(name = resolve_template(u, name, path, &s)))
1870 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1873 r = unit_add_dependency(other, d, u, add_reference);
1880 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1886 assert(name || path);
1888 if (!(name = resolve_template(u, name, path, &s)))
1891 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1894 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1902 int set_unit_path(const char *p) {
1906 /* This is mostly for debug purposes */
1908 if (path_is_absolute(p)) {
1909 if (!(c = strdup(p)))
1912 if (!(cwd = get_current_dir_name()))
1915 r = asprintf(&c, "%s/%s", cwd, p);
1922 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1931 char *unit_dbus_path(Unit *u) {
1937 return unit_dbus_path_from_name(u->id);
1940 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1948 if (!b->controller) {
1949 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1956 /* Ensure this hasn't been added yet */
1959 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1962 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1963 LIST_PREPEND(CGroupBonding, by_path, l, b);
1965 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1967 LIST_REMOVE(CGroupBonding, by_path, l, b);
1972 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1978 char *unit_default_cgroup_path(Unit *u) {
1982 _cleanup_free_ char *t = NULL;
1984 t = unit_name_template(u->id);
1988 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1990 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1993 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1994 char *controller = NULL, *path = NULL;
1995 CGroupBonding *b = NULL;
2002 r = cg_split_spec(name, &controller, &path);
2007 path = unit_default_cgroup_path(u);
2012 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2016 if (!path || !controller) {
2022 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2024 if (streq(path, b->path)) {
2033 if (overwrite && !b->essential) {
2040 b->realized = false;
2053 b = new0(CGroupBonding, 1);
2059 b->controller = controller;
2062 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2064 r = unit_add_cgroup(u, b);
2081 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2082 CGroupBonding *b = NULL;
2088 controller = SYSTEMD_CGROUP_CONTROLLER;
2090 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2093 b = new0(CGroupBonding, 1);
2097 b->controller = strdup(controller);
2101 b->path = unit_default_cgroup_path(u);
2106 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2108 r = unit_add_cgroup(u, b);
2116 free(b->controller);
2122 int unit_add_default_cgroups(Unit *u) {
2129 /* Adds in the default cgroups, if they weren't specified
2132 if (!u->manager->cgroup_hierarchy)
2135 r = unit_add_one_default_cgroup(u, NULL);
2139 STRV_FOREACH(c, u->manager->default_controllers)
2140 unit_add_one_default_cgroup(u, *c);
2142 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2143 unit_add_one_default_cgroup(u, a->controller);
2148 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2151 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2154 int unit_add_cgroup_attribute(
2156 const char *controller,
2159 CGroupAttributeMapCallback map_callback,
2160 CGroupAttribute **ret) {
2162 _cleanup_free_ char *c = NULL;
2171 r = cg_controller_from_attr(name, &c);
2177 if (!filename_is_safe(name))
2180 if (!filename_is_safe(controller))
2184 if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2187 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2191 if (streq(value, a->value)) {
2211 a = new0(CGroupAttribute, 1);
2219 a->controller = strdup(controller);
2221 a->name = strdup(name);
2222 a->value = strdup(value);
2224 if (!a->controller || !a->name || !a->value) {
2225 free(a->controller);
2233 a->map_callback = map_callback;
2236 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2244 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2252 if (!(t = unit_name_change_suffix(u->id, type)))
2255 assert(!unit_has_name(u, t));
2257 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2260 assert(r < 0 || *_found != u);
2265 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2273 if (!(t = unit_name_change_suffix(u->id, type)))
2276 assert(!unit_has_name(u, t));
2278 found = manager_get_unit(u->manager, t);
2288 int unit_watch_bus_name(Unit *u, const char *name) {
2292 /* Watch a specific name on the bus. We only support one unit
2293 * watching each name for now. */
2295 return hashmap_put(u->manager->watch_bus, name, u);
2298 void unit_unwatch_bus_name(Unit *u, const char *name) {
2302 hashmap_remove_value(u->manager->watch_bus, name, u);
2305 bool unit_can_serialize(Unit *u) {
2308 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2311 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2318 if (!unit_can_serialize(u))
2321 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2325 if (serialize_jobs) {
2327 fprintf(f, "job\n");
2328 job_serialize(u->job, f, fds);
2332 fprintf(f, "job\n");
2333 job_serialize(u->nop_job, f, fds);
2337 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2338 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2339 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2340 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2341 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2343 if (dual_timestamp_is_set(&u->condition_timestamp))
2344 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2351 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2362 va_start(ap, format);
2363 vfprintf(f, format, ap);
2369 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2375 fprintf(f, "%s=%s\n", key, value);
2378 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2385 if (!unit_can_serialize(u))
2389 char line[LINE_MAX], *l, *v;
2392 if (!fgets(line, sizeof(line), f)) {
2405 k = strcspn(l, "=");
2413 if (streq(l, "job")) {
2415 /* new-style serialized job */
2416 Job *j = job_new_raw(u);
2420 r = job_deserialize(j, f, fds);
2426 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2432 r = job_install_deserialized(j);
2434 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2440 JobType type = job_type_from_string(v);
2442 log_debug("Failed to parse job type value %s", v);
2444 u->deserialized_job = type;
2447 } else if (streq(l, "inactive-exit-timestamp")) {
2448 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2450 } else if (streq(l, "active-enter-timestamp")) {
2451 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2453 } else if (streq(l, "active-exit-timestamp")) {
2454 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2456 } else if (streq(l, "inactive-enter-timestamp")) {
2457 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2459 } else if (streq(l, "condition-timestamp")) {
2460 dual_timestamp_deserialize(v, &u->condition_timestamp);
2462 } else if (streq(l, "condition-result")) {
2465 if ((b = parse_boolean(v)) < 0)
2466 log_debug("Failed to parse condition result value %s", v);
2468 u->condition_result = b;
2473 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2478 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2488 /* Adds in links to the device node that this unit is based on */
2490 if (!is_device_path(what))
2493 e = unit_name_from_path(what, ".device");
2497 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2502 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2507 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2515 int unit_coldplug(Unit *u) {
2520 if (UNIT_VTABLE(u)->coldplug)
2521 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2525 r = job_coldplug(u->job);
2528 } else if (u->deserialized_job >= 0) {
2530 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2534 u->deserialized_job = _JOB_TYPE_INVALID;
2540 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2546 if (!manager_get_show_status(u->manager))
2549 if (!manager_is_booting_or_shutting_down(u->manager))
2552 va_start(ap, format);
2553 status_vprintf(status, true, format, ap);
2557 bool unit_need_daemon_reload(Unit *u) {
2562 if (u->fragment_path) {
2564 if (stat(u->fragment_path, &st) < 0)
2565 /* What, cannot access this anymore? */
2568 if (u->fragment_mtime > 0 &&
2569 timespec_load(&st.st_mtim) != u->fragment_mtime)
2573 if (u->source_path) {
2575 if (stat(u->source_path, &st) < 0)
2578 if (u->source_mtime > 0 &&
2579 timespec_load(&st.st_mtim) != u->source_mtime)
2586 void unit_reset_failed(Unit *u) {
2589 if (UNIT_VTABLE(u)->reset_failed)
2590 UNIT_VTABLE(u)->reset_failed(u);
2593 Unit *unit_following(Unit *u) {
2596 if (UNIT_VTABLE(u)->following)
2597 return UNIT_VTABLE(u)->following(u);
2602 bool unit_pending_inactive(Unit *u) {
2605 /* Returns true if the unit is inactive or going down */
2607 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2610 if (u->job && u->job->type == JOB_STOP)
2616 bool unit_pending_active(Unit *u) {
2619 /* Returns true if the unit is active or going up */
2621 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2625 (u->job->type == JOB_START ||
2626 u->job->type == JOB_RELOAD_OR_START ||
2627 u->job->type == JOB_RESTART))
2633 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2635 assert(w >= 0 && w < _KILL_WHO_MAX);
2637 assert(signo < _NSIG);
2639 if (!UNIT_VTABLE(u)->kill)
2642 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2645 int unit_following_set(Unit *u, Set **s) {
2649 if (UNIT_VTABLE(u)->following_set)
2650 return UNIT_VTABLE(u)->following_set(u, s);
2656 UnitFileState unit_get_unit_file_state(Unit *u) {
2659 if (u->unit_file_state < 0 && u->fragment_path)
2660 u->unit_file_state = unit_file_get_state(
2661 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2662 NULL, path_get_file_name(u->fragment_path));
2664 return u->unit_file_state;
2667 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2672 unit_ref_unset(ref);
2675 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2679 void unit_ref_unset(UnitRef *ref) {
2685 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2689 int unit_add_one_mount_link(Unit *u, Mount *m) {
2695 if (u->load_state != UNIT_LOADED ||
2696 UNIT(m)->load_state != UNIT_LOADED)
2699 STRV_FOREACH(i, u->requires_mounts_for) {
2704 if (!path_startswith(*i, m->where))
2707 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2713 int unit_add_mount_links(Unit *u) {
2719 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2720 r = unit_add_one_mount_link(u, MOUNT(other));
2728 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2735 /* This only copies in the ones that need memory */
2737 for (i = 0; i < RLIMIT_NLIMITS; i++)
2738 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2739 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2744 if (u->manager->running_as == SYSTEMD_USER &&
2745 !c->working_directory) {
2747 r = get_home_dir(&c->working_directory);
2755 ExecContext *unit_get_exec_context(Unit *u) {
2759 offset = UNIT_VTABLE(u)->exec_context_offset;
2763 return (ExecContext*) ((uint8_t*) u + offset);
2766 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2767 _cleanup_free_ char *p = NULL, *q = NULL;
2770 if (u->manager->running_as != SYSTEMD_SYSTEM)
2773 if (!filename_is_safe(name))
2776 p = strjoin(runtime ? "/run/systemd/system/" : "/etc/systemd/system/", u->id, ".d", NULL);
2780 q = strjoin(p, "/50-", name, ".conf", NULL);
2785 return write_one_line_file_atomic_label(q, data);
2788 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2789 _cleanup_free_ char *p = NULL, *q = NULL;
2793 if (u->manager->running_as != SYSTEMD_SYSTEM)
2796 if (!filename_is_safe(name))
2799 p = strjoin(runtime ? "/run/systemd/system/" : "/etc/systemd/system/", u->id, ".d", NULL);
2803 q = strjoin(p, "/50-", name, ".conf", NULL);
2814 int unit_kill_context(
2820 bool main_pid_alien) {
2822 int sig, wait_for_exit = 0, r;
2827 if (c->kill_mode == KILL_NONE)
2830 sig = sigkill ? SIGKILL : c->kill_signal;
2833 r = kill_and_sigcont(main_pid, sig);
2835 if (r < 0 && r != -ESRCH) {
2836 _cleanup_free_ char *comm = NULL;
2837 get_process_comm(main_pid, &comm);
2839 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2840 (long) main_pid, strna(comm), strerror(-r));
2842 wait_for_exit = !main_pid_alien;
2845 if (control_pid > 0) {
2846 r = kill_and_sigcont(control_pid, sig);
2848 if (r < 0 && r != -ESRCH) {
2849 _cleanup_free_ char *comm = NULL;
2850 get_process_comm(control_pid, &comm);
2852 log_warning_unit(u->id,
2853 "Failed to kill control process %li (%s): %s",
2854 (long) control_pid, strna(comm), strerror(-r));
2856 wait_for_exit = true;
2859 if (c->kill_mode == KILL_CONTROL_GROUP) {
2860 _cleanup_set_free_ Set *pid_set = NULL;
2862 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2866 /* Exclude the main/control pids from being killed via the cgroup */
2868 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2873 if (control_pid > 0) {
2874 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2879 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2881 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2882 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2884 wait_for_exit = true;
2887 return wait_for_exit;
2890 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2891 [UNIT_ACTIVE] = "active",
2892 [UNIT_RELOADING] = "reloading",
2893 [UNIT_INACTIVE] = "inactive",
2894 [UNIT_FAILED] = "failed",
2895 [UNIT_ACTIVATING] = "activating",
2896 [UNIT_DEACTIVATING] = "deactivating"
2899 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2901 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2902 [UNIT_REQUIRES] = "Requires",
2903 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2904 [UNIT_REQUISITE] = "Requisite",
2905 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2906 [UNIT_WANTS] = "Wants",
2907 [UNIT_BINDS_TO] = "BindsTo",
2908 [UNIT_PART_OF] = "PartOf",
2909 [UNIT_REQUIRED_BY] = "RequiredBy",
2910 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2911 [UNIT_WANTED_BY] = "WantedBy",
2912 [UNIT_BOUND_BY] = "BoundBy",
2913 [UNIT_CONSISTS_OF] = "ConsistsOf",
2914 [UNIT_CONFLICTS] = "Conflicts",
2915 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2916 [UNIT_BEFORE] = "Before",
2917 [UNIT_AFTER] = "After",
2918 [UNIT_ON_FAILURE] = "OnFailure",
2919 [UNIT_TRIGGERS] = "Triggers",
2920 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2921 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2922 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2923 [UNIT_REFERENCES] = "References",
2924 [UNIT_REFERENCED_BY] = "ReferencedBy",
2927 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);