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 free(u->fragment_path);
403 set_free_free(u->names);
405 condition_free_list(u->conditions);
408 unit_ref_unset(u->refs);
413 UnitActiveState unit_active_state(Unit *u) {
416 if (u->load_state == UNIT_MERGED)
417 return unit_active_state(unit_follow_merge(u));
419 /* After a reload it might happen that a unit is not correctly
420 * loaded but still has a process around. That's why we won't
421 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
423 return UNIT_VTABLE(u)->active_state(u);
426 const char* unit_sub_state_to_string(Unit *u) {
429 return UNIT_VTABLE(u)->sub_state_to_string(u);
432 static void complete_move(Set **s, Set **other) {
440 set_move(*s, *other);
447 static void merge_names(Unit *u, Unit *other) {
454 complete_move(&u->names, &other->names);
456 set_free_free(other->names);
460 SET_FOREACH(t, u->names, i)
461 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
464 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
471 assert(d < _UNIT_DEPENDENCY_MAX);
473 /* Fix backwards pointers */
474 SET_FOREACH(back, other->dependencies[d], i) {
477 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
478 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
481 set_remove(back->dependencies[k], other);
483 assert(r == -ENOENT);
487 complete_move(&u->dependencies[d], &other->dependencies[d]);
489 set_free(other->dependencies[d]);
490 other->dependencies[d] = NULL;
493 int unit_merge(Unit *u, Unit *other) {
498 assert(u->manager == other->manager);
499 assert(u->type != _UNIT_TYPE_INVALID);
501 other = unit_follow_merge(other);
506 if (u->type != other->type)
509 if (!u->instance != !other->instance)
512 if (other->load_state != UNIT_STUB &&
513 other->load_state != UNIT_ERROR)
522 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
526 merge_names(u, other);
528 /* Redirect all references */
530 unit_ref_set(other->refs, u);
532 /* Merge dependencies */
533 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
534 merge_dependencies(u, other, d);
536 other->load_state = UNIT_MERGED;
537 other->merged_into = u;
539 /* If there is still some data attached to the other node, we
540 * don't need it anymore, and can free it. */
541 if (other->load_state != UNIT_STUB)
542 if (UNIT_VTABLE(other)->done)
543 UNIT_VTABLE(other)->done(other);
545 unit_add_to_dbus_queue(u);
546 unit_add_to_cleanup_queue(other);
551 int unit_merge_by_name(Unit *u, const char *name) {
559 if (unit_name_is_template(name)) {
563 if (!(s = unit_name_replace_instance(name, u->instance)))
569 if (!(other = manager_get_unit(u->manager, name)))
570 r = unit_add_name(u, name);
572 r = unit_merge(u, other);
578 Unit* unit_follow_merge(Unit *u) {
581 while (u->load_state == UNIT_MERGED)
582 assert_se(u = u->merged_into);
587 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
593 if (c->std_output != EXEC_OUTPUT_KMSG &&
594 c->std_output != EXEC_OUTPUT_SYSLOG &&
595 c->std_output != EXEC_OUTPUT_JOURNAL &&
596 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
597 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
598 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
599 c->std_error != EXEC_OUTPUT_KMSG &&
600 c->std_error != EXEC_OUTPUT_SYSLOG &&
601 c->std_error != EXEC_OUTPUT_JOURNAL &&
602 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
603 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
604 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
607 /* If syslog or kernel logging is requested, make sure our own
608 * logging daemon is run first. */
610 if (u->manager->running_as == MANAGER_SYSTEM)
611 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
617 const char *unit_description(Unit *u) {
621 return u->description;
626 void unit_dump(Unit *u, FILE *f, const char *prefix) {
633 timestamp1[FORMAT_TIMESTAMP_MAX],
634 timestamp2[FORMAT_TIMESTAMP_MAX],
635 timestamp3[FORMAT_TIMESTAMP_MAX],
636 timestamp4[FORMAT_TIMESTAMP_MAX],
637 timespan[FORMAT_TIMESPAN_MAX];
641 assert(u->type >= 0);
645 p2 = strappend(prefix, "\t");
646 prefix2 = p2 ? p2 : prefix;
650 "%s\tDescription: %s\n"
652 "%s\tUnit Load State: %s\n"
653 "%s\tUnit Active State: %s\n"
654 "%s\tInactive Exit Timestamp: %s\n"
655 "%s\tActive Enter Timestamp: %s\n"
656 "%s\tActive Exit Timestamp: %s\n"
657 "%s\tInactive Enter Timestamp: %s\n"
658 "%s\tGC Check Good: %s\n"
659 "%s\tNeed Daemon Reload: %s\n",
661 prefix, unit_description(u),
662 prefix, strna(u->instance),
663 prefix, unit_load_state_to_string(u->load_state),
664 prefix, unit_active_state_to_string(unit_active_state(u)),
665 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
666 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
667 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
668 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
669 prefix, yes_no(unit_check_gc(u)),
670 prefix, yes_no(unit_need_daemon_reload(u)));
672 SET_FOREACH(t, u->names, i)
673 fprintf(f, "%s\tName: %s\n", prefix, t);
675 if ((following = unit_following(u)))
676 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
678 if (u->fragment_path)
679 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
681 if (u->job_timeout > 0)
682 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
684 condition_dump_list(u->conditions, f, prefix);
686 if (dual_timestamp_is_set(&u->condition_timestamp))
688 "%s\tCondition Timestamp: %s\n"
689 "%s\tCondition Result: %s\n",
690 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
691 prefix, yes_no(u->condition_result));
693 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
696 SET_FOREACH(other, u->dependencies[d], i)
697 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
700 if (!strv_isempty(u->requires_mounts_for)) {
704 "%s\tRequiresMountsFor:", prefix);
706 STRV_FOREACH(j, u->requires_mounts_for)
707 fprintf(f, " %s", *j);
712 if (u->load_state == UNIT_LOADED) {
717 "%s\tStopWhenUnneeded: %s\n"
718 "%s\tRefuseManualStart: %s\n"
719 "%s\tRefuseManualStop: %s\n"
720 "%s\tDefaultDependencies: %s\n"
721 "%s\tOnFailureIsolate: %s\n"
722 "%s\tIgnoreOnIsolate: %s\n"
723 "%s\tIgnoreOnSnapshot: %s\n",
724 prefix, yes_no(u->stop_when_unneeded),
725 prefix, yes_no(u->refuse_manual_start),
726 prefix, yes_no(u->refuse_manual_stop),
727 prefix, yes_no(u->default_dependencies),
728 prefix, yes_no(u->on_failure_isolate),
729 prefix, yes_no(u->ignore_on_isolate),
730 prefix, yes_no(u->ignore_on_snapshot));
732 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
733 fprintf(f, "%s\tControlGroup: %s:%s\n",
734 prefix, b->controller, b->path);
736 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
740 a->map_callback(a->controller, a->name, a->value, &v);
742 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
743 prefix, a->controller, a->name, v ? v : a->value);
748 if (UNIT_VTABLE(u)->dump)
749 UNIT_VTABLE(u)->dump(u, f, prefix2);
751 } else if (u->load_state == UNIT_MERGED)
753 "%s\tMerged into: %s\n",
754 prefix, u->merged_into->id);
755 else if (u->load_state == UNIT_ERROR)
756 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
760 job_dump(u->job, f, prefix2);
763 job_dump(u->nop_job, f, prefix2);
768 /* Common implementation for multiple backends */
769 int unit_load_fragment_and_dropin(Unit *u) {
774 /* Load a .service file */
775 if ((r = unit_load_fragment(u)) < 0)
778 if (u->load_state == UNIT_STUB)
781 /* Load drop-in directory data */
782 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
788 /* Common implementation for multiple backends */
789 int unit_load_fragment_and_dropin_optional(Unit *u) {
794 /* Same as unit_load_fragment_and_dropin(), but whether
795 * something can be loaded or not doesn't matter. */
797 /* Load a .service file */
798 if ((r = unit_load_fragment(u)) < 0)
801 if (u->load_state == UNIT_STUB)
802 u->load_state = UNIT_LOADED;
804 /* Load drop-in directory data */
805 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
811 int unit_add_default_target_dependency(Unit *u, Unit *target) {
815 if (target->type != UNIT_TARGET)
818 /* Only add the dependency if both units are loaded, so that
819 * that loop check below is reliable */
820 if (u->load_state != UNIT_LOADED ||
821 target->load_state != UNIT_LOADED)
824 /* If either side wants no automatic dependencies, then let's
826 if (!u->default_dependencies ||
827 !target->default_dependencies)
830 /* Don't create loops */
831 if (set_get(target->dependencies[UNIT_BEFORE], u))
834 return unit_add_dependency(target, UNIT_AFTER, u, true);
837 static int unit_add_default_dependencies(Unit *u) {
838 static const UnitDependency deps[] = {
840 UNIT_REQUIRED_BY_OVERRIDABLE,
852 for (k = 0; k < ELEMENTSOF(deps); k++)
853 SET_FOREACH(target, u->dependencies[deps[k]], i)
854 if ((r = unit_add_default_target_dependency(u, target)) < 0)
860 int unit_load(Unit *u) {
865 if (u->in_load_queue) {
866 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
867 u->in_load_queue = false;
870 if (u->type == _UNIT_TYPE_INVALID)
873 if (u->load_state != UNIT_STUB)
876 if (UNIT_VTABLE(u)->load)
877 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
880 if (u->load_state == UNIT_STUB) {
885 if (u->load_state == UNIT_LOADED &&
886 u->default_dependencies)
887 if ((r = unit_add_default_dependencies(u)) < 0)
890 if (u->load_state == UNIT_LOADED) {
891 r = unit_add_mount_links(u);
896 if (u->on_failure_isolate &&
897 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
899 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
906 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
908 unit_add_to_dbus_queue(unit_follow_merge(u));
909 unit_add_to_gc_queue(u);
914 u->load_state = UNIT_ERROR;
916 unit_add_to_dbus_queue(u);
917 unit_add_to_gc_queue(u);
919 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
924 bool unit_condition_test(Unit *u) {
927 dual_timestamp_get(&u->condition_timestamp);
928 u->condition_result = condition_test_list(u->conditions);
930 return u->condition_result;
933 static void unit_status_print_starting_stopping(Unit *u, bool stopping) {
934 const UnitStatusMessageFormats *format_table;
937 format_table = &UNIT_VTABLE(u)->status_message_formats;
941 format = format_table->starting_stopping[stopping];
945 unit_status_printf(u, "", format, unit_description(u));
949 * -EBADR: This unit type does not support starting.
950 * -EALREADY: Unit is already started.
951 * -EAGAIN: An operation is already in progress. Retry later.
952 * -ECANCELED: Too many requests for now.
954 int unit_start(Unit *u) {
955 UnitActiveState state;
960 if (u->load_state != UNIT_LOADED)
963 /* If this is already started, then this will succeed. Note
964 * that this will even succeed if this unit is not startable
965 * by the user. This is relied on to detect when we need to
966 * wait for units and when waiting is finished. */
967 state = unit_active_state(u);
968 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
971 /* If the conditions failed, don't do anything at all. If we
972 * already are activating this call might still be useful to
973 * speed up activation in case there is some hold-off time,
974 * but we don't want to recheck the condition in that case. */
975 if (state != UNIT_ACTIVATING &&
976 !unit_condition_test(u)) {
977 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
981 /* Forward to the main object, if we aren't it. */
982 if ((following = unit_following(u))) {
983 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
984 return unit_start(following);
987 unit_status_print_starting_stopping(u, false);
989 /* If it is stopped, but we cannot start it, then fail */
990 if (!UNIT_VTABLE(u)->start)
993 /* We don't suppress calls to ->start() here when we are
994 * already starting, to allow this request to be used as a
995 * "hurry up" call, for example when the unit is in some "auto
996 * restart" state where it waits for a holdoff timer to elapse
997 * before it will start again. */
999 unit_add_to_dbus_queue(u);
1001 return UNIT_VTABLE(u)->start(u);
1004 bool unit_can_start(Unit *u) {
1007 return !!UNIT_VTABLE(u)->start;
1010 bool unit_can_isolate(Unit *u) {
1013 return unit_can_start(u) &&
1018 * -EBADR: This unit type does not support stopping.
1019 * -EALREADY: Unit is already stopped.
1020 * -EAGAIN: An operation is already in progress. Retry later.
1022 int unit_stop(Unit *u) {
1023 UnitActiveState state;
1028 state = unit_active_state(u);
1029 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1032 if ((following = unit_following(u))) {
1033 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1034 return unit_stop(following);
1037 unit_status_print_starting_stopping(u, true);
1039 if (!UNIT_VTABLE(u)->stop)
1042 unit_add_to_dbus_queue(u);
1044 return UNIT_VTABLE(u)->stop(u);
1048 * -EBADR: This unit type does not support reloading.
1049 * -ENOEXEC: Unit is not started.
1050 * -EAGAIN: An operation is already in progress. Retry later.
1052 int unit_reload(Unit *u) {
1053 UnitActiveState state;
1058 if (u->load_state != UNIT_LOADED)
1061 if (!unit_can_reload(u))
1064 state = unit_active_state(u);
1065 if (state == UNIT_RELOADING)
1068 if (state != UNIT_ACTIVE)
1071 if ((following = unit_following(u))) {
1072 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1073 return unit_reload(following);
1076 unit_add_to_dbus_queue(u);
1077 return UNIT_VTABLE(u)->reload(u);
1080 bool unit_can_reload(Unit *u) {
1083 if (!UNIT_VTABLE(u)->reload)
1086 if (!UNIT_VTABLE(u)->can_reload)
1089 return UNIT_VTABLE(u)->can_reload(u);
1092 static void unit_check_unneeded(Unit *u) {
1098 /* If this service shall be shut down when unneeded then do
1101 if (!u->stop_when_unneeded)
1104 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1107 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1108 if (unit_pending_active(other))
1111 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1112 if (unit_pending_active(other))
1115 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1116 if (unit_pending_active(other))
1119 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1120 if (unit_pending_active(other))
1123 log_info("Service %s is not needed anymore. Stopping.", u->id);
1125 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1126 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1129 static void retroactively_start_dependencies(Unit *u) {
1134 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1136 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1137 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1138 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1139 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1141 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1142 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1143 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1144 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1146 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1147 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1148 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1149 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1151 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1152 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1153 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1154 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1156 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1157 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1158 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1159 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1161 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1162 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1163 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1165 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1166 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1167 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1170 static void retroactively_stop_dependencies(Unit *u) {
1175 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1177 /* Pull down units which are bound to us recursively if enabled */
1178 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1179 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1180 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1183 static void check_unneeded_dependencies(Unit *u) {
1188 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1190 /* Garbage collect services that might not be needed anymore, if enabled */
1191 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1192 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1193 unit_check_unneeded(other);
1194 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1195 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1196 unit_check_unneeded(other);
1197 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1198 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1199 unit_check_unneeded(other);
1200 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1201 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1202 unit_check_unneeded(other);
1203 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1204 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1205 unit_check_unneeded(other);
1206 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1207 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1208 unit_check_unneeded(other);
1211 void unit_trigger_on_failure(Unit *u) {
1217 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1220 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1222 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1225 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1226 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1230 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1234 assert(os < _UNIT_ACTIVE_STATE_MAX);
1235 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1237 /* Note that this is called for all low-level state changes,
1238 * even if they might map to the same high-level
1239 * UnitActiveState! That means that ns == os is OK an expected
1240 * behaviour here. For example: if a mount point is remounted
1241 * this function will be called too! */
1243 if (u->manager->n_reloading <= 0) {
1246 dual_timestamp_get(&ts);
1248 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1249 u->inactive_exit_timestamp = ts;
1250 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1251 u->inactive_enter_timestamp = ts;
1253 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1254 u->active_enter_timestamp = ts;
1255 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1256 u->active_exit_timestamp = ts;
1258 timer_unit_notify(u, ns);
1259 path_unit_notify(u, ns);
1262 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1263 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1268 if (u->job->state == JOB_WAITING)
1270 /* So we reached a different state for this
1271 * job. Let's see if we can run it now if it
1272 * failed previously due to EAGAIN. */
1273 job_add_to_run_queue(u->job);
1275 /* Let's check whether this state change constitutes a
1276 * finished job, or maybe contradicts a running job and
1277 * hence needs to invalidate jobs. */
1279 switch (u->job->type) {
1282 case JOB_VERIFY_ACTIVE:
1284 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1285 job_finish_and_invalidate(u->job, JOB_DONE, true);
1286 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1289 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1290 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1296 case JOB_RELOAD_OR_START:
1298 if (u->job->state == JOB_RUNNING) {
1299 if (ns == UNIT_ACTIVE)
1300 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1301 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1304 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1305 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1313 case JOB_TRY_RESTART:
1315 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1316 job_finish_and_invalidate(u->job, JOB_DONE, true);
1317 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1319 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1325 assert_not_reached("Job type unknown");
1331 if (u->manager->n_reloading <= 0) {
1333 /* If this state change happened without being
1334 * requested by a job, then let's retroactively start
1335 * or stop dependencies. We skip that step when
1336 * deserializing, since we don't want to create any
1337 * additional jobs just because something is already
1341 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1342 retroactively_start_dependencies(u);
1343 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1344 retroactively_stop_dependencies(u);
1347 /* stop unneeded units regardless if going down was expected or not */
1348 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1349 check_unneeded_dependencies(u);
1351 if (ns != os && ns == UNIT_FAILED) {
1352 log_notice("Unit %s entered failed state.", u->id);
1353 unit_trigger_on_failure(u);
1357 /* Some names are special */
1358 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1360 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1361 /* The bus just might have become available,
1362 * hence try to connect to it, if we aren't
1364 bus_init(u->manager, true);
1366 if (u->type == UNIT_SERVICE &&
1367 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1368 u->manager->n_reloading <= 0) {
1369 /* Write audit record if we have just finished starting up */
1370 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1374 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1375 manager_send_unit_plymouth(u->manager, u);
1379 /* We don't care about D-Bus here, since we'll get an
1380 * asynchronous notification for it anyway. */
1382 if (u->type == UNIT_SERVICE &&
1383 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1384 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1385 u->manager->n_reloading <= 0) {
1387 /* Hmm, if there was no start record written
1388 * write it now, so that we always have a nice
1391 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1393 if (ns == UNIT_INACTIVE)
1394 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1396 /* Write audit record if we have just finished shutting down */
1397 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1399 u->in_audit = false;
1403 manager_recheck_journal(u->manager);
1405 /* Maybe we finished startup and are now ready for being
1406 * stopped because unneeded? */
1407 unit_check_unneeded(u);
1409 unit_add_to_dbus_queue(u);
1410 unit_add_to_gc_queue(u);
1413 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1414 struct epoll_event ev;
1419 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1425 if (epoll_ctl(u->manager->epoll_fd,
1426 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1438 void unit_unwatch_fd(Unit *u, Watch *w) {
1442 if (w->type == WATCH_INVALID)
1445 assert(w->type == WATCH_FD);
1446 assert(w->data.unit == u);
1447 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1450 w->type = WATCH_INVALID;
1451 w->data.unit = NULL;
1454 int unit_watch_pid(Unit *u, pid_t pid) {
1458 /* Watch a specific PID. We only support one unit watching
1459 * each PID for now. */
1461 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1464 void unit_unwatch_pid(Unit *u, pid_t pid) {
1468 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1471 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1472 struct itimerspec its;
1478 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1480 /* This will try to reuse the old timer if there is one */
1482 if (w->type == WATCH_UNIT_TIMER) {
1483 assert(w->data.unit == u);
1488 } else if (w->type == WATCH_INVALID) {
1491 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1494 assert_not_reached("Invalid watch type");
1499 /* Set absolute time in the past, but not 0, since we
1500 * don't want to disarm the timer */
1501 its.it_value.tv_sec = 0;
1502 its.it_value.tv_nsec = 1;
1504 flags = TFD_TIMER_ABSTIME;
1506 timespec_store(&its.it_value, delay);
1510 /* This will also flush the elapse counter */
1511 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1514 if (w->type == WATCH_INVALID) {
1515 struct epoll_event ev;
1519 ev.events = EPOLLIN;
1521 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1525 w->type = WATCH_UNIT_TIMER;
1533 close_nointr_nofail(fd);
1538 void unit_unwatch_timer(Unit *u, Watch *w) {
1542 if (w->type == WATCH_INVALID)
1545 assert(w->type == WATCH_UNIT_TIMER);
1546 assert(w->data.unit == u);
1549 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1550 close_nointr_nofail(w->fd);
1553 w->type = WATCH_INVALID;
1554 w->data.unit = NULL;
1557 bool unit_job_is_applicable(Unit *u, JobType j) {
1559 assert(j >= 0 && j < _JOB_TYPE_MAX);
1563 case JOB_VERIFY_ACTIVE:
1570 case JOB_TRY_RESTART:
1571 return unit_can_start(u);
1574 return unit_can_reload(u);
1576 case JOB_RELOAD_OR_START:
1577 return unit_can_reload(u) && unit_can_start(u);
1580 assert_not_reached("Invalid job type");
1584 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1586 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1587 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1588 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1589 [UNIT_WANTS] = UNIT_WANTED_BY,
1590 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1591 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1592 [UNIT_BIND_TO] = UNIT_BOUND_BY,
1593 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1594 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1595 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1596 [UNIT_BOUND_BY] = UNIT_BIND_TO,
1597 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1598 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1599 [UNIT_BEFORE] = UNIT_AFTER,
1600 [UNIT_AFTER] = UNIT_BEFORE,
1601 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1602 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1603 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1604 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1605 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1606 [UNIT_PROPAGATE_RELOAD_TO] = UNIT_PROPAGATE_RELOAD_FROM,
1607 [UNIT_PROPAGATE_RELOAD_FROM] = UNIT_PROPAGATE_RELOAD_TO
1609 int r, q = 0, v = 0, w = 0;
1612 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1615 u = unit_follow_merge(u);
1616 other = unit_follow_merge(other);
1618 /* We won't allow dependencies on ourselves. We will not
1619 * consider them an error however. */
1623 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1626 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1627 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1631 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1632 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1635 if ((q = set_put(u->dependencies[d], other)) < 0)
1638 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1639 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1644 if (add_reference) {
1645 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1650 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1654 unit_add_to_dbus_queue(u);
1659 set_remove(u->dependencies[d], other);
1662 set_remove(other->dependencies[inverse_table[d]], u);
1665 set_remove(u->dependencies[UNIT_REFERENCES], other);
1670 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1675 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1678 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1684 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1688 assert(name || path);
1691 name = path_get_file_name(path);
1693 if (!unit_name_is_template(name)) {
1699 s = unit_name_replace_instance(name, u->instance);
1703 if (!(i = unit_name_to_prefix(u->id)))
1706 s = unit_name_replace_instance(name, i);
1717 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1723 assert(name || path);
1725 if (!(name = resolve_template(u, name, path, &s)))
1728 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1731 r = unit_add_dependency(u, d, other, add_reference);
1738 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1744 assert(name || path);
1746 if (!(name = resolve_template(u, name, path, &s)))
1749 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1752 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1759 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1765 assert(name || path);
1767 if (!(name = resolve_template(u, name, path, &s)))
1770 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1773 r = unit_add_dependency(other, d, u, add_reference);
1780 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1786 assert(name || path);
1788 if (!(name = resolve_template(u, name, path, &s)))
1791 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1794 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1802 int set_unit_path(const char *p) {
1806 /* This is mostly for debug purposes */
1808 if (path_is_absolute(p)) {
1809 if (!(c = strdup(p)))
1812 if (!(cwd = get_current_dir_name()))
1815 r = asprintf(&c, "%s/%s", cwd, p);
1822 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1831 char *unit_dbus_path(Unit *u) {
1839 if (!(e = bus_path_escape(u->id)))
1842 p = strappend("/org/freedesktop/systemd1/unit/", e);
1848 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1856 if (!b->controller) {
1857 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1863 /* Ensure this hasn't been added yet */
1866 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1869 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1870 LIST_PREPEND(CGroupBonding, by_path, l, b);
1872 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1873 LIST_REMOVE(CGroupBonding, by_path, l, b);
1878 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1884 static char *default_cgroup_path(Unit *u) {
1892 t = unit_name_template(u->id);
1896 p = join(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1899 p = join(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1904 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1905 char *controller = NULL, *path = NULL;
1906 CGroupBonding *b = NULL;
1913 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1917 path = default_cgroup_path(u);
1922 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1926 if (!path || !controller) {
1933 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1938 if (!(b = new0(CGroupBonding, 1))) {
1943 b->controller = controller;
1946 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1948 if ((r = unit_add_cgroup(u, b)) < 0)
1961 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1962 CGroupBonding *b = NULL;
1968 controller = SYSTEMD_CGROUP_CONTROLLER;
1970 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1973 if (!(b = new0(CGroupBonding, 1)))
1976 if (!(b->controller = strdup(controller)))
1979 if (!(b->path = default_cgroup_path(u)))
1983 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1985 if ((r = unit_add_cgroup(u, b)) < 0)
1992 free(b->controller);
1998 int unit_add_default_cgroups(Unit *u) {
2005 /* Adds in the default cgroups, if they weren't specified
2008 if (!u->manager->cgroup_hierarchy)
2011 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
2014 STRV_FOREACH(c, u->manager->default_controllers)
2015 unit_add_one_default_cgroup(u, *c);
2017 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2018 unit_add_one_default_cgroup(u, a->controller);
2023 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2026 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
2029 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
2041 dot = strchr(name, '.');
2045 c = strndup(name, dot - name);
2052 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2057 a = new0(CGroupAttribute, 1);
2067 a->controller = strdup(controller);
2069 a->name = strdup(name);
2070 a->value = strdup(value);
2072 if (!a->controller || !a->name || !a->value) {
2073 free(a->controller);
2081 a->map_callback = map_callback;
2083 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2092 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2100 if (!(t = unit_name_change_suffix(u->id, type)))
2103 assert(!unit_has_name(u, t));
2105 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2108 assert(r < 0 || *_found != u);
2113 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2121 if (!(t = unit_name_change_suffix(u->id, type)))
2124 assert(!unit_has_name(u, t));
2126 found = manager_get_unit(u->manager, t);
2136 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2140 return unit_name_to_prefix_and_instance(u->id);
2143 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2147 return unit_name_to_prefix(u->id);
2150 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2156 if (!(p = unit_name_to_prefix(u->id)))
2159 r = unit_name_unescape(p);
2165 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2170 return unit_name_unescape(u->instance);
2175 static char *specifier_filename(char specifier, void *data, void *userdata) {
2180 return unit_name_path_unescape(u->instance);
2182 return unit_name_to_path(u->instance);
2185 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2189 return default_cgroup_path(u);
2192 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2197 if (specifier == 'r')
2198 return strdup(u->manager->cgroup_hierarchy);
2200 if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
2203 if (streq(p, "/")) {
2211 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2215 if (u->manager->running_as == MANAGER_USER) {
2218 e = getenv("XDG_RUNTIME_DIR");
2223 return strdup("/run");
2226 char *unit_name_printf(Unit *u, const char* format) {
2229 * This will use the passed string as format string and
2230 * replace the following specifiers:
2232 * %n: the full id of the unit (foo@bar.waldo)
2233 * %N: the id of the unit without the suffix (foo@bar)
2234 * %p: the prefix (foo)
2235 * %i: the instance (bar)
2238 const Specifier table[] = {
2239 { 'n', specifier_string, u->id },
2240 { 'N', specifier_prefix_and_instance, NULL },
2241 { 'p', specifier_prefix, NULL },
2242 { 'i', specifier_string, u->instance },
2249 return specifier_printf(format, table, u);
2252 char *unit_full_printf(Unit *u, const char *format) {
2254 /* This is similar to unit_name_printf() but also supports
2255 * unescaping. Also, adds a couple of additional codes:
2257 * %c cgroup path of unit
2258 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2259 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2260 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2263 const Specifier table[] = {
2264 { 'n', specifier_string, u->id },
2265 { 'N', specifier_prefix_and_instance, NULL },
2266 { 'p', specifier_prefix, NULL },
2267 { 'P', specifier_prefix_unescaped, NULL },
2268 { 'i', specifier_string, u->instance },
2269 { 'I', specifier_instance_unescaped, NULL },
2270 { 'f', specifier_filename, NULL },
2271 { 'c', specifier_cgroup, NULL },
2272 { 'r', specifier_cgroup_root, NULL },
2273 { 'R', specifier_cgroup_root, NULL },
2274 { 't', specifier_runtime, NULL },
2281 return specifier_printf(format, table, u);
2284 char **unit_full_printf_strv(Unit *u, char **l) {
2288 /* Applies unit_full_printf to every entry in l */
2293 if (!(r = new(char*, n+1)))
2296 for (i = l, j = r; *i; i++, j++)
2297 if (!(*j = unit_full_printf(u, *i)))
2304 for (j--; j >= r; j--)
2312 int unit_watch_bus_name(Unit *u, const char *name) {
2316 /* Watch a specific name on the bus. We only support one unit
2317 * watching each name for now. */
2319 return hashmap_put(u->manager->watch_bus, name, u);
2322 void unit_unwatch_bus_name(Unit *u, const char *name) {
2326 hashmap_remove_value(u->manager->watch_bus, name, u);
2329 bool unit_can_serialize(Unit *u) {
2332 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2335 int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
2342 if (!unit_can_serialize(u))
2345 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2349 fprintf(f, "job\n");
2350 job_serialize(u->job, f, fds);
2354 fprintf(f, "job\n");
2355 job_serialize(u->nop_job, f, fds);
2358 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2359 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2360 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2361 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2362 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2364 if (dual_timestamp_is_set(&u->condition_timestamp))
2365 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2372 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2383 va_start(ap, format);
2384 vfprintf(f, format, ap);
2390 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2396 fprintf(f, "%s=%s\n", key, value);
2399 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2406 if (!unit_can_serialize(u))
2410 char line[LINE_MAX], *l, *v;
2413 if (!fgets(line, sizeof(line), f)) {
2426 k = strcspn(l, "=");
2434 if (streq(l, "job")) {
2436 /* new-style serialized job */
2437 Job *j = job_new_raw(u);
2441 r = job_deserialize(j, f, fds);
2447 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2453 r = job_install_deserialized(j);
2455 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2461 JobType type = job_type_from_string(v);
2463 log_debug("Failed to parse job type value %s", v);
2465 u->deserialized_job = type;
2468 } else if (streq(l, "inactive-exit-timestamp")) {
2469 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2471 } else if (streq(l, "active-enter-timestamp")) {
2472 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2474 } else if (streq(l, "active-exit-timestamp")) {
2475 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2477 } else if (streq(l, "inactive-enter-timestamp")) {
2478 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2480 } else if (streq(l, "condition-timestamp")) {
2481 dual_timestamp_deserialize(v, &u->condition_timestamp);
2483 } else if (streq(l, "condition-result")) {
2486 if ((b = parse_boolean(v)) < 0)
2487 log_debug("Failed to parse condition result value %s", v);
2489 u->condition_result = b;
2494 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2499 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2509 /* Adds in links to the device node that this unit is based on */
2511 if (!is_device_path(what))
2514 if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
2517 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2523 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BIND_TO, device, true)) < 0)
2527 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2533 int unit_coldplug(Unit *u) {
2538 if (UNIT_VTABLE(u)->coldplug)
2539 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2543 r = job_coldplug(u->job);
2546 } else if (u->deserialized_job >= 0) {
2548 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2552 u->deserialized_job = _JOB_TYPE_INVALID;
2558 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2564 if (!manager_get_show_status(u->manager))
2567 if (!manager_is_booting_or_shutting_down(u->manager))
2570 va_start(ap, format);
2571 status_vprintf(status, true, format, ap);
2575 bool unit_need_daemon_reload(Unit *u) {
2578 if (u->fragment_path) {
2582 if (stat(u->fragment_path, &st) < 0)
2583 /* What, cannot access this anymore? */
2586 if (u->fragment_mtime > 0 &&
2587 timespec_load(&st.st_mtim) != u->fragment_mtime)
2591 if (UNIT_VTABLE(u)->need_daemon_reload)
2592 return UNIT_VTABLE(u)->need_daemon_reload(u);
2597 void unit_reset_failed(Unit *u) {
2600 if (UNIT_VTABLE(u)->reset_failed)
2601 UNIT_VTABLE(u)->reset_failed(u);
2604 Unit *unit_following(Unit *u) {
2607 if (UNIT_VTABLE(u)->following)
2608 return UNIT_VTABLE(u)->following(u);
2613 bool unit_pending_inactive(Unit *u) {
2616 /* Returns true if the unit is inactive or going down */
2618 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2621 if (u->job && u->job->type == JOB_STOP)
2627 bool unit_pending_active(Unit *u) {
2630 /* Returns true if the unit is active or going up */
2632 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2636 (u->job->type == JOB_START ||
2637 u->job->type == JOB_RELOAD_OR_START ||
2638 u->job->type == JOB_RESTART))
2644 UnitType unit_name_to_type(const char *n) {
2649 for (t = 0; t < _UNIT_TYPE_MAX; t++)
2650 if (endswith(n, unit_vtable[t]->suffix))
2653 return _UNIT_TYPE_INVALID;
2656 bool unit_name_is_valid(const char *n, bool template_ok) {
2659 t = unit_name_to_type(n);
2660 if (t < 0 || t >= _UNIT_TYPE_MAX)
2663 return unit_name_is_valid_no_type(n, template_ok);
2666 int unit_kill(Unit *u, KillWho w, KillMode m, int signo, DBusError *error) {
2668 assert(w >= 0 && w < _KILL_WHO_MAX);
2669 assert(m >= 0 && m < _KILL_MODE_MAX);
2671 assert(signo < _NSIG);
2676 if (!UNIT_VTABLE(u)->kill)
2679 return UNIT_VTABLE(u)->kill(u, w, m, signo, error);
2682 int unit_following_set(Unit *u, Set **s) {
2686 if (UNIT_VTABLE(u)->following_set)
2687 return UNIT_VTABLE(u)->following_set(u, s);
2693 UnitFileState unit_get_unit_file_state(Unit *u) {
2696 if (u->unit_file_state < 0 && u->fragment_path)
2697 u->unit_file_state = unit_file_get_state(
2698 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2699 NULL, path_get_file_name(u->fragment_path));
2701 return u->unit_file_state;
2704 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2709 unit_ref_unset(ref);
2712 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2716 void unit_ref_unset(UnitRef *ref) {
2722 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2726 int unit_add_one_mount_link(Unit *u, Mount *m) {
2732 if (u->load_state != UNIT_LOADED ||
2733 UNIT(m)->load_state != UNIT_LOADED)
2736 STRV_FOREACH(i, u->requires_mounts_for) {
2741 if (!path_startswith(*i, m->where))
2744 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2750 int unit_add_mount_links(Unit *u) {
2756 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2757 r = unit_add_one_mount_link(u, MOUNT(other));
2765 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
2766 [UNIT_STUB] = "stub",
2767 [UNIT_LOADED] = "loaded",
2768 [UNIT_ERROR] = "error",
2769 [UNIT_MERGED] = "merged",
2770 [UNIT_MASKED] = "masked"
2773 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
2775 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2776 [UNIT_ACTIVE] = "active",
2777 [UNIT_RELOADING] = "reloading",
2778 [UNIT_INACTIVE] = "inactive",
2779 [UNIT_FAILED] = "failed",
2780 [UNIT_ACTIVATING] = "activating",
2781 [UNIT_DEACTIVATING] = "deactivating"
2784 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2786 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2787 [UNIT_REQUIRES] = "Requires",
2788 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2789 [UNIT_WANTS] = "Wants",
2790 [UNIT_REQUISITE] = "Requisite",
2791 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2792 [UNIT_REQUIRED_BY] = "RequiredBy",
2793 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2794 [UNIT_BIND_TO] = "BindTo",
2795 [UNIT_WANTED_BY] = "WantedBy",
2796 [UNIT_CONFLICTS] = "Conflicts",
2797 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2798 [UNIT_BOUND_BY] = "BoundBy",
2799 [UNIT_BEFORE] = "Before",
2800 [UNIT_AFTER] = "After",
2801 [UNIT_REFERENCES] = "References",
2802 [UNIT_REFERENCED_BY] = "ReferencedBy",
2803 [UNIT_ON_FAILURE] = "OnFailure",
2804 [UNIT_TRIGGERS] = "Triggers",
2805 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2806 [UNIT_PROPAGATE_RELOAD_TO] = "PropagateReloadTo",
2807 [UNIT_PROPAGATE_RELOAD_FROM] = "PropagateReloadFrom"
2810 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);