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"
49 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
50 [UNIT_SERVICE] = &service_vtable,
51 [UNIT_TIMER] = &timer_vtable,
52 [UNIT_SOCKET] = &socket_vtable,
53 [UNIT_TARGET] = &target_vtable,
54 [UNIT_DEVICE] = &device_vtable,
55 [UNIT_MOUNT] = &mount_vtable,
56 [UNIT_AUTOMOUNT] = &automount_vtable,
57 [UNIT_SNAPSHOT] = &snapshot_vtable,
58 [UNIT_SWAP] = &swap_vtable,
59 [UNIT_PATH] = &path_vtable
62 Unit *unit_new(Manager *m, size_t size) {
66 assert(size >= sizeof(Unit));
72 u->names = set_new(string_hash_func, string_compare_func);
79 u->type = _UNIT_TYPE_INVALID;
80 u->deserialized_job = _JOB_TYPE_INVALID;
81 u->default_dependencies = true;
82 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
87 bool unit_has_name(Unit *u, const char *name) {
91 return !!set_get(u->names, (char*) name);
94 int unit_add_name(Unit *u, const char *text) {
102 if (unit_name_is_template(text)) {
106 s = unit_name_replace_instance(text, u->instance);
113 if (!unit_name_is_valid(s, false)) {
118 assert_se((t = unit_name_to_type(s)) >= 0);
120 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
125 if ((r = unit_name_to_instance(s, &i)) < 0)
128 if (i && unit_vtable[t]->no_instances) {
133 /* Ensure that this unit is either instanced or not instanced,
135 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
140 if (unit_vtable[t]->no_alias &&
141 !set_isempty(u->names) &&
142 !set_get(u->names, s)) {
147 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
152 if ((r = set_put(u->names, s)) < 0) {
158 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
159 set_remove(u->names, s);
163 if (u->type == _UNIT_TYPE_INVALID) {
169 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
171 if (UNIT_VTABLE(u)->init)
172 UNIT_VTABLE(u)->init(u);
176 unit_add_to_dbus_queue(u);
186 int unit_choose_id(Unit *u, const char *name) {
187 char *s, *t = NULL, *i;
193 if (unit_name_is_template(name)) {
198 if (!(t = unit_name_replace_instance(name, u->instance)))
204 /* Selects one of the names of this unit as the id */
205 s = set_get(u->names, (char*) name);
211 if ((r = unit_name_to_instance(s, &i)) < 0)
219 unit_add_to_dbus_queue(u);
224 int unit_set_description(Unit *u, const char *description) {
229 if (!(s = strdup(description)))
232 free(u->description);
235 unit_add_to_dbus_queue(u);
239 bool unit_check_gc(Unit *u) {
242 if (u->load_state == UNIT_STUB)
245 if (UNIT_VTABLE(u)->no_gc)
257 if (unit_active_state(u) != UNIT_INACTIVE)
263 if (UNIT_VTABLE(u)->check_gc)
264 if (UNIT_VTABLE(u)->check_gc(u))
270 void unit_add_to_load_queue(Unit *u) {
272 assert(u->type != _UNIT_TYPE_INVALID);
274 if (u->load_state != UNIT_STUB || u->in_load_queue)
277 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
278 u->in_load_queue = true;
281 void unit_add_to_cleanup_queue(Unit *u) {
284 if (u->in_cleanup_queue)
287 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
288 u->in_cleanup_queue = true;
291 void unit_add_to_gc_queue(Unit *u) {
294 if (u->in_gc_queue || u->in_cleanup_queue)
297 if (unit_check_gc(u))
300 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
301 u->in_gc_queue = true;
303 u->manager->n_in_gc_queue ++;
305 if (u->manager->gc_queue_timestamp <= 0)
306 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
309 void unit_add_to_dbus_queue(Unit *u) {
311 assert(u->type != _UNIT_TYPE_INVALID);
313 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
316 /* Shortcut things if nobody cares */
317 if (!bus_has_subscriber(u->manager)) {
318 u->sent_dbus_new_signal = true;
322 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
323 u->in_dbus_queue = true;
326 static void bidi_set_free(Unit *u, Set *s) {
332 /* Frees the set and makes sure we are dropped from the
333 * inverse pointers */
335 SET_FOREACH(other, s, i) {
338 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
339 set_remove(other->dependencies[d], u);
341 unit_add_to_gc_queue(other);
347 void unit_free(Unit *u) {
354 bus_unit_send_removed_signal(u);
356 if (u->load_state != UNIT_STUB)
357 if (UNIT_VTABLE(u)->done)
358 UNIT_VTABLE(u)->done(u);
360 SET_FOREACH(t, u->names, i)
361 hashmap_remove_value(u->manager->units, t, u);
375 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
376 bidi_set_free(u, u->dependencies[d]);
378 if (u->requires_mounts_for) {
379 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
380 strv_free(u->requires_mounts_for);
383 if (u->type != _UNIT_TYPE_INVALID)
384 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
386 if (u->in_load_queue)
387 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
389 if (u->in_dbus_queue)
390 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
392 if (u->in_cleanup_queue)
393 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
395 if (u->in_gc_queue) {
396 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
397 u->manager->n_in_gc_queue--;
400 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
401 cgroup_attribute_free_list(u->cgroup_attributes);
403 free(u->description);
404 strv_free(u->documentation);
405 free(u->fragment_path);
406 free(u->source_path);
409 set_free_free(u->names);
411 condition_free_list(u->conditions);
414 unit_ref_unset(u->refs);
419 UnitActiveState unit_active_state(Unit *u) {
422 if (u->load_state == UNIT_MERGED)
423 return unit_active_state(unit_follow_merge(u));
425 /* After a reload it might happen that a unit is not correctly
426 * loaded but still has a process around. That's why we won't
427 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
429 return UNIT_VTABLE(u)->active_state(u);
432 const char* unit_sub_state_to_string(Unit *u) {
435 return UNIT_VTABLE(u)->sub_state_to_string(u);
438 static void complete_move(Set **s, Set **other) {
446 set_move(*s, *other);
453 static void merge_names(Unit *u, Unit *other) {
460 complete_move(&u->names, &other->names);
462 set_free_free(other->names);
466 SET_FOREACH(t, u->names, i)
467 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
470 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
477 assert(d < _UNIT_DEPENDENCY_MAX);
479 /* Fix backwards pointers */
480 SET_FOREACH(back, other->dependencies[d], i) {
483 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
484 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
487 set_remove(back->dependencies[k], other);
489 assert(r == -ENOENT);
493 complete_move(&u->dependencies[d], &other->dependencies[d]);
495 set_free(other->dependencies[d]);
496 other->dependencies[d] = NULL;
499 int unit_merge(Unit *u, Unit *other) {
504 assert(u->manager == other->manager);
505 assert(u->type != _UNIT_TYPE_INVALID);
507 other = unit_follow_merge(other);
512 if (u->type != other->type)
515 if (!u->instance != !other->instance)
518 if (other->load_state != UNIT_STUB &&
519 other->load_state != UNIT_ERROR)
528 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
532 merge_names(u, other);
534 /* Redirect all references */
536 unit_ref_set(other->refs, u);
538 /* Merge dependencies */
539 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
540 merge_dependencies(u, other, d);
542 other->load_state = UNIT_MERGED;
543 other->merged_into = u;
545 /* If there is still some data attached to the other node, we
546 * don't need it anymore, and can free it. */
547 if (other->load_state != UNIT_STUB)
548 if (UNIT_VTABLE(other)->done)
549 UNIT_VTABLE(other)->done(other);
551 unit_add_to_dbus_queue(u);
552 unit_add_to_cleanup_queue(other);
557 int unit_merge_by_name(Unit *u, const char *name) {
565 if (unit_name_is_template(name)) {
569 if (!(s = unit_name_replace_instance(name, u->instance)))
575 if (!(other = manager_get_unit(u->manager, name)))
576 r = unit_add_name(u, name);
578 r = unit_merge(u, other);
584 Unit* unit_follow_merge(Unit *u) {
587 while (u->load_state == UNIT_MERGED)
588 assert_se(u = u->merged_into);
593 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
599 if (c->std_output != EXEC_OUTPUT_KMSG &&
600 c->std_output != EXEC_OUTPUT_SYSLOG &&
601 c->std_output != EXEC_OUTPUT_JOURNAL &&
602 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
603 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
604 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
605 c->std_error != EXEC_OUTPUT_KMSG &&
606 c->std_error != EXEC_OUTPUT_SYSLOG &&
607 c->std_error != EXEC_OUTPUT_JOURNAL &&
608 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
609 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
610 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
613 /* If syslog or kernel logging is requested, make sure our own
614 * logging daemon is run first. */
616 if (u->manager->running_as == SYSTEMD_SYSTEM)
617 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
623 const char *unit_description(Unit *u) {
627 return u->description;
632 void unit_dump(Unit *u, FILE *f, const char *prefix) {
639 timestamp1[FORMAT_TIMESTAMP_MAX],
640 timestamp2[FORMAT_TIMESTAMP_MAX],
641 timestamp3[FORMAT_TIMESTAMP_MAX],
642 timestamp4[FORMAT_TIMESTAMP_MAX],
643 timespan[FORMAT_TIMESPAN_MAX];
647 assert(u->type >= 0);
651 p2 = strappend(prefix, "\t");
652 prefix2 = p2 ? p2 : prefix;
656 "%s\tDescription: %s\n"
658 "%s\tUnit Load State: %s\n"
659 "%s\tUnit Active State: %s\n"
660 "%s\tInactive Exit Timestamp: %s\n"
661 "%s\tActive Enter Timestamp: %s\n"
662 "%s\tActive Exit Timestamp: %s\n"
663 "%s\tInactive Enter Timestamp: %s\n"
664 "%s\tGC Check Good: %s\n"
665 "%s\tNeed Daemon Reload: %s\n",
667 prefix, unit_description(u),
668 prefix, strna(u->instance),
669 prefix, unit_load_state_to_string(u->load_state),
670 prefix, unit_active_state_to_string(unit_active_state(u)),
671 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
672 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
673 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
674 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
675 prefix, yes_no(unit_check_gc(u)),
676 prefix, yes_no(unit_need_daemon_reload(u)));
678 SET_FOREACH(t, u->names, i)
679 fprintf(f, "%s\tName: %s\n", prefix, t);
681 STRV_FOREACH(j, u->documentation)
682 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
684 if ((following = unit_following(u)))
685 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
687 if (u->fragment_path)
688 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
691 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
693 if (u->job_timeout > 0)
694 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
696 condition_dump_list(u->conditions, f, prefix);
698 if (dual_timestamp_is_set(&u->condition_timestamp))
700 "%s\tCondition Timestamp: %s\n"
701 "%s\tCondition Result: %s\n",
702 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
703 prefix, yes_no(u->condition_result));
705 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
708 SET_FOREACH(other, u->dependencies[d], i)
709 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
712 if (!strv_isempty(u->requires_mounts_for)) {
714 "%s\tRequiresMountsFor:", prefix);
716 STRV_FOREACH(j, u->requires_mounts_for)
717 fprintf(f, " %s", *j);
722 if (u->load_state == UNIT_LOADED) {
727 "%s\tStopWhenUnneeded: %s\n"
728 "%s\tRefuseManualStart: %s\n"
729 "%s\tRefuseManualStop: %s\n"
730 "%s\tDefaultDependencies: %s\n"
731 "%s\tOnFailureIsolate: %s\n"
732 "%s\tIgnoreOnIsolate: %s\n"
733 "%s\tIgnoreOnSnapshot: %s\n",
734 prefix, yes_no(u->stop_when_unneeded),
735 prefix, yes_no(u->refuse_manual_start),
736 prefix, yes_no(u->refuse_manual_stop),
737 prefix, yes_no(u->default_dependencies),
738 prefix, yes_no(u->on_failure_isolate),
739 prefix, yes_no(u->ignore_on_isolate),
740 prefix, yes_no(u->ignore_on_snapshot));
742 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
743 fprintf(f, "%s\tControlGroup: %s:%s\n",
744 prefix, b->controller, b->path);
746 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
750 a->map_callback(a->controller, a->name, a->value, &v);
752 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
753 prefix, a->controller, a->name, v ? v : a->value);
758 if (UNIT_VTABLE(u)->dump)
759 UNIT_VTABLE(u)->dump(u, f, prefix2);
761 } else if (u->load_state == UNIT_MERGED)
763 "%s\tMerged into: %s\n",
764 prefix, u->merged_into->id);
765 else if (u->load_state == UNIT_ERROR)
766 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
770 job_dump(u->job, f, prefix2);
773 job_dump(u->nop_job, f, prefix2);
778 /* Common implementation for multiple backends */
779 int unit_load_fragment_and_dropin(Unit *u) {
784 /* Load a .service file */
785 if ((r = unit_load_fragment(u)) < 0)
788 if (u->load_state == UNIT_STUB)
791 /* Load drop-in directory data */
792 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
798 /* Common implementation for multiple backends */
799 int unit_load_fragment_and_dropin_optional(Unit *u) {
804 /* Same as unit_load_fragment_and_dropin(), but whether
805 * something can be loaded or not doesn't matter. */
807 /* Load a .service file */
808 if ((r = unit_load_fragment(u)) < 0)
811 if (u->load_state == UNIT_STUB)
812 u->load_state = UNIT_LOADED;
814 /* Load drop-in directory data */
815 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
821 int unit_add_default_target_dependency(Unit *u, Unit *target) {
825 if (target->type != UNIT_TARGET)
828 /* Only add the dependency if both units are loaded, so that
829 * that loop check below is reliable */
830 if (u->load_state != UNIT_LOADED ||
831 target->load_state != UNIT_LOADED)
834 /* If either side wants no automatic dependencies, then let's
836 if (!u->default_dependencies ||
837 !target->default_dependencies)
840 /* Don't create loops */
841 if (set_get(target->dependencies[UNIT_BEFORE], u))
844 return unit_add_dependency(target, UNIT_AFTER, u, true);
847 static int unit_add_default_dependencies(Unit *u) {
848 static const UnitDependency deps[] = {
850 UNIT_REQUIRED_BY_OVERRIDABLE,
862 for (k = 0; k < ELEMENTSOF(deps); k++)
863 SET_FOREACH(target, u->dependencies[deps[k]], i)
864 if ((r = unit_add_default_target_dependency(u, target)) < 0)
870 int unit_load(Unit *u) {
875 if (u->in_load_queue) {
876 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
877 u->in_load_queue = false;
880 if (u->type == _UNIT_TYPE_INVALID)
883 if (u->load_state != UNIT_STUB)
886 if (UNIT_VTABLE(u)->load)
887 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
890 if (u->load_state == UNIT_STUB) {
895 if (u->load_state == UNIT_LOADED &&
896 u->default_dependencies)
897 if ((r = unit_add_default_dependencies(u)) < 0)
900 if (u->load_state == UNIT_LOADED) {
901 r = unit_add_mount_links(u);
906 if (u->on_failure_isolate &&
907 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
909 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
916 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
918 unit_add_to_dbus_queue(unit_follow_merge(u));
919 unit_add_to_gc_queue(u);
924 u->load_state = UNIT_ERROR;
926 unit_add_to_dbus_queue(u);
927 unit_add_to_gc_queue(u);
929 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
934 bool unit_condition_test(Unit *u) {
937 dual_timestamp_get(&u->condition_timestamp);
938 u->condition_result = condition_test_list(u->conditions);
940 return u->condition_result;
943 static const char* unit_get_status_message_format(Unit *u, JobType t) {
944 const UnitStatusMessageFormats *format_table;
948 assert(t < _JOB_TYPE_MAX);
950 if (t != JOB_START && t != JOB_STOP)
953 format_table = &UNIT_VTABLE(u)->status_message_formats;
957 return format_table->starting_stopping[t == JOB_STOP];
960 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
965 assert(t < _JOB_TYPE_MAX);
967 format = unit_get_status_message_format(u, t);
971 /* Return generic strings */
973 return "Starting %s.";
974 else if (t == JOB_STOP)
975 return "Stopping %s.";
976 else if (t == JOB_RELOAD)
977 return "Reloading %s.";
982 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
987 /* We only print status messages for selected units on
988 * selected operations. */
990 format = unit_get_status_message_format(u, t);
994 unit_status_printf(u, "", format, unit_description(u));
997 #pragma GCC diagnostic push
998 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
999 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1006 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1009 if (log_on_console())
1012 /* We log status messages for all units and all operations. */
1014 format = unit_get_status_message_format_try_harder(u, t);
1018 snprintf(buf, sizeof(buf), format, unit_description(u));
1021 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1022 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1023 SD_MESSAGE_UNIT_RELOADING;
1025 log_struct_unit(LOG_INFO,
1031 #pragma GCC diagnostic pop
1034 * -EBADR: This unit type does not support starting.
1035 * -EALREADY: Unit is already started.
1036 * -EAGAIN: An operation is already in progress. Retry later.
1037 * -ECANCELED: Too many requests for now.
1039 int unit_start(Unit *u) {
1040 UnitActiveState state;
1045 if (u->load_state != UNIT_LOADED)
1048 /* If this is already started, then this will succeed. Note
1049 * that this will even succeed if this unit is not startable
1050 * by the user. This is relied on to detect when we need to
1051 * wait for units and when waiting is finished. */
1052 state = unit_active_state(u);
1053 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1056 /* If the conditions failed, don't do anything at all. If we
1057 * already are activating this call might still be useful to
1058 * speed up activation in case there is some hold-off time,
1059 * but we don't want to recheck the condition in that case. */
1060 if (state != UNIT_ACTIVATING &&
1061 !unit_condition_test(u)) {
1062 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1066 /* Forward to the main object, if we aren't it. */
1067 if ((following = unit_following(u))) {
1068 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1069 return unit_start(following);
1072 unit_status_log_starting_stopping_reloading(u, JOB_START);
1073 unit_status_print_starting_stopping(u, JOB_START);
1075 /* If it is stopped, but we cannot start it, then fail */
1076 if (!UNIT_VTABLE(u)->start)
1079 /* We don't suppress calls to ->start() here when we are
1080 * already starting, to allow this request to be used as a
1081 * "hurry up" call, for example when the unit is in some "auto
1082 * restart" state where it waits for a holdoff timer to elapse
1083 * before it will start again. */
1085 unit_add_to_dbus_queue(u);
1087 return UNIT_VTABLE(u)->start(u);
1090 bool unit_can_start(Unit *u) {
1093 return !!UNIT_VTABLE(u)->start;
1096 bool unit_can_isolate(Unit *u) {
1099 return unit_can_start(u) &&
1104 * -EBADR: This unit type does not support stopping.
1105 * -EALREADY: Unit is already stopped.
1106 * -EAGAIN: An operation is already in progress. Retry later.
1108 int unit_stop(Unit *u) {
1109 UnitActiveState state;
1114 state = unit_active_state(u);
1115 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1118 if ((following = unit_following(u))) {
1119 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1120 return unit_stop(following);
1123 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1124 unit_status_print_starting_stopping(u, JOB_STOP);
1126 if (!UNIT_VTABLE(u)->stop)
1129 unit_add_to_dbus_queue(u);
1131 return UNIT_VTABLE(u)->stop(u);
1135 * -EBADR: This unit type does not support reloading.
1136 * -ENOEXEC: Unit is not started.
1137 * -EAGAIN: An operation is already in progress. Retry later.
1139 int unit_reload(Unit *u) {
1140 UnitActiveState state;
1145 if (u->load_state != UNIT_LOADED)
1148 if (!unit_can_reload(u))
1151 state = unit_active_state(u);
1152 if (state == UNIT_RELOADING)
1155 if (state != UNIT_ACTIVE)
1158 if ((following = unit_following(u))) {
1159 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1160 return unit_reload(following);
1163 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1165 unit_add_to_dbus_queue(u);
1166 return UNIT_VTABLE(u)->reload(u);
1169 bool unit_can_reload(Unit *u) {
1172 if (!UNIT_VTABLE(u)->reload)
1175 if (!UNIT_VTABLE(u)->can_reload)
1178 return UNIT_VTABLE(u)->can_reload(u);
1181 static void unit_check_unneeded(Unit *u) {
1187 /* If this service shall be shut down when unneeded then do
1190 if (!u->stop_when_unneeded)
1193 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1196 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1197 if (unit_pending_active(other))
1200 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1201 if (unit_pending_active(other))
1204 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1205 if (unit_pending_active(other))
1208 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1209 if (unit_pending_active(other))
1212 log_info("Service %s is not needed anymore. Stopping.", u->id);
1214 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1215 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1218 static void retroactively_start_dependencies(Unit *u) {
1223 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1225 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1226 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1227 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1228 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1230 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], 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_REQUIRES_OVERRIDABLE], 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_FAIL, false, NULL, NULL);
1240 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], 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_REPLACE, true, NULL, NULL);
1245 SET_FOREACH(other, u->dependencies[UNIT_WANTS], 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_FAIL, false, NULL, NULL);
1250 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1251 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1252 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1254 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], 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);
1259 static void retroactively_stop_dependencies(Unit *u) {
1264 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1266 /* Pull down units which are bound to us recursively if enabled */
1267 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1268 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1269 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1272 static void check_unneeded_dependencies(Unit *u) {
1277 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1279 /* Garbage collect services that might not be needed anymore, if enabled */
1280 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1281 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1282 unit_check_unneeded(other);
1283 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1284 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1285 unit_check_unneeded(other);
1286 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1287 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1288 unit_check_unneeded(other);
1289 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1290 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1291 unit_check_unneeded(other);
1292 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1293 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1294 unit_check_unneeded(other);
1295 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1296 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1297 unit_check_unneeded(other);
1300 void unit_trigger_on_failure(Unit *u) {
1306 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1309 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1311 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1314 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1315 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1319 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1323 assert(os < _UNIT_ACTIVE_STATE_MAX);
1324 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1326 /* Note that this is called for all low-level state changes,
1327 * even if they might map to the same high-level
1328 * UnitActiveState! That means that ns == os is OK an expected
1329 * behavior here. For example: if a mount point is remounted
1330 * this function will be called too! */
1332 if (u->manager->n_reloading <= 0) {
1335 dual_timestamp_get(&ts);
1337 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1338 u->inactive_exit_timestamp = ts;
1339 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1340 u->inactive_enter_timestamp = ts;
1342 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1343 u->active_enter_timestamp = ts;
1344 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1345 u->active_exit_timestamp = ts;
1347 timer_unit_notify(u, ns);
1348 path_unit_notify(u, ns);
1351 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1352 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1357 if (u->job->state == JOB_WAITING)
1359 /* So we reached a different state for this
1360 * job. Let's see if we can run it now if it
1361 * failed previously due to EAGAIN. */
1362 job_add_to_run_queue(u->job);
1364 /* Let's check whether this state change constitutes a
1365 * finished job, or maybe contradicts a running job and
1366 * hence needs to invalidate jobs. */
1368 switch (u->job->type) {
1371 case JOB_VERIFY_ACTIVE:
1373 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1374 job_finish_and_invalidate(u->job, JOB_DONE, true);
1375 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1378 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1379 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1385 case JOB_RELOAD_OR_START:
1387 if (u->job->state == JOB_RUNNING) {
1388 if (ns == UNIT_ACTIVE)
1389 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1390 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1393 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1394 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1402 case JOB_TRY_RESTART:
1404 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1405 job_finish_and_invalidate(u->job, JOB_DONE, true);
1406 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1408 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1414 assert_not_reached("Job type unknown");
1420 if (u->manager->n_reloading <= 0) {
1422 /* If this state change happened without being
1423 * requested by a job, then let's retroactively start
1424 * or stop dependencies. We skip that step when
1425 * deserializing, since we don't want to create any
1426 * additional jobs just because something is already
1430 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1431 retroactively_start_dependencies(u);
1432 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1433 retroactively_stop_dependencies(u);
1436 /* stop unneeded units regardless if going down was expected or not */
1437 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1438 check_unneeded_dependencies(u);
1440 if (ns != os && ns == UNIT_FAILED) {
1441 log_struct_unit(LOG_NOTICE,
1443 "MESSAGE=Unit %s entered failed state", u->id,
1445 unit_trigger_on_failure(u);
1449 /* Some names are special */
1450 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1452 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1453 /* The bus just might have become available,
1454 * hence try to connect to it, if we aren't
1456 bus_init(u->manager, true);
1458 if (u->type == UNIT_SERVICE &&
1459 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1460 u->manager->n_reloading <= 0) {
1461 /* Write audit record if we have just finished starting up */
1462 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1466 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1467 manager_send_unit_plymouth(u->manager, u);
1471 /* We don't care about D-Bus here, since we'll get an
1472 * asynchronous notification for it anyway. */
1474 if (u->type == UNIT_SERVICE &&
1475 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1476 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1477 u->manager->n_reloading <= 0) {
1479 /* Hmm, if there was no start record written
1480 * write it now, so that we always have a nice
1483 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1485 if (ns == UNIT_INACTIVE)
1486 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1488 /* Write audit record if we have just finished shutting down */
1489 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1491 u->in_audit = false;
1495 manager_recheck_journal(u->manager);
1497 /* Maybe we finished startup and are now ready for being
1498 * stopped because unneeded? */
1499 unit_check_unneeded(u);
1501 unit_add_to_dbus_queue(u);
1502 unit_add_to_gc_queue(u);
1505 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1506 struct epoll_event ev;
1511 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1517 if (epoll_ctl(u->manager->epoll_fd,
1518 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1530 void unit_unwatch_fd(Unit *u, Watch *w) {
1534 if (w->type == WATCH_INVALID)
1537 assert(w->type == WATCH_FD);
1538 assert(w->data.unit == u);
1539 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1542 w->type = WATCH_INVALID;
1543 w->data.unit = NULL;
1546 int unit_watch_pid(Unit *u, pid_t pid) {
1550 /* Watch a specific PID. We only support one unit watching
1551 * each PID for now. */
1553 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1556 void unit_unwatch_pid(Unit *u, pid_t pid) {
1560 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1563 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1564 struct itimerspec its;
1570 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1572 /* This will try to reuse the old timer if there is one */
1574 if (w->type == WATCH_UNIT_TIMER) {
1575 assert(w->data.unit == u);
1580 } else if (w->type == WATCH_INVALID) {
1583 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1587 assert_not_reached("Invalid watch type");
1592 /* Set absolute time in the past, but not 0, since we
1593 * don't want to disarm the timer */
1594 its.it_value.tv_sec = 0;
1595 its.it_value.tv_nsec = 1;
1597 flags = TFD_TIMER_ABSTIME;
1599 timespec_store(&its.it_value, usec);
1600 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1603 /* This will also flush the elapse counter */
1604 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1607 if (w->type == WATCH_INVALID) {
1608 struct epoll_event ev;
1612 ev.events = EPOLLIN;
1614 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1618 w->type = WATCH_UNIT_TIMER;
1626 close_nointr_nofail(fd);
1631 void unit_unwatch_timer(Unit *u, Watch *w) {
1635 if (w->type == WATCH_INVALID)
1638 assert(w->type == WATCH_UNIT_TIMER);
1639 assert(w->data.unit == u);
1642 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1643 close_nointr_nofail(w->fd);
1646 w->type = WATCH_INVALID;
1647 w->data.unit = NULL;
1650 bool unit_job_is_applicable(Unit *u, JobType j) {
1652 assert(j >= 0 && j < _JOB_TYPE_MAX);
1656 case JOB_VERIFY_ACTIVE:
1663 case JOB_TRY_RESTART:
1664 return unit_can_start(u);
1667 return unit_can_reload(u);
1669 case JOB_RELOAD_OR_START:
1670 return unit_can_reload(u) && unit_can_start(u);
1673 assert_not_reached("Invalid job type");
1677 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1679 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1680 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1681 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1682 [UNIT_WANTS] = UNIT_WANTED_BY,
1683 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1684 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1685 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1686 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1687 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1688 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1689 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1690 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1691 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1692 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1693 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1694 [UNIT_BEFORE] = UNIT_AFTER,
1695 [UNIT_AFTER] = UNIT_BEFORE,
1696 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1697 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1698 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1699 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1700 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1701 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1702 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1704 int r, q = 0, v = 0, w = 0;
1707 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1710 u = unit_follow_merge(u);
1711 other = unit_follow_merge(other);
1713 /* We won't allow dependencies on ourselves. We will not
1714 * consider them an error however. */
1718 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1721 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1722 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1726 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1727 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1730 if ((q = set_put(u->dependencies[d], other)) < 0)
1733 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1734 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1739 if (add_reference) {
1740 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1745 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1749 unit_add_to_dbus_queue(u);
1754 set_remove(u->dependencies[d], other);
1757 set_remove(other->dependencies[inverse_table[d]], u);
1760 set_remove(u->dependencies[UNIT_REFERENCES], other);
1765 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1770 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1773 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1779 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1783 assert(name || path);
1787 name = path_get_file_name(path);
1789 if (!unit_name_is_template(name)) {
1795 s = unit_name_replace_instance(name, u->instance);
1799 i = unit_name_to_prefix(u->id);
1803 s = unit_name_replace_instance(name, i);
1814 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1817 _cleanup_free_ char *s = NULL;
1820 assert(name || path);
1822 name = resolve_template(u, name, path, &s);
1826 r = manager_load_unit(u->manager, name, path, NULL, &other);
1830 return unit_add_dependency(u, d, other, add_reference);
1833 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1839 assert(name || path);
1841 if (!(name = resolve_template(u, name, path, &s)))
1844 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1847 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1854 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1860 assert(name || path);
1862 if (!(name = resolve_template(u, name, path, &s)))
1865 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1868 r = unit_add_dependency(other, d, u, add_reference);
1875 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1881 assert(name || path);
1883 if (!(name = resolve_template(u, name, path, &s)))
1886 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1889 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1897 int set_unit_path(const char *p) {
1901 /* This is mostly for debug purposes */
1903 if (path_is_absolute(p)) {
1904 if (!(c = strdup(p)))
1907 if (!(cwd = get_current_dir_name()))
1910 r = asprintf(&c, "%s/%s", cwd, p);
1917 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 char *controller,
2154 CGroupAttributeMapCallback map_callback,
2155 CGroupAttribute **ret) {
2157 _cleanup_free_ char *c = NULL;
2167 dot = strchr(name, '.');
2171 c = strndup(name, dot - name);
2178 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2181 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2185 if (streq(value, a->value)) {
2205 a = new0(CGroupAttribute, 1);
2213 a->controller = strdup(controller);
2215 a->name = strdup(name);
2216 a->value = strdup(value);
2218 if (!a->controller || !a->name || !a->value) {
2219 free(a->controller);
2227 a->map_callback = map_callback;
2230 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2238 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2246 if (!(t = unit_name_change_suffix(u->id, type)))
2249 assert(!unit_has_name(u, t));
2251 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2254 assert(r < 0 || *_found != u);
2259 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2267 if (!(t = unit_name_change_suffix(u->id, type)))
2270 assert(!unit_has_name(u, t));
2272 found = manager_get_unit(u->manager, t);
2282 int unit_watch_bus_name(Unit *u, const char *name) {
2286 /* Watch a specific name on the bus. We only support one unit
2287 * watching each name for now. */
2289 return hashmap_put(u->manager->watch_bus, name, u);
2292 void unit_unwatch_bus_name(Unit *u, const char *name) {
2296 hashmap_remove_value(u->manager->watch_bus, name, u);
2299 bool unit_can_serialize(Unit *u) {
2302 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2305 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2312 if (!unit_can_serialize(u))
2315 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2319 if (serialize_jobs) {
2321 fprintf(f, "job\n");
2322 job_serialize(u->job, f, fds);
2326 fprintf(f, "job\n");
2327 job_serialize(u->nop_job, f, fds);
2331 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2332 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2333 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2334 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2335 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2337 if (dual_timestamp_is_set(&u->condition_timestamp))
2338 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2345 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2356 va_start(ap, format);
2357 vfprintf(f, format, ap);
2363 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2369 fprintf(f, "%s=%s\n", key, value);
2372 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2379 if (!unit_can_serialize(u))
2383 char line[LINE_MAX], *l, *v;
2386 if (!fgets(line, sizeof(line), f)) {
2399 k = strcspn(l, "=");
2407 if (streq(l, "job")) {
2409 /* new-style serialized job */
2410 Job *j = job_new_raw(u);
2414 r = job_deserialize(j, f, fds);
2420 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2426 r = job_install_deserialized(j);
2428 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2434 JobType type = job_type_from_string(v);
2436 log_debug("Failed to parse job type value %s", v);
2438 u->deserialized_job = type;
2441 } else if (streq(l, "inactive-exit-timestamp")) {
2442 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2444 } else if (streq(l, "active-enter-timestamp")) {
2445 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2447 } else if (streq(l, "active-exit-timestamp")) {
2448 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2450 } else if (streq(l, "inactive-enter-timestamp")) {
2451 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2453 } else if (streq(l, "condition-timestamp")) {
2454 dual_timestamp_deserialize(v, &u->condition_timestamp);
2456 } else if (streq(l, "condition-result")) {
2459 if ((b = parse_boolean(v)) < 0)
2460 log_debug("Failed to parse condition result value %s", v);
2462 u->condition_result = b;
2467 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2472 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2482 /* Adds in links to the device node that this unit is based on */
2484 if (!is_device_path(what))
2487 e = unit_name_from_path(what, ".device");
2491 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2496 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2501 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2509 int unit_coldplug(Unit *u) {
2514 if (UNIT_VTABLE(u)->coldplug)
2515 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2519 r = job_coldplug(u->job);
2522 } else if (u->deserialized_job >= 0) {
2524 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2528 u->deserialized_job = _JOB_TYPE_INVALID;
2534 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2540 if (!manager_get_show_status(u->manager))
2543 if (!manager_is_booting_or_shutting_down(u->manager))
2546 va_start(ap, format);
2547 status_vprintf(status, true, format, ap);
2551 bool unit_need_daemon_reload(Unit *u) {
2556 if (u->fragment_path) {
2558 if (stat(u->fragment_path, &st) < 0)
2559 /* What, cannot access this anymore? */
2562 if (u->fragment_mtime > 0 &&
2563 timespec_load(&st.st_mtim) != u->fragment_mtime)
2567 if (u->source_path) {
2569 if (stat(u->source_path, &st) < 0)
2572 if (u->source_mtime > 0 &&
2573 timespec_load(&st.st_mtim) != u->source_mtime)
2580 void unit_reset_failed(Unit *u) {
2583 if (UNIT_VTABLE(u)->reset_failed)
2584 UNIT_VTABLE(u)->reset_failed(u);
2587 Unit *unit_following(Unit *u) {
2590 if (UNIT_VTABLE(u)->following)
2591 return UNIT_VTABLE(u)->following(u);
2596 bool unit_pending_inactive(Unit *u) {
2599 /* Returns true if the unit is inactive or going down */
2601 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2604 if (u->job && u->job->type == JOB_STOP)
2610 bool unit_pending_active(Unit *u) {
2613 /* Returns true if the unit is active or going up */
2615 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2619 (u->job->type == JOB_START ||
2620 u->job->type == JOB_RELOAD_OR_START ||
2621 u->job->type == JOB_RESTART))
2627 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2629 assert(w >= 0 && w < _KILL_WHO_MAX);
2631 assert(signo < _NSIG);
2633 if (!UNIT_VTABLE(u)->kill)
2636 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2639 int unit_following_set(Unit *u, Set **s) {
2643 if (UNIT_VTABLE(u)->following_set)
2644 return UNIT_VTABLE(u)->following_set(u, s);
2650 UnitFileState unit_get_unit_file_state(Unit *u) {
2653 if (u->unit_file_state < 0 && u->fragment_path)
2654 u->unit_file_state = unit_file_get_state(
2655 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2656 NULL, path_get_file_name(u->fragment_path));
2658 return u->unit_file_state;
2661 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2666 unit_ref_unset(ref);
2669 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2673 void unit_ref_unset(UnitRef *ref) {
2679 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2683 int unit_add_one_mount_link(Unit *u, Mount *m) {
2689 if (u->load_state != UNIT_LOADED ||
2690 UNIT(m)->load_state != UNIT_LOADED)
2693 STRV_FOREACH(i, u->requires_mounts_for) {
2698 if (!path_startswith(*i, m->where))
2701 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2707 int unit_add_mount_links(Unit *u) {
2713 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2714 r = unit_add_one_mount_link(u, MOUNT(other));
2722 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2729 /* This only copies in the ones that need memory */
2731 for (i = 0; i < RLIMIT_NLIMITS; i++)
2732 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2733 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2738 if (u->manager->running_as == SYSTEMD_USER &&
2739 !c->working_directory) {
2741 r = get_home_dir(&c->working_directory);
2749 ExecContext *unit_get_exec_context(Unit *u) {
2753 offset = UNIT_VTABLE(u)->exec_context_offset;
2757 return (ExecContext*) ((uint8_t*) u + offset);
2760 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2761 [UNIT_ACTIVE] = "active",
2762 [UNIT_RELOADING] = "reloading",
2763 [UNIT_INACTIVE] = "inactive",
2764 [UNIT_FAILED] = "failed",
2765 [UNIT_ACTIVATING] = "activating",
2766 [UNIT_DEACTIVATING] = "deactivating"
2769 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2771 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2772 [UNIT_REQUIRES] = "Requires",
2773 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2774 [UNIT_REQUISITE] = "Requisite",
2775 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2776 [UNIT_WANTS] = "Wants",
2777 [UNIT_BINDS_TO] = "BindsTo",
2778 [UNIT_PART_OF] = "PartOf",
2779 [UNIT_REQUIRED_BY] = "RequiredBy",
2780 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2781 [UNIT_WANTED_BY] = "WantedBy",
2782 [UNIT_BOUND_BY] = "BoundBy",
2783 [UNIT_CONSISTS_OF] = "ConsistsOf",
2784 [UNIT_CONFLICTS] = "Conflicts",
2785 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2786 [UNIT_BEFORE] = "Before",
2787 [UNIT_AFTER] = "After",
2788 [UNIT_ON_FAILURE] = "OnFailure",
2789 [UNIT_TRIGGERS] = "Triggers",
2790 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2791 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2792 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2793 [UNIT_REFERENCES] = "References",
2794 [UNIT_REFERENCED_BY] = "ReferencedBy",
2797 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);