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>
36 #include "path-util.h"
37 #include "load-fragment.h"
38 #include "load-dropin.h"
40 #include "unit-name.h"
41 #include "specifier.h"
42 #include "dbus-unit.h"
44 #include "cgroup-util.h"
46 #include "cgroup-attr.h"
48 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
49 [UNIT_SERVICE] = &service_vtable,
50 [UNIT_TIMER] = &timer_vtable,
51 [UNIT_SOCKET] = &socket_vtable,
52 [UNIT_TARGET] = &target_vtable,
53 [UNIT_DEVICE] = &device_vtable,
54 [UNIT_MOUNT] = &mount_vtable,
55 [UNIT_AUTOMOUNT] = &automount_vtable,
56 [UNIT_SNAPSHOT] = &snapshot_vtable,
57 [UNIT_SWAP] = &swap_vtable,
58 [UNIT_PATH] = &path_vtable
61 Unit *unit_new(Manager *m, size_t size) {
65 assert(size >= sizeof(Unit));
71 u->names = set_new(string_hash_func, string_compare_func);
78 u->type = _UNIT_TYPE_INVALID;
79 u->deserialized_job = _JOB_TYPE_INVALID;
80 u->default_dependencies = true;
81 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
86 bool unit_has_name(Unit *u, const char *name) {
90 return !!set_get(u->names, (char*) name);
93 int unit_add_name(Unit *u, const char *text) {
101 if (unit_name_is_template(text)) {
105 s = unit_name_replace_instance(text, u->instance);
112 if (!unit_name_is_valid(s, false)) {
117 assert_se((t = unit_name_to_type(s)) >= 0);
119 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
124 if ((r = unit_name_to_instance(s, &i)) < 0)
127 if (i && unit_vtable[t]->no_instances) {
132 /* Ensure that this unit is either instanced or not instanced,
134 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
139 if (unit_vtable[t]->no_alias &&
140 !set_isempty(u->names) &&
141 !set_get(u->names, s)) {
146 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
151 if ((r = set_put(u->names, s)) < 0) {
157 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
158 set_remove(u->names, s);
162 if (u->type == _UNIT_TYPE_INVALID) {
168 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
170 if (UNIT_VTABLE(u)->init)
171 UNIT_VTABLE(u)->init(u);
175 unit_add_to_dbus_queue(u);
185 int unit_choose_id(Unit *u, const char *name) {
186 char *s, *t = NULL, *i;
192 if (unit_name_is_template(name)) {
197 if (!(t = unit_name_replace_instance(name, u->instance)))
203 /* Selects one of the names of this unit as the id */
204 s = set_get(u->names, (char*) name);
210 if ((r = unit_name_to_instance(s, &i)) < 0)
218 unit_add_to_dbus_queue(u);
223 int unit_set_description(Unit *u, const char *description) {
228 if (!(s = strdup(description)))
231 free(u->description);
234 unit_add_to_dbus_queue(u);
238 bool unit_check_gc(Unit *u) {
241 if (u->load_state == UNIT_STUB)
244 if (UNIT_VTABLE(u)->no_gc)
256 if (unit_active_state(u) != UNIT_INACTIVE)
259 if (UNIT_VTABLE(u)->check_gc)
260 if (UNIT_VTABLE(u)->check_gc(u))
266 void unit_add_to_load_queue(Unit *u) {
268 assert(u->type != _UNIT_TYPE_INVALID);
270 if (u->load_state != UNIT_STUB || u->in_load_queue)
273 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
274 u->in_load_queue = true;
277 void unit_add_to_cleanup_queue(Unit *u) {
280 if (u->in_cleanup_queue)
283 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
284 u->in_cleanup_queue = true;
287 void unit_add_to_gc_queue(Unit *u) {
290 if (u->in_gc_queue || u->in_cleanup_queue)
293 if (unit_check_gc(u))
296 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
297 u->in_gc_queue = true;
299 u->manager->n_in_gc_queue ++;
301 if (u->manager->gc_queue_timestamp <= 0)
302 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
305 void unit_add_to_dbus_queue(Unit *u) {
307 assert(u->type != _UNIT_TYPE_INVALID);
309 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
312 /* Shortcut things if nobody cares */
313 if (!bus_has_subscriber(u->manager)) {
314 u->sent_dbus_new_signal = true;
318 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
319 u->in_dbus_queue = true;
322 static void bidi_set_free(Unit *u, Set *s) {
328 /* Frees the set and makes sure we are dropped from the
329 * inverse pointers */
331 SET_FOREACH(other, s, i) {
334 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
335 set_remove(other->dependencies[d], u);
337 unit_add_to_gc_queue(other);
343 void unit_free(Unit *u) {
350 bus_unit_send_removed_signal(u);
352 if (u->load_state != UNIT_STUB)
353 if (UNIT_VTABLE(u)->done)
354 UNIT_VTABLE(u)->done(u);
356 SET_FOREACH(t, u->names, i)
357 hashmap_remove_value(u->manager->units, t, u);
371 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
372 bidi_set_free(u, u->dependencies[d]);
374 if (u->requires_mounts_for) {
375 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
376 strv_free(u->requires_mounts_for);
379 if (u->type != _UNIT_TYPE_INVALID)
380 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
382 if (u->in_load_queue)
383 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
385 if (u->in_dbus_queue)
386 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
388 if (u->in_cleanup_queue)
389 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
391 if (u->in_gc_queue) {
392 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
393 u->manager->n_in_gc_queue--;
396 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
397 cgroup_attribute_free_list(u->cgroup_attributes);
399 free(u->description);
400 strv_free(u->documentation);
401 free(u->fragment_path);
404 set_free_free(u->names);
406 condition_free_list(u->conditions);
409 unit_ref_unset(u->refs);
414 UnitActiveState unit_active_state(Unit *u) {
417 if (u->load_state == UNIT_MERGED)
418 return unit_active_state(unit_follow_merge(u));
420 /* After a reload it might happen that a unit is not correctly
421 * loaded but still has a process around. That's why we won't
422 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
424 return UNIT_VTABLE(u)->active_state(u);
427 const char* unit_sub_state_to_string(Unit *u) {
430 return UNIT_VTABLE(u)->sub_state_to_string(u);
433 static void complete_move(Set **s, Set **other) {
441 set_move(*s, *other);
448 static void merge_names(Unit *u, Unit *other) {
455 complete_move(&u->names, &other->names);
457 set_free_free(other->names);
461 SET_FOREACH(t, u->names, i)
462 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
465 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
472 assert(d < _UNIT_DEPENDENCY_MAX);
474 /* Fix backwards pointers */
475 SET_FOREACH(back, other->dependencies[d], i) {
478 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
479 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
482 set_remove(back->dependencies[k], other);
484 assert(r == -ENOENT);
488 complete_move(&u->dependencies[d], &other->dependencies[d]);
490 set_free(other->dependencies[d]);
491 other->dependencies[d] = NULL;
494 int unit_merge(Unit *u, Unit *other) {
499 assert(u->manager == other->manager);
500 assert(u->type != _UNIT_TYPE_INVALID);
502 other = unit_follow_merge(other);
507 if (u->type != other->type)
510 if (!u->instance != !other->instance)
513 if (other->load_state != UNIT_STUB &&
514 other->load_state != UNIT_ERROR)
523 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
527 merge_names(u, other);
529 /* Redirect all references */
531 unit_ref_set(other->refs, u);
533 /* Merge dependencies */
534 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
535 merge_dependencies(u, other, d);
537 other->load_state = UNIT_MERGED;
538 other->merged_into = u;
540 /* If there is still some data attached to the other node, we
541 * don't need it anymore, and can free it. */
542 if (other->load_state != UNIT_STUB)
543 if (UNIT_VTABLE(other)->done)
544 UNIT_VTABLE(other)->done(other);
546 unit_add_to_dbus_queue(u);
547 unit_add_to_cleanup_queue(other);
552 int unit_merge_by_name(Unit *u, const char *name) {
560 if (unit_name_is_template(name)) {
564 if (!(s = unit_name_replace_instance(name, u->instance)))
570 if (!(other = manager_get_unit(u->manager, name)))
571 r = unit_add_name(u, name);
573 r = unit_merge(u, other);
579 Unit* unit_follow_merge(Unit *u) {
582 while (u->load_state == UNIT_MERGED)
583 assert_se(u = u->merged_into);
588 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
594 if (c->std_output != EXEC_OUTPUT_KMSG &&
595 c->std_output != EXEC_OUTPUT_SYSLOG &&
596 c->std_output != EXEC_OUTPUT_JOURNAL &&
597 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
598 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
599 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
600 c->std_error != EXEC_OUTPUT_KMSG &&
601 c->std_error != EXEC_OUTPUT_SYSLOG &&
602 c->std_error != EXEC_OUTPUT_JOURNAL &&
603 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
604 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
605 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
608 /* If syslog or kernel logging is requested, make sure our own
609 * logging daemon is run first. */
611 if (u->manager->running_as == MANAGER_SYSTEM)
612 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
618 const char *unit_description(Unit *u) {
622 return u->description;
627 void unit_dump(Unit *u, FILE *f, const char *prefix) {
634 timestamp1[FORMAT_TIMESTAMP_MAX],
635 timestamp2[FORMAT_TIMESTAMP_MAX],
636 timestamp3[FORMAT_TIMESTAMP_MAX],
637 timestamp4[FORMAT_TIMESTAMP_MAX],
638 timespan[FORMAT_TIMESPAN_MAX];
642 assert(u->type >= 0);
646 p2 = strappend(prefix, "\t");
647 prefix2 = p2 ? p2 : prefix;
651 "%s\tDescription: %s\n"
653 "%s\tUnit Load State: %s\n"
654 "%s\tUnit Active State: %s\n"
655 "%s\tInactive Exit Timestamp: %s\n"
656 "%s\tActive Enter Timestamp: %s\n"
657 "%s\tActive Exit Timestamp: %s\n"
658 "%s\tInactive Enter Timestamp: %s\n"
659 "%s\tGC Check Good: %s\n"
660 "%s\tNeed Daemon Reload: %s\n",
662 prefix, unit_description(u),
663 prefix, strna(u->instance),
664 prefix, unit_load_state_to_string(u->load_state),
665 prefix, unit_active_state_to_string(unit_active_state(u)),
666 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
667 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
668 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
669 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
670 prefix, yes_no(unit_check_gc(u)),
671 prefix, yes_no(unit_need_daemon_reload(u)));
673 SET_FOREACH(t, u->names, i)
674 fprintf(f, "%s\tName: %s\n", prefix, t);
676 STRV_FOREACH(j, u->documentation)
677 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
679 if ((following = unit_following(u)))
680 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
682 if (u->fragment_path)
683 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
685 if (u->job_timeout > 0)
686 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
688 condition_dump_list(u->conditions, f, prefix);
690 if (dual_timestamp_is_set(&u->condition_timestamp))
692 "%s\tCondition Timestamp: %s\n"
693 "%s\tCondition Result: %s\n",
694 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
695 prefix, yes_no(u->condition_result));
697 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
700 SET_FOREACH(other, u->dependencies[d], i)
701 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
704 if (!strv_isempty(u->requires_mounts_for)) {
706 "%s\tRequiresMountsFor:", prefix);
708 STRV_FOREACH(j, u->requires_mounts_for)
709 fprintf(f, " %s", *j);
714 if (u->load_state == UNIT_LOADED) {
719 "%s\tStopWhenUnneeded: %s\n"
720 "%s\tRefuseManualStart: %s\n"
721 "%s\tRefuseManualStop: %s\n"
722 "%s\tDefaultDependencies: %s\n"
723 "%s\tOnFailureIsolate: %s\n"
724 "%s\tIgnoreOnIsolate: %s\n"
725 "%s\tIgnoreOnSnapshot: %s\n",
726 prefix, yes_no(u->stop_when_unneeded),
727 prefix, yes_no(u->refuse_manual_start),
728 prefix, yes_no(u->refuse_manual_stop),
729 prefix, yes_no(u->default_dependencies),
730 prefix, yes_no(u->on_failure_isolate),
731 prefix, yes_no(u->ignore_on_isolate),
732 prefix, yes_no(u->ignore_on_snapshot));
734 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
735 fprintf(f, "%s\tControlGroup: %s:%s\n",
736 prefix, b->controller, b->path);
738 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
742 a->map_callback(a->controller, a->name, a->value, &v);
744 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
745 prefix, a->controller, a->name, v ? v : a->value);
750 if (UNIT_VTABLE(u)->dump)
751 UNIT_VTABLE(u)->dump(u, f, prefix2);
753 } else if (u->load_state == UNIT_MERGED)
755 "%s\tMerged into: %s\n",
756 prefix, u->merged_into->id);
757 else if (u->load_state == UNIT_ERROR)
758 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
762 job_dump(u->job, f, prefix2);
765 job_dump(u->nop_job, f, prefix2);
770 /* Common implementation for multiple backends */
771 int unit_load_fragment_and_dropin(Unit *u) {
776 /* Load a .service file */
777 if ((r = unit_load_fragment(u)) < 0)
780 if (u->load_state == UNIT_STUB)
783 /* Load drop-in directory data */
784 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
790 /* Common implementation for multiple backends */
791 int unit_load_fragment_and_dropin_optional(Unit *u) {
796 /* Same as unit_load_fragment_and_dropin(), but whether
797 * something can be loaded or not doesn't matter. */
799 /* Load a .service file */
800 if ((r = unit_load_fragment(u)) < 0)
803 if (u->load_state == UNIT_STUB)
804 u->load_state = UNIT_LOADED;
806 /* Load drop-in directory data */
807 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
813 int unit_add_default_target_dependency(Unit *u, Unit *target) {
817 if (target->type != UNIT_TARGET)
820 /* Only add the dependency if both units are loaded, so that
821 * that loop check below is reliable */
822 if (u->load_state != UNIT_LOADED ||
823 target->load_state != UNIT_LOADED)
826 /* If either side wants no automatic dependencies, then let's
828 if (!u->default_dependencies ||
829 !target->default_dependencies)
832 /* Don't create loops */
833 if (set_get(target->dependencies[UNIT_BEFORE], u))
836 return unit_add_dependency(target, UNIT_AFTER, u, true);
839 static int unit_add_default_dependencies(Unit *u) {
840 static const UnitDependency deps[] = {
842 UNIT_REQUIRED_BY_OVERRIDABLE,
854 for (k = 0; k < ELEMENTSOF(deps); k++)
855 SET_FOREACH(target, u->dependencies[deps[k]], i)
856 if ((r = unit_add_default_target_dependency(u, target)) < 0)
862 int unit_load(Unit *u) {
867 if (u->in_load_queue) {
868 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
869 u->in_load_queue = false;
872 if (u->type == _UNIT_TYPE_INVALID)
875 if (u->load_state != UNIT_STUB)
878 if (UNIT_VTABLE(u)->load)
879 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
882 if (u->load_state == UNIT_STUB) {
887 if (u->load_state == UNIT_LOADED &&
888 u->default_dependencies)
889 if ((r = unit_add_default_dependencies(u)) < 0)
892 if (u->load_state == UNIT_LOADED) {
893 r = unit_add_mount_links(u);
898 if (u->on_failure_isolate &&
899 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
901 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
908 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
910 unit_add_to_dbus_queue(unit_follow_merge(u));
911 unit_add_to_gc_queue(u);
916 u->load_state = UNIT_ERROR;
918 unit_add_to_dbus_queue(u);
919 unit_add_to_gc_queue(u);
921 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
926 bool unit_condition_test(Unit *u) {
929 dual_timestamp_get(&u->condition_timestamp);
930 u->condition_result = condition_test_list(u->conditions);
932 return u->condition_result;
935 static void unit_status_print_starting_stopping(Unit *u, bool stopping) {
936 const UnitStatusMessageFormats *format_table;
939 format_table = &UNIT_VTABLE(u)->status_message_formats;
943 format = format_table->starting_stopping[stopping];
947 unit_status_printf(u, "", format, unit_description(u));
951 * -EBADR: This unit type does not support starting.
952 * -EALREADY: Unit is already started.
953 * -EAGAIN: An operation is already in progress. Retry later.
954 * -ECANCELED: Too many requests for now.
956 int unit_start(Unit *u) {
957 UnitActiveState state;
962 if (u->load_state != UNIT_LOADED)
965 /* If this is already started, then this will succeed. Note
966 * that this will even succeed if this unit is not startable
967 * by the user. This is relied on to detect when we need to
968 * wait for units and when waiting is finished. */
969 state = unit_active_state(u);
970 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
973 /* If the conditions failed, don't do anything at all. If we
974 * already are activating this call might still be useful to
975 * speed up activation in case there is some hold-off time,
976 * but we don't want to recheck the condition in that case. */
977 if (state != UNIT_ACTIVATING &&
978 !unit_condition_test(u)) {
979 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
983 /* Forward to the main object, if we aren't it. */
984 if ((following = unit_following(u))) {
985 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
986 return unit_start(following);
989 unit_status_print_starting_stopping(u, false);
991 /* If it is stopped, but we cannot start it, then fail */
992 if (!UNIT_VTABLE(u)->start)
995 /* We don't suppress calls to ->start() here when we are
996 * already starting, to allow this request to be used as a
997 * "hurry up" call, for example when the unit is in some "auto
998 * restart" state where it waits for a holdoff timer to elapse
999 * before it will start again. */
1001 unit_add_to_dbus_queue(u);
1003 return UNIT_VTABLE(u)->start(u);
1006 bool unit_can_start(Unit *u) {
1009 return !!UNIT_VTABLE(u)->start;
1012 bool unit_can_isolate(Unit *u) {
1015 return unit_can_start(u) &&
1020 * -EBADR: This unit type does not support stopping.
1021 * -EALREADY: Unit is already stopped.
1022 * -EAGAIN: An operation is already in progress. Retry later.
1024 int unit_stop(Unit *u) {
1025 UnitActiveState state;
1030 state = unit_active_state(u);
1031 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1034 if ((following = unit_following(u))) {
1035 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1036 return unit_stop(following);
1039 unit_status_print_starting_stopping(u, true);
1041 if (!UNIT_VTABLE(u)->stop)
1044 unit_add_to_dbus_queue(u);
1046 return UNIT_VTABLE(u)->stop(u);
1050 * -EBADR: This unit type does not support reloading.
1051 * -ENOEXEC: Unit is not started.
1052 * -EAGAIN: An operation is already in progress. Retry later.
1054 int unit_reload(Unit *u) {
1055 UnitActiveState state;
1060 if (u->load_state != UNIT_LOADED)
1063 if (!unit_can_reload(u))
1066 state = unit_active_state(u);
1067 if (state == UNIT_RELOADING)
1070 if (state != UNIT_ACTIVE)
1073 if ((following = unit_following(u))) {
1074 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1075 return unit_reload(following);
1078 unit_add_to_dbus_queue(u);
1079 return UNIT_VTABLE(u)->reload(u);
1082 bool unit_can_reload(Unit *u) {
1085 if (!UNIT_VTABLE(u)->reload)
1088 if (!UNIT_VTABLE(u)->can_reload)
1091 return UNIT_VTABLE(u)->can_reload(u);
1094 static void unit_check_unneeded(Unit *u) {
1100 /* If this service shall be shut down when unneeded then do
1103 if (!u->stop_when_unneeded)
1106 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1109 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1110 if (unit_pending_active(other))
1113 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1114 if (unit_pending_active(other))
1117 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1118 if (unit_pending_active(other))
1121 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1122 if (unit_pending_active(other))
1125 log_info("Service %s is not needed anymore. Stopping.", u->id);
1127 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1128 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1131 static void retroactively_start_dependencies(Unit *u) {
1136 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1138 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1139 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1140 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1141 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1143 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1144 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1145 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1146 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1148 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1149 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1150 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1151 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1153 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1154 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1155 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1156 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1158 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1159 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1160 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1161 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1163 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1164 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1165 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1167 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1168 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1169 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1172 static void retroactively_stop_dependencies(Unit *u) {
1177 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1179 /* Pull down units which are bound to us recursively if enabled */
1180 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1181 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1182 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1185 static void check_unneeded_dependencies(Unit *u) {
1190 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1192 /* Garbage collect services that might not be needed anymore, if enabled */
1193 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1194 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1195 unit_check_unneeded(other);
1196 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1197 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1198 unit_check_unneeded(other);
1199 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1200 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1201 unit_check_unneeded(other);
1202 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1203 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1204 unit_check_unneeded(other);
1205 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1206 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1207 unit_check_unneeded(other);
1208 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1209 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1210 unit_check_unneeded(other);
1213 void unit_trigger_on_failure(Unit *u) {
1219 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1222 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1224 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1227 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1228 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1232 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1236 assert(os < _UNIT_ACTIVE_STATE_MAX);
1237 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1239 /* Note that this is called for all low-level state changes,
1240 * even if they might map to the same high-level
1241 * UnitActiveState! That means that ns == os is OK an expected
1242 * behaviour here. For example: if a mount point is remounted
1243 * this function will be called too! */
1245 if (u->manager->n_reloading <= 0) {
1248 dual_timestamp_get(&ts);
1250 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1251 u->inactive_exit_timestamp = ts;
1252 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1253 u->inactive_enter_timestamp = ts;
1255 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1256 u->active_enter_timestamp = ts;
1257 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1258 u->active_exit_timestamp = ts;
1260 timer_unit_notify(u, ns);
1261 path_unit_notify(u, ns);
1264 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1265 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1270 if (u->job->state == JOB_WAITING)
1272 /* So we reached a different state for this
1273 * job. Let's see if we can run it now if it
1274 * failed previously due to EAGAIN. */
1275 job_add_to_run_queue(u->job);
1277 /* Let's check whether this state change constitutes a
1278 * finished job, or maybe contradicts a running job and
1279 * hence needs to invalidate jobs. */
1281 switch (u->job->type) {
1284 case JOB_VERIFY_ACTIVE:
1286 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1287 job_finish_and_invalidate(u->job, JOB_DONE, true);
1288 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1291 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1292 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1298 case JOB_RELOAD_OR_START:
1300 if (u->job->state == JOB_RUNNING) {
1301 if (ns == UNIT_ACTIVE)
1302 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1303 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1306 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1307 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1315 case JOB_TRY_RESTART:
1317 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1318 job_finish_and_invalidate(u->job, JOB_DONE, true);
1319 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1321 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1327 assert_not_reached("Job type unknown");
1333 if (u->manager->n_reloading <= 0) {
1335 /* If this state change happened without being
1336 * requested by a job, then let's retroactively start
1337 * or stop dependencies. We skip that step when
1338 * deserializing, since we don't want to create any
1339 * additional jobs just because something is already
1343 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1344 retroactively_start_dependencies(u);
1345 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1346 retroactively_stop_dependencies(u);
1349 /* stop unneeded units regardless if going down was expected or not */
1350 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1351 check_unneeded_dependencies(u);
1353 if (ns != os && ns == UNIT_FAILED) {
1354 log_notice("Unit %s entered failed state.", u->id);
1355 unit_trigger_on_failure(u);
1359 /* Some names are special */
1360 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1362 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1363 /* The bus just might have become available,
1364 * hence try to connect to it, if we aren't
1366 bus_init(u->manager, true);
1368 if (u->type == UNIT_SERVICE &&
1369 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1370 u->manager->n_reloading <= 0) {
1371 /* Write audit record if we have just finished starting up */
1372 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1376 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1377 manager_send_unit_plymouth(u->manager, u);
1381 /* We don't care about D-Bus here, since we'll get an
1382 * asynchronous notification for it anyway. */
1384 if (u->type == UNIT_SERVICE &&
1385 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1386 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1387 u->manager->n_reloading <= 0) {
1389 /* Hmm, if there was no start record written
1390 * write it now, so that we always have a nice
1393 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1395 if (ns == UNIT_INACTIVE)
1396 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1398 /* Write audit record if we have just finished shutting down */
1399 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1401 u->in_audit = false;
1405 manager_recheck_journal(u->manager);
1407 /* Maybe we finished startup and are now ready for being
1408 * stopped because unneeded? */
1409 unit_check_unneeded(u);
1411 unit_add_to_dbus_queue(u);
1412 unit_add_to_gc_queue(u);
1415 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1416 struct epoll_event ev;
1421 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1427 if (epoll_ctl(u->manager->epoll_fd,
1428 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1440 void unit_unwatch_fd(Unit *u, Watch *w) {
1444 if (w->type == WATCH_INVALID)
1447 assert(w->type == WATCH_FD);
1448 assert(w->data.unit == u);
1449 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1452 w->type = WATCH_INVALID;
1453 w->data.unit = NULL;
1456 int unit_watch_pid(Unit *u, pid_t pid) {
1460 /* Watch a specific PID. We only support one unit watching
1461 * each PID for now. */
1463 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1466 void unit_unwatch_pid(Unit *u, pid_t pid) {
1470 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1473 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1474 struct itimerspec its;
1480 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1482 /* This will try to reuse the old timer if there is one */
1484 if (w->type == WATCH_UNIT_TIMER) {
1485 assert(w->data.unit == u);
1490 } else if (w->type == WATCH_INVALID) {
1493 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1496 assert_not_reached("Invalid watch type");
1501 /* Set absolute time in the past, but not 0, since we
1502 * don't want to disarm the timer */
1503 its.it_value.tv_sec = 0;
1504 its.it_value.tv_nsec = 1;
1506 flags = TFD_TIMER_ABSTIME;
1508 timespec_store(&its.it_value, delay);
1512 /* This will also flush the elapse counter */
1513 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1516 if (w->type == WATCH_INVALID) {
1517 struct epoll_event ev;
1521 ev.events = EPOLLIN;
1523 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1527 w->type = WATCH_UNIT_TIMER;
1535 close_nointr_nofail(fd);
1540 void unit_unwatch_timer(Unit *u, Watch *w) {
1544 if (w->type == WATCH_INVALID)
1547 assert(w->type == WATCH_UNIT_TIMER);
1548 assert(w->data.unit == u);
1551 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1552 close_nointr_nofail(w->fd);
1555 w->type = WATCH_INVALID;
1556 w->data.unit = NULL;
1559 bool unit_job_is_applicable(Unit *u, JobType j) {
1561 assert(j >= 0 && j < _JOB_TYPE_MAX);
1565 case JOB_VERIFY_ACTIVE:
1572 case JOB_TRY_RESTART:
1573 return unit_can_start(u);
1576 return unit_can_reload(u);
1578 case JOB_RELOAD_OR_START:
1579 return unit_can_reload(u) && unit_can_start(u);
1582 assert_not_reached("Invalid job type");
1586 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1588 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1589 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1590 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1591 [UNIT_WANTS] = UNIT_WANTED_BY,
1592 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1593 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1594 [UNIT_BIND_TO] = UNIT_BOUND_BY,
1595 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1596 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1597 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1598 [UNIT_BOUND_BY] = UNIT_BIND_TO,
1599 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1600 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1601 [UNIT_BEFORE] = UNIT_AFTER,
1602 [UNIT_AFTER] = UNIT_BEFORE,
1603 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1604 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1605 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1606 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1607 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1608 [UNIT_PROPAGATE_RELOAD_TO] = UNIT_PROPAGATE_RELOAD_FROM,
1609 [UNIT_PROPAGATE_RELOAD_FROM] = UNIT_PROPAGATE_RELOAD_TO
1611 int r, q = 0, v = 0, w = 0;
1614 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1617 u = unit_follow_merge(u);
1618 other = unit_follow_merge(other);
1620 /* We won't allow dependencies on ourselves. We will not
1621 * consider them an error however. */
1625 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1628 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1629 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1633 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1634 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1637 if ((q = set_put(u->dependencies[d], other)) < 0)
1640 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1641 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1646 if (add_reference) {
1647 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1652 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1656 unit_add_to_dbus_queue(u);
1661 set_remove(u->dependencies[d], other);
1664 set_remove(other->dependencies[inverse_table[d]], u);
1667 set_remove(u->dependencies[UNIT_REFERENCES], other);
1672 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1677 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1680 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1686 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1690 assert(name || path);
1693 name = path_get_file_name(path);
1695 if (!unit_name_is_template(name)) {
1701 s = unit_name_replace_instance(name, u->instance);
1705 if (!(i = unit_name_to_prefix(u->id)))
1708 s = unit_name_replace_instance(name, i);
1719 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1725 assert(name || path);
1727 if (!(name = resolve_template(u, name, path, &s)))
1730 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1733 r = unit_add_dependency(u, d, other, add_reference);
1740 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1746 assert(name || path);
1748 if (!(name = resolve_template(u, name, path, &s)))
1751 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1754 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1761 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1767 assert(name || path);
1769 if (!(name = resolve_template(u, name, path, &s)))
1772 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1775 r = unit_add_dependency(other, d, u, add_reference);
1782 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1788 assert(name || path);
1790 if (!(name = resolve_template(u, name, path, &s)))
1793 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1796 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1804 int set_unit_path(const char *p) {
1808 /* This is mostly for debug purposes */
1810 if (path_is_absolute(p)) {
1811 if (!(c = strdup(p)))
1814 if (!(cwd = get_current_dir_name()))
1817 r = asprintf(&c, "%s/%s", cwd, p);
1824 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1833 char *unit_dbus_path(Unit *u) {
1841 if (!(e = bus_path_escape(u->id)))
1844 p = strappend("/org/freedesktop/systemd1/unit/", e);
1850 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1858 if (!b->controller) {
1859 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1865 /* Ensure this hasn't been added yet */
1868 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1871 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1872 LIST_PREPEND(CGroupBonding, by_path, l, b);
1874 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1875 LIST_REMOVE(CGroupBonding, by_path, l, b);
1880 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1886 static char *default_cgroup_path(Unit *u) {
1894 t = unit_name_template(u->id);
1898 p = join(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1901 p = join(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1906 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1907 char *controller = NULL, *path = NULL;
1908 CGroupBonding *b = NULL;
1915 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1919 path = default_cgroup_path(u);
1924 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1928 if (!path || !controller) {
1935 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1940 if (!(b = new0(CGroupBonding, 1))) {
1945 b->controller = controller;
1948 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1950 if ((r = unit_add_cgroup(u, b)) < 0)
1963 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1964 CGroupBonding *b = NULL;
1970 controller = SYSTEMD_CGROUP_CONTROLLER;
1972 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1975 if (!(b = new0(CGroupBonding, 1)))
1978 if (!(b->controller = strdup(controller)))
1981 if (!(b->path = default_cgroup_path(u)))
1985 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1987 if ((r = unit_add_cgroup(u, b)) < 0)
1994 free(b->controller);
2000 int unit_add_default_cgroups(Unit *u) {
2007 /* Adds in the default cgroups, if they weren't specified
2010 if (!u->manager->cgroup_hierarchy)
2013 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
2016 STRV_FOREACH(c, u->manager->default_controllers)
2017 unit_add_one_default_cgroup(u, *c);
2019 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2020 unit_add_one_default_cgroup(u, a->controller);
2025 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2028 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
2031 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
2043 dot = strchr(name, '.');
2047 c = strndup(name, dot - name);
2054 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2059 a = new0(CGroupAttribute, 1);
2069 a->controller = strdup(controller);
2071 a->name = strdup(name);
2072 a->value = strdup(value);
2074 if (!a->controller || !a->name || !a->value) {
2075 free(a->controller);
2083 a->map_callback = map_callback;
2085 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2094 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2102 if (!(t = unit_name_change_suffix(u->id, type)))
2105 assert(!unit_has_name(u, t));
2107 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2110 assert(r < 0 || *_found != u);
2115 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2123 if (!(t = unit_name_change_suffix(u->id, type)))
2126 assert(!unit_has_name(u, t));
2128 found = manager_get_unit(u->manager, t);
2138 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2142 return unit_name_to_prefix_and_instance(u->id);
2145 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2149 return unit_name_to_prefix(u->id);
2152 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2158 if (!(p = unit_name_to_prefix(u->id)))
2161 r = unit_name_unescape(p);
2167 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2172 return unit_name_unescape(u->instance);
2177 static char *specifier_filename(char specifier, void *data, void *userdata) {
2182 return unit_name_path_unescape(u->instance);
2184 return unit_name_to_path(u->instance);
2187 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2191 return default_cgroup_path(u);
2194 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2199 if (specifier == 'r')
2200 return strdup(u->manager->cgroup_hierarchy);
2202 if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
2205 if (streq(p, "/")) {
2213 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2217 if (u->manager->running_as == MANAGER_USER) {
2220 e = getenv("XDG_RUNTIME_DIR");
2225 return strdup("/run");
2228 char *unit_name_printf(Unit *u, const char* format) {
2231 * This will use the passed string as format string and
2232 * replace the following specifiers:
2234 * %n: the full id of the unit (foo@bar.waldo)
2235 * %N: the id of the unit without the suffix (foo@bar)
2236 * %p: the prefix (foo)
2237 * %i: the instance (bar)
2240 const Specifier table[] = {
2241 { 'n', specifier_string, u->id },
2242 { 'N', specifier_prefix_and_instance, NULL },
2243 { 'p', specifier_prefix, NULL },
2244 { 'i', specifier_string, u->instance },
2251 return specifier_printf(format, table, u);
2254 char *unit_full_printf(Unit *u, const char *format) {
2256 /* This is similar to unit_name_printf() but also supports
2257 * unescaping. Also, adds a couple of additional codes:
2259 * %c cgroup path of unit
2260 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2261 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2262 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2265 const Specifier table[] = {
2266 { 'n', specifier_string, u->id },
2267 { 'N', specifier_prefix_and_instance, NULL },
2268 { 'p', specifier_prefix, NULL },
2269 { 'P', specifier_prefix_unescaped, NULL },
2270 { 'i', specifier_string, u->instance },
2271 { 'I', specifier_instance_unescaped, NULL },
2272 { 'f', specifier_filename, NULL },
2273 { 'c', specifier_cgroup, NULL },
2274 { 'r', specifier_cgroup_root, NULL },
2275 { 'R', specifier_cgroup_root, NULL },
2276 { 't', specifier_runtime, NULL },
2283 return specifier_printf(format, table, u);
2286 char **unit_full_printf_strv(Unit *u, char **l) {
2290 /* Applies unit_full_printf to every entry in l */
2295 if (!(r = new(char*, n+1)))
2298 for (i = l, j = r; *i; i++, j++)
2299 if (!(*j = unit_full_printf(u, *i)))
2306 for (j--; j >= r; j--)
2314 int unit_watch_bus_name(Unit *u, const char *name) {
2318 /* Watch a specific name on the bus. We only support one unit
2319 * watching each name for now. */
2321 return hashmap_put(u->manager->watch_bus, name, u);
2324 void unit_unwatch_bus_name(Unit *u, const char *name) {
2328 hashmap_remove_value(u->manager->watch_bus, name, u);
2331 bool unit_can_serialize(Unit *u) {
2334 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2337 int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
2344 if (!unit_can_serialize(u))
2347 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2351 fprintf(f, "job\n");
2352 job_serialize(u->job, f, fds);
2356 fprintf(f, "job\n");
2357 job_serialize(u->nop_job, f, fds);
2360 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2361 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2362 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2363 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2364 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2366 if (dual_timestamp_is_set(&u->condition_timestamp))
2367 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2374 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2385 va_start(ap, format);
2386 vfprintf(f, format, ap);
2392 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2398 fprintf(f, "%s=%s\n", key, value);
2401 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2408 if (!unit_can_serialize(u))
2412 char line[LINE_MAX], *l, *v;
2415 if (!fgets(line, sizeof(line), f)) {
2428 k = strcspn(l, "=");
2436 if (streq(l, "job")) {
2438 /* new-style serialized job */
2439 Job *j = job_new_raw(u);
2443 r = job_deserialize(j, f, fds);
2449 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2455 r = job_install_deserialized(j);
2457 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2463 JobType type = job_type_from_string(v);
2465 log_debug("Failed to parse job type value %s", v);
2467 u->deserialized_job = type;
2470 } else if (streq(l, "inactive-exit-timestamp")) {
2471 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2473 } else if (streq(l, "active-enter-timestamp")) {
2474 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2476 } else if (streq(l, "active-exit-timestamp")) {
2477 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2479 } else if (streq(l, "inactive-enter-timestamp")) {
2480 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2482 } else if (streq(l, "condition-timestamp")) {
2483 dual_timestamp_deserialize(v, &u->condition_timestamp);
2485 } else if (streq(l, "condition-result")) {
2488 if ((b = parse_boolean(v)) < 0)
2489 log_debug("Failed to parse condition result value %s", v);
2491 u->condition_result = b;
2496 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2501 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2511 /* Adds in links to the device node that this unit is based on */
2513 if (!is_device_path(what))
2516 if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
2519 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2525 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BIND_TO, device, true)) < 0)
2529 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2535 int unit_coldplug(Unit *u) {
2540 if (UNIT_VTABLE(u)->coldplug)
2541 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2545 r = job_coldplug(u->job);
2548 } else if (u->deserialized_job >= 0) {
2550 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2554 u->deserialized_job = _JOB_TYPE_INVALID;
2560 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2566 if (!manager_get_show_status(u->manager))
2569 if (!manager_is_booting_or_shutting_down(u->manager))
2572 va_start(ap, format);
2573 status_vprintf(status, true, format, ap);
2577 bool unit_need_daemon_reload(Unit *u) {
2580 if (u->fragment_path) {
2584 if (stat(u->fragment_path, &st) < 0)
2585 /* What, cannot access this anymore? */
2588 if (u->fragment_mtime > 0 &&
2589 timespec_load(&st.st_mtim) != u->fragment_mtime)
2593 if (UNIT_VTABLE(u)->need_daemon_reload)
2594 return UNIT_VTABLE(u)->need_daemon_reload(u);
2599 void unit_reset_failed(Unit *u) {
2602 if (UNIT_VTABLE(u)->reset_failed)
2603 UNIT_VTABLE(u)->reset_failed(u);
2606 Unit *unit_following(Unit *u) {
2609 if (UNIT_VTABLE(u)->following)
2610 return UNIT_VTABLE(u)->following(u);
2615 bool unit_pending_inactive(Unit *u) {
2618 /* Returns true if the unit is inactive or going down */
2620 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2623 if (u->job && u->job->type == JOB_STOP)
2629 bool unit_pending_active(Unit *u) {
2632 /* Returns true if the unit is active or going up */
2634 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2638 (u->job->type == JOB_START ||
2639 u->job->type == JOB_RELOAD_OR_START ||
2640 u->job->type == JOB_RESTART))
2646 UnitType unit_name_to_type(const char *n) {
2651 for (t = 0; t < _UNIT_TYPE_MAX; t++)
2652 if (endswith(n, unit_vtable[t]->suffix))
2655 return _UNIT_TYPE_INVALID;
2658 bool unit_name_is_valid(const char *n, bool template_ok) {
2661 t = unit_name_to_type(n);
2662 if (t < 0 || t >= _UNIT_TYPE_MAX)
2665 return unit_name_is_valid_no_type(n, template_ok);
2668 int unit_kill(Unit *u, KillWho w, KillMode m, int signo, DBusError *error) {
2670 assert(w >= 0 && w < _KILL_WHO_MAX);
2671 assert(m >= 0 && m < _KILL_MODE_MAX);
2673 assert(signo < _NSIG);
2678 if (!UNIT_VTABLE(u)->kill)
2681 return UNIT_VTABLE(u)->kill(u, w, m, signo, error);
2684 int unit_following_set(Unit *u, Set **s) {
2688 if (UNIT_VTABLE(u)->following_set)
2689 return UNIT_VTABLE(u)->following_set(u, s);
2695 UnitFileState unit_get_unit_file_state(Unit *u) {
2698 if (u->unit_file_state < 0 && u->fragment_path)
2699 u->unit_file_state = unit_file_get_state(
2700 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2701 NULL, path_get_file_name(u->fragment_path));
2703 return u->unit_file_state;
2706 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2711 unit_ref_unset(ref);
2714 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2718 void unit_ref_unset(UnitRef *ref) {
2724 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2728 int unit_add_one_mount_link(Unit *u, Mount *m) {
2734 if (u->load_state != UNIT_LOADED ||
2735 UNIT(m)->load_state != UNIT_LOADED)
2738 STRV_FOREACH(i, u->requires_mounts_for) {
2743 if (!path_startswith(*i, m->where))
2746 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2752 int unit_add_mount_links(Unit *u) {
2758 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2759 r = unit_add_one_mount_link(u, MOUNT(other));
2767 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
2768 [UNIT_STUB] = "stub",
2769 [UNIT_LOADED] = "loaded",
2770 [UNIT_ERROR] = "error",
2771 [UNIT_MERGED] = "merged",
2772 [UNIT_MASKED] = "masked"
2775 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
2777 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2778 [UNIT_ACTIVE] = "active",
2779 [UNIT_RELOADING] = "reloading",
2780 [UNIT_INACTIVE] = "inactive",
2781 [UNIT_FAILED] = "failed",
2782 [UNIT_ACTIVATING] = "activating",
2783 [UNIT_DEACTIVATING] = "deactivating"
2786 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2788 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2789 [UNIT_REQUIRES] = "Requires",
2790 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2791 [UNIT_WANTS] = "Wants",
2792 [UNIT_REQUISITE] = "Requisite",
2793 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2794 [UNIT_REQUIRED_BY] = "RequiredBy",
2795 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2796 [UNIT_BIND_TO] = "BindTo",
2797 [UNIT_WANTED_BY] = "WantedBy",
2798 [UNIT_CONFLICTS] = "Conflicts",
2799 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2800 [UNIT_BOUND_BY] = "BoundBy",
2801 [UNIT_BEFORE] = "Before",
2802 [UNIT_AFTER] = "After",
2803 [UNIT_REFERENCES] = "References",
2804 [UNIT_REFERENCED_BY] = "ReferencedBy",
2805 [UNIT_ON_FAILURE] = "OnFailure",
2806 [UNIT_TRIGGERS] = "Triggers",
2807 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2808 [UNIT_PROPAGATE_RELOAD_TO] = "PropagateReloadTo",
2809 [UNIT_PROPAGATE_RELOAD_FROM] = "PropagateReloadFrom"
2812 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);