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);
361 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
362 bidi_set_free(u, u->dependencies[d]);
364 if (u->type != _UNIT_TYPE_INVALID)
365 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
367 if (u->in_load_queue)
368 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
370 if (u->in_dbus_queue)
371 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
373 if (u->in_cleanup_queue)
374 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
376 if (u->in_gc_queue) {
377 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
378 u->manager->n_in_gc_queue--;
381 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
382 cgroup_attribute_free_list(u->cgroup_attributes);
384 free(u->description);
385 free(u->fragment_path);
388 set_free_free(u->names);
390 condition_free_list(u->conditions);
393 unit_ref_unset(u->refs);
398 UnitActiveState unit_active_state(Unit *u) {
401 if (u->load_state == UNIT_MERGED)
402 return unit_active_state(unit_follow_merge(u));
404 /* After a reload it might happen that a unit is not correctly
405 * loaded but still has a process around. That's why we won't
406 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
408 return UNIT_VTABLE(u)->active_state(u);
411 const char* unit_sub_state_to_string(Unit *u) {
414 return UNIT_VTABLE(u)->sub_state_to_string(u);
417 static void complete_move(Set **s, Set **other) {
425 set_move(*s, *other);
432 static void merge_names(Unit *u, Unit *other) {
439 complete_move(&u->names, &other->names);
441 set_free_free(other->names);
445 SET_FOREACH(t, u->names, i)
446 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
449 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
456 assert(d < _UNIT_DEPENDENCY_MAX);
458 /* Fix backwards pointers */
459 SET_FOREACH(back, other->dependencies[d], i) {
462 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
463 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
466 set_remove(back->dependencies[k], other);
468 assert(r == -ENOENT);
472 complete_move(&u->dependencies[d], &other->dependencies[d]);
474 set_free(other->dependencies[d]);
475 other->dependencies[d] = NULL;
478 int unit_merge(Unit *u, Unit *other) {
483 assert(u->manager == other->manager);
484 assert(u->type != _UNIT_TYPE_INVALID);
486 other = unit_follow_merge(other);
491 if (u->type != other->type)
494 if (!u->instance != !other->instance)
497 if (other->load_state != UNIT_STUB &&
498 other->load_state != UNIT_ERROR)
504 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
508 merge_names(u, other);
510 /* Redirect all references */
512 unit_ref_set(other->refs, u);
514 /* Merge dependencies */
515 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
516 merge_dependencies(u, other, d);
518 other->load_state = UNIT_MERGED;
519 other->merged_into = u;
521 /* If there is still some data attached to the other node, we
522 * don't need it anymore, and can free it. */
523 if (other->load_state != UNIT_STUB)
524 if (UNIT_VTABLE(other)->done)
525 UNIT_VTABLE(other)->done(other);
527 unit_add_to_dbus_queue(u);
528 unit_add_to_cleanup_queue(other);
533 int unit_merge_by_name(Unit *u, const char *name) {
541 if (unit_name_is_template(name)) {
545 if (!(s = unit_name_replace_instance(name, u->instance)))
551 if (!(other = manager_get_unit(u->manager, name)))
552 r = unit_add_name(u, name);
554 r = unit_merge(u, other);
560 Unit* unit_follow_merge(Unit *u) {
563 while (u->load_state == UNIT_MERGED)
564 assert_se(u = u->merged_into);
569 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
575 if (c->std_output != EXEC_OUTPUT_KMSG &&
576 c->std_output != EXEC_OUTPUT_SYSLOG &&
577 c->std_output != EXEC_OUTPUT_JOURNAL &&
578 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
579 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
580 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
581 c->std_error != EXEC_OUTPUT_KMSG &&
582 c->std_error != EXEC_OUTPUT_SYSLOG &&
583 c->std_error != EXEC_OUTPUT_JOURNAL &&
584 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
585 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
586 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
589 /* If syslog or kernel logging is requested, make sure our own
590 * logging daemon is run first. */
592 if (u->manager->running_as == MANAGER_SYSTEM)
593 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
599 const char *unit_description(Unit *u) {
603 return u->description;
608 void unit_dump(Unit *u, FILE *f, const char *prefix) {
615 timestamp1[FORMAT_TIMESTAMP_MAX],
616 timestamp2[FORMAT_TIMESTAMP_MAX],
617 timestamp3[FORMAT_TIMESTAMP_MAX],
618 timestamp4[FORMAT_TIMESTAMP_MAX],
619 timespan[FORMAT_TIMESPAN_MAX];
623 assert(u->type >= 0);
627 p2 = strappend(prefix, "\t");
628 prefix2 = p2 ? p2 : prefix;
632 "%s\tDescription: %s\n"
634 "%s\tUnit Load State: %s\n"
635 "%s\tUnit Active State: %s\n"
636 "%s\tInactive Exit Timestamp: %s\n"
637 "%s\tActive Enter Timestamp: %s\n"
638 "%s\tActive Exit Timestamp: %s\n"
639 "%s\tInactive Enter Timestamp: %s\n"
640 "%s\tGC Check Good: %s\n"
641 "%s\tNeed Daemon Reload: %s\n",
643 prefix, unit_description(u),
644 prefix, strna(u->instance),
645 prefix, unit_load_state_to_string(u->load_state),
646 prefix, unit_active_state_to_string(unit_active_state(u)),
647 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
648 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
649 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
650 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
651 prefix, yes_no(unit_check_gc(u)),
652 prefix, yes_no(unit_need_daemon_reload(u)));
654 SET_FOREACH(t, u->names, i)
655 fprintf(f, "%s\tName: %s\n", prefix, t);
657 if ((following = unit_following(u)))
658 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
660 if (u->fragment_path)
661 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
663 if (u->job_timeout > 0)
664 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
666 condition_dump_list(u->conditions, f, prefix);
668 if (dual_timestamp_is_set(&u->condition_timestamp))
670 "%s\tCondition Timestamp: %s\n"
671 "%s\tCondition Result: %s\n",
672 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
673 prefix, yes_no(u->condition_result));
675 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
678 SET_FOREACH(other, u->dependencies[d], i)
679 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
682 if (u->load_state == UNIT_LOADED) {
687 "%s\tStopWhenUnneeded: %s\n"
688 "%s\tRefuseManualStart: %s\n"
689 "%s\tRefuseManualStop: %s\n"
690 "%s\tDefaultDependencies: %s\n"
691 "%s\tOnFailureIsolate: %s\n"
692 "%s\tIgnoreOnIsolate: %s\n"
693 "%s\tIgnoreOnSnapshot: %s\n",
694 prefix, yes_no(u->stop_when_unneeded),
695 prefix, yes_no(u->refuse_manual_start),
696 prefix, yes_no(u->refuse_manual_stop),
697 prefix, yes_no(u->default_dependencies),
698 prefix, yes_no(u->on_failure_isolate),
699 prefix, yes_no(u->ignore_on_isolate),
700 prefix, yes_no(u->ignore_on_snapshot));
702 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
703 fprintf(f, "%s\tControlGroup: %s:%s\n",
704 prefix, b->controller, b->path);
706 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
710 a->map_callback(a->controller, a->name, a->value, &v);
712 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
713 prefix, a->controller, a->name, v ? v : a->value);
718 if (UNIT_VTABLE(u)->dump)
719 UNIT_VTABLE(u)->dump(u, f, prefix2);
721 } else if (u->load_state == UNIT_MERGED)
723 "%s\tMerged into: %s\n",
724 prefix, u->merged_into->id);
725 else if (u->load_state == UNIT_ERROR)
726 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
730 job_dump(u->job, f, prefix2);
735 /* Common implementation for multiple backends */
736 int unit_load_fragment_and_dropin(Unit *u) {
741 /* Load a .service file */
742 if ((r = unit_load_fragment(u)) < 0)
745 if (u->load_state == UNIT_STUB)
748 /* Load drop-in directory data */
749 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
755 /* Common implementation for multiple backends */
756 int unit_load_fragment_and_dropin_optional(Unit *u) {
761 /* Same as unit_load_fragment_and_dropin(), but whether
762 * something can be loaded or not doesn't matter. */
764 /* Load a .service file */
765 if ((r = unit_load_fragment(u)) < 0)
768 if (u->load_state == UNIT_STUB)
769 u->load_state = UNIT_LOADED;
771 /* Load drop-in directory data */
772 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
778 int unit_add_default_target_dependency(Unit *u, Unit *target) {
782 if (target->type != UNIT_TARGET)
785 /* Only add the dependency if both units are loaded, so that
786 * that loop check below is reliable */
787 if (u->load_state != UNIT_LOADED ||
788 target->load_state != UNIT_LOADED)
791 /* If either side wants no automatic dependencies, then let's
793 if (!u->default_dependencies ||
794 !target->default_dependencies)
797 /* Don't create loops */
798 if (set_get(target->dependencies[UNIT_BEFORE], u))
801 return unit_add_dependency(target, UNIT_AFTER, u, true);
804 static int unit_add_default_dependencies(Unit *u) {
805 static const UnitDependency deps[] = {
807 UNIT_REQUIRED_BY_OVERRIDABLE,
819 for (k = 0; k < ELEMENTSOF(deps); k++)
820 SET_FOREACH(target, u->dependencies[deps[k]], i)
821 if ((r = unit_add_default_target_dependency(u, target)) < 0)
827 int unit_load(Unit *u) {
832 if (u->in_load_queue) {
833 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
834 u->in_load_queue = false;
837 if (u->type == _UNIT_TYPE_INVALID)
840 if (u->load_state != UNIT_STUB)
843 if (UNIT_VTABLE(u)->load)
844 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
847 if (u->load_state == UNIT_STUB) {
852 if (u->load_state == UNIT_LOADED &&
853 u->default_dependencies)
854 if ((r = unit_add_default_dependencies(u)) < 0)
857 if (u->on_failure_isolate &&
858 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
860 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
867 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
869 unit_add_to_dbus_queue(unit_follow_merge(u));
870 unit_add_to_gc_queue(u);
875 u->load_state = UNIT_ERROR;
877 unit_add_to_dbus_queue(u);
878 unit_add_to_gc_queue(u);
880 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
885 bool unit_condition_test(Unit *u) {
888 dual_timestamp_get(&u->condition_timestamp);
889 u->condition_result = condition_test_list(u->conditions);
891 return u->condition_result;
895 * -EBADR: This unit type does not support starting.
896 * -EALREADY: Unit is already started.
897 * -EAGAIN: An operation is already in progress. Retry later.
898 * -ECANCELED: Too many requests for now.
900 int unit_start(Unit *u) {
901 UnitActiveState state;
906 if (u->load_state != UNIT_LOADED)
909 /* If this is already started, then this will succeed. Note
910 * that this will even succeed if this unit is not startable
911 * by the user. This is relied on to detect when we need to
912 * wait for units and when waiting is finished. */
913 state = unit_active_state(u);
914 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
917 /* If the conditions failed, don't do anything at all. If we
918 * already are activating this call might still be useful to
919 * speed up activation in case there is some hold-off time,
920 * but we don't want to recheck the condition in that case. */
921 if (state != UNIT_ACTIVATING &&
922 !unit_condition_test(u)) {
923 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
927 /* Forward to the main object, if we aren't it. */
928 if ((following = unit_following(u))) {
929 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
930 return unit_start(following);
933 /* If it is stopped, but we cannot start it, then fail */
934 if (!UNIT_VTABLE(u)->start)
937 /* We don't suppress calls to ->start() here when we are
938 * already starting, to allow this request to be used as a
939 * "hurry up" call, for example when the unit is in some "auto
940 * restart" state where it waits for a holdoff timer to elapse
941 * before it will start again. */
943 unit_add_to_dbus_queue(u);
945 unit_status_printf(u, NULL, "Starting %s...", unit_description(u));
946 return UNIT_VTABLE(u)->start(u);
949 bool unit_can_start(Unit *u) {
952 return !!UNIT_VTABLE(u)->start;
955 bool unit_can_isolate(Unit *u) {
958 return unit_can_start(u) &&
963 * -EBADR: This unit type does not support stopping.
964 * -EALREADY: Unit is already stopped.
965 * -EAGAIN: An operation is already in progress. Retry later.
967 int unit_stop(Unit *u) {
968 UnitActiveState state;
973 state = unit_active_state(u);
974 if (UNIT_IS_INACTIVE_OR_FAILED(state))
977 if ((following = unit_following(u))) {
978 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
979 return unit_stop(following);
982 if (!UNIT_VTABLE(u)->stop)
985 unit_add_to_dbus_queue(u);
987 unit_status_printf(u, NULL, "Stopping %s...", unit_description(u));
988 return UNIT_VTABLE(u)->stop(u);
992 * -EBADR: This unit type does not support reloading.
993 * -ENOEXEC: Unit is not started.
994 * -EAGAIN: An operation is already in progress. Retry later.
996 int unit_reload(Unit *u) {
997 UnitActiveState state;
1002 if (u->load_state != UNIT_LOADED)
1005 if (!unit_can_reload(u))
1008 state = unit_active_state(u);
1009 if (state == UNIT_RELOADING)
1012 if (state != UNIT_ACTIVE)
1015 if ((following = unit_following(u))) {
1016 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1017 return unit_reload(following);
1020 unit_add_to_dbus_queue(u);
1021 return UNIT_VTABLE(u)->reload(u);
1024 bool unit_can_reload(Unit *u) {
1027 if (!UNIT_VTABLE(u)->reload)
1030 if (!UNIT_VTABLE(u)->can_reload)
1033 return UNIT_VTABLE(u)->can_reload(u);
1036 static void unit_check_unneeded(Unit *u) {
1042 /* If this service shall be shut down when unneeded then do
1045 if (!u->stop_when_unneeded)
1048 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1051 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1052 if (unit_pending_active(other))
1055 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1056 if (unit_pending_active(other))
1059 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1060 if (unit_pending_active(other))
1063 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1064 if (unit_pending_active(other))
1067 log_info("Service %s is not needed anymore. Stopping.", u->id);
1069 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1070 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1073 static void retroactively_start_dependencies(Unit *u) {
1078 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1080 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1081 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1082 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1083 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1085 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1086 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1087 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1088 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1090 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1091 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1092 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1093 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1095 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1096 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1097 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1098 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1100 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1101 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1102 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1103 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1105 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1106 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1107 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1109 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1110 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1111 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1114 static void retroactively_stop_dependencies(Unit *u) {
1119 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1121 /* Pull down units which are bound to us recursively if enabled */
1122 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1123 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1124 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1127 static void check_unneeded_dependencies(Unit *u) {
1132 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1134 /* Garbage collect services that might not be needed anymore, if enabled */
1135 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1136 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1137 unit_check_unneeded(other);
1138 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1139 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1140 unit_check_unneeded(other);
1141 SET_FOREACH(other, u->dependencies[UNIT_WANTS], 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], i)
1145 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1146 unit_check_unneeded(other);
1147 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1148 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1149 unit_check_unneeded(other);
1150 SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1151 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1152 unit_check_unneeded(other);
1155 void unit_trigger_on_failure(Unit *u) {
1161 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1164 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1166 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1169 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1170 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1174 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1178 assert(os < _UNIT_ACTIVE_STATE_MAX);
1179 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1181 /* Note that this is called for all low-level state changes,
1182 * even if they might map to the same high-level
1183 * UnitActiveState! That means that ns == os is OK an expected
1184 * behaviour here. For example: if a mount point is remounted
1185 * this function will be called too! */
1187 if (u->manager->n_reloading <= 0) {
1190 dual_timestamp_get(&ts);
1192 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1193 u->inactive_exit_timestamp = ts;
1194 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1195 u->inactive_enter_timestamp = ts;
1197 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1198 u->active_enter_timestamp = ts;
1199 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1200 u->active_exit_timestamp = ts;
1202 timer_unit_notify(u, ns);
1203 path_unit_notify(u, ns);
1206 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1207 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1212 if (u->job->state == JOB_WAITING)
1214 /* So we reached a different state for this
1215 * job. Let's see if we can run it now if it
1216 * failed previously due to EAGAIN. */
1217 job_add_to_run_queue(u->job);
1219 /* Let's check whether this state change constitutes a
1220 * finished job, or maybe contradicts a running job and
1221 * hence needs to invalidate jobs. */
1223 switch (u->job->type) {
1226 case JOB_VERIFY_ACTIVE:
1228 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1229 job_finish_and_invalidate(u->job, JOB_DONE, true);
1230 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1233 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1234 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1240 case JOB_RELOAD_OR_START:
1242 if (u->job->state == JOB_RUNNING) {
1243 if (ns == UNIT_ACTIVE)
1244 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1245 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1248 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1249 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1257 case JOB_TRY_RESTART:
1259 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1260 job_finish_and_invalidate(u->job, JOB_DONE, true);
1261 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1263 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1269 assert_not_reached("Job type unknown");
1275 if (u->manager->n_reloading <= 0) {
1277 /* If this state change happened without being
1278 * requested by a job, then let's retroactively start
1279 * or stop dependencies. We skip that step when
1280 * deserializing, since we don't want to create any
1281 * additional jobs just because something is already
1285 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1286 retroactively_start_dependencies(u);
1287 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1288 retroactively_stop_dependencies(u);
1291 /* stop unneeded units regardless if going down was expected or not */
1292 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1293 check_unneeded_dependencies(u);
1295 if (ns != os && ns == UNIT_FAILED) {
1296 log_notice("Unit %s entered failed state.", u->id);
1297 unit_trigger_on_failure(u);
1301 /* Some names are special */
1302 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1304 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1305 /* The bus just might have become available,
1306 * hence try to connect to it, if we aren't
1308 bus_init(u->manager, true);
1310 if (u->type == UNIT_SERVICE &&
1311 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1312 u->manager->n_reloading <= 0) {
1313 /* Write audit record if we have just finished starting up */
1314 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1318 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1319 manager_send_unit_plymouth(u->manager, u);
1323 /* We don't care about D-Bus here, since we'll get an
1324 * asynchronous notification for it anyway. */
1326 if (u->type == UNIT_SERVICE &&
1327 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1328 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1329 u->manager->n_reloading <= 0) {
1331 /* Hmm, if there was no start record written
1332 * write it now, so that we always have a nice
1335 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1337 if (ns == UNIT_INACTIVE)
1338 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1340 /* Write audit record if we have just finished shutting down */
1341 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1343 u->in_audit = false;
1347 manager_recheck_journal(u->manager);
1349 /* Maybe we finished startup and are now ready for being
1350 * stopped because unneeded? */
1351 unit_check_unneeded(u);
1353 unit_add_to_dbus_queue(u);
1354 unit_add_to_gc_queue(u);
1357 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1358 struct epoll_event ev;
1363 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1369 if (epoll_ctl(u->manager->epoll_fd,
1370 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1382 void unit_unwatch_fd(Unit *u, Watch *w) {
1386 if (w->type == WATCH_INVALID)
1389 assert(w->type == WATCH_FD);
1390 assert(w->data.unit == u);
1391 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1394 w->type = WATCH_INVALID;
1395 w->data.unit = NULL;
1398 int unit_watch_pid(Unit *u, pid_t pid) {
1402 /* Watch a specific PID. We only support one unit watching
1403 * each PID for now. */
1405 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1408 void unit_unwatch_pid(Unit *u, pid_t pid) {
1412 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1415 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1416 struct itimerspec its;
1422 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1424 /* This will try to reuse the old timer if there is one */
1426 if (w->type == WATCH_UNIT_TIMER) {
1427 assert(w->data.unit == u);
1432 } else if (w->type == WATCH_INVALID) {
1435 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1438 assert_not_reached("Invalid watch type");
1443 /* Set absolute time in the past, but not 0, since we
1444 * don't want to disarm the timer */
1445 its.it_value.tv_sec = 0;
1446 its.it_value.tv_nsec = 1;
1448 flags = TFD_TIMER_ABSTIME;
1450 timespec_store(&its.it_value, delay);
1454 /* This will also flush the elapse counter */
1455 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1458 if (w->type == WATCH_INVALID) {
1459 struct epoll_event ev;
1463 ev.events = EPOLLIN;
1465 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1469 w->type = WATCH_UNIT_TIMER;
1477 close_nointr_nofail(fd);
1482 void unit_unwatch_timer(Unit *u, Watch *w) {
1486 if (w->type == WATCH_INVALID)
1489 assert(w->type == WATCH_UNIT_TIMER);
1490 assert(w->data.unit == u);
1493 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1494 close_nointr_nofail(w->fd);
1497 w->type = WATCH_INVALID;
1498 w->data.unit = NULL;
1501 bool unit_job_is_applicable(Unit *u, JobType j) {
1503 assert(j >= 0 && j < _JOB_TYPE_MAX);
1507 case JOB_VERIFY_ACTIVE:
1513 case JOB_TRY_RESTART:
1514 return unit_can_start(u);
1517 return unit_can_reload(u);
1519 case JOB_RELOAD_OR_START:
1520 return unit_can_reload(u) && unit_can_start(u);
1523 assert_not_reached("Invalid job type");
1527 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1529 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1530 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1531 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1532 [UNIT_WANTS] = UNIT_WANTED_BY,
1533 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1534 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1535 [UNIT_BIND_TO] = UNIT_BOUND_BY,
1536 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1537 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1538 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1539 [UNIT_BOUND_BY] = UNIT_BIND_TO,
1540 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1541 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1542 [UNIT_BEFORE] = UNIT_AFTER,
1543 [UNIT_AFTER] = UNIT_BEFORE,
1544 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1545 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1546 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1547 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1548 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1549 [UNIT_PROPAGATE_RELOAD_TO] = UNIT_PROPAGATE_RELOAD_FROM,
1550 [UNIT_PROPAGATE_RELOAD_FROM] = UNIT_PROPAGATE_RELOAD_TO
1552 int r, q = 0, v = 0, w = 0;
1555 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1558 u = unit_follow_merge(u);
1559 other = unit_follow_merge(other);
1561 /* We won't allow dependencies on ourselves. We will not
1562 * consider them an error however. */
1566 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1569 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1570 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1574 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1575 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1578 if ((q = set_put(u->dependencies[d], other)) < 0)
1581 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1582 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1587 if (add_reference) {
1588 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1593 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1597 unit_add_to_dbus_queue(u);
1602 set_remove(u->dependencies[d], other);
1605 set_remove(other->dependencies[inverse_table[d]], u);
1608 set_remove(u->dependencies[UNIT_REFERENCES], other);
1613 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1618 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1621 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1627 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1631 assert(name || path);
1634 name = file_name_from_path(path);
1636 if (!unit_name_is_template(name)) {
1642 s = unit_name_replace_instance(name, u->instance);
1646 if (!(i = unit_name_to_prefix(u->id)))
1649 s = unit_name_replace_instance(name, i);
1660 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1666 assert(name || path);
1668 if (!(name = resolve_template(u, name, path, &s)))
1671 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1674 r = unit_add_dependency(u, d, other, add_reference);
1681 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1687 assert(name || path);
1689 if (!(name = resolve_template(u, name, path, &s)))
1692 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1695 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1702 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1708 assert(name || path);
1710 if (!(name = resolve_template(u, name, path, &s)))
1713 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1716 r = unit_add_dependency(other, d, u, add_reference);
1723 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1729 assert(name || path);
1731 if (!(name = resolve_template(u, name, path, &s)))
1734 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1737 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1745 int set_unit_path(const char *p) {
1749 /* This is mostly for debug purposes */
1751 if (path_is_absolute(p)) {
1752 if (!(c = strdup(p)))
1755 if (!(cwd = get_current_dir_name()))
1758 r = asprintf(&c, "%s/%s", cwd, p);
1765 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1774 char *unit_dbus_path(Unit *u) {
1782 if (!(e = bus_path_escape(u->id)))
1785 p = strappend("/org/freedesktop/systemd1/unit/", e);
1791 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1799 if (!b->controller) {
1800 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1806 /* Ensure this hasn't been added yet */
1809 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1812 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1813 LIST_PREPEND(CGroupBonding, by_path, l, b);
1815 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1816 LIST_REMOVE(CGroupBonding, by_path, l, b);
1821 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1827 static char *default_cgroup_path(Unit *u) {
1835 t = unit_name_template(u->id);
1839 p = join(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1842 p = join(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1847 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1848 char *controller = NULL, *path = NULL;
1849 CGroupBonding *b = NULL;
1856 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1860 path = default_cgroup_path(u);
1865 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1869 if (!path || !controller) {
1876 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1881 if (!(b = new0(CGroupBonding, 1))) {
1886 b->controller = controller;
1889 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1891 if ((r = unit_add_cgroup(u, b)) < 0)
1904 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1905 CGroupBonding *b = NULL;
1911 controller = SYSTEMD_CGROUP_CONTROLLER;
1913 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1916 if (!(b = new0(CGroupBonding, 1)))
1919 if (!(b->controller = strdup(controller)))
1922 if (!(b->path = default_cgroup_path(u)))
1926 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1928 if ((r = unit_add_cgroup(u, b)) < 0)
1935 free(b->controller);
1941 int unit_add_default_cgroups(Unit *u) {
1948 /* Adds in the default cgroups, if they weren't specified
1951 if (!u->manager->cgroup_hierarchy)
1954 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
1957 STRV_FOREACH(c, u->manager->default_controllers)
1958 unit_add_one_default_cgroup(u, *c);
1960 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
1961 unit_add_one_default_cgroup(u, a->controller);
1966 CGroupBonding* unit_get_default_cgroup(Unit *u) {
1969 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
1972 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
1984 dot = strchr(name, '.');
1988 c = strndup(name, dot - name);
1995 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2000 a = new0(CGroupAttribute, 1);
2010 a->controller = strdup(controller);
2012 a->name = strdup(name);
2013 a->value = strdup(value);
2015 if (!a->controller || !a->name || !a->value) {
2016 free(a->controller);
2024 a->map_callback = map_callback;
2026 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2035 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2043 if (!(t = unit_name_change_suffix(u->id, type)))
2046 assert(!unit_has_name(u, t));
2048 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2051 assert(r < 0 || *_found != u);
2056 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2064 if (!(t = unit_name_change_suffix(u->id, type)))
2067 assert(!unit_has_name(u, t));
2069 found = manager_get_unit(u->manager, t);
2079 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2083 return unit_name_to_prefix_and_instance(u->id);
2086 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2090 return unit_name_to_prefix(u->id);
2093 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2099 if (!(p = unit_name_to_prefix(u->id)))
2102 r = unit_name_unescape(p);
2108 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2113 return unit_name_unescape(u->instance);
2118 static char *specifier_filename(char specifier, void *data, void *userdata) {
2123 return unit_name_path_unescape(u->instance);
2125 return unit_name_to_path(u->instance);
2128 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2132 return default_cgroup_path(u);
2135 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2140 if (specifier == 'r')
2141 return strdup(u->manager->cgroup_hierarchy);
2143 if (parent_of_path(u->manager->cgroup_hierarchy, &p) < 0)
2146 if (streq(p, "/")) {
2154 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2158 if (u->manager->running_as == MANAGER_USER) {
2161 e = getenv("XDG_RUNTIME_DIR");
2166 return strdup("/run");
2169 char *unit_name_printf(Unit *u, const char* format) {
2172 * This will use the passed string as format string and
2173 * replace the following specifiers:
2175 * %n: the full id of the unit (foo@bar.waldo)
2176 * %N: the id of the unit without the suffix (foo@bar)
2177 * %p: the prefix (foo)
2178 * %i: the instance (bar)
2181 const Specifier table[] = {
2182 { 'n', specifier_string, u->id },
2183 { 'N', specifier_prefix_and_instance, NULL },
2184 { 'p', specifier_prefix, NULL },
2185 { 'i', specifier_string, u->instance },
2192 return specifier_printf(format, table, u);
2195 char *unit_full_printf(Unit *u, const char *format) {
2197 /* This is similar to unit_name_printf() but also supports
2198 * unescaping. Also, adds a couple of additional codes:
2200 * %c cgroup path of unit
2201 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2202 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2203 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2206 const Specifier table[] = {
2207 { 'n', specifier_string, u->id },
2208 { 'N', specifier_prefix_and_instance, NULL },
2209 { 'p', specifier_prefix, NULL },
2210 { 'P', specifier_prefix_unescaped, NULL },
2211 { 'i', specifier_string, u->instance },
2212 { 'I', specifier_instance_unescaped, NULL },
2213 { 'f', specifier_filename, NULL },
2214 { 'c', specifier_cgroup, NULL },
2215 { 'r', specifier_cgroup_root, NULL },
2216 { 'R', specifier_cgroup_root, NULL },
2217 { 't', specifier_runtime, NULL },
2224 return specifier_printf(format, table, u);
2227 char **unit_full_printf_strv(Unit *u, char **l) {
2231 /* Applies unit_full_printf to every entry in l */
2236 if (!(r = new(char*, n+1)))
2239 for (i = l, j = r; *i; i++, j++)
2240 if (!(*j = unit_full_printf(u, *i)))
2247 for (j--; j >= r; j--)
2255 int unit_watch_bus_name(Unit *u, const char *name) {
2259 /* Watch a specific name on the bus. We only support one unit
2260 * watching each name for now. */
2262 return hashmap_put(u->manager->watch_bus, name, u);
2265 void unit_unwatch_bus_name(Unit *u, const char *name) {
2269 hashmap_remove_value(u->manager->watch_bus, name, u);
2272 bool unit_can_serialize(Unit *u) {
2275 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2278 int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
2285 if (!unit_can_serialize(u))
2288 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2292 fprintf(f, "job\n");
2293 job_serialize(u->job, f, fds);
2296 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2297 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2298 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2299 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2300 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2302 if (dual_timestamp_is_set(&u->condition_timestamp))
2303 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2310 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2321 va_start(ap, format);
2322 vfprintf(f, format, ap);
2328 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2334 fprintf(f, "%s=%s\n", key, value);
2337 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2344 if (!unit_can_serialize(u))
2348 char line[LINE_MAX], *l, *v;
2351 if (!fgets(line, sizeof(line), f)) {
2364 k = strcspn(l, "=");
2372 if (streq(l, "job")) {
2374 /* new-style serialized job */
2375 Job *j = job_new_raw(u);
2379 r = job_deserialize(j, f, fds);
2385 job_install_deserialized(j);
2386 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2393 JobType type = job_type_from_string(v);
2395 log_debug("Failed to parse job type value %s", v);
2397 u->deserialized_job = type;
2400 } else if (streq(l, "inactive-exit-timestamp")) {
2401 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2403 } else if (streq(l, "active-enter-timestamp")) {
2404 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2406 } else if (streq(l, "active-exit-timestamp")) {
2407 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2409 } else if (streq(l, "inactive-enter-timestamp")) {
2410 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2412 } else if (streq(l, "condition-timestamp")) {
2413 dual_timestamp_deserialize(v, &u->condition_timestamp);
2415 } else if (streq(l, "condition-result")) {
2418 if ((b = parse_boolean(v)) < 0)
2419 log_debug("Failed to parse condition result value %s", v);
2421 u->condition_result = b;
2426 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2431 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2441 /* Adds in links to the device node that this unit is based on */
2443 if (!is_device_path(what))
2446 if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
2449 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2455 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BIND_TO, device, true)) < 0)
2459 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2465 int unit_coldplug(Unit *u) {
2470 if (UNIT_VTABLE(u)->coldplug)
2471 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2475 r = job_coldplug(u->job);
2478 } else if (u->deserialized_job >= 0) {
2480 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2484 u->deserialized_job = _JOB_TYPE_INVALID;
2490 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2496 if (!UNIT_VTABLE(u)->show_status)
2499 if (!manager_get_show_status(u->manager))
2502 if (!manager_is_booting_or_shutting_down(u->manager))
2505 va_start(ap, format);
2506 status_vprintf(status, true, format, ap);
2510 bool unit_need_daemon_reload(Unit *u) {
2513 if (u->fragment_path) {
2517 if (stat(u->fragment_path, &st) < 0)
2518 /* What, cannot access this anymore? */
2521 if (u->fragment_mtime > 0 &&
2522 timespec_load(&st.st_mtim) != u->fragment_mtime)
2526 if (UNIT_VTABLE(u)->need_daemon_reload)
2527 return UNIT_VTABLE(u)->need_daemon_reload(u);
2532 void unit_reset_failed(Unit *u) {
2535 if (UNIT_VTABLE(u)->reset_failed)
2536 UNIT_VTABLE(u)->reset_failed(u);
2539 Unit *unit_following(Unit *u) {
2542 if (UNIT_VTABLE(u)->following)
2543 return UNIT_VTABLE(u)->following(u);
2548 bool unit_pending_inactive(Unit *u) {
2551 /* Returns true if the unit is inactive or going down */
2553 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2556 if (u->job && u->job->type == JOB_STOP)
2562 bool unit_pending_active(Unit *u) {
2565 /* Returns true if the unit is active or going up */
2567 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2571 (u->job->type == JOB_START ||
2572 u->job->type == JOB_RELOAD_OR_START ||
2573 u->job->type == JOB_RESTART))
2579 UnitType unit_name_to_type(const char *n) {
2584 for (t = 0; t < _UNIT_TYPE_MAX; t++)
2585 if (endswith(n, unit_vtable[t]->suffix))
2588 return _UNIT_TYPE_INVALID;
2591 bool unit_name_is_valid(const char *n, bool template_ok) {
2594 t = unit_name_to_type(n);
2595 if (t < 0 || t >= _UNIT_TYPE_MAX)
2598 return unit_name_is_valid_no_type(n, template_ok);
2601 int unit_kill(Unit *u, KillWho w, KillMode m, int signo, DBusError *error) {
2603 assert(w >= 0 && w < _KILL_WHO_MAX);
2604 assert(m >= 0 && m < _KILL_MODE_MAX);
2606 assert(signo < _NSIG);
2611 if (!UNIT_VTABLE(u)->kill)
2614 return UNIT_VTABLE(u)->kill(u, w, m, signo, error);
2617 int unit_following_set(Unit *u, Set **s) {
2621 if (UNIT_VTABLE(u)->following_set)
2622 return UNIT_VTABLE(u)->following_set(u, s);
2628 UnitFileState unit_get_unit_file_state(Unit *u) {
2631 if (u->unit_file_state < 0 && u->fragment_path)
2632 u->unit_file_state = unit_file_get_state(
2633 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2634 NULL, file_name_from_path(u->fragment_path));
2636 return u->unit_file_state;
2639 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2644 unit_ref_unset(ref);
2647 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2651 void unit_ref_unset(UnitRef *ref) {
2657 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2661 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
2662 [UNIT_STUB] = "stub",
2663 [UNIT_LOADED] = "loaded",
2664 [UNIT_ERROR] = "error",
2665 [UNIT_MERGED] = "merged",
2666 [UNIT_MASKED] = "masked"
2669 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
2671 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2672 [UNIT_ACTIVE] = "active",
2673 [UNIT_RELOADING] = "reloading",
2674 [UNIT_INACTIVE] = "inactive",
2675 [UNIT_FAILED] = "failed",
2676 [UNIT_ACTIVATING] = "activating",
2677 [UNIT_DEACTIVATING] = "deactivating"
2680 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2682 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2683 [UNIT_REQUIRES] = "Requires",
2684 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2685 [UNIT_WANTS] = "Wants",
2686 [UNIT_REQUISITE] = "Requisite",
2687 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2688 [UNIT_REQUIRED_BY] = "RequiredBy",
2689 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2690 [UNIT_BIND_TO] = "BindTo",
2691 [UNIT_WANTED_BY] = "WantedBy",
2692 [UNIT_CONFLICTS] = "Conflicts",
2693 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2694 [UNIT_BOUND_BY] = "BoundBy",
2695 [UNIT_BEFORE] = "Before",
2696 [UNIT_AFTER] = "After",
2697 [UNIT_REFERENCES] = "References",
2698 [UNIT_REFERENCED_BY] = "ReferencedBy",
2699 [UNIT_ON_FAILURE] = "OnFailure",
2700 [UNIT_TRIGGERS] = "Triggers",
2701 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2702 [UNIT_PROPAGATE_RELOAD_TO] = "PropagateReloadTo",
2703 [UNIT_PROPAGATE_RELOAD_FROM] = "PropagateReloadFrom"
2706 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);