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);
402 free(u->source_path);
405 set_free_free(u->names);
407 condition_free_list(u->conditions);
410 unit_ref_unset(u->refs);
415 UnitActiveState unit_active_state(Unit *u) {
418 if (u->load_state == UNIT_MERGED)
419 return unit_active_state(unit_follow_merge(u));
421 /* After a reload it might happen that a unit is not correctly
422 * loaded but still has a process around. That's why we won't
423 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
425 return UNIT_VTABLE(u)->active_state(u);
428 const char* unit_sub_state_to_string(Unit *u) {
431 return UNIT_VTABLE(u)->sub_state_to_string(u);
434 static void complete_move(Set **s, Set **other) {
442 set_move(*s, *other);
449 static void merge_names(Unit *u, Unit *other) {
456 complete_move(&u->names, &other->names);
458 set_free_free(other->names);
462 SET_FOREACH(t, u->names, i)
463 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
466 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
473 assert(d < _UNIT_DEPENDENCY_MAX);
475 /* Fix backwards pointers */
476 SET_FOREACH(back, other->dependencies[d], i) {
479 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
480 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
483 set_remove(back->dependencies[k], other);
485 assert(r == -ENOENT);
489 complete_move(&u->dependencies[d], &other->dependencies[d]);
491 set_free(other->dependencies[d]);
492 other->dependencies[d] = NULL;
495 int unit_merge(Unit *u, Unit *other) {
500 assert(u->manager == other->manager);
501 assert(u->type != _UNIT_TYPE_INVALID);
503 other = unit_follow_merge(other);
508 if (u->type != other->type)
511 if (!u->instance != !other->instance)
514 if (other->load_state != UNIT_STUB &&
515 other->load_state != UNIT_ERROR)
524 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
528 merge_names(u, other);
530 /* Redirect all references */
532 unit_ref_set(other->refs, u);
534 /* Merge dependencies */
535 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
536 merge_dependencies(u, other, d);
538 other->load_state = UNIT_MERGED;
539 other->merged_into = u;
541 /* If there is still some data attached to the other node, we
542 * don't need it anymore, and can free it. */
543 if (other->load_state != UNIT_STUB)
544 if (UNIT_VTABLE(other)->done)
545 UNIT_VTABLE(other)->done(other);
547 unit_add_to_dbus_queue(u);
548 unit_add_to_cleanup_queue(other);
553 int unit_merge_by_name(Unit *u, const char *name) {
561 if (unit_name_is_template(name)) {
565 if (!(s = unit_name_replace_instance(name, u->instance)))
571 if (!(other = manager_get_unit(u->manager, name)))
572 r = unit_add_name(u, name);
574 r = unit_merge(u, other);
580 Unit* unit_follow_merge(Unit *u) {
583 while (u->load_state == UNIT_MERGED)
584 assert_se(u = u->merged_into);
589 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
595 if (c->std_output != EXEC_OUTPUT_KMSG &&
596 c->std_output != EXEC_OUTPUT_SYSLOG &&
597 c->std_output != EXEC_OUTPUT_JOURNAL &&
598 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
599 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
600 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
601 c->std_error != EXEC_OUTPUT_KMSG &&
602 c->std_error != EXEC_OUTPUT_SYSLOG &&
603 c->std_error != EXEC_OUTPUT_JOURNAL &&
604 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
605 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
606 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
609 /* If syslog or kernel logging is requested, make sure our own
610 * logging daemon is run first. */
612 if (u->manager->running_as == MANAGER_SYSTEM)
613 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
619 const char *unit_description(Unit *u) {
623 return u->description;
628 void unit_dump(Unit *u, FILE *f, const char *prefix) {
635 timestamp1[FORMAT_TIMESTAMP_MAX],
636 timestamp2[FORMAT_TIMESTAMP_MAX],
637 timestamp3[FORMAT_TIMESTAMP_MAX],
638 timestamp4[FORMAT_TIMESTAMP_MAX],
639 timespan[FORMAT_TIMESPAN_MAX];
643 assert(u->type >= 0);
647 p2 = strappend(prefix, "\t");
648 prefix2 = p2 ? p2 : prefix;
652 "%s\tDescription: %s\n"
654 "%s\tUnit Load State: %s\n"
655 "%s\tUnit Active State: %s\n"
656 "%s\tInactive Exit Timestamp: %s\n"
657 "%s\tActive Enter Timestamp: %s\n"
658 "%s\tActive Exit Timestamp: %s\n"
659 "%s\tInactive Enter Timestamp: %s\n"
660 "%s\tGC Check Good: %s\n"
661 "%s\tNeed Daemon Reload: %s\n",
663 prefix, unit_description(u),
664 prefix, strna(u->instance),
665 prefix, unit_load_state_to_string(u->load_state),
666 prefix, unit_active_state_to_string(unit_active_state(u)),
667 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
668 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
669 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
670 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
671 prefix, yes_no(unit_check_gc(u)),
672 prefix, yes_no(unit_need_daemon_reload(u)));
674 SET_FOREACH(t, u->names, i)
675 fprintf(f, "%s\tName: %s\n", prefix, t);
677 STRV_FOREACH(j, u->documentation)
678 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
680 if ((following = unit_following(u)))
681 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
683 if (u->fragment_path)
684 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
687 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
689 if (u->job_timeout > 0)
690 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
692 condition_dump_list(u->conditions, f, prefix);
694 if (dual_timestamp_is_set(&u->condition_timestamp))
696 "%s\tCondition Timestamp: %s\n"
697 "%s\tCondition Result: %s\n",
698 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
699 prefix, yes_no(u->condition_result));
701 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
704 SET_FOREACH(other, u->dependencies[d], i)
705 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
708 if (!strv_isempty(u->requires_mounts_for)) {
710 "%s\tRequiresMountsFor:", prefix);
712 STRV_FOREACH(j, u->requires_mounts_for)
713 fprintf(f, " %s", *j);
718 if (u->load_state == UNIT_LOADED) {
723 "%s\tStopWhenUnneeded: %s\n"
724 "%s\tRefuseManualStart: %s\n"
725 "%s\tRefuseManualStop: %s\n"
726 "%s\tDefaultDependencies: %s\n"
727 "%s\tOnFailureIsolate: %s\n"
728 "%s\tIgnoreOnIsolate: %s\n"
729 "%s\tIgnoreOnSnapshot: %s\n",
730 prefix, yes_no(u->stop_when_unneeded),
731 prefix, yes_no(u->refuse_manual_start),
732 prefix, yes_no(u->refuse_manual_stop),
733 prefix, yes_no(u->default_dependencies),
734 prefix, yes_no(u->on_failure_isolate),
735 prefix, yes_no(u->ignore_on_isolate),
736 prefix, yes_no(u->ignore_on_snapshot));
738 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
739 fprintf(f, "%s\tControlGroup: %s:%s\n",
740 prefix, b->controller, b->path);
742 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
746 a->map_callback(a->controller, a->name, a->value, &v);
748 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
749 prefix, a->controller, a->name, v ? v : a->value);
754 if (UNIT_VTABLE(u)->dump)
755 UNIT_VTABLE(u)->dump(u, f, prefix2);
757 } else if (u->load_state == UNIT_MERGED)
759 "%s\tMerged into: %s\n",
760 prefix, u->merged_into->id);
761 else if (u->load_state == UNIT_ERROR)
762 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
766 job_dump(u->job, f, prefix2);
769 job_dump(u->nop_job, f, prefix2);
774 /* Common implementation for multiple backends */
775 int unit_load_fragment_and_dropin(Unit *u) {
780 /* Load a .service file */
781 if ((r = unit_load_fragment(u)) < 0)
784 if (u->load_state == UNIT_STUB)
787 /* Load drop-in directory data */
788 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
794 /* Common implementation for multiple backends */
795 int unit_load_fragment_and_dropin_optional(Unit *u) {
800 /* Same as unit_load_fragment_and_dropin(), but whether
801 * something can be loaded or not doesn't matter. */
803 /* Load a .service file */
804 if ((r = unit_load_fragment(u)) < 0)
807 if (u->load_state == UNIT_STUB)
808 u->load_state = UNIT_LOADED;
810 /* Load drop-in directory data */
811 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
817 int unit_add_default_target_dependency(Unit *u, Unit *target) {
821 if (target->type != UNIT_TARGET)
824 /* Only add the dependency if both units are loaded, so that
825 * that loop check below is reliable */
826 if (u->load_state != UNIT_LOADED ||
827 target->load_state != UNIT_LOADED)
830 /* If either side wants no automatic dependencies, then let's
832 if (!u->default_dependencies ||
833 !target->default_dependencies)
836 /* Don't create loops */
837 if (set_get(target->dependencies[UNIT_BEFORE], u))
840 return unit_add_dependency(target, UNIT_AFTER, u, true);
843 static int unit_add_default_dependencies(Unit *u) {
844 static const UnitDependency deps[] = {
846 UNIT_REQUIRED_BY_OVERRIDABLE,
858 for (k = 0; k < ELEMENTSOF(deps); k++)
859 SET_FOREACH(target, u->dependencies[deps[k]], i)
860 if ((r = unit_add_default_target_dependency(u, target)) < 0)
866 int unit_load(Unit *u) {
871 if (u->in_load_queue) {
872 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
873 u->in_load_queue = false;
876 if (u->type == _UNIT_TYPE_INVALID)
879 if (u->load_state != UNIT_STUB)
882 if (UNIT_VTABLE(u)->load)
883 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
886 if (u->load_state == UNIT_STUB) {
891 if (u->load_state == UNIT_LOADED &&
892 u->default_dependencies)
893 if ((r = unit_add_default_dependencies(u)) < 0)
896 if (u->load_state == UNIT_LOADED) {
897 r = unit_add_mount_links(u);
902 if (u->on_failure_isolate &&
903 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
905 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
912 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
914 unit_add_to_dbus_queue(unit_follow_merge(u));
915 unit_add_to_gc_queue(u);
920 u->load_state = UNIT_ERROR;
922 unit_add_to_dbus_queue(u);
923 unit_add_to_gc_queue(u);
925 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
930 bool unit_condition_test(Unit *u) {
933 dual_timestamp_get(&u->condition_timestamp);
934 u->condition_result = condition_test_list(u->conditions);
936 return u->condition_result;
939 static void unit_status_print_starting_stopping(Unit *u, bool stopping) {
940 const UnitStatusMessageFormats *format_table;
943 format_table = &UNIT_VTABLE(u)->status_message_formats;
947 format = format_table->starting_stopping[stopping];
951 unit_status_printf(u, "", format, unit_description(u));
955 * -EBADR: This unit type does not support starting.
956 * -EALREADY: Unit is already started.
957 * -EAGAIN: An operation is already in progress. Retry later.
958 * -ECANCELED: Too many requests for now.
960 int unit_start(Unit *u) {
961 UnitActiveState state;
966 if (u->load_state != UNIT_LOADED)
969 /* If this is already started, then this will succeed. Note
970 * that this will even succeed if this unit is not startable
971 * by the user. This is relied on to detect when we need to
972 * wait for units and when waiting is finished. */
973 state = unit_active_state(u);
974 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
977 /* If the conditions failed, don't do anything at all. If we
978 * already are activating this call might still be useful to
979 * speed up activation in case there is some hold-off time,
980 * but we don't want to recheck the condition in that case. */
981 if (state != UNIT_ACTIVATING &&
982 !unit_condition_test(u)) {
983 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
987 /* Forward to the main object, if we aren't it. */
988 if ((following = unit_following(u))) {
989 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
990 return unit_start(following);
993 unit_status_print_starting_stopping(u, false);
995 /* If it is stopped, but we cannot start it, then fail */
996 if (!UNIT_VTABLE(u)->start)
999 /* We don't suppress calls to ->start() here when we are
1000 * already starting, to allow this request to be used as a
1001 * "hurry up" call, for example when the unit is in some "auto
1002 * restart" state where it waits for a holdoff timer to elapse
1003 * before it will start again. */
1005 unit_add_to_dbus_queue(u);
1007 return UNIT_VTABLE(u)->start(u);
1010 bool unit_can_start(Unit *u) {
1013 return !!UNIT_VTABLE(u)->start;
1016 bool unit_can_isolate(Unit *u) {
1019 return unit_can_start(u) &&
1024 * -EBADR: This unit type does not support stopping.
1025 * -EALREADY: Unit is already stopped.
1026 * -EAGAIN: An operation is already in progress. Retry later.
1028 int unit_stop(Unit *u) {
1029 UnitActiveState state;
1034 state = unit_active_state(u);
1035 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1038 if ((following = unit_following(u))) {
1039 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1040 return unit_stop(following);
1043 unit_status_print_starting_stopping(u, true);
1045 if (!UNIT_VTABLE(u)->stop)
1048 unit_add_to_dbus_queue(u);
1050 return UNIT_VTABLE(u)->stop(u);
1054 * -EBADR: This unit type does not support reloading.
1055 * -ENOEXEC: Unit is not started.
1056 * -EAGAIN: An operation is already in progress. Retry later.
1058 int unit_reload(Unit *u) {
1059 UnitActiveState state;
1064 if (u->load_state != UNIT_LOADED)
1067 if (!unit_can_reload(u))
1070 state = unit_active_state(u);
1071 if (state == UNIT_RELOADING)
1074 if (state != UNIT_ACTIVE)
1077 if ((following = unit_following(u))) {
1078 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1079 return unit_reload(following);
1082 unit_add_to_dbus_queue(u);
1083 return UNIT_VTABLE(u)->reload(u);
1086 bool unit_can_reload(Unit *u) {
1089 if (!UNIT_VTABLE(u)->reload)
1092 if (!UNIT_VTABLE(u)->can_reload)
1095 return UNIT_VTABLE(u)->can_reload(u);
1098 static void unit_check_unneeded(Unit *u) {
1104 /* If this service shall be shut down when unneeded then do
1107 if (!u->stop_when_unneeded)
1110 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1113 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1114 if (unit_pending_active(other))
1117 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1118 if (unit_pending_active(other))
1121 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1122 if (unit_pending_active(other))
1125 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1126 if (unit_pending_active(other))
1129 log_info("Service %s is not needed anymore. Stopping.", u->id);
1131 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1132 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1135 static void retroactively_start_dependencies(Unit *u) {
1140 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1142 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1143 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1144 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1145 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1147 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1148 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1149 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1150 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1152 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1153 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1154 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1155 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1157 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1158 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1159 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1160 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1162 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1163 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1164 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1165 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1167 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], 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);
1171 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1172 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1173 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1176 static void retroactively_stop_dependencies(Unit *u) {
1181 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1183 /* Pull down units which are bound to us recursively if enabled */
1184 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1185 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1186 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1189 static void check_unneeded_dependencies(Unit *u) {
1194 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1196 /* Garbage collect services that might not be needed anymore, if enabled */
1197 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1198 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1199 unit_check_unneeded(other);
1200 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1201 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1202 unit_check_unneeded(other);
1203 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1204 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1205 unit_check_unneeded(other);
1206 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1207 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1208 unit_check_unneeded(other);
1209 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1210 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1211 unit_check_unneeded(other);
1212 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1213 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1214 unit_check_unneeded(other);
1217 void unit_trigger_on_failure(Unit *u) {
1223 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1226 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1228 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1231 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1232 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1236 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1240 assert(os < _UNIT_ACTIVE_STATE_MAX);
1241 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1243 /* Note that this is called for all low-level state changes,
1244 * even if they might map to the same high-level
1245 * UnitActiveState! That means that ns == os is OK an expected
1246 * behaviour here. For example: if a mount point is remounted
1247 * this function will be called too! */
1249 if (u->manager->n_reloading <= 0) {
1252 dual_timestamp_get(&ts);
1254 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1255 u->inactive_exit_timestamp = ts;
1256 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1257 u->inactive_enter_timestamp = ts;
1259 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1260 u->active_enter_timestamp = ts;
1261 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1262 u->active_exit_timestamp = ts;
1264 timer_unit_notify(u, ns);
1265 path_unit_notify(u, ns);
1268 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1269 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1274 if (u->job->state == JOB_WAITING)
1276 /* So we reached a different state for this
1277 * job. Let's see if we can run it now if it
1278 * failed previously due to EAGAIN. */
1279 job_add_to_run_queue(u->job);
1281 /* Let's check whether this state change constitutes a
1282 * finished job, or maybe contradicts a running job and
1283 * hence needs to invalidate jobs. */
1285 switch (u->job->type) {
1288 case JOB_VERIFY_ACTIVE:
1290 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1291 job_finish_and_invalidate(u->job, JOB_DONE, true);
1292 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1295 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1296 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1302 case JOB_RELOAD_OR_START:
1304 if (u->job->state == JOB_RUNNING) {
1305 if (ns == UNIT_ACTIVE)
1306 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1307 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1310 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1311 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1319 case JOB_TRY_RESTART:
1321 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1322 job_finish_and_invalidate(u->job, JOB_DONE, true);
1323 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1325 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1331 assert_not_reached("Job type unknown");
1337 if (u->manager->n_reloading <= 0) {
1339 /* If this state change happened without being
1340 * requested by a job, then let's retroactively start
1341 * or stop dependencies. We skip that step when
1342 * deserializing, since we don't want to create any
1343 * additional jobs just because something is already
1347 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1348 retroactively_start_dependencies(u);
1349 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1350 retroactively_stop_dependencies(u);
1353 /* stop unneeded units regardless if going down was expected or not */
1354 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1355 check_unneeded_dependencies(u);
1357 if (ns != os && ns == UNIT_FAILED) {
1358 log_notice("Unit %s entered failed state.", u->id);
1359 unit_trigger_on_failure(u);
1363 /* Some names are special */
1364 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1366 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1367 /* The bus just might have become available,
1368 * hence try to connect to it, if we aren't
1370 bus_init(u->manager, true);
1372 if (u->type == UNIT_SERVICE &&
1373 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1374 u->manager->n_reloading <= 0) {
1375 /* Write audit record if we have just finished starting up */
1376 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1380 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1381 manager_send_unit_plymouth(u->manager, u);
1385 /* We don't care about D-Bus here, since we'll get an
1386 * asynchronous notification for it anyway. */
1388 if (u->type == UNIT_SERVICE &&
1389 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1390 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1391 u->manager->n_reloading <= 0) {
1393 /* Hmm, if there was no start record written
1394 * write it now, so that we always have a nice
1397 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1399 if (ns == UNIT_INACTIVE)
1400 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1402 /* Write audit record if we have just finished shutting down */
1403 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1405 u->in_audit = false;
1409 manager_recheck_journal(u->manager);
1411 /* Maybe we finished startup and are now ready for being
1412 * stopped because unneeded? */
1413 unit_check_unneeded(u);
1415 unit_add_to_dbus_queue(u);
1416 unit_add_to_gc_queue(u);
1419 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1420 struct epoll_event ev;
1425 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1431 if (epoll_ctl(u->manager->epoll_fd,
1432 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1444 void unit_unwatch_fd(Unit *u, Watch *w) {
1448 if (w->type == WATCH_INVALID)
1451 assert(w->type == WATCH_FD);
1452 assert(w->data.unit == u);
1453 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1456 w->type = WATCH_INVALID;
1457 w->data.unit = NULL;
1460 int unit_watch_pid(Unit *u, pid_t pid) {
1464 /* Watch a specific PID. We only support one unit watching
1465 * each PID for now. */
1467 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1470 void unit_unwatch_pid(Unit *u, pid_t pid) {
1474 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1477 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1478 struct itimerspec its;
1484 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1486 /* This will try to reuse the old timer if there is one */
1488 if (w->type == WATCH_UNIT_TIMER) {
1489 assert(w->data.unit == u);
1494 } else if (w->type == WATCH_INVALID) {
1497 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1500 assert_not_reached("Invalid watch type");
1505 /* Set absolute time in the past, but not 0, since we
1506 * don't want to disarm the timer */
1507 its.it_value.tv_sec = 0;
1508 its.it_value.tv_nsec = 1;
1510 flags = TFD_TIMER_ABSTIME;
1512 timespec_store(&its.it_value, delay);
1516 /* This will also flush the elapse counter */
1517 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1520 if (w->type == WATCH_INVALID) {
1521 struct epoll_event ev;
1525 ev.events = EPOLLIN;
1527 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1531 w->type = WATCH_UNIT_TIMER;
1539 close_nointr_nofail(fd);
1544 void unit_unwatch_timer(Unit *u, Watch *w) {
1548 if (w->type == WATCH_INVALID)
1551 assert(w->type == WATCH_UNIT_TIMER);
1552 assert(w->data.unit == u);
1555 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1556 close_nointr_nofail(w->fd);
1559 w->type = WATCH_INVALID;
1560 w->data.unit = NULL;
1563 bool unit_job_is_applicable(Unit *u, JobType j) {
1565 assert(j >= 0 && j < _JOB_TYPE_MAX);
1569 case JOB_VERIFY_ACTIVE:
1576 case JOB_TRY_RESTART:
1577 return unit_can_start(u);
1580 return unit_can_reload(u);
1582 case JOB_RELOAD_OR_START:
1583 return unit_can_reload(u) && unit_can_start(u);
1586 assert_not_reached("Invalid job type");
1590 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1592 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1593 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1594 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1595 [UNIT_WANTS] = UNIT_WANTED_BY,
1596 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1597 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1598 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1599 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1600 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1601 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1602 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1603 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1604 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1605 [UNIT_BEFORE] = UNIT_AFTER,
1606 [UNIT_AFTER] = UNIT_BEFORE,
1607 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1608 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1609 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1610 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1611 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1612 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1613 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1614 [UNIT_PART_OF] = UNIT_CONSISTS_OF
1616 int r, q = 0, v = 0, w = 0;
1619 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1622 u = unit_follow_merge(u);
1623 other = unit_follow_merge(other);
1625 /* We won't allow dependencies on ourselves. We will not
1626 * consider them an error however. */
1630 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1633 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1634 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1638 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1639 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1642 if ((q = set_put(u->dependencies[d], other)) < 0)
1645 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1646 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1651 if (add_reference) {
1652 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1657 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1661 unit_add_to_dbus_queue(u);
1666 set_remove(u->dependencies[d], other);
1669 set_remove(other->dependencies[inverse_table[d]], u);
1672 set_remove(u->dependencies[UNIT_REFERENCES], other);
1677 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1682 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1685 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1691 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1695 assert(name || path);
1698 name = path_get_file_name(path);
1700 if (!unit_name_is_template(name)) {
1706 s = unit_name_replace_instance(name, u->instance);
1710 if (!(i = unit_name_to_prefix(u->id)))
1713 s = unit_name_replace_instance(name, i);
1724 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1730 assert(name || path);
1732 if (!(name = resolve_template(u, name, path, &s)))
1735 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1738 r = unit_add_dependency(u, d, other, add_reference);
1745 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1751 assert(name || path);
1753 if (!(name = resolve_template(u, name, path, &s)))
1756 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1759 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1766 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1772 assert(name || path);
1774 if (!(name = resolve_template(u, name, path, &s)))
1777 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1780 r = unit_add_dependency(other, d, u, add_reference);
1787 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1793 assert(name || path);
1795 if (!(name = resolve_template(u, name, path, &s)))
1798 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1801 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1809 int set_unit_path(const char *p) {
1813 /* This is mostly for debug purposes */
1815 if (path_is_absolute(p)) {
1816 if (!(c = strdup(p)))
1819 if (!(cwd = get_current_dir_name()))
1822 r = asprintf(&c, "%s/%s", cwd, p);
1829 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1838 char *unit_dbus_path(Unit *u) {
1844 return unit_dbus_path_from_name(u->id);
1847 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1855 if (!b->controller) {
1856 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1862 /* Ensure this hasn't been added yet */
1865 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1868 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1869 LIST_PREPEND(CGroupBonding, by_path, l, b);
1871 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1872 LIST_REMOVE(CGroupBonding, by_path, l, b);
1877 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1883 static char *default_cgroup_path(Unit *u) {
1891 t = unit_name_template(u->id);
1895 p = strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1898 p = strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1903 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1904 char *controller = NULL, *path = NULL;
1905 CGroupBonding *b = NULL;
1912 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1916 path = default_cgroup_path(u);
1921 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1925 if (!path || !controller) {
1932 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1937 if (!(b = new0(CGroupBonding, 1))) {
1942 b->controller = controller;
1945 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1947 if ((r = unit_add_cgroup(u, b)) < 0)
1960 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1961 CGroupBonding *b = NULL;
1967 controller = SYSTEMD_CGROUP_CONTROLLER;
1969 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1972 if (!(b = new0(CGroupBonding, 1)))
1975 if (!(b->controller = strdup(controller)))
1978 if (!(b->path = default_cgroup_path(u)))
1982 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1984 if ((r = unit_add_cgroup(u, b)) < 0)
1991 free(b->controller);
1997 int unit_add_default_cgroups(Unit *u) {
2004 /* Adds in the default cgroups, if they weren't specified
2007 if (!u->manager->cgroup_hierarchy)
2010 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
2013 STRV_FOREACH(c, u->manager->default_controllers)
2014 unit_add_one_default_cgroup(u, *c);
2016 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2017 unit_add_one_default_cgroup(u, a->controller);
2022 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2025 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
2028 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
2040 dot = strchr(name, '.');
2044 c = strndup(name, dot - name);
2051 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2056 a = new0(CGroupAttribute, 1);
2066 a->controller = strdup(controller);
2068 a->name = strdup(name);
2069 a->value = strdup(value);
2071 if (!a->controller || !a->name || !a->value) {
2072 free(a->controller);
2080 a->map_callback = map_callback;
2082 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2091 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2099 if (!(t = unit_name_change_suffix(u->id, type)))
2102 assert(!unit_has_name(u, t));
2104 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2107 assert(r < 0 || *_found != u);
2112 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2120 if (!(t = unit_name_change_suffix(u->id, type)))
2123 assert(!unit_has_name(u, t));
2125 found = manager_get_unit(u->manager, t);
2135 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2139 return unit_name_to_prefix_and_instance(u->id);
2142 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2146 return unit_name_to_prefix(u->id);
2149 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2155 if (!(p = unit_name_to_prefix(u->id)))
2158 r = unit_name_unescape(p);
2164 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2169 return unit_name_unescape(u->instance);
2174 static char *specifier_filename(char specifier, void *data, void *userdata) {
2179 return unit_name_path_unescape(u->instance);
2181 return unit_name_to_path(u->instance);
2184 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2188 return default_cgroup_path(u);
2191 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2196 if (specifier == 'r')
2197 return strdup(u->manager->cgroup_hierarchy);
2199 if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
2202 if (streq(p, "/")) {
2210 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2214 if (u->manager->running_as == MANAGER_USER) {
2217 e = getenv("XDG_RUNTIME_DIR");
2222 return strdup("/run");
2225 static char *specifier_user_name(char specifier, void *data, void *userdata) {
2226 Service *s = userdata;
2228 const char *username;
2230 /* get USER env from our own env if set */
2231 if (!s->exec_context.user)
2232 return getusername_malloc();
2234 /* fish username from passwd */
2235 username = s->exec_context.user;
2236 r = get_user_creds(&username, NULL, NULL, NULL, NULL);
2240 return strdup(username);
2243 static char *specifier_user_home(char specifier, void *data, void *userdata) {
2244 Service *s = userdata;
2246 const char *username, *home;
2248 /* return HOME if set, otherwise from passwd */
2249 if (!s->exec_context.user) {
2252 r = get_home_dir(&h);
2259 username = s->exec_context.user;
2260 r = get_user_creds(&username, NULL, NULL, &home, NULL);
2264 return strdup(home);
2267 static char *specifier_user_shell(char specifier, void *data, void *userdata) {
2268 Service *s = userdata;
2270 const char *username, *shell;
2272 /* return HOME if set, otherwise from passwd */
2273 if (!s->exec_context.user) {
2278 return strdup("/bin/sh");
2283 username = s->exec_context.user;
2284 r = get_user_creds(&username, NULL, NULL, NULL, &shell);
2286 return strdup("/bin/sh");
2288 return strdup(shell);
2291 char *unit_name_printf(Unit *u, const char* format) {
2294 * This will use the passed string as format string and
2295 * replace the following specifiers:
2297 * %n: the full id of the unit (foo@bar.waldo)
2298 * %N: the id of the unit without the suffix (foo@bar)
2299 * %p: the prefix (foo)
2300 * %i: the instance (bar)
2303 const Specifier table[] = {
2304 { 'n', specifier_string, u->id },
2305 { 'N', specifier_prefix_and_instance, NULL },
2306 { 'p', specifier_prefix, NULL },
2307 { 'i', specifier_string, u->instance },
2314 return specifier_printf(format, table, u);
2317 char *unit_full_printf(Unit *u, const char *format) {
2319 /* This is similar to unit_name_printf() but also supports
2320 * unescaping. Also, adds a couple of additional codes:
2322 * %c cgroup path of unit
2323 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2324 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2325 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2326 * %u the username of the configured User or running user
2327 * %h the homedir of the configured User or running user
2330 const Specifier table[] = {
2331 { 'n', specifier_string, u->id },
2332 { 'N', specifier_prefix_and_instance, NULL },
2333 { 'p', specifier_prefix, NULL },
2334 { 'P', specifier_prefix_unescaped, NULL },
2335 { 'i', specifier_string, u->instance },
2336 { 'I', specifier_instance_unescaped, NULL },
2337 { 'f', specifier_filename, NULL },
2338 { 'c', specifier_cgroup, NULL },
2339 { 'r', specifier_cgroup_root, NULL },
2340 { 'R', specifier_cgroup_root, NULL },
2341 { 't', specifier_runtime, NULL },
2342 { 'u', specifier_user_name, NULL },
2343 { 'h', specifier_user_home, NULL },
2344 { 's', specifier_user_shell, NULL },
2351 return specifier_printf(format, table, u);
2354 char **unit_full_printf_strv(Unit *u, char **l) {
2358 /* Applies unit_full_printf to every entry in l */
2363 if (!(r = new(char*, n+1)))
2366 for (i = l, j = r; *i; i++, j++)
2367 if (!(*j = unit_full_printf(u, *i)))
2374 for (j--; j >= r; j--)
2382 int unit_watch_bus_name(Unit *u, const char *name) {
2386 /* Watch a specific name on the bus. We only support one unit
2387 * watching each name for now. */
2389 return hashmap_put(u->manager->watch_bus, name, u);
2392 void unit_unwatch_bus_name(Unit *u, const char *name) {
2396 hashmap_remove_value(u->manager->watch_bus, name, u);
2399 bool unit_can_serialize(Unit *u) {
2402 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2405 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2412 if (!unit_can_serialize(u))
2415 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2419 if (serialize_jobs) {
2421 fprintf(f, "job\n");
2422 job_serialize(u->job, f, fds);
2426 fprintf(f, "job\n");
2427 job_serialize(u->nop_job, f, fds);
2431 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2432 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2433 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2434 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2435 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2437 if (dual_timestamp_is_set(&u->condition_timestamp))
2438 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2445 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2456 va_start(ap, format);
2457 vfprintf(f, format, ap);
2463 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2469 fprintf(f, "%s=%s\n", key, value);
2472 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2479 if (!unit_can_serialize(u))
2483 char line[LINE_MAX], *l, *v;
2486 if (!fgets(line, sizeof(line), f)) {
2499 k = strcspn(l, "=");
2507 if (streq(l, "job")) {
2509 /* new-style serialized job */
2510 Job *j = job_new_raw(u);
2514 r = job_deserialize(j, f, fds);
2520 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2526 r = job_install_deserialized(j);
2528 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2534 JobType type = job_type_from_string(v);
2536 log_debug("Failed to parse job type value %s", v);
2538 u->deserialized_job = type;
2541 } else if (streq(l, "inactive-exit-timestamp")) {
2542 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2544 } else if (streq(l, "active-enter-timestamp")) {
2545 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2547 } else if (streq(l, "active-exit-timestamp")) {
2548 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2550 } else if (streq(l, "inactive-enter-timestamp")) {
2551 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2553 } else if (streq(l, "condition-timestamp")) {
2554 dual_timestamp_deserialize(v, &u->condition_timestamp);
2556 } else if (streq(l, "condition-result")) {
2559 if ((b = parse_boolean(v)) < 0)
2560 log_debug("Failed to parse condition result value %s", v);
2562 u->condition_result = b;
2567 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2572 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2582 /* Adds in links to the device node that this unit is based on */
2584 if (!is_device_path(what))
2587 e = unit_name_from_path(what, ".device");
2591 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2597 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true)) < 0)
2601 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2607 int unit_coldplug(Unit *u) {
2612 if (UNIT_VTABLE(u)->coldplug)
2613 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2617 r = job_coldplug(u->job);
2620 } else if (u->deserialized_job >= 0) {
2622 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2626 u->deserialized_job = _JOB_TYPE_INVALID;
2632 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2638 if (!manager_get_show_status(u->manager))
2641 if (!manager_is_booting_or_shutting_down(u->manager))
2644 va_start(ap, format);
2645 status_vprintf(status, true, format, ap);
2649 bool unit_need_daemon_reload(Unit *u) {
2654 if (u->fragment_path) {
2656 if (stat(u->fragment_path, &st) < 0)
2657 /* What, cannot access this anymore? */
2660 if (u->fragment_mtime > 0 &&
2661 timespec_load(&st.st_mtim) != u->fragment_mtime)
2665 if (u->source_path) {
2667 if (stat(u->source_path, &st) < 0)
2670 if (u->source_mtime > 0 &&
2671 timespec_load(&st.st_mtim) != u->source_mtime)
2678 void unit_reset_failed(Unit *u) {
2681 if (UNIT_VTABLE(u)->reset_failed)
2682 UNIT_VTABLE(u)->reset_failed(u);
2685 Unit *unit_following(Unit *u) {
2688 if (UNIT_VTABLE(u)->following)
2689 return UNIT_VTABLE(u)->following(u);
2694 bool unit_pending_inactive(Unit *u) {
2697 /* Returns true if the unit is inactive or going down */
2699 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2702 if (u->job && u->job->type == JOB_STOP)
2708 bool unit_pending_active(Unit *u) {
2711 /* Returns true if the unit is active or going up */
2713 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2717 (u->job->type == JOB_START ||
2718 u->job->type == JOB_RELOAD_OR_START ||
2719 u->job->type == JOB_RESTART))
2725 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2727 assert(w >= 0 && w < _KILL_WHO_MAX);
2729 assert(signo < _NSIG);
2731 if (!UNIT_VTABLE(u)->kill)
2734 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2737 int unit_following_set(Unit *u, Set **s) {
2741 if (UNIT_VTABLE(u)->following_set)
2742 return UNIT_VTABLE(u)->following_set(u, s);
2748 UnitFileState unit_get_unit_file_state(Unit *u) {
2751 if (u->unit_file_state < 0 && u->fragment_path)
2752 u->unit_file_state = unit_file_get_state(
2753 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2754 NULL, path_get_file_name(u->fragment_path));
2756 return u->unit_file_state;
2759 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2764 unit_ref_unset(ref);
2767 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2771 void unit_ref_unset(UnitRef *ref) {
2777 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2781 int unit_add_one_mount_link(Unit *u, Mount *m) {
2787 if (u->load_state != UNIT_LOADED ||
2788 UNIT(m)->load_state != UNIT_LOADED)
2791 STRV_FOREACH(i, u->requires_mounts_for) {
2796 if (!path_startswith(*i, m->where))
2799 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2805 int unit_add_mount_links(Unit *u) {
2811 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2812 r = unit_add_one_mount_link(u, MOUNT(other));
2820 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2827 /* This only copies in the ones that need memory */
2829 for (i = 0; i < RLIMIT_NLIMITS; i++)
2830 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2831 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2836 if (u->manager->running_as == MANAGER_USER &&
2837 !c->working_directory) {
2839 r = get_home_dir(&c->working_directory);
2847 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2848 [UNIT_ACTIVE] = "active",
2849 [UNIT_RELOADING] = "reloading",
2850 [UNIT_INACTIVE] = "inactive",
2851 [UNIT_FAILED] = "failed",
2852 [UNIT_ACTIVATING] = "activating",
2853 [UNIT_DEACTIVATING] = "deactivating"
2856 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2858 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2859 [UNIT_REQUIRES] = "Requires",
2860 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2861 [UNIT_WANTS] = "Wants",
2862 [UNIT_REQUISITE] = "Requisite",
2863 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2864 [UNIT_REQUIRED_BY] = "RequiredBy",
2865 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2866 [UNIT_BINDS_TO] = "BindsTo",
2867 [UNIT_WANTED_BY] = "WantedBy",
2868 [UNIT_CONFLICTS] = "Conflicts",
2869 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2870 [UNIT_BOUND_BY] = "BoundBy",
2871 [UNIT_BEFORE] = "Before",
2872 [UNIT_AFTER] = "After",
2873 [UNIT_REFERENCES] = "References",
2874 [UNIT_REFERENCED_BY] = "ReferencedBy",
2875 [UNIT_ON_FAILURE] = "OnFailure",
2876 [UNIT_TRIGGERS] = "Triggers",
2877 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2878 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2879 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom"
2882 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);