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>
32 #include "systemd/sd-id128.h"
33 #include "systemd/sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
47 #include "cgroup-attr.h"
50 #include "fileio-label.h"
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_TIMER] = &timer_vtable,
55 [UNIT_SOCKET] = &socket_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_DEVICE] = &device_vtable,
58 [UNIT_MOUNT] = &mount_vtable,
59 [UNIT_AUTOMOUNT] = &automount_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_PATH] = &path_vtable
65 Unit *unit_new(Manager *m, size_t size) {
69 assert(size >= sizeof(Unit));
75 u->names = set_new(string_hash_func, string_compare_func);
82 u->type = _UNIT_TYPE_INVALID;
83 u->deserialized_job = _JOB_TYPE_INVALID;
84 u->default_dependencies = true;
85 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
90 bool unit_has_name(Unit *u, const char *name) {
94 return !!set_get(u->names, (char*) name);
97 int unit_add_name(Unit *u, const char *text) {
105 if (unit_name_is_template(text)) {
109 s = unit_name_replace_instance(text, u->instance);
116 if (!unit_name_is_valid(s, false)) {
121 assert_se((t = unit_name_to_type(s)) >= 0);
123 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
128 if ((r = unit_name_to_instance(s, &i)) < 0)
131 if (i && unit_vtable[t]->no_instances) {
136 /* Ensure that this unit is either instanced or not instanced,
138 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
143 if (unit_vtable[t]->no_alias &&
144 !set_isempty(u->names) &&
145 !set_get(u->names, s)) {
150 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
155 if ((r = set_put(u->names, s)) < 0) {
161 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
162 set_remove(u->names, s);
166 if (u->type == _UNIT_TYPE_INVALID) {
172 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
174 if (UNIT_VTABLE(u)->init)
175 UNIT_VTABLE(u)->init(u);
179 unit_add_to_dbus_queue(u);
189 int unit_choose_id(Unit *u, const char *name) {
190 char *s, *t = NULL, *i;
196 if (unit_name_is_template(name)) {
201 if (!(t = unit_name_replace_instance(name, u->instance)))
207 /* Selects one of the names of this unit as the id */
208 s = set_get(u->names, (char*) name);
214 if ((r = unit_name_to_instance(s, &i)) < 0)
222 unit_add_to_dbus_queue(u);
227 int unit_set_description(Unit *u, const char *description) {
232 if (!(s = strdup(description)))
235 free(u->description);
238 unit_add_to_dbus_queue(u);
242 bool unit_check_gc(Unit *u) {
245 if (u->load_state == UNIT_STUB)
248 if (UNIT_VTABLE(u)->no_gc)
260 if (unit_active_state(u) != UNIT_INACTIVE)
266 if (UNIT_VTABLE(u)->check_gc)
267 if (UNIT_VTABLE(u)->check_gc(u))
273 void unit_add_to_load_queue(Unit *u) {
275 assert(u->type != _UNIT_TYPE_INVALID);
277 if (u->load_state != UNIT_STUB || u->in_load_queue)
280 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
281 u->in_load_queue = true;
284 void unit_add_to_cleanup_queue(Unit *u) {
287 if (u->in_cleanup_queue)
290 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
291 u->in_cleanup_queue = true;
294 void unit_add_to_gc_queue(Unit *u) {
297 if (u->in_gc_queue || u->in_cleanup_queue)
300 if (unit_check_gc(u))
303 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
304 u->in_gc_queue = true;
306 u->manager->n_in_gc_queue ++;
308 if (u->manager->gc_queue_timestamp <= 0)
309 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
312 void unit_add_to_dbus_queue(Unit *u) {
314 assert(u->type != _UNIT_TYPE_INVALID);
316 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
319 /* Shortcut things if nobody cares */
320 if (!bus_has_subscriber(u->manager)) {
321 u->sent_dbus_new_signal = true;
325 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
326 u->in_dbus_queue = true;
329 static void bidi_set_free(Unit *u, Set *s) {
335 /* Frees the set and makes sure we are dropped from the
336 * inverse pointers */
338 SET_FOREACH(other, s, i) {
341 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
342 set_remove(other->dependencies[d], u);
344 unit_add_to_gc_queue(other);
350 void unit_free(Unit *u) {
357 bus_unit_send_removed_signal(u);
359 if (u->load_state != UNIT_STUB)
360 if (UNIT_VTABLE(u)->done)
361 UNIT_VTABLE(u)->done(u);
363 SET_FOREACH(t, u->names, i)
364 hashmap_remove_value(u->manager->units, t, u);
378 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
379 bidi_set_free(u, u->dependencies[d]);
381 if (u->requires_mounts_for) {
382 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
383 strv_free(u->requires_mounts_for);
386 if (u->type != _UNIT_TYPE_INVALID)
387 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
389 if (u->in_load_queue)
390 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
392 if (u->in_dbus_queue)
393 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
395 if (u->in_cleanup_queue)
396 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
398 if (u->in_gc_queue) {
399 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
400 u->manager->n_in_gc_queue--;
403 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
404 cgroup_attribute_free_list(u->cgroup_attributes);
406 free(u->description);
407 strv_free(u->documentation);
408 free(u->fragment_path);
409 free(u->source_path);
412 set_free_free(u->names);
414 condition_free_list(u->conditions);
417 unit_ref_unset(u->refs);
422 UnitActiveState unit_active_state(Unit *u) {
425 if (u->load_state == UNIT_MERGED)
426 return unit_active_state(unit_follow_merge(u));
428 /* After a reload it might happen that a unit is not correctly
429 * loaded but still has a process around. That's why we won't
430 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
432 return UNIT_VTABLE(u)->active_state(u);
435 const char* unit_sub_state_to_string(Unit *u) {
438 return UNIT_VTABLE(u)->sub_state_to_string(u);
441 static void complete_move(Set **s, Set **other) {
449 set_move(*s, *other);
456 static void merge_names(Unit *u, Unit *other) {
463 complete_move(&u->names, &other->names);
465 set_free_free(other->names);
469 SET_FOREACH(t, u->names, i)
470 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
473 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
480 assert(d < _UNIT_DEPENDENCY_MAX);
482 /* Fix backwards pointers */
483 SET_FOREACH(back, other->dependencies[d], i) {
486 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
487 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
490 set_remove(back->dependencies[k], other);
492 assert(r == -ENOENT);
496 complete_move(&u->dependencies[d], &other->dependencies[d]);
498 set_free(other->dependencies[d]);
499 other->dependencies[d] = NULL;
502 int unit_merge(Unit *u, Unit *other) {
507 assert(u->manager == other->manager);
508 assert(u->type != _UNIT_TYPE_INVALID);
510 other = unit_follow_merge(other);
515 if (u->type != other->type)
518 if (!u->instance != !other->instance)
521 if (other->load_state != UNIT_STUB &&
522 other->load_state != UNIT_ERROR)
531 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
535 merge_names(u, other);
537 /* Redirect all references */
539 unit_ref_set(other->refs, u);
541 /* Merge dependencies */
542 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
543 merge_dependencies(u, other, d);
545 other->load_state = UNIT_MERGED;
546 other->merged_into = u;
548 /* If there is still some data attached to the other node, we
549 * don't need it anymore, and can free it. */
550 if (other->load_state != UNIT_STUB)
551 if (UNIT_VTABLE(other)->done)
552 UNIT_VTABLE(other)->done(other);
554 unit_add_to_dbus_queue(u);
555 unit_add_to_cleanup_queue(other);
560 int unit_merge_by_name(Unit *u, const char *name) {
568 if (unit_name_is_template(name)) {
572 if (!(s = unit_name_replace_instance(name, u->instance)))
578 if (!(other = manager_get_unit(u->manager, name)))
579 r = unit_add_name(u, name);
581 r = unit_merge(u, other);
587 Unit* unit_follow_merge(Unit *u) {
590 while (u->load_state == UNIT_MERGED)
591 assert_se(u = u->merged_into);
596 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
602 if (c->std_output != EXEC_OUTPUT_KMSG &&
603 c->std_output != EXEC_OUTPUT_SYSLOG &&
604 c->std_output != EXEC_OUTPUT_JOURNAL &&
605 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
606 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
607 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
608 c->std_error != EXEC_OUTPUT_KMSG &&
609 c->std_error != EXEC_OUTPUT_SYSLOG &&
610 c->std_error != EXEC_OUTPUT_JOURNAL &&
611 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
612 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
613 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
616 /* If syslog or kernel logging is requested, make sure our own
617 * logging daemon is run first. */
619 if (u->manager->running_as == SYSTEMD_SYSTEM) {
620 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
628 const char *unit_description(Unit *u) {
632 return u->description;
637 void unit_dump(Unit *u, FILE *f, const char *prefix) {
644 timestamp1[FORMAT_TIMESTAMP_MAX],
645 timestamp2[FORMAT_TIMESTAMP_MAX],
646 timestamp3[FORMAT_TIMESTAMP_MAX],
647 timestamp4[FORMAT_TIMESTAMP_MAX],
648 timespan[FORMAT_TIMESPAN_MAX];
652 assert(u->type >= 0);
656 p2 = strappend(prefix, "\t");
657 prefix2 = p2 ? p2 : prefix;
661 "%s\tDescription: %s\n"
663 "%s\tUnit Load State: %s\n"
664 "%s\tUnit Active State: %s\n"
665 "%s\tInactive Exit Timestamp: %s\n"
666 "%s\tActive Enter Timestamp: %s\n"
667 "%s\tActive Exit Timestamp: %s\n"
668 "%s\tInactive Enter Timestamp: %s\n"
669 "%s\tGC Check Good: %s\n"
670 "%s\tNeed Daemon Reload: %s\n",
672 prefix, unit_description(u),
673 prefix, strna(u->instance),
674 prefix, unit_load_state_to_string(u->load_state),
675 prefix, unit_active_state_to_string(unit_active_state(u)),
676 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
677 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
678 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
679 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
680 prefix, yes_no(unit_check_gc(u)),
681 prefix, yes_no(unit_need_daemon_reload(u)));
683 SET_FOREACH(t, u->names, i)
684 fprintf(f, "%s\tName: %s\n", prefix, t);
686 STRV_FOREACH(j, u->documentation)
687 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
689 if ((following = unit_following(u)))
690 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
692 if (u->fragment_path)
693 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
696 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
698 if (u->job_timeout > 0)
699 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
701 condition_dump_list(u->conditions, f, prefix);
703 if (dual_timestamp_is_set(&u->condition_timestamp))
705 "%s\tCondition Timestamp: %s\n"
706 "%s\tCondition Result: %s\n",
707 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
708 prefix, yes_no(u->condition_result));
710 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
713 SET_FOREACH(other, u->dependencies[d], i)
714 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
717 if (!strv_isempty(u->requires_mounts_for)) {
719 "%s\tRequiresMountsFor:", prefix);
721 STRV_FOREACH(j, u->requires_mounts_for)
722 fprintf(f, " %s", *j);
727 if (u->load_state == UNIT_LOADED) {
732 "%s\tStopWhenUnneeded: %s\n"
733 "%s\tRefuseManualStart: %s\n"
734 "%s\tRefuseManualStop: %s\n"
735 "%s\tDefaultDependencies: %s\n"
736 "%s\tOnFailureIsolate: %s\n"
737 "%s\tIgnoreOnIsolate: %s\n"
738 "%s\tIgnoreOnSnapshot: %s\n",
739 prefix, yes_no(u->stop_when_unneeded),
740 prefix, yes_no(u->refuse_manual_start),
741 prefix, yes_no(u->refuse_manual_stop),
742 prefix, yes_no(u->default_dependencies),
743 prefix, yes_no(u->on_failure_isolate),
744 prefix, yes_no(u->ignore_on_isolate),
745 prefix, yes_no(u->ignore_on_snapshot));
747 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
748 fprintf(f, "%s\tControlGroup: %s:%s\n",
749 prefix, b->controller, b->path);
751 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
752 _cleanup_free_ char *v = NULL;
754 if (a->semantics && a->semantics->map_write)
755 a->semantics->map_write(a->semantics, a->value, &v);
757 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
758 prefix, a->controller, a->name, v ? v : a->value);
761 if (UNIT_VTABLE(u)->dump)
762 UNIT_VTABLE(u)->dump(u, f, prefix2);
764 } else if (u->load_state == UNIT_MERGED)
766 "%s\tMerged into: %s\n",
767 prefix, u->merged_into->id);
768 else if (u->load_state == UNIT_ERROR)
769 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
773 job_dump(u->job, f, prefix2);
776 job_dump(u->nop_job, f, prefix2);
781 /* Common implementation for multiple backends */
782 int unit_load_fragment_and_dropin(Unit *u) {
787 /* Load a .service file */
788 if ((r = unit_load_fragment(u)) < 0)
791 if (u->load_state == UNIT_STUB)
794 /* Load drop-in directory data */
795 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
801 /* Common implementation for multiple backends */
802 int unit_load_fragment_and_dropin_optional(Unit *u) {
807 /* Same as unit_load_fragment_and_dropin(), but whether
808 * something can be loaded or not doesn't matter. */
810 /* Load a .service file */
811 if ((r = unit_load_fragment(u)) < 0)
814 if (u->load_state == UNIT_STUB)
815 u->load_state = UNIT_LOADED;
817 /* Load drop-in directory data */
818 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
824 int unit_add_default_target_dependency(Unit *u, Unit *target) {
828 if (target->type != UNIT_TARGET)
831 /* Only add the dependency if both units are loaded, so that
832 * that loop check below is reliable */
833 if (u->load_state != UNIT_LOADED ||
834 target->load_state != UNIT_LOADED)
837 /* If either side wants no automatic dependencies, then let's
839 if (!u->default_dependencies ||
840 !target->default_dependencies)
843 /* Don't create loops */
844 if (set_get(target->dependencies[UNIT_BEFORE], u))
847 return unit_add_dependency(target, UNIT_AFTER, u, true);
850 static int unit_add_default_dependencies(Unit *u) {
851 static const UnitDependency deps[] = {
853 UNIT_REQUIRED_BY_OVERRIDABLE,
865 for (k = 0; k < ELEMENTSOF(deps); k++)
866 SET_FOREACH(target, u->dependencies[deps[k]], i)
867 if ((r = unit_add_default_target_dependency(u, target)) < 0)
873 int unit_load(Unit *u) {
878 if (u->in_load_queue) {
879 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
880 u->in_load_queue = false;
883 if (u->type == _UNIT_TYPE_INVALID)
886 if (u->load_state != UNIT_STUB)
889 if (UNIT_VTABLE(u)->load)
890 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
893 if (u->load_state == UNIT_STUB) {
898 if (u->load_state == UNIT_LOADED &&
899 u->default_dependencies)
900 if ((r = unit_add_default_dependencies(u)) < 0)
903 if (u->load_state == UNIT_LOADED) {
904 r = unit_add_mount_links(u);
909 if (u->on_failure_isolate &&
910 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
912 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
919 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
921 unit_add_to_dbus_queue(unit_follow_merge(u));
922 unit_add_to_gc_queue(u);
927 u->load_state = UNIT_ERROR;
929 unit_add_to_dbus_queue(u);
930 unit_add_to_gc_queue(u);
932 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
937 bool unit_condition_test(Unit *u) {
940 dual_timestamp_get(&u->condition_timestamp);
941 u->condition_result = condition_test_list(u->conditions);
943 return u->condition_result;
946 static const char* unit_get_status_message_format(Unit *u, JobType t) {
947 const UnitStatusMessageFormats *format_table;
951 assert(t < _JOB_TYPE_MAX);
953 if (t != JOB_START && t != JOB_STOP)
956 format_table = &UNIT_VTABLE(u)->status_message_formats;
960 return format_table->starting_stopping[t == JOB_STOP];
963 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
968 assert(t < _JOB_TYPE_MAX);
970 format = unit_get_status_message_format(u, t);
974 /* Return generic strings */
976 return "Starting %s.";
977 else if (t == JOB_STOP)
978 return "Stopping %s.";
979 else if (t == JOB_RELOAD)
980 return "Reloading %s.";
985 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
990 /* We only print status messages for selected units on
991 * selected operations. */
993 format = unit_get_status_message_format(u, t);
997 unit_status_printf(u, "", format, unit_description(u));
1000 #pragma GCC diagnostic push
1001 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1002 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1009 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1012 if (log_on_console())
1015 /* We log status messages for all units and all operations. */
1017 format = unit_get_status_message_format_try_harder(u, t);
1021 snprintf(buf, sizeof(buf), format, unit_description(u));
1024 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1025 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1026 SD_MESSAGE_UNIT_RELOADING;
1028 log_struct_unit(LOG_INFO,
1034 #pragma GCC diagnostic pop
1037 * -EBADR: This unit type does not support starting.
1038 * -EALREADY: Unit is already started.
1039 * -EAGAIN: An operation is already in progress. Retry later.
1040 * -ECANCELED: Too many requests for now.
1042 int unit_start(Unit *u) {
1043 UnitActiveState state;
1048 if (u->load_state != UNIT_LOADED)
1051 /* If this is already started, then this will succeed. Note
1052 * that this will even succeed if this unit is not startable
1053 * by the user. This is relied on to detect when we need to
1054 * wait for units and when waiting is finished. */
1055 state = unit_active_state(u);
1056 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1059 /* If the conditions failed, don't do anything at all. If we
1060 * already are activating this call might still be useful to
1061 * speed up activation in case there is some hold-off time,
1062 * but we don't want to recheck the condition in that case. */
1063 if (state != UNIT_ACTIVATING &&
1064 !unit_condition_test(u)) {
1065 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1069 /* Forward to the main object, if we aren't it. */
1070 if ((following = unit_following(u))) {
1071 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1072 return unit_start(following);
1075 unit_status_log_starting_stopping_reloading(u, JOB_START);
1076 unit_status_print_starting_stopping(u, JOB_START);
1078 /* If it is stopped, but we cannot start it, then fail */
1079 if (!UNIT_VTABLE(u)->start)
1082 /* We don't suppress calls to ->start() here when we are
1083 * already starting, to allow this request to be used as a
1084 * "hurry up" call, for example when the unit is in some "auto
1085 * restart" state where it waits for a holdoff timer to elapse
1086 * before it will start again. */
1088 unit_add_to_dbus_queue(u);
1090 return UNIT_VTABLE(u)->start(u);
1093 bool unit_can_start(Unit *u) {
1096 return !!UNIT_VTABLE(u)->start;
1099 bool unit_can_isolate(Unit *u) {
1102 return unit_can_start(u) &&
1107 * -EBADR: This unit type does not support stopping.
1108 * -EALREADY: Unit is already stopped.
1109 * -EAGAIN: An operation is already in progress. Retry later.
1111 int unit_stop(Unit *u) {
1112 UnitActiveState state;
1117 state = unit_active_state(u);
1118 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1121 if ((following = unit_following(u))) {
1122 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1123 return unit_stop(following);
1126 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1127 unit_status_print_starting_stopping(u, JOB_STOP);
1129 if (!UNIT_VTABLE(u)->stop)
1132 unit_add_to_dbus_queue(u);
1134 return UNIT_VTABLE(u)->stop(u);
1138 * -EBADR: This unit type does not support reloading.
1139 * -ENOEXEC: Unit is not started.
1140 * -EAGAIN: An operation is already in progress. Retry later.
1142 int unit_reload(Unit *u) {
1143 UnitActiveState state;
1148 if (u->load_state != UNIT_LOADED)
1151 if (!unit_can_reload(u))
1154 state = unit_active_state(u);
1155 if (state == UNIT_RELOADING)
1158 if (state != UNIT_ACTIVE)
1161 if ((following = unit_following(u))) {
1162 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1163 return unit_reload(following);
1166 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1168 unit_add_to_dbus_queue(u);
1169 return UNIT_VTABLE(u)->reload(u);
1172 bool unit_can_reload(Unit *u) {
1175 if (!UNIT_VTABLE(u)->reload)
1178 if (!UNIT_VTABLE(u)->can_reload)
1181 return UNIT_VTABLE(u)->can_reload(u);
1184 static void unit_check_unneeded(Unit *u) {
1190 /* If this service shall be shut down when unneeded then do
1193 if (!u->stop_when_unneeded)
1196 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1199 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1200 if (unit_pending_active(other))
1203 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1204 if (unit_pending_active(other))
1207 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1208 if (unit_pending_active(other))
1211 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1212 if (unit_pending_active(other))
1215 log_info("Service %s is not needed anymore. Stopping.", u->id);
1217 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1218 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1221 static void retroactively_start_dependencies(Unit *u) {
1226 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1228 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1229 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1230 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1231 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1233 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1234 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1235 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1236 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1238 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1239 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1240 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1241 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1243 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1244 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1245 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1246 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1248 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1249 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1250 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1251 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1253 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1254 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1255 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1257 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1258 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1259 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1262 static void retroactively_stop_dependencies(Unit *u) {
1267 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1269 /* Pull down units which are bound to us recursively if enabled */
1270 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1271 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1272 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1275 static void check_unneeded_dependencies(Unit *u) {
1280 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1282 /* Garbage collect services that might not be needed anymore, if enabled */
1283 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1284 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1285 unit_check_unneeded(other);
1286 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1287 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1288 unit_check_unneeded(other);
1289 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1290 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1291 unit_check_unneeded(other);
1292 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1293 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1294 unit_check_unneeded(other);
1295 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1296 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1297 unit_check_unneeded(other);
1298 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1299 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1300 unit_check_unneeded(other);
1303 void unit_trigger_on_failure(Unit *u) {
1309 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1312 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1314 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1317 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1318 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1322 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1326 assert(os < _UNIT_ACTIVE_STATE_MAX);
1327 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1329 /* Note that this is called for all low-level state changes,
1330 * even if they might map to the same high-level
1331 * UnitActiveState! That means that ns == os is OK an expected
1332 * behavior here. For example: if a mount point is remounted
1333 * this function will be called too! */
1335 if (u->manager->n_reloading <= 0) {
1338 dual_timestamp_get(&ts);
1340 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1341 u->inactive_exit_timestamp = ts;
1342 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1343 u->inactive_enter_timestamp = ts;
1345 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1346 u->active_enter_timestamp = ts;
1347 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1348 u->active_exit_timestamp = ts;
1350 timer_unit_notify(u, ns);
1351 path_unit_notify(u, ns);
1354 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1355 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1360 if (u->job->state == JOB_WAITING)
1362 /* So we reached a different state for this
1363 * job. Let's see if we can run it now if it
1364 * failed previously due to EAGAIN. */
1365 job_add_to_run_queue(u->job);
1367 /* Let's check whether this state change constitutes a
1368 * finished job, or maybe contradicts a running job and
1369 * hence needs to invalidate jobs. */
1371 switch (u->job->type) {
1374 case JOB_VERIFY_ACTIVE:
1376 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1377 job_finish_and_invalidate(u->job, JOB_DONE, true);
1378 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1381 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1382 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1388 case JOB_RELOAD_OR_START:
1390 if (u->job->state == JOB_RUNNING) {
1391 if (ns == UNIT_ACTIVE)
1392 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1393 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1396 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1397 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1405 case JOB_TRY_RESTART:
1407 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1408 job_finish_and_invalidate(u->job, JOB_DONE, true);
1409 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1411 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1417 assert_not_reached("Job type unknown");
1423 if (u->manager->n_reloading <= 0) {
1425 /* If this state change happened without being
1426 * requested by a job, then let's retroactively start
1427 * or stop dependencies. We skip that step when
1428 * deserializing, since we don't want to create any
1429 * additional jobs just because something is already
1433 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1434 retroactively_start_dependencies(u);
1435 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1436 retroactively_stop_dependencies(u);
1439 /* stop unneeded units regardless if going down was expected or not */
1440 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1441 check_unneeded_dependencies(u);
1443 if (ns != os && ns == UNIT_FAILED) {
1444 log_struct_unit(LOG_NOTICE,
1446 "MESSAGE=Unit %s entered failed state", u->id,
1448 unit_trigger_on_failure(u);
1452 /* Some names are special */
1453 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1455 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1456 /* The bus just might have become available,
1457 * hence try to connect to it, if we aren't
1459 bus_init(u->manager, true);
1461 if (u->type == UNIT_SERVICE &&
1462 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1463 u->manager->n_reloading <= 0) {
1464 /* Write audit record if we have just finished starting up */
1465 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1469 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1470 manager_send_unit_plymouth(u->manager, u);
1474 /* We don't care about D-Bus here, since we'll get an
1475 * asynchronous notification for it anyway. */
1477 if (u->type == UNIT_SERVICE &&
1478 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1479 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1480 u->manager->n_reloading <= 0) {
1482 /* Hmm, if there was no start record written
1483 * write it now, so that we always have a nice
1486 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1488 if (ns == UNIT_INACTIVE)
1489 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1491 /* Write audit record if we have just finished shutting down */
1492 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1494 u->in_audit = false;
1498 manager_recheck_journal(u->manager);
1500 /* Maybe we finished startup and are now ready for being
1501 * stopped because unneeded? */
1502 unit_check_unneeded(u);
1504 unit_add_to_dbus_queue(u);
1505 unit_add_to_gc_queue(u);
1508 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1509 struct epoll_event ev;
1514 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1520 if (epoll_ctl(u->manager->epoll_fd,
1521 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1533 void unit_unwatch_fd(Unit *u, Watch *w) {
1537 if (w->type == WATCH_INVALID)
1540 assert(w->type == WATCH_FD);
1541 assert(w->data.unit == u);
1542 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1545 w->type = WATCH_INVALID;
1546 w->data.unit = NULL;
1549 int unit_watch_pid(Unit *u, pid_t pid) {
1553 /* Watch a specific PID. We only support one unit watching
1554 * each PID for now. */
1556 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1559 void unit_unwatch_pid(Unit *u, pid_t pid) {
1563 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1566 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1567 struct itimerspec its;
1573 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1575 /* This will try to reuse the old timer if there is one */
1577 if (w->type == WATCH_UNIT_TIMER) {
1578 assert(w->data.unit == u);
1583 } else if (w->type == WATCH_INVALID) {
1586 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1590 assert_not_reached("Invalid watch type");
1595 /* Set absolute time in the past, but not 0, since we
1596 * don't want to disarm the timer */
1597 its.it_value.tv_sec = 0;
1598 its.it_value.tv_nsec = 1;
1600 flags = TFD_TIMER_ABSTIME;
1602 timespec_store(&its.it_value, usec);
1603 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1606 /* This will also flush the elapse counter */
1607 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1610 if (w->type == WATCH_INVALID) {
1611 struct epoll_event ev;
1615 ev.events = EPOLLIN;
1617 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1621 w->type = WATCH_UNIT_TIMER;
1629 close_nointr_nofail(fd);
1634 void unit_unwatch_timer(Unit *u, Watch *w) {
1638 if (w->type == WATCH_INVALID)
1641 assert(w->type == WATCH_UNIT_TIMER);
1642 assert(w->data.unit == u);
1645 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1646 close_nointr_nofail(w->fd);
1649 w->type = WATCH_INVALID;
1650 w->data.unit = NULL;
1653 bool unit_job_is_applicable(Unit *u, JobType j) {
1655 assert(j >= 0 && j < _JOB_TYPE_MAX);
1659 case JOB_VERIFY_ACTIVE:
1666 case JOB_TRY_RESTART:
1667 return unit_can_start(u);
1670 return unit_can_reload(u);
1672 case JOB_RELOAD_OR_START:
1673 return unit_can_reload(u) && unit_can_start(u);
1676 assert_not_reached("Invalid job type");
1680 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1682 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1683 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1684 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1685 [UNIT_WANTS] = UNIT_WANTED_BY,
1686 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1687 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1688 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1689 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1690 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1691 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1692 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1693 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1694 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1695 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1696 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1697 [UNIT_BEFORE] = UNIT_AFTER,
1698 [UNIT_AFTER] = UNIT_BEFORE,
1699 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1700 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1701 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1702 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1703 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1704 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1705 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1707 int r, q = 0, v = 0, w = 0;
1710 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1713 u = unit_follow_merge(u);
1714 other = unit_follow_merge(other);
1716 /* We won't allow dependencies on ourselves. We will not
1717 * consider them an error however. */
1721 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1724 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1725 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1729 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1730 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1733 if ((q = set_put(u->dependencies[d], other)) < 0)
1736 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1737 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1742 if (add_reference) {
1743 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1748 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1752 unit_add_to_dbus_queue(u);
1757 set_remove(u->dependencies[d], other);
1760 set_remove(other->dependencies[inverse_table[d]], u);
1763 set_remove(u->dependencies[UNIT_REFERENCES], other);
1768 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1773 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1776 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1782 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1786 assert(name || path);
1790 name = path_get_file_name(path);
1792 if (!unit_name_is_template(name)) {
1798 s = unit_name_replace_instance(name, u->instance);
1802 i = unit_name_to_prefix(u->id);
1806 s = unit_name_replace_instance(name, i);
1817 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1820 _cleanup_free_ char *s = NULL;
1823 assert(name || path);
1825 name = resolve_template(u, name, path, &s);
1829 r = manager_load_unit(u->manager, name, path, NULL, &other);
1833 return unit_add_dependency(u, d, other, add_reference);
1836 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1842 assert(name || path);
1844 if (!(name = resolve_template(u, name, path, &s)))
1847 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1850 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1857 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1863 assert(name || path);
1865 if (!(name = resolve_template(u, name, path, &s)))
1868 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1871 r = unit_add_dependency(other, d, u, add_reference);
1878 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1884 assert(name || path);
1886 if (!(name = resolve_template(u, name, path, &s)))
1889 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1892 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1900 int set_unit_path(const char *p) {
1901 _cleanup_free_ char *c = NULL;
1903 /* This is mostly for debug purposes */
1904 c = path_make_absolute_cwd(p);
1905 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1911 char *unit_dbus_path(Unit *u) {
1917 return unit_dbus_path_from_name(u->id);
1920 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1928 if (!b->controller) {
1929 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1936 /* Ensure this hasn't been added yet */
1939 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1942 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1943 LIST_PREPEND(CGroupBonding, by_path, l, b);
1945 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1947 LIST_REMOVE(CGroupBonding, by_path, l, b);
1952 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1958 char *unit_default_cgroup_path(Unit *u) {
1962 _cleanup_free_ char *t = NULL;
1964 t = unit_name_template(u->id);
1968 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1970 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1973 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1974 char *controller = NULL, *path = NULL;
1975 CGroupBonding *b = NULL;
1982 r = cg_split_spec(name, &controller, &path);
1987 path = unit_default_cgroup_path(u);
1992 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1996 if (!path || !controller) {
2002 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2004 if (streq(path, b->path)) {
2013 if (overwrite && !b->essential) {
2020 b->realized = false;
2033 b = new0(CGroupBonding, 1);
2039 b->controller = controller;
2042 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2044 r = unit_add_cgroup(u, b);
2061 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2062 CGroupBonding *b = NULL;
2068 controller = SYSTEMD_CGROUP_CONTROLLER;
2070 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2073 b = new0(CGroupBonding, 1);
2077 b->controller = strdup(controller);
2081 b->path = unit_default_cgroup_path(u);
2086 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2088 r = unit_add_cgroup(u, b);
2096 free(b->controller);
2102 int unit_add_default_cgroups(Unit *u) {
2109 /* Adds in the default cgroups, if they weren't specified
2112 if (!u->manager->cgroup_hierarchy)
2115 r = unit_add_one_default_cgroup(u, NULL);
2119 STRV_FOREACH(c, u->manager->default_controllers)
2120 unit_add_one_default_cgroup(u, *c);
2122 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2123 unit_add_one_default_cgroup(u, a->controller);
2128 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2131 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2134 int unit_add_cgroup_attribute(
2136 const CGroupSemantics *semantics,
2137 const char *controller,
2140 CGroupAttribute **ret) {
2142 _cleanup_free_ char *c = NULL;
2150 /* Semantics always take precedence */
2151 if (semantics->name)
2152 name = semantics->name;
2154 if (semantics->controller)
2155 controller = semantics->controller;
2162 r = cg_controller_from_attr(name, &c);
2169 if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2172 if (!filename_is_safe(name))
2175 if (!filename_is_safe(controller))
2178 /* Check if this attribute already exists. Note that we will
2179 * explicitly check for the value here too, as there are
2180 * attributes which accept multiple values. */
2181 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2183 if (streq(value, a->value)) {
2184 /* Exactly the same value is always OK, let's ignore this */
2191 if (semantics && !semantics->multiple) {
2194 /* If this is a single-item entry, we can
2195 * simply patch the existing attribute */
2210 a = new0(CGroupAttribute, 1);
2218 a->controller = strdup(controller);
2220 a->name = strdup(name);
2221 a->value = strdup(value);
2223 if (!a->controller || !a->name || !a->value) {
2224 free(a->controller);
2231 a->semantics = semantics;
2234 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2242 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2250 if (!(t = unit_name_change_suffix(u->id, type)))
2253 assert(!unit_has_name(u, t));
2255 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2258 assert(r < 0 || *_found != u);
2263 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2271 if (!(t = unit_name_change_suffix(u->id, type)))
2274 assert(!unit_has_name(u, t));
2276 found = manager_get_unit(u->manager, t);
2286 int unit_watch_bus_name(Unit *u, const char *name) {
2290 /* Watch a specific name on the bus. We only support one unit
2291 * watching each name for now. */
2293 return hashmap_put(u->manager->watch_bus, name, u);
2296 void unit_unwatch_bus_name(Unit *u, const char *name) {
2300 hashmap_remove_value(u->manager->watch_bus, name, u);
2303 bool unit_can_serialize(Unit *u) {
2306 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2309 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2316 if (!unit_can_serialize(u))
2319 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2323 if (serialize_jobs) {
2325 fprintf(f, "job\n");
2326 job_serialize(u->job, f, fds);
2330 fprintf(f, "job\n");
2331 job_serialize(u->nop_job, f, fds);
2335 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2336 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2337 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2338 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2339 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2341 if (dual_timestamp_is_set(&u->condition_timestamp))
2342 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2349 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2360 va_start(ap, format);
2361 vfprintf(f, format, ap);
2367 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2373 fprintf(f, "%s=%s\n", key, value);
2376 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2383 if (!unit_can_serialize(u))
2387 char line[LINE_MAX], *l, *v;
2390 if (!fgets(line, sizeof(line), f)) {
2403 k = strcspn(l, "=");
2411 if (streq(l, "job")) {
2413 /* new-style serialized job */
2414 Job *j = job_new_raw(u);
2418 r = job_deserialize(j, f, fds);
2424 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2430 r = job_install_deserialized(j);
2432 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2438 JobType type = job_type_from_string(v);
2440 log_debug("Failed to parse job type value %s", v);
2442 u->deserialized_job = type;
2445 } else if (streq(l, "inactive-exit-timestamp")) {
2446 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2448 } else if (streq(l, "active-enter-timestamp")) {
2449 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2451 } else if (streq(l, "active-exit-timestamp")) {
2452 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2454 } else if (streq(l, "inactive-enter-timestamp")) {
2455 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2457 } else if (streq(l, "condition-timestamp")) {
2458 dual_timestamp_deserialize(v, &u->condition_timestamp);
2460 } else if (streq(l, "condition-result")) {
2463 if ((b = parse_boolean(v)) < 0)
2464 log_debug("Failed to parse condition result value %s", v);
2466 u->condition_result = b;
2471 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2476 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2486 /* Adds in links to the device node that this unit is based on */
2488 if (!is_device_path(what))
2491 e = unit_name_from_path(what, ".device");
2495 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2500 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2505 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2513 int unit_coldplug(Unit *u) {
2518 if (UNIT_VTABLE(u)->coldplug)
2519 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2523 r = job_coldplug(u->job);
2526 } else if (u->deserialized_job >= 0) {
2528 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2532 u->deserialized_job = _JOB_TYPE_INVALID;
2538 bool unit_need_daemon_reload(Unit *u) {
2543 if (u->fragment_path) {
2545 if (stat(u->fragment_path, &st) < 0)
2546 /* What, cannot access this anymore? */
2549 if (u->fragment_mtime > 0 &&
2550 timespec_load(&st.st_mtim) != u->fragment_mtime)
2554 if (u->source_path) {
2556 if (stat(u->source_path, &st) < 0)
2559 if (u->source_mtime > 0 &&
2560 timespec_load(&st.st_mtim) != u->source_mtime)
2567 void unit_reset_failed(Unit *u) {
2570 if (UNIT_VTABLE(u)->reset_failed)
2571 UNIT_VTABLE(u)->reset_failed(u);
2574 Unit *unit_following(Unit *u) {
2577 if (UNIT_VTABLE(u)->following)
2578 return UNIT_VTABLE(u)->following(u);
2583 bool unit_pending_inactive(Unit *u) {
2586 /* Returns true if the unit is inactive or going down */
2588 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2591 if (u->job && u->job->type == JOB_STOP)
2597 bool unit_pending_active(Unit *u) {
2600 /* Returns true if the unit is active or going up */
2602 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2606 (u->job->type == JOB_START ||
2607 u->job->type == JOB_RELOAD_OR_START ||
2608 u->job->type == JOB_RESTART))
2614 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2616 assert(w >= 0 && w < _KILL_WHO_MAX);
2618 assert(signo < _NSIG);
2620 if (!UNIT_VTABLE(u)->kill)
2623 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2626 int unit_following_set(Unit *u, Set **s) {
2630 if (UNIT_VTABLE(u)->following_set)
2631 return UNIT_VTABLE(u)->following_set(u, s);
2637 UnitFileState unit_get_unit_file_state(Unit *u) {
2640 if (u->unit_file_state < 0 && u->fragment_path)
2641 u->unit_file_state = unit_file_get_state(
2642 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2643 NULL, path_get_file_name(u->fragment_path));
2645 return u->unit_file_state;
2648 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2653 unit_ref_unset(ref);
2656 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2660 void unit_ref_unset(UnitRef *ref) {
2666 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2670 int unit_add_one_mount_link(Unit *u, Mount *m) {
2676 if (u->load_state != UNIT_LOADED ||
2677 UNIT(m)->load_state != UNIT_LOADED)
2680 STRV_FOREACH(i, u->requires_mounts_for) {
2685 if (!path_startswith(*i, m->where))
2688 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2694 int unit_add_mount_links(Unit *u) {
2700 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2701 r = unit_add_one_mount_link(u, MOUNT(other));
2709 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2716 /* This only copies in the ones that need memory */
2718 for (i = 0; i < RLIMIT_NLIMITS; i++)
2719 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2720 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2725 if (u->manager->running_as == SYSTEMD_USER &&
2726 !c->working_directory) {
2728 r = get_home_dir(&c->working_directory);
2736 ExecContext *unit_get_exec_context(Unit *u) {
2740 offset = UNIT_VTABLE(u)->exec_context_offset;
2744 return (ExecContext*) ((uint8_t*) u + offset);
2747 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2756 if (u->manager->running_as == SYSTEMD_USER && runtime)
2759 if (!filename_is_safe(name))
2762 if (u->manager->running_as == SYSTEMD_USER) {
2763 _cleanup_free_ char *c = NULL;
2765 r = user_config_home(&c);
2771 p = strjoin(c, "/", u->id, ".d", NULL);
2773 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2775 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2779 q = strjoin(p, "/50-", name, ".conf", NULL);
2790 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2791 _cleanup_free_ char *p = NULL, *q = NULL;
2796 r = drop_in_file(u, runtime, name, &p, &q);
2801 return write_one_line_file_atomic_label(q, data);
2804 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2805 _cleanup_free_ char *p = NULL, *q = NULL;
2810 r = drop_in_file(u, runtime, name, &p, &q);
2820 int unit_kill_context(
2826 bool main_pid_alien) {
2828 int sig, wait_for_exit = 0, r;
2833 if (c->kill_mode == KILL_NONE)
2836 sig = sigkill ? SIGKILL : c->kill_signal;
2839 r = kill_and_sigcont(main_pid, sig);
2841 if (r < 0 && r != -ESRCH) {
2842 _cleanup_free_ char *comm = NULL;
2843 get_process_comm(main_pid, &comm);
2845 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2846 (long) main_pid, strna(comm), strerror(-r));
2848 wait_for_exit = !main_pid_alien;
2851 if (control_pid > 0) {
2852 r = kill_and_sigcont(control_pid, sig);
2854 if (r < 0 && r != -ESRCH) {
2855 _cleanup_free_ char *comm = NULL;
2856 get_process_comm(control_pid, &comm);
2858 log_warning_unit(u->id,
2859 "Failed to kill control process %li (%s): %s",
2860 (long) control_pid, strna(comm), strerror(-r));
2862 wait_for_exit = true;
2865 if (c->kill_mode == KILL_CONTROL_GROUP) {
2866 _cleanup_set_free_ Set *pid_set = NULL;
2868 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2872 /* Exclude the main/control pids from being killed via the cgroup */
2874 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2879 if (control_pid > 0) {
2880 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2885 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2887 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2888 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2890 wait_for_exit = true;
2893 return wait_for_exit;
2896 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2897 [UNIT_ACTIVE] = "active",
2898 [UNIT_RELOADING] = "reloading",
2899 [UNIT_INACTIVE] = "inactive",
2900 [UNIT_FAILED] = "failed",
2901 [UNIT_ACTIVATING] = "activating",
2902 [UNIT_DEACTIVATING] = "deactivating"
2905 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2907 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2908 [UNIT_REQUIRES] = "Requires",
2909 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2910 [UNIT_REQUISITE] = "Requisite",
2911 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2912 [UNIT_WANTS] = "Wants",
2913 [UNIT_BINDS_TO] = "BindsTo",
2914 [UNIT_PART_OF] = "PartOf",
2915 [UNIT_REQUIRED_BY] = "RequiredBy",
2916 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2917 [UNIT_WANTED_BY] = "WantedBy",
2918 [UNIT_BOUND_BY] = "BoundBy",
2919 [UNIT_CONSISTS_OF] = "ConsistsOf",
2920 [UNIT_CONFLICTS] = "Conflicts",
2921 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2922 [UNIT_BEFORE] = "Before",
2923 [UNIT_AFTER] = "After",
2924 [UNIT_ON_FAILURE] = "OnFailure",
2925 [UNIT_TRIGGERS] = "Triggers",
2926 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2927 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2928 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2929 [UNIT_REFERENCES] = "References",
2930 [UNIT_REFERENCED_BY] = "ReferencedBy",
2933 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);