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 "load-fragment.h"
37 #include "load-dropin.h"
39 #include "unit-name.h"
40 #include "specifier.h"
41 #include "dbus-unit.h"
43 #include "cgroup-util.h"
45 #include "cgroup-attr.h"
47 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
48 [UNIT_SERVICE] = &service_vtable,
49 [UNIT_TIMER] = &timer_vtable,
50 [UNIT_SOCKET] = &socket_vtable,
51 [UNIT_TARGET] = &target_vtable,
52 [UNIT_DEVICE] = &device_vtable,
53 [UNIT_MOUNT] = &mount_vtable,
54 [UNIT_AUTOMOUNT] = &automount_vtable,
55 [UNIT_SNAPSHOT] = &snapshot_vtable,
56 [UNIT_SWAP] = &swap_vtable,
57 [UNIT_PATH] = &path_vtable
60 Unit *unit_new(Manager *m, size_t size) {
64 assert(size >= sizeof(Unit));
70 u->names = set_new(string_hash_func, string_compare_func);
77 u->type = _UNIT_TYPE_INVALID;
78 u->deserialized_job = _JOB_TYPE_INVALID;
79 u->default_dependencies = true;
80 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
85 bool unit_has_name(Unit *u, const char *name) {
89 return !!set_get(u->names, (char*) name);
92 int unit_add_name(Unit *u, const char *text) {
100 if (unit_name_is_template(text)) {
104 s = unit_name_replace_instance(text, u->instance);
111 if (!unit_name_is_valid(s, false)) {
116 assert_se((t = unit_name_to_type(s)) >= 0);
118 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
123 if ((r = unit_name_to_instance(s, &i)) < 0)
126 if (i && unit_vtable[t]->no_instances) {
131 /* Ensure that this unit is either instanced or not instanced,
133 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
138 if (unit_vtable[t]->no_alias &&
139 !set_isempty(u->names) &&
140 !set_get(u->names, s)) {
145 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
150 if ((r = set_put(u->names, s)) < 0) {
156 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
157 set_remove(u->names, s);
161 if (u->type == _UNIT_TYPE_INVALID) {
167 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
169 if (UNIT_VTABLE(u)->init)
170 UNIT_VTABLE(u)->init(u);
174 unit_add_to_dbus_queue(u);
184 int unit_choose_id(Unit *u, const char *name) {
185 char *s, *t = NULL, *i;
191 if (unit_name_is_template(name)) {
196 if (!(t = unit_name_replace_instance(name, u->instance)))
202 /* Selects one of the names of this unit as the id */
203 s = set_get(u->names, (char*) name);
209 if ((r = unit_name_to_instance(s, &i)) < 0)
217 unit_add_to_dbus_queue(u);
222 int unit_set_description(Unit *u, const char *description) {
227 if (!(s = strdup(description)))
230 free(u->description);
233 unit_add_to_dbus_queue(u);
237 bool unit_check_gc(Unit *u) {
240 if (u->load_state == UNIT_STUB)
243 if (UNIT_VTABLE(u)->no_gc)
252 if (unit_active_state(u) != UNIT_INACTIVE)
255 if (UNIT_VTABLE(u)->check_gc)
256 if (UNIT_VTABLE(u)->check_gc(u))
262 void unit_add_to_load_queue(Unit *u) {
264 assert(u->type != _UNIT_TYPE_INVALID);
266 if (u->load_state != UNIT_STUB || u->in_load_queue)
269 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
270 u->in_load_queue = true;
273 void unit_add_to_cleanup_queue(Unit *u) {
276 if (u->in_cleanup_queue)
279 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
280 u->in_cleanup_queue = true;
283 void unit_add_to_gc_queue(Unit *u) {
286 if (u->in_gc_queue || u->in_cleanup_queue)
289 if (unit_check_gc(u))
292 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
293 u->in_gc_queue = true;
295 u->manager->n_in_gc_queue ++;
297 if (u->manager->gc_queue_timestamp <= 0)
298 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
301 void unit_add_to_dbus_queue(Unit *u) {
303 assert(u->type != _UNIT_TYPE_INVALID);
305 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
308 /* Shortcut things if nobody cares */
309 if (!bus_has_subscriber(u->manager)) {
310 u->sent_dbus_new_signal = true;
314 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
315 u->in_dbus_queue = true;
318 static void bidi_set_free(Unit *u, Set *s) {
324 /* Frees the set and makes sure we are dropped from the
325 * inverse pointers */
327 SET_FOREACH(other, s, i) {
330 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
331 set_remove(other->dependencies[d], u);
333 unit_add_to_gc_queue(other);
339 void unit_free(Unit *u) {
346 bus_unit_send_removed_signal(u);
348 if (u->load_state != UNIT_STUB)
349 if (UNIT_VTABLE(u)->done)
350 UNIT_VTABLE(u)->done(u);
352 SET_FOREACH(t, u->names, i)
353 hashmap_remove_value(u->manager->units, t, u);
358 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
359 bidi_set_free(u, u->dependencies[d]);
361 if (u->type != _UNIT_TYPE_INVALID)
362 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
364 if (u->in_load_queue)
365 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
367 if (u->in_dbus_queue)
368 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
370 if (u->in_cleanup_queue)
371 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
373 if (u->in_gc_queue) {
374 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
375 u->manager->n_in_gc_queue--;
378 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
379 cgroup_attribute_free_list(u->cgroup_attributes);
381 free(u->description);
382 free(u->fragment_path);
385 set_free_free(u->names);
387 condition_free_list(u->conditions);
390 unit_ref_unset(u->refs);
395 UnitActiveState unit_active_state(Unit *u) {
398 if (u->load_state == UNIT_MERGED)
399 return unit_active_state(unit_follow_merge(u));
401 /* After a reload it might happen that a unit is not correctly
402 * loaded but still has a process around. That's why we won't
403 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
405 return UNIT_VTABLE(u)->active_state(u);
408 const char* unit_sub_state_to_string(Unit *u) {
411 return UNIT_VTABLE(u)->sub_state_to_string(u);
414 static void complete_move(Set **s, Set **other) {
422 set_move(*s, *other);
429 static void merge_names(Unit *u, Unit *other) {
436 complete_move(&u->names, &other->names);
438 set_free_free(other->names);
442 SET_FOREACH(t, u->names, i)
443 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
446 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
453 assert(d < _UNIT_DEPENDENCY_MAX);
455 /* Fix backwards pointers */
456 SET_FOREACH(back, other->dependencies[d], i) {
459 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
460 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
463 set_remove(back->dependencies[k], other);
465 assert(r == -ENOENT);
469 complete_move(&u->dependencies[d], &other->dependencies[d]);
471 set_free(other->dependencies[d]);
472 other->dependencies[d] = NULL;
475 int unit_merge(Unit *u, Unit *other) {
480 assert(u->manager == other->manager);
481 assert(u->type != _UNIT_TYPE_INVALID);
483 other = unit_follow_merge(other);
488 if (u->type != other->type)
491 if (!u->instance != !other->instance)
494 if (other->load_state != UNIT_STUB &&
495 other->load_state != UNIT_ERROR)
501 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
505 merge_names(u, other);
507 /* Redirect all references */
509 unit_ref_set(other->refs, u);
511 /* Merge dependencies */
512 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
513 merge_dependencies(u, other, d);
515 other->load_state = UNIT_MERGED;
516 other->merged_into = u;
518 /* If there is still some data attached to the other node, we
519 * don't need it anymore, and can free it. */
520 if (other->load_state != UNIT_STUB)
521 if (UNIT_VTABLE(other)->done)
522 UNIT_VTABLE(other)->done(other);
524 unit_add_to_dbus_queue(u);
525 unit_add_to_cleanup_queue(other);
530 int unit_merge_by_name(Unit *u, const char *name) {
538 if (unit_name_is_template(name)) {
542 if (!(s = unit_name_replace_instance(name, u->instance)))
548 if (!(other = manager_get_unit(u->manager, name)))
549 r = unit_add_name(u, name);
551 r = unit_merge(u, other);
557 Unit* unit_follow_merge(Unit *u) {
560 while (u->load_state == UNIT_MERGED)
561 assert_se(u = u->merged_into);
566 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
572 if (c->std_output != EXEC_OUTPUT_KMSG &&
573 c->std_output != EXEC_OUTPUT_SYSLOG &&
574 c->std_output != EXEC_OUTPUT_JOURNAL &&
575 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
576 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
577 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
578 c->std_error != EXEC_OUTPUT_KMSG &&
579 c->std_error != EXEC_OUTPUT_SYSLOG &&
580 c->std_error != EXEC_OUTPUT_JOURNAL &&
581 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
582 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
583 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
586 /* If syslog or kernel logging is requested, make sure our own
587 * logging daemon is run first. */
589 if (u->manager->running_as == MANAGER_SYSTEM)
590 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
596 const char *unit_description(Unit *u) {
600 return u->description;
605 void unit_dump(Unit *u, FILE *f, const char *prefix) {
612 timestamp1[FORMAT_TIMESTAMP_MAX],
613 timestamp2[FORMAT_TIMESTAMP_MAX],
614 timestamp3[FORMAT_TIMESTAMP_MAX],
615 timestamp4[FORMAT_TIMESTAMP_MAX],
616 timespan[FORMAT_TIMESPAN_MAX];
620 assert(u->type >= 0);
624 p2 = strappend(prefix, "\t");
625 prefix2 = p2 ? p2 : prefix;
629 "%s\tDescription: %s\n"
631 "%s\tUnit Load State: %s\n"
632 "%s\tUnit Active State: %s\n"
633 "%s\tInactive Exit Timestamp: %s\n"
634 "%s\tActive Enter Timestamp: %s\n"
635 "%s\tActive Exit Timestamp: %s\n"
636 "%s\tInactive Enter Timestamp: %s\n"
637 "%s\tGC Check Good: %s\n"
638 "%s\tNeed Daemon Reload: %s\n",
640 prefix, unit_description(u),
641 prefix, strna(u->instance),
642 prefix, unit_load_state_to_string(u->load_state),
643 prefix, unit_active_state_to_string(unit_active_state(u)),
644 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
645 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
646 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
647 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
648 prefix, yes_no(unit_check_gc(u)),
649 prefix, yes_no(unit_need_daemon_reload(u)));
651 SET_FOREACH(t, u->names, i)
652 fprintf(f, "%s\tName: %s\n", prefix, t);
654 if ((following = unit_following(u)))
655 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
657 if (u->fragment_path)
658 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
660 if (u->job_timeout > 0)
661 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
663 condition_dump_list(u->conditions, f, prefix);
665 if (dual_timestamp_is_set(&u->condition_timestamp))
667 "%s\tCondition Timestamp: %s\n"
668 "%s\tCondition Result: %s\n",
669 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
670 prefix, yes_no(u->condition_result));
672 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
675 SET_FOREACH(other, u->dependencies[d], i)
676 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
679 if (u->load_state == UNIT_LOADED) {
684 "%s\tStopWhenUnneeded: %s\n"
685 "%s\tRefuseManualStart: %s\n"
686 "%s\tRefuseManualStop: %s\n"
687 "%s\tDefaultDependencies: %s\n"
688 "%s\tOnFailureIsolate: %s\n"
689 "%s\tIgnoreOnIsolate: %s\n"
690 "%s\tIgnoreOnSnapshot: %s\n",
691 prefix, yes_no(u->stop_when_unneeded),
692 prefix, yes_no(u->refuse_manual_start),
693 prefix, yes_no(u->refuse_manual_stop),
694 prefix, yes_no(u->default_dependencies),
695 prefix, yes_no(u->on_failure_isolate),
696 prefix, yes_no(u->ignore_on_isolate),
697 prefix, yes_no(u->ignore_on_snapshot));
699 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
700 fprintf(f, "%s\tControlGroup: %s:%s\n",
701 prefix, b->controller, b->path);
703 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
707 a->map_callback(a->controller, a->name, a->value, &v);
709 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
710 prefix, a->controller, a->name, v ? v : a->value);
715 if (UNIT_VTABLE(u)->dump)
716 UNIT_VTABLE(u)->dump(u, f, prefix2);
718 } else if (u->load_state == UNIT_MERGED)
720 "%s\tMerged into: %s\n",
721 prefix, u->merged_into->id);
722 else if (u->load_state == UNIT_ERROR)
723 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
727 job_dump(u->job, f, prefix2);
732 /* Common implementation for multiple backends */
733 int unit_load_fragment_and_dropin(Unit *u) {
738 /* Load a .service file */
739 if ((r = unit_load_fragment(u)) < 0)
742 if (u->load_state == UNIT_STUB)
745 /* Load drop-in directory data */
746 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
752 /* Common implementation for multiple backends */
753 int unit_load_fragment_and_dropin_optional(Unit *u) {
758 /* Same as unit_load_fragment_and_dropin(), but whether
759 * something can be loaded or not doesn't matter. */
761 /* Load a .service file */
762 if ((r = unit_load_fragment(u)) < 0)
765 if (u->load_state == UNIT_STUB)
766 u->load_state = UNIT_LOADED;
768 /* Load drop-in directory data */
769 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
775 int unit_add_default_target_dependency(Unit *u, Unit *target) {
779 if (target->type != UNIT_TARGET)
782 /* Only add the dependency if both units are loaded, so that
783 * that loop check below is reliable */
784 if (u->load_state != UNIT_LOADED ||
785 target->load_state != UNIT_LOADED)
788 /* If either side wants no automatic dependencies, then let's
790 if (!u->default_dependencies ||
791 !target->default_dependencies)
794 /* Don't create loops */
795 if (set_get(target->dependencies[UNIT_BEFORE], u))
798 return unit_add_dependency(target, UNIT_AFTER, u, true);
801 static int unit_add_default_dependencies(Unit *u) {
802 static const UnitDependency deps[] = {
804 UNIT_REQUIRED_BY_OVERRIDABLE,
816 for (k = 0; k < ELEMENTSOF(deps); k++)
817 SET_FOREACH(target, u->dependencies[deps[k]], i)
818 if ((r = unit_add_default_target_dependency(u, target)) < 0)
824 int unit_load(Unit *u) {
829 if (u->in_load_queue) {
830 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
831 u->in_load_queue = false;
834 if (u->type == _UNIT_TYPE_INVALID)
837 if (u->load_state != UNIT_STUB)
840 if (UNIT_VTABLE(u)->load)
841 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
844 if (u->load_state == UNIT_STUB) {
849 if (u->load_state == UNIT_LOADED &&
850 u->default_dependencies)
851 if ((r = unit_add_default_dependencies(u)) < 0)
854 if (u->on_failure_isolate &&
855 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
857 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
864 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
866 unit_add_to_dbus_queue(unit_follow_merge(u));
867 unit_add_to_gc_queue(u);
872 u->load_state = UNIT_ERROR;
874 unit_add_to_dbus_queue(u);
875 unit_add_to_gc_queue(u);
877 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
882 bool unit_condition_test(Unit *u) {
885 dual_timestamp_get(&u->condition_timestamp);
886 u->condition_result = condition_test_list(u->conditions);
888 return u->condition_result;
892 * -EBADR: This unit type does not support starting.
893 * -EALREADY: Unit is already started.
894 * -EAGAIN: An operation is already in progress. Retry later.
895 * -ECANCELED: Too many requests for now.
897 int unit_start(Unit *u) {
898 UnitActiveState state;
903 if (u->load_state != UNIT_LOADED)
906 /* If this is already started, then this will succeed. Note
907 * that this will even succeed if this unit is not startable
908 * by the user. This is relied on to detect when we need to
909 * wait for units and when waiting is finished. */
910 state = unit_active_state(u);
911 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
914 /* If the conditions failed, don't do anything at all. If we
915 * already are activating this call might still be useful to
916 * speed up activation in case there is some hold-off time,
917 * but we don't want to recheck the condition in that case. */
918 if (state != UNIT_ACTIVATING &&
919 !unit_condition_test(u)) {
920 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
924 /* Forward to the main object, if we aren't it. */
925 if ((following = unit_following(u))) {
926 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
927 return unit_start(following);
930 /* If it is stopped, but we cannot start it, then fail */
931 if (!UNIT_VTABLE(u)->start)
934 /* We don't suppress calls to ->start() here when we are
935 * already starting, to allow this request to be used as a
936 * "hurry up" call, for example when the unit is in some "auto
937 * restart" state where it waits for a holdoff timer to elapse
938 * before it will start again. */
940 unit_add_to_dbus_queue(u);
942 unit_status_printf(u, NULL, "Starting %s...", unit_description(u));
943 return UNIT_VTABLE(u)->start(u);
946 bool unit_can_start(Unit *u) {
949 return !!UNIT_VTABLE(u)->start;
952 bool unit_can_isolate(Unit *u) {
955 return unit_can_start(u) &&
960 * -EBADR: This unit type does not support stopping.
961 * -EALREADY: Unit is already stopped.
962 * -EAGAIN: An operation is already in progress. Retry later.
964 int unit_stop(Unit *u) {
965 UnitActiveState state;
970 state = unit_active_state(u);
971 if (UNIT_IS_INACTIVE_OR_FAILED(state))
974 if ((following = unit_following(u))) {
975 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
976 return unit_stop(following);
979 if (!UNIT_VTABLE(u)->stop)
982 unit_add_to_dbus_queue(u);
984 unit_status_printf(u, NULL, "Stopping %s...", unit_description(u));
985 return UNIT_VTABLE(u)->stop(u);
989 * -EBADR: This unit type does not support reloading.
990 * -ENOEXEC: Unit is not started.
991 * -EAGAIN: An operation is already in progress. Retry later.
993 int unit_reload(Unit *u) {
994 UnitActiveState state;
999 if (u->load_state != UNIT_LOADED)
1002 if (!unit_can_reload(u))
1005 state = unit_active_state(u);
1006 if (state == UNIT_RELOADING)
1009 if (state != UNIT_ACTIVE)
1012 if ((following = unit_following(u))) {
1013 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1014 return unit_reload(following);
1017 unit_add_to_dbus_queue(u);
1018 return UNIT_VTABLE(u)->reload(u);
1021 bool unit_can_reload(Unit *u) {
1024 if (!UNIT_VTABLE(u)->reload)
1027 if (!UNIT_VTABLE(u)->can_reload)
1030 return UNIT_VTABLE(u)->can_reload(u);
1033 static void unit_check_unneeded(Unit *u) {
1039 /* If this service shall be shut down when unneeded then do
1042 if (!u->stop_when_unneeded)
1045 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1048 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1049 if (unit_pending_active(other))
1052 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1053 if (unit_pending_active(other))
1056 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1057 if (unit_pending_active(other))
1060 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1061 if (unit_pending_active(other))
1064 log_info("Service %s is not needed anymore. Stopping.", u->id);
1066 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1067 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1070 static void retroactively_start_dependencies(Unit *u) {
1075 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1077 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1078 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1079 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1080 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1082 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1083 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1084 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1085 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1087 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1088 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1089 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1090 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1092 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1093 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1094 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1095 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1097 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1098 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1099 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1100 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1102 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1103 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1104 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1106 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1107 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1108 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1111 static void retroactively_stop_dependencies(Unit *u) {
1116 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1118 /* Pull down units which are bound to us recursively if enabled */
1119 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1120 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1121 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1124 static void check_unneeded_dependencies(Unit *u) {
1129 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1131 /* Garbage collect services that might not be needed anymore, if enabled */
1132 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1133 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1134 unit_check_unneeded(other);
1135 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1136 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1137 unit_check_unneeded(other);
1138 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1139 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1140 unit_check_unneeded(other);
1141 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1142 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1143 unit_check_unneeded(other);
1144 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1145 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1146 unit_check_unneeded(other);
1147 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1148 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1149 unit_check_unneeded(other);
1152 void unit_trigger_on_failure(Unit *u) {
1158 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1161 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1163 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1166 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1167 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1171 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1175 assert(os < _UNIT_ACTIVE_STATE_MAX);
1176 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1178 /* Note that this is called for all low-level state changes,
1179 * even if they might map to the same high-level
1180 * UnitActiveState! That means that ns == os is OK an expected
1181 * behaviour here. For example: if a mount point is remounted
1182 * this function will be called too! */
1184 if (u->manager->n_reloading <= 0) {
1187 dual_timestamp_get(&ts);
1189 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1190 u->inactive_exit_timestamp = ts;
1191 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1192 u->inactive_enter_timestamp = ts;
1194 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1195 u->active_enter_timestamp = ts;
1196 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1197 u->active_exit_timestamp = ts;
1199 timer_unit_notify(u, ns);
1200 path_unit_notify(u, ns);
1203 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1204 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1209 if (u->job->state == JOB_WAITING)
1211 /* So we reached a different state for this
1212 * job. Let's see if we can run it now if it
1213 * failed previously due to EAGAIN. */
1214 job_add_to_run_queue(u->job);
1216 /* Let's check whether this state change constitutes a
1217 * finished job, or maybe contradicts a running job and
1218 * hence needs to invalidate jobs. */
1220 switch (u->job->type) {
1223 case JOB_VERIFY_ACTIVE:
1225 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1226 job_finish_and_invalidate(u->job, JOB_DONE);
1227 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1230 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1231 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE);
1237 case JOB_RELOAD_OR_START:
1239 if (u->job->state == JOB_RUNNING) {
1240 if (ns == UNIT_ACTIVE)
1241 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED);
1242 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1245 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1246 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE);
1254 case JOB_TRY_RESTART:
1256 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1257 job_finish_and_invalidate(u->job, JOB_DONE);
1258 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1260 job_finish_and_invalidate(u->job, JOB_FAILED);
1266 assert_not_reached("Job type unknown");
1272 if (u->manager->n_reloading <= 0) {
1274 /* If this state change happened without being
1275 * requested by a job, then let's retroactively start
1276 * or stop dependencies. We skip that step when
1277 * deserializing, since we don't want to create any
1278 * additional jobs just because something is already
1282 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1283 retroactively_start_dependencies(u);
1284 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1285 retroactively_stop_dependencies(u);
1288 /* stop unneeded units regardless if going down was expected or not */
1289 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1290 check_unneeded_dependencies(u);
1292 if (ns != os && ns == UNIT_FAILED) {
1293 log_notice("Unit %s entered failed state.", u->id);
1294 unit_trigger_on_failure(u);
1298 /* Some names are special */
1299 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1301 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1302 /* The bus just might have become available,
1303 * hence try to connect to it, if we aren't
1305 bus_init(u->manager, true);
1307 if (u->type == UNIT_SERVICE &&
1308 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1309 u->manager->n_reloading <= 0) {
1310 /* Write audit record if we have just finished starting up */
1311 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1315 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1316 manager_send_unit_plymouth(u->manager, u);
1320 /* We don't care about D-Bus here, since we'll get an
1321 * asynchronous notification for it anyway. */
1323 if (u->type == UNIT_SERVICE &&
1324 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1325 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1326 u->manager->n_reloading <= 0) {
1328 /* Hmm, if there was no start record written
1329 * write it now, so that we always have a nice
1332 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1334 if (ns == UNIT_INACTIVE)
1335 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1337 /* Write audit record if we have just finished shutting down */
1338 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1340 u->in_audit = false;
1344 manager_recheck_journal(u->manager);
1346 /* Maybe we finished startup and are now ready for being
1347 * stopped because unneeded? */
1348 unit_check_unneeded(u);
1350 unit_add_to_dbus_queue(u);
1351 unit_add_to_gc_queue(u);
1354 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1355 struct epoll_event ev;
1360 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1366 if (epoll_ctl(u->manager->epoll_fd,
1367 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1379 void unit_unwatch_fd(Unit *u, Watch *w) {
1383 if (w->type == WATCH_INVALID)
1386 assert(w->type == WATCH_FD);
1387 assert(w->data.unit == u);
1388 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1391 w->type = WATCH_INVALID;
1392 w->data.unit = NULL;
1395 int unit_watch_pid(Unit *u, pid_t pid) {
1399 /* Watch a specific PID. We only support one unit watching
1400 * each PID for now. */
1402 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1405 void unit_unwatch_pid(Unit *u, pid_t pid) {
1409 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1412 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1413 struct itimerspec its;
1419 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1421 /* This will try to reuse the old timer if there is one */
1423 if (w->type == WATCH_UNIT_TIMER) {
1424 assert(w->data.unit == u);
1429 } else if (w->type == WATCH_INVALID) {
1432 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1435 assert_not_reached("Invalid watch type");
1440 /* Set absolute time in the past, but not 0, since we
1441 * don't want to disarm the timer */
1442 its.it_value.tv_sec = 0;
1443 its.it_value.tv_nsec = 1;
1445 flags = TFD_TIMER_ABSTIME;
1447 timespec_store(&its.it_value, delay);
1451 /* This will also flush the elapse counter */
1452 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1455 if (w->type == WATCH_INVALID) {
1456 struct epoll_event ev;
1460 ev.events = EPOLLIN;
1462 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1466 w->type = WATCH_UNIT_TIMER;
1474 close_nointr_nofail(fd);
1479 void unit_unwatch_timer(Unit *u, Watch *w) {
1483 if (w->type == WATCH_INVALID)
1486 assert(w->type == WATCH_UNIT_TIMER);
1487 assert(w->data.unit == u);
1490 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1491 close_nointr_nofail(w->fd);
1494 w->type = WATCH_INVALID;
1495 w->data.unit = NULL;
1498 bool unit_job_is_applicable(Unit *u, JobType j) {
1500 assert(j >= 0 && j < _JOB_TYPE_MAX);
1504 case JOB_VERIFY_ACTIVE:
1510 case JOB_TRY_RESTART:
1511 return unit_can_start(u);
1514 return unit_can_reload(u);
1516 case JOB_RELOAD_OR_START:
1517 return unit_can_reload(u) && unit_can_start(u);
1520 assert_not_reached("Invalid job type");
1524 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1526 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1527 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1528 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1529 [UNIT_WANTS] = UNIT_WANTED_BY,
1530 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1531 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1532 [UNIT_BIND_TO] = UNIT_BOUND_BY,
1533 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1534 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1535 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1536 [UNIT_BOUND_BY] = UNIT_BIND_TO,
1537 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1538 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1539 [UNIT_BEFORE] = UNIT_AFTER,
1540 [UNIT_AFTER] = UNIT_BEFORE,
1541 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1542 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1543 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1544 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1545 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1546 [UNIT_PROPAGATE_RELOAD_TO] = UNIT_PROPAGATE_RELOAD_FROM,
1547 [UNIT_PROPAGATE_RELOAD_FROM] = UNIT_PROPAGATE_RELOAD_TO
1549 int r, q = 0, v = 0, w = 0;
1552 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1555 u = unit_follow_merge(u);
1556 other = unit_follow_merge(other);
1558 /* We won't allow dependencies on ourselves. We will not
1559 * consider them an error however. */
1563 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1566 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1567 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1571 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1572 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1575 if ((q = set_put(u->dependencies[d], other)) < 0)
1578 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1579 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1584 if (add_reference) {
1585 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1590 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1594 unit_add_to_dbus_queue(u);
1599 set_remove(u->dependencies[d], other);
1602 set_remove(other->dependencies[inverse_table[d]], u);
1605 set_remove(u->dependencies[UNIT_REFERENCES], other);
1610 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1615 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1618 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1624 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1628 assert(name || path);
1631 name = file_name_from_path(path);
1633 if (!unit_name_is_template(name)) {
1639 s = unit_name_replace_instance(name, u->instance);
1643 if (!(i = unit_name_to_prefix(u->id)))
1646 s = unit_name_replace_instance(name, i);
1657 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1663 assert(name || path);
1665 if (!(name = resolve_template(u, name, path, &s)))
1668 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1671 r = unit_add_dependency(u, d, other, add_reference);
1678 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1684 assert(name || path);
1686 if (!(name = resolve_template(u, name, path, &s)))
1689 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1692 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1699 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1705 assert(name || path);
1707 if (!(name = resolve_template(u, name, path, &s)))
1710 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1713 r = unit_add_dependency(other, d, u, add_reference);
1720 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1726 assert(name || path);
1728 if (!(name = resolve_template(u, name, path, &s)))
1731 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1734 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1742 int set_unit_path(const char *p) {
1746 /* This is mostly for debug purposes */
1748 if (path_is_absolute(p)) {
1749 if (!(c = strdup(p)))
1752 if (!(cwd = get_current_dir_name()))
1755 r = asprintf(&c, "%s/%s", cwd, p);
1762 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1771 char *unit_dbus_path(Unit *u) {
1779 if (!(e = bus_path_escape(u->id)))
1782 p = strappend("/org/freedesktop/systemd1/unit/", e);
1788 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1796 if (!b->controller) {
1797 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1803 /* Ensure this hasn't been added yet */
1806 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1809 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1810 LIST_PREPEND(CGroupBonding, by_path, l, b);
1812 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1813 LIST_REMOVE(CGroupBonding, by_path, l, b);
1818 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1824 static char *default_cgroup_path(Unit *u) {
1832 t = unit_name_template(u->id);
1836 p = join(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1839 p = join(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1844 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1845 char *controller = NULL, *path = NULL;
1846 CGroupBonding *b = NULL;
1853 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1857 path = default_cgroup_path(u);
1862 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1866 if (!path || !controller) {
1873 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1878 if (!(b = new0(CGroupBonding, 1))) {
1883 b->controller = controller;
1886 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1888 if ((r = unit_add_cgroup(u, b)) < 0)
1901 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1902 CGroupBonding *b = NULL;
1908 controller = SYSTEMD_CGROUP_CONTROLLER;
1910 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1913 if (!(b = new0(CGroupBonding, 1)))
1916 if (!(b->controller = strdup(controller)))
1919 if (!(b->path = default_cgroup_path(u)))
1923 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1925 if ((r = unit_add_cgroup(u, b)) < 0)
1932 free(b->controller);
1938 int unit_add_default_cgroups(Unit *u) {
1945 /* Adds in the default cgroups, if they weren't specified
1948 if (!u->manager->cgroup_hierarchy)
1951 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
1954 STRV_FOREACH(c, u->manager->default_controllers)
1955 unit_add_one_default_cgroup(u, *c);
1957 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
1958 unit_add_one_default_cgroup(u, a->controller);
1963 CGroupBonding* unit_get_default_cgroup(Unit *u) {
1966 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
1969 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
1981 dot = strchr(name, '.');
1985 c = strndup(name, dot - name);
1992 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
1997 a = new0(CGroupAttribute, 1);
2007 a->controller = strdup(controller);
2009 a->name = strdup(name);
2010 a->value = strdup(value);
2012 if (!a->controller || !a->name || !a->value) {
2013 free(a->controller);
2021 a->map_callback = map_callback;
2023 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2032 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2040 if (!(t = unit_name_change_suffix(u->id, type)))
2043 assert(!unit_has_name(u, t));
2045 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2048 assert(r < 0 || *_found != u);
2053 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2061 if (!(t = unit_name_change_suffix(u->id, type)))
2064 assert(!unit_has_name(u, t));
2066 found = manager_get_unit(u->manager, t);
2076 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2080 return unit_name_to_prefix_and_instance(u->id);
2083 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2087 return unit_name_to_prefix(u->id);
2090 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2096 if (!(p = unit_name_to_prefix(u->id)))
2099 r = unit_name_unescape(p);
2105 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2110 return unit_name_unescape(u->instance);
2115 static char *specifier_filename(char specifier, void *data, void *userdata) {
2120 return unit_name_path_unescape(u->instance);
2122 return unit_name_to_path(u->instance);
2125 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2129 return default_cgroup_path(u);
2132 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2137 if (specifier == 'r')
2138 return strdup(u->manager->cgroup_hierarchy);
2140 if (parent_of_path(u->manager->cgroup_hierarchy, &p) < 0)
2143 if (streq(p, "/")) {
2151 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2155 if (u->manager->running_as == MANAGER_USER) {
2158 e = getenv("XDG_RUNTIME_DIR");
2163 return strdup("/run");
2166 char *unit_name_printf(Unit *u, const char* format) {
2169 * This will use the passed string as format string and
2170 * replace the following specifiers:
2172 * %n: the full id of the unit (foo@bar.waldo)
2173 * %N: the id of the unit without the suffix (foo@bar)
2174 * %p: the prefix (foo)
2175 * %i: the instance (bar)
2178 const Specifier table[] = {
2179 { 'n', specifier_string, u->id },
2180 { 'N', specifier_prefix_and_instance, NULL },
2181 { 'p', specifier_prefix, NULL },
2182 { 'i', specifier_string, u->instance },
2189 return specifier_printf(format, table, u);
2192 char *unit_full_printf(Unit *u, const char *format) {
2194 /* This is similar to unit_name_printf() but also supports
2195 * unescaping. Also, adds a couple of additional codes:
2197 * %c cgroup path of unit
2198 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2199 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2200 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2203 const Specifier table[] = {
2204 { 'n', specifier_string, u->id },
2205 { 'N', specifier_prefix_and_instance, NULL },
2206 { 'p', specifier_prefix, NULL },
2207 { 'P', specifier_prefix_unescaped, NULL },
2208 { 'i', specifier_string, u->instance },
2209 { 'I', specifier_instance_unescaped, NULL },
2210 { 'f', specifier_filename, NULL },
2211 { 'c', specifier_cgroup, NULL },
2212 { 'r', specifier_cgroup_root, NULL },
2213 { 'R', specifier_cgroup_root, NULL },
2214 { 't', specifier_runtime, NULL },
2221 return specifier_printf(format, table, u);
2224 char **unit_full_printf_strv(Unit *u, char **l) {
2228 /* Applies unit_full_printf to every entry in l */
2233 if (!(r = new(char*, n+1)))
2236 for (i = l, j = r; *i; i++, j++)
2237 if (!(*j = unit_full_printf(u, *i)))
2244 for (j--; j >= r; j--)
2252 int unit_watch_bus_name(Unit *u, const char *name) {
2256 /* Watch a specific name on the bus. We only support one unit
2257 * watching each name for now. */
2259 return hashmap_put(u->manager->watch_bus, name, u);
2262 void unit_unwatch_bus_name(Unit *u, const char *name) {
2266 hashmap_remove_value(u->manager->watch_bus, name, u);
2269 bool unit_can_serialize(Unit *u) {
2272 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2275 int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
2282 if (!unit_can_serialize(u))
2285 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2289 unit_serialize_item(u, f, "job", job_type_to_string(u->job->type));
2291 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2292 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2293 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2294 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2295 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2297 if (dual_timestamp_is_set(&u->condition_timestamp))
2298 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2305 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2316 va_start(ap, format);
2317 vfprintf(f, format, ap);
2323 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2329 fprintf(f, "%s=%s\n", key, value);
2332 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2339 if (!unit_can_serialize(u))
2343 char line[LINE_MAX], *l, *v;
2346 if (!fgets(line, sizeof(line), f)) {
2359 k = strcspn(l, "=");
2367 if (streq(l, "job")) {
2370 if ((type = job_type_from_string(v)) < 0)
2371 log_debug("Failed to parse job type value %s", v);
2373 u->deserialized_job = type;
2376 } else if (streq(l, "inactive-exit-timestamp")) {
2377 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2379 } else if (streq(l, "active-enter-timestamp")) {
2380 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2382 } else if (streq(l, "active-exit-timestamp")) {
2383 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2385 } else if (streq(l, "inactive-enter-timestamp")) {
2386 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2388 } else if (streq(l, "condition-timestamp")) {
2389 dual_timestamp_deserialize(v, &u->condition_timestamp);
2391 } else if (streq(l, "condition-result")) {
2394 if ((b = parse_boolean(v)) < 0)
2395 log_debug("Failed to parse condition result value %s", v);
2397 u->condition_result = b;
2402 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2407 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2417 /* Adds in links to the device node that this unit is based on */
2419 if (!is_device_path(what))
2422 if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
2425 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2431 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BIND_TO, device, true)) < 0)
2435 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2441 int unit_coldplug(Unit *u) {
2446 if (UNIT_VTABLE(u)->coldplug)
2447 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2450 if (u->deserialized_job >= 0) {
2451 if ((r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL)) < 0)
2454 u->deserialized_job = _JOB_TYPE_INVALID;
2460 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2466 if (!UNIT_VTABLE(u)->show_status)
2469 if (!manager_get_show_status(u->manager))
2472 if (!manager_is_booting_or_shutting_down(u->manager))
2475 va_start(ap, format);
2476 status_vprintf(status, true, format, ap);
2480 bool unit_need_daemon_reload(Unit *u) {
2483 if (u->fragment_path) {
2487 if (stat(u->fragment_path, &st) < 0)
2488 /* What, cannot access this anymore? */
2491 if (u->fragment_mtime > 0 &&
2492 timespec_load(&st.st_mtim) != u->fragment_mtime)
2496 if (UNIT_VTABLE(u)->need_daemon_reload)
2497 return UNIT_VTABLE(u)->need_daemon_reload(u);
2502 void unit_reset_failed(Unit *u) {
2505 if (UNIT_VTABLE(u)->reset_failed)
2506 UNIT_VTABLE(u)->reset_failed(u);
2509 Unit *unit_following(Unit *u) {
2512 if (UNIT_VTABLE(u)->following)
2513 return UNIT_VTABLE(u)->following(u);
2518 bool unit_pending_inactive(Unit *u) {
2521 /* Returns true if the unit is inactive or going down */
2523 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2526 if (u->job && u->job->type == JOB_STOP)
2532 bool unit_pending_active(Unit *u) {
2535 /* Returns true if the unit is active or going up */
2537 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2541 (u->job->type == JOB_START ||
2542 u->job->type == JOB_RELOAD_OR_START ||
2543 u->job->type == JOB_RESTART))
2549 UnitType unit_name_to_type(const char *n) {
2554 for (t = 0; t < _UNIT_TYPE_MAX; t++)
2555 if (endswith(n, unit_vtable[t]->suffix))
2558 return _UNIT_TYPE_INVALID;
2561 bool unit_name_is_valid(const char *n, bool template_ok) {
2564 t = unit_name_to_type(n);
2565 if (t < 0 || t >= _UNIT_TYPE_MAX)
2568 return unit_name_is_valid_no_type(n, template_ok);
2571 int unit_kill(Unit *u, KillWho w, KillMode m, int signo, DBusError *error) {
2573 assert(w >= 0 && w < _KILL_WHO_MAX);
2574 assert(m >= 0 && m < _KILL_MODE_MAX);
2576 assert(signo < _NSIG);
2581 if (!UNIT_VTABLE(u)->kill)
2584 return UNIT_VTABLE(u)->kill(u, w, m, signo, error);
2587 int unit_following_set(Unit *u, Set **s) {
2591 if (UNIT_VTABLE(u)->following_set)
2592 return UNIT_VTABLE(u)->following_set(u, s);
2598 UnitFileState unit_get_unit_file_state(Unit *u) {
2601 if (u->unit_file_state < 0 && u->fragment_path)
2602 u->unit_file_state = unit_file_get_state(
2603 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2604 NULL, file_name_from_path(u->fragment_path));
2606 return u->unit_file_state;
2609 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2614 unit_ref_unset(ref);
2617 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2621 void unit_ref_unset(UnitRef *ref) {
2627 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2631 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
2632 [UNIT_STUB] = "stub",
2633 [UNIT_LOADED] = "loaded",
2634 [UNIT_ERROR] = "error",
2635 [UNIT_MERGED] = "merged",
2636 [UNIT_MASKED] = "masked"
2639 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
2641 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2642 [UNIT_ACTIVE] = "active",
2643 [UNIT_RELOADING] = "reloading",
2644 [UNIT_INACTIVE] = "inactive",
2645 [UNIT_FAILED] = "failed",
2646 [UNIT_ACTIVATING] = "activating",
2647 [UNIT_DEACTIVATING] = "deactivating"
2650 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2652 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2653 [UNIT_REQUIRES] = "Requires",
2654 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2655 [UNIT_WANTS] = "Wants",
2656 [UNIT_REQUISITE] = "Requisite",
2657 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2658 [UNIT_REQUIRED_BY] = "RequiredBy",
2659 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2660 [UNIT_BIND_TO] = "BindTo",
2661 [UNIT_WANTED_BY] = "WantedBy",
2662 [UNIT_CONFLICTS] = "Conflicts",
2663 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2664 [UNIT_BOUND_BY] = "BoundBy",
2665 [UNIT_BEFORE] = "Before",
2666 [UNIT_AFTER] = "After",
2667 [UNIT_REFERENCES] = "References",
2668 [UNIT_REFERENCED_BY] = "ReferencedBy",
2669 [UNIT_ON_FAILURE] = "OnFailure",
2670 [UNIT_TRIGGERS] = "Triggers",
2671 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2672 [UNIT_PROPAGATE_RELOAD_TO] = "PropagateReloadTo",
2673 [UNIT_PROPAGATE_RELOAD_FROM] = "PropagateReloadFrom"
2676 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);