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"
49 #include "fileio-label.h"
50 #include "bus-errors.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,
63 [UNIT_SLICE] = &slice_vtable,
64 [UNIT_SCOPE] = &scope_vtable
67 Unit *unit_new(Manager *m, size_t size) {
71 assert(size >= sizeof(Unit));
77 u->names = set_new(string_hash_func, string_compare_func);
84 u->type = _UNIT_TYPE_INVALID;
85 u->deserialized_job = _JOB_TYPE_INVALID;
86 u->default_dependencies = true;
87 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 bool unit_has_name(Unit *u, const char *name) {
96 return !!set_get(u->names, (char*) name);
99 int unit_add_name(Unit *u, const char *text) {
107 if (unit_name_is_template(text)) {
111 s = unit_name_replace_instance(text, u->instance);
118 if (!unit_name_is_valid(s, false)) {
123 assert_se((t = unit_name_to_type(s)) >= 0);
125 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
130 if ((r = unit_name_to_instance(s, &i)) < 0)
133 if (i && unit_vtable[t]->no_instances) {
138 /* Ensure that this unit is either instanced or not instanced,
140 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
145 if (unit_vtable[t]->no_alias &&
146 !set_isempty(u->names) &&
147 !set_get(u->names, s)) {
152 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
157 if ((r = set_put(u->names, s)) < 0) {
163 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
164 set_remove(u->names, s);
168 if (u->type == _UNIT_TYPE_INVALID) {
174 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
176 if (UNIT_VTABLE(u)->init)
177 UNIT_VTABLE(u)->init(u);
181 unit_add_to_dbus_queue(u);
191 int unit_choose_id(Unit *u, const char *name) {
192 char *s, *t = NULL, *i;
198 if (unit_name_is_template(name)) {
203 if (!(t = unit_name_replace_instance(name, u->instance)))
209 /* Selects one of the names of this unit as the id */
210 s = set_get(u->names, (char*) name);
216 if ((r = unit_name_to_instance(s, &i)) < 0)
224 unit_add_to_dbus_queue(u);
229 int unit_set_description(Unit *u, const char *description) {
234 if (isempty(description))
237 s = strdup(description);
242 free(u->description);
245 unit_add_to_dbus_queue(u);
249 bool unit_check_gc(Unit *u) {
252 if (u->load_state == UNIT_STUB)
255 if (UNIT_VTABLE(u)->no_gc)
267 if (unit_active_state(u) != UNIT_INACTIVE)
273 if (UNIT_VTABLE(u)->check_gc)
274 if (UNIT_VTABLE(u)->check_gc(u))
280 void unit_add_to_load_queue(Unit *u) {
282 assert(u->type != _UNIT_TYPE_INVALID);
284 if (u->load_state != UNIT_STUB || u->in_load_queue)
287 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
288 u->in_load_queue = true;
291 void unit_add_to_cleanup_queue(Unit *u) {
294 if (u->in_cleanup_queue)
297 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
298 u->in_cleanup_queue = true;
301 void unit_add_to_gc_queue(Unit *u) {
304 if (u->in_gc_queue || u->in_cleanup_queue)
307 if (unit_check_gc(u))
310 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
311 u->in_gc_queue = true;
313 u->manager->n_in_gc_queue ++;
316 void unit_add_to_dbus_queue(Unit *u) {
318 assert(u->type != _UNIT_TYPE_INVALID);
320 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
323 /* Shortcut things if nobody cares */
324 if (!bus_has_subscriber(u->manager)) {
325 u->sent_dbus_new_signal = true;
329 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
330 u->in_dbus_queue = true;
333 static void bidi_set_free(Unit *u, Set *s) {
339 /* Frees the set and makes sure we are dropped from the
340 * inverse pointers */
342 SET_FOREACH(other, s, i) {
345 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
346 set_remove(other->dependencies[d], u);
348 unit_add_to_gc_queue(other);
354 static void unit_remove_transient(Unit *u) {
362 if (u->fragment_path)
363 unlink(u->fragment_path);
365 STRV_FOREACH(i, u->dropin_paths) {
366 _cleanup_free_ char *p = NULL;
371 r = path_get_parent(*i, &p);
377 void unit_free(Unit *u) {
384 if (u->manager->n_reloading <= 0)
385 unit_remove_transient(u);
387 bus_unit_send_removed_signal(u);
389 if (u->load_state != UNIT_STUB)
390 if (UNIT_VTABLE(u)->done)
391 UNIT_VTABLE(u)->done(u);
393 SET_FOREACH(t, u->names, i)
394 hashmap_remove_value(u->manager->units, t, u);
408 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
409 bidi_set_free(u, u->dependencies[d]);
411 if (u->requires_mounts_for) {
412 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
413 strv_free(u->requires_mounts_for);
416 if (u->type != _UNIT_TYPE_INVALID)
417 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
419 if (u->in_load_queue)
420 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
422 if (u->in_dbus_queue)
423 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
425 if (u->in_cleanup_queue)
426 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
428 if (u->in_gc_queue) {
429 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
430 u->manager->n_in_gc_queue--;
433 if (u->in_cgroup_queue)
434 LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
436 free(u->cgroup_path);
437 free(u->description);
438 strv_free(u->documentation);
439 free(u->fragment_path);
440 free(u->source_path);
441 strv_free(u->dropin_paths);
444 set_free_free(u->names);
446 condition_free_list(u->conditions);
448 unit_ref_unset(&u->slice);
451 unit_ref_unset(u->refs);
456 UnitActiveState unit_active_state(Unit *u) {
459 if (u->load_state == UNIT_MERGED)
460 return unit_active_state(unit_follow_merge(u));
462 /* After a reload it might happen that a unit is not correctly
463 * loaded but still has a process around. That's why we won't
464 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
466 return UNIT_VTABLE(u)->active_state(u);
469 const char* unit_sub_state_to_string(Unit *u) {
472 return UNIT_VTABLE(u)->sub_state_to_string(u);
475 static void complete_move(Set **s, Set **other) {
483 set_move(*s, *other);
490 static void merge_names(Unit *u, Unit *other) {
497 complete_move(&u->names, &other->names);
499 set_free_free(other->names);
503 SET_FOREACH(t, u->names, i)
504 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
507 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
514 assert(d < _UNIT_DEPENDENCY_MAX);
516 /* Fix backwards pointers */
517 SET_FOREACH(back, other->dependencies[d], i) {
520 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
521 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
524 set_remove(back->dependencies[k], other);
526 assert(r == -ENOENT);
530 complete_move(&u->dependencies[d], &other->dependencies[d]);
532 set_free(other->dependencies[d]);
533 other->dependencies[d] = NULL;
536 int unit_merge(Unit *u, Unit *other) {
541 assert(u->manager == other->manager);
542 assert(u->type != _UNIT_TYPE_INVALID);
544 other = unit_follow_merge(other);
549 if (u->type != other->type)
552 if (!u->instance != !other->instance)
555 if (other->load_state != UNIT_STUB &&
556 other->load_state != UNIT_NOT_FOUND)
565 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
569 merge_names(u, other);
571 /* Redirect all references */
573 unit_ref_set(other->refs, u);
575 /* Merge dependencies */
576 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
577 merge_dependencies(u, other, d);
579 other->load_state = UNIT_MERGED;
580 other->merged_into = u;
582 /* If there is still some data attached to the other node, we
583 * don't need it anymore, and can free it. */
584 if (other->load_state != UNIT_STUB)
585 if (UNIT_VTABLE(other)->done)
586 UNIT_VTABLE(other)->done(other);
588 unit_add_to_dbus_queue(u);
589 unit_add_to_cleanup_queue(other);
594 int unit_merge_by_name(Unit *u, const char *name) {
602 if (unit_name_is_template(name)) {
606 if (!(s = unit_name_replace_instance(name, u->instance)))
612 other = manager_get_unit(u->manager, name);
614 r = unit_add_name(u, name);
616 r = unit_merge(u, other);
622 Unit* unit_follow_merge(Unit *u) {
625 while (u->load_state == UNIT_MERGED)
626 assert_se(u = u->merged_into);
631 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
637 if (c->std_output != EXEC_OUTPUT_KMSG &&
638 c->std_output != EXEC_OUTPUT_SYSLOG &&
639 c->std_output != EXEC_OUTPUT_JOURNAL &&
640 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
641 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
642 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
643 c->std_error != EXEC_OUTPUT_KMSG &&
644 c->std_error != EXEC_OUTPUT_SYSLOG &&
645 c->std_error != EXEC_OUTPUT_JOURNAL &&
646 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
647 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
648 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
651 /* If syslog or kernel logging is requested, make sure our own
652 * logging daemon is run first. */
654 if (u->manager->running_as == SYSTEMD_SYSTEM) {
655 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
663 const char *unit_description(Unit *u) {
667 return u->description;
672 void unit_dump(Unit *u, FILE *f, const char *prefix) {
679 timestamp1[FORMAT_TIMESTAMP_MAX],
680 timestamp2[FORMAT_TIMESTAMP_MAX],
681 timestamp3[FORMAT_TIMESTAMP_MAX],
682 timestamp4[FORMAT_TIMESTAMP_MAX],
683 timespan[FORMAT_TIMESPAN_MAX];
687 assert(u->type >= 0);
691 p2 = strappend(prefix, "\t");
692 prefix2 = p2 ? p2 : prefix;
696 "%s\tDescription: %s\n"
698 "%s\tUnit Load State: %s\n"
699 "%s\tUnit Active State: %s\n"
700 "%s\tInactive Exit Timestamp: %s\n"
701 "%s\tActive Enter Timestamp: %s\n"
702 "%s\tActive Exit Timestamp: %s\n"
703 "%s\tInactive Enter Timestamp: %s\n"
704 "%s\tGC Check Good: %s\n"
705 "%s\tNeed Daemon Reload: %s\n"
706 "%s\tTransient: %s\n"
709 "%s\tCGroup realized: %s\n"
710 "%s\tCGroup mask: 0x%x\n",
712 prefix, unit_description(u),
713 prefix, strna(u->instance),
714 prefix, unit_load_state_to_string(u->load_state),
715 prefix, unit_active_state_to_string(unit_active_state(u)),
716 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
717 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
718 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
719 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
720 prefix, yes_no(unit_check_gc(u)),
721 prefix, yes_no(unit_need_daemon_reload(u)),
722 prefix, yes_no(u->transient),
723 prefix, strna(unit_slice_name(u)),
724 prefix, strna(u->cgroup_path),
725 prefix, yes_no(u->cgroup_realized),
726 prefix, u->cgroup_mask);
728 SET_FOREACH(t, u->names, i)
729 fprintf(f, "%s\tName: %s\n", prefix, t);
731 STRV_FOREACH(j, u->documentation)
732 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
734 if ((following = unit_following(u)))
735 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
737 if (u->fragment_path)
738 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
741 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
743 STRV_FOREACH(j, u->dropin_paths)
744 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
746 if (u->job_timeout > 0)
747 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
749 condition_dump_list(u->conditions, f, prefix);
751 if (dual_timestamp_is_set(&u->condition_timestamp))
753 "%s\tCondition Timestamp: %s\n"
754 "%s\tCondition Result: %s\n",
755 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
756 prefix, yes_no(u->condition_result));
758 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
761 SET_FOREACH(other, u->dependencies[d], i)
762 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
765 if (!strv_isempty(u->requires_mounts_for)) {
767 "%s\tRequiresMountsFor:", prefix);
769 STRV_FOREACH(j, u->requires_mounts_for)
770 fprintf(f, " %s", *j);
775 if (u->load_state == UNIT_LOADED) {
778 "%s\tStopWhenUnneeded: %s\n"
779 "%s\tRefuseManualStart: %s\n"
780 "%s\tRefuseManualStop: %s\n"
781 "%s\tDefaultDependencies: %s\n"
782 "%s\tOnFailureIsolate: %s\n"
783 "%s\tIgnoreOnIsolate: %s\n"
784 "%s\tIgnoreOnSnapshot: %s\n",
785 prefix, yes_no(u->stop_when_unneeded),
786 prefix, yes_no(u->refuse_manual_start),
787 prefix, yes_no(u->refuse_manual_stop),
788 prefix, yes_no(u->default_dependencies),
789 prefix, yes_no(u->on_failure_isolate),
790 prefix, yes_no(u->ignore_on_isolate),
791 prefix, yes_no(u->ignore_on_snapshot));
793 if (UNIT_VTABLE(u)->dump)
794 UNIT_VTABLE(u)->dump(u, f, prefix2);
796 } else if (u->load_state == UNIT_MERGED)
798 "%s\tMerged into: %s\n",
799 prefix, u->merged_into->id);
800 else if (u->load_state == UNIT_ERROR)
801 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
805 job_dump(u->job, f, prefix2);
808 job_dump(u->nop_job, f, prefix2);
813 /* Common implementation for multiple backends */
814 int unit_load_fragment_and_dropin(Unit *u) {
819 /* Load a .service file */
820 r = unit_load_fragment(u);
824 if (u->load_state == UNIT_STUB)
827 /* Load drop-in directory data */
828 r = unit_load_dropin(unit_follow_merge(u));
835 /* Common implementation for multiple backends */
836 int unit_load_fragment_and_dropin_optional(Unit *u) {
841 /* Same as unit_load_fragment_and_dropin(), but whether
842 * something can be loaded or not doesn't matter. */
844 /* Load a .service file */
845 r = unit_load_fragment(u);
849 if (u->load_state == UNIT_STUB)
850 u->load_state = UNIT_LOADED;
852 /* Load drop-in directory data */
853 r = unit_load_dropin(unit_follow_merge(u));
860 int unit_add_default_target_dependency(Unit *u, Unit *target) {
864 if (target->type != UNIT_TARGET)
867 /* Only add the dependency if both units are loaded, so that
868 * that loop check below is reliable */
869 if (u->load_state != UNIT_LOADED ||
870 target->load_state != UNIT_LOADED)
873 /* If either side wants no automatic dependencies, then let's
875 if (!u->default_dependencies ||
876 !target->default_dependencies)
879 /* Don't create loops */
880 if (set_get(target->dependencies[UNIT_BEFORE], u))
883 return unit_add_dependency(target, UNIT_AFTER, u, true);
886 static int unit_add_default_dependencies(Unit *u) {
888 static const UnitDependency deps[] = {
890 UNIT_REQUIRED_BY_OVERRIDABLE,
902 for (k = 0; k < ELEMENTSOF(deps); k++)
903 SET_FOREACH(target, u->dependencies[deps[k]], i) {
904 r = unit_add_default_target_dependency(u, target);
909 if (u->default_dependencies && unit_get_cgroup_context(u)) {
910 if (UNIT_ISSET(u->slice))
911 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
913 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
922 int unit_load(Unit *u) {
927 if (u->in_load_queue) {
928 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
929 u->in_load_queue = false;
932 if (u->type == _UNIT_TYPE_INVALID)
935 if (u->load_state != UNIT_STUB)
938 if (UNIT_VTABLE(u)->load) {
939 r = UNIT_VTABLE(u)->load(u);
944 if (u->load_state == UNIT_STUB) {
949 if (u->load_state == UNIT_LOADED) {
951 if (u->default_dependencies) {
952 r = unit_add_default_dependencies(u);
957 r = unit_add_mount_links(u);
961 if (u->on_failure_isolate &&
962 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
964 log_error_unit(u->id,
965 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
972 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
974 unit_add_to_dbus_queue(unit_follow_merge(u));
975 unit_add_to_gc_queue(u);
980 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
982 unit_add_to_dbus_queue(u);
983 unit_add_to_gc_queue(u);
985 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
986 u->id, strerror(-r));
991 bool unit_condition_test(Unit *u) {
994 dual_timestamp_get(&u->condition_timestamp);
995 u->condition_result = condition_test_list(u->conditions);
997 return u->condition_result;
1000 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1001 const UnitStatusMessageFormats *format_table;
1005 assert(t < _JOB_TYPE_MAX);
1007 if (t != JOB_START && t != JOB_STOP)
1010 format_table = &UNIT_VTABLE(u)->status_message_formats;
1014 return format_table->starting_stopping[t == JOB_STOP];
1017 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1022 assert(t < _JOB_TYPE_MAX);
1024 format = unit_get_status_message_format(u, t);
1028 /* Return generic strings */
1030 return "Starting %s.";
1031 else if (t == JOB_STOP)
1032 return "Stopping %s.";
1033 else if (t == JOB_RELOAD)
1034 return "Reloading %s.";
1039 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1044 /* We only print status messages for selected units on
1045 * selected operations. */
1047 format = unit_get_status_message_format(u, t);
1051 unit_status_printf(u, "", format);
1054 #pragma GCC diagnostic push
1055 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1056 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1063 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1066 if (log_on_console())
1069 /* We log status messages for all units and all operations. */
1071 format = unit_get_status_message_format_try_harder(u, t);
1075 snprintf(buf, sizeof(buf), format, unit_description(u));
1078 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1079 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1080 SD_MESSAGE_UNIT_RELOADING;
1082 log_struct_unit(LOG_INFO,
1088 #pragma GCC diagnostic pop
1091 * -EBADR: This unit type does not support starting.
1092 * -EALREADY: Unit is already started.
1093 * -EAGAIN: An operation is already in progress. Retry later.
1094 * -ECANCELED: Too many requests for now.
1096 int unit_start(Unit *u) {
1097 UnitActiveState state;
1102 if (u->load_state != UNIT_LOADED)
1105 /* If this is already started, then this will succeed. Note
1106 * that this will even succeed if this unit is not startable
1107 * by the user. This is relied on to detect when we need to
1108 * wait for units and when waiting is finished. */
1109 state = unit_active_state(u);
1110 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1113 /* If the conditions failed, don't do anything at all. If we
1114 * already are activating this call might still be useful to
1115 * speed up activation in case there is some hold-off time,
1116 * but we don't want to recheck the condition in that case. */
1117 if (state != UNIT_ACTIVATING &&
1118 !unit_condition_test(u)) {
1119 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1123 /* Forward to the main object, if we aren't it. */
1124 if ((following = unit_following(u))) {
1125 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1126 u->id, following->id);
1127 return unit_start(following);
1130 unit_status_log_starting_stopping_reloading(u, JOB_START);
1131 unit_status_print_starting_stopping(u, JOB_START);
1133 /* If it is stopped, but we cannot start it, then fail */
1134 if (!UNIT_VTABLE(u)->start)
1137 /* We don't suppress calls to ->start() here when we are
1138 * already starting, to allow this request to be used as a
1139 * "hurry up" call, for example when the unit is in some "auto
1140 * restart" state where it waits for a holdoff timer to elapse
1141 * before it will start again. */
1143 unit_add_to_dbus_queue(u);
1145 return UNIT_VTABLE(u)->start(u);
1148 bool unit_can_start(Unit *u) {
1151 return !!UNIT_VTABLE(u)->start;
1154 bool unit_can_isolate(Unit *u) {
1157 return unit_can_start(u) &&
1162 * -EBADR: This unit type does not support stopping.
1163 * -EALREADY: Unit is already stopped.
1164 * -EAGAIN: An operation is already in progress. Retry later.
1166 int unit_stop(Unit *u) {
1167 UnitActiveState state;
1172 state = unit_active_state(u);
1173 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1176 if ((following = unit_following(u))) {
1177 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1178 u->id, following->id);
1179 return unit_stop(following);
1182 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1183 unit_status_print_starting_stopping(u, JOB_STOP);
1185 if (!UNIT_VTABLE(u)->stop)
1188 unit_add_to_dbus_queue(u);
1190 return UNIT_VTABLE(u)->stop(u);
1194 * -EBADR: This unit type does not support reloading.
1195 * -ENOEXEC: Unit is not started.
1196 * -EAGAIN: An operation is already in progress. Retry later.
1198 int unit_reload(Unit *u) {
1199 UnitActiveState state;
1204 if (u->load_state != UNIT_LOADED)
1207 if (!unit_can_reload(u))
1210 state = unit_active_state(u);
1211 if (state == UNIT_RELOADING)
1214 if (state != UNIT_ACTIVE)
1217 if ((following = unit_following(u))) {
1218 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1219 u->id, following->id);
1220 return unit_reload(following);
1223 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1225 unit_add_to_dbus_queue(u);
1226 return UNIT_VTABLE(u)->reload(u);
1229 bool unit_can_reload(Unit *u) {
1232 if (!UNIT_VTABLE(u)->reload)
1235 if (!UNIT_VTABLE(u)->can_reload)
1238 return UNIT_VTABLE(u)->can_reload(u);
1241 static void unit_check_unneeded(Unit *u) {
1247 /* If this service shall be shut down when unneeded then do
1250 if (!u->stop_when_unneeded)
1253 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1256 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1257 if (unit_active_or_pending(other))
1260 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1261 if (unit_active_or_pending(other))
1264 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1265 if (unit_active_or_pending(other))
1268 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1269 if (unit_active_or_pending(other))
1272 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1274 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1275 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1278 static void retroactively_start_dependencies(Unit *u) {
1283 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1285 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1286 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1287 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1288 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1290 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1291 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1292 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1293 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1295 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1296 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1297 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1298 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1300 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1301 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1302 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1303 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1305 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1306 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1307 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1309 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1310 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1311 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1314 static void retroactively_stop_dependencies(Unit *u) {
1319 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1321 /* Pull down units which are bound to us recursively if enabled */
1322 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1323 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1324 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1327 static void check_unneeded_dependencies(Unit *u) {
1332 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1334 /* Garbage collect services that might not be needed anymore, if enabled */
1335 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1336 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1337 unit_check_unneeded(other);
1338 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1339 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1340 unit_check_unneeded(other);
1341 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1342 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1343 unit_check_unneeded(other);
1344 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1345 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1346 unit_check_unneeded(other);
1347 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1348 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1349 unit_check_unneeded(other);
1350 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1351 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1352 unit_check_unneeded(other);
1355 void unit_start_on_failure(Unit *u) {
1361 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1364 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1366 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1369 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1371 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1375 void unit_trigger_notify(Unit *u) {
1381 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1382 if (UNIT_VTABLE(other)->trigger_notify)
1383 UNIT_VTABLE(other)->trigger_notify(other, u);
1386 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1391 assert(os < _UNIT_ACTIVE_STATE_MAX);
1392 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1394 /* Note that this is called for all low-level state changes,
1395 * even if they might map to the same high-level
1396 * UnitActiveState! That means that ns == os is OK an expected
1397 * behavior here. For example: if a mount point is remounted
1398 * this function will be called too! */
1402 if (m->n_reloading <= 0) {
1405 dual_timestamp_get(&ts);
1407 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1408 u->inactive_exit_timestamp = ts;
1409 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1410 u->inactive_enter_timestamp = ts;
1412 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1413 u->active_enter_timestamp = ts;
1414 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1415 u->active_exit_timestamp = ts;
1418 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1419 unit_destroy_cgroup(u);
1421 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1422 ExecContext *ec = unit_get_exec_context(u);
1423 if (ec && exec_context_may_touch_console(ec)) {
1424 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1434 if (u->job->state == JOB_WAITING)
1436 /* So we reached a different state for this
1437 * job. Let's see if we can run it now if it
1438 * failed previously due to EAGAIN. */
1439 job_add_to_run_queue(u->job);
1441 /* Let's check whether this state change constitutes a
1442 * finished job, or maybe contradicts a running job and
1443 * hence needs to invalidate jobs. */
1445 switch (u->job->type) {
1448 case JOB_VERIFY_ACTIVE:
1450 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1451 job_finish_and_invalidate(u->job, JOB_DONE, true);
1452 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1455 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1456 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1462 case JOB_RELOAD_OR_START:
1464 if (u->job->state == JOB_RUNNING) {
1465 if (ns == UNIT_ACTIVE)
1466 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1467 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1470 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1471 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1479 case JOB_TRY_RESTART:
1481 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1482 job_finish_and_invalidate(u->job, JOB_DONE, true);
1483 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1485 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1491 assert_not_reached("Job type unknown");
1497 if (m->n_reloading <= 0) {
1499 /* If this state change happened without being
1500 * requested by a job, then let's retroactively start
1501 * or stop dependencies. We skip that step when
1502 * deserializing, since we don't want to create any
1503 * additional jobs just because something is already
1507 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1508 retroactively_start_dependencies(u);
1509 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1510 retroactively_stop_dependencies(u);
1513 /* stop unneeded units regardless if going down was expected or not */
1514 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1515 check_unneeded_dependencies(u);
1517 if (ns != os && ns == UNIT_FAILED) {
1518 log_notice_unit(u->id,
1519 "Unit %s entered failed state.", u->id);
1520 unit_start_on_failure(u);
1524 /* Some names are special */
1525 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1527 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1528 /* The bus just might have become available,
1529 * hence try to connect to it, if we aren't
1533 if (u->type == UNIT_SERVICE &&
1534 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1535 m->n_reloading <= 0) {
1536 /* Write audit record if we have just finished starting up */
1537 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1541 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1542 manager_send_unit_plymouth(m, u);
1546 /* We don't care about D-Bus here, since we'll get an
1547 * asynchronous notification for it anyway. */
1549 if (u->type == UNIT_SERVICE &&
1550 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1551 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1552 m->n_reloading <= 0) {
1554 /* Hmm, if there was no start record written
1555 * write it now, so that we always have a nice
1558 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1560 if (ns == UNIT_INACTIVE)
1561 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1563 /* Write audit record if we have just finished shutting down */
1564 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1566 u->in_audit = false;
1570 manager_recheck_journal(m);
1571 unit_trigger_notify(u);
1573 /* Maybe we finished startup and are now ready for being
1574 * stopped because unneeded? */
1575 if (u->manager->n_reloading <= 0)
1576 unit_check_unneeded(u);
1578 unit_add_to_dbus_queue(u);
1579 unit_add_to_gc_queue(u);
1582 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1583 struct epoll_event ev = {
1591 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1593 if (epoll_ctl(u->manager->epoll_fd,
1594 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1606 void unit_unwatch_fd(Unit *u, Watch *w) {
1610 if (w->type == WATCH_INVALID)
1613 assert(w->type == WATCH_FD);
1614 assert(w->data.unit == u);
1615 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1618 w->type = WATCH_INVALID;
1619 w->data.unit = NULL;
1622 int unit_watch_pid(Unit *u, pid_t pid) {
1626 /* Watch a specific PID. We only support one unit watching
1627 * each PID for now. */
1629 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1632 void unit_unwatch_pid(Unit *u, pid_t pid) {
1636 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1639 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1640 struct itimerspec its = {};
1646 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1648 /* This will try to reuse the old timer if there is one */
1650 if (w->type == WATCH_UNIT_TIMER) {
1651 assert(w->data.unit == u);
1656 } else if (w->type == WATCH_INVALID) {
1659 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1663 assert_not_reached("Invalid watch type");
1666 /* Set absolute time in the past, but not 0, since we
1667 * don't want to disarm the timer */
1668 its.it_value.tv_sec = 0;
1669 its.it_value.tv_nsec = 1;
1671 flags = TFD_TIMER_ABSTIME;
1673 timespec_store(&its.it_value, usec);
1674 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1677 /* This will also flush the elapse counter */
1678 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1681 if (w->type == WATCH_INVALID) {
1682 struct epoll_event ev = {
1687 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1691 w->type = WATCH_UNIT_TIMER;
1699 close_nointr_nofail(fd);
1704 void unit_unwatch_timer(Unit *u, Watch *w) {
1708 if (w->type == WATCH_INVALID)
1711 assert(w->type == WATCH_UNIT_TIMER);
1712 assert(w->data.unit == u);
1715 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1716 close_nointr_nofail(w->fd);
1719 w->type = WATCH_INVALID;
1720 w->data.unit = NULL;
1723 bool unit_job_is_applicable(Unit *u, JobType j) {
1725 assert(j >= 0 && j < _JOB_TYPE_MAX);
1729 case JOB_VERIFY_ACTIVE:
1736 case JOB_TRY_RESTART:
1737 return unit_can_start(u);
1740 return unit_can_reload(u);
1742 case JOB_RELOAD_OR_START:
1743 return unit_can_reload(u) && unit_can_start(u);
1746 assert_not_reached("Invalid job type");
1750 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1752 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1753 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1754 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1755 [UNIT_WANTS] = UNIT_WANTED_BY,
1756 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1757 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1758 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1759 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1760 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1761 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1762 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1763 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1764 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1765 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1766 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1767 [UNIT_BEFORE] = UNIT_AFTER,
1768 [UNIT_AFTER] = UNIT_BEFORE,
1769 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1770 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1771 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1772 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1773 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1774 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1775 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1777 int r, q = 0, v = 0, w = 0;
1780 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1783 u = unit_follow_merge(u);
1784 other = unit_follow_merge(other);
1786 /* We won't allow dependencies on ourselves. We will not
1787 * consider them an error however. */
1791 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1794 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1795 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1799 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1800 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1803 if ((q = set_put(u->dependencies[d], other)) < 0)
1806 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1807 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1812 if (add_reference) {
1813 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1818 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1822 unit_add_to_dbus_queue(u);
1827 set_remove(u->dependencies[d], other);
1830 set_remove(other->dependencies[inverse_table[d]], u);
1833 set_remove(u->dependencies[UNIT_REFERENCES], other);
1838 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1843 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1846 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1852 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1856 assert(name || path);
1860 name = path_get_file_name(path);
1862 if (!unit_name_is_template(name)) {
1868 s = unit_name_replace_instance(name, u->instance);
1870 _cleanup_free_ char *i = NULL;
1872 i = unit_name_to_prefix(u->id);
1876 s = unit_name_replace_instance(name, i);
1886 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1889 _cleanup_free_ char *s = NULL;
1892 assert(name || path);
1894 name = resolve_template(u, name, path, &s);
1898 r = manager_load_unit(u->manager, name, path, NULL, &other);
1902 return unit_add_dependency(u, d, other, add_reference);
1905 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1911 assert(name || path);
1913 if (!(name = resolve_template(u, name, path, &s)))
1916 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1919 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1926 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1932 assert(name || path);
1934 if (!(name = resolve_template(u, name, path, &s)))
1937 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1940 r = unit_add_dependency(other, d, u, add_reference);
1947 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1953 assert(name || path);
1955 if (!(name = resolve_template(u, name, path, &s)))
1958 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1961 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1969 int set_unit_path(const char *p) {
1970 _cleanup_free_ char *c = NULL;
1972 /* This is mostly for debug purposes */
1973 c = path_make_absolute_cwd(p);
1974 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1980 char *unit_dbus_path(Unit *u) {
1986 return unit_dbus_path_from_name(u->id);
1989 char *unit_default_cgroup_path(Unit *u) {
1990 _cleanup_free_ char *escaped_instance = NULL, *slice = NULL;
1995 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1996 return strdup(u->manager->cgroup_root);
1998 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1999 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2004 escaped_instance = cg_escape(u->id);
2005 if (!escaped_instance)
2009 _cleanup_free_ char *t = NULL, *escaped_template = NULL;
2011 t = unit_name_template(u->id);
2015 escaped_template = cg_escape(t);
2016 if (!escaped_template)
2019 return strjoin(u->manager->cgroup_root, "/",
2020 slice ? slice : "", slice ? "/" : "",
2021 escaped_template, "/", escaped_instance, NULL);
2023 return strjoin(u->manager->cgroup_root, "/",
2024 slice ? slice : "", slice ? "/" : "",
2025 escaped_instance, NULL);
2028 int unit_add_default_slice(Unit *u) {
2034 if (UNIT_ISSET(u->slice))
2037 if (!unit_get_cgroup_context(u))
2040 r = manager_load_unit(u->manager, u->manager->running_as == SYSTEMD_SYSTEM ? SPECIAL_SYSTEM_SLICE : SPECIAL_ROOT_SLICE, NULL, NULL, &slice);
2044 unit_ref_set(&u->slice, slice);
2048 const char *unit_slice_name(Unit *u) {
2051 if (!UNIT_ISSET(u->slice))
2054 return UNIT_DEREF(u->slice)->id;
2057 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2058 _cleanup_free_ char *t = NULL;
2065 t = unit_name_change_suffix(u->id, type);
2069 assert(!unit_has_name(u, t));
2071 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2072 assert(r < 0 || *_found != u);
2076 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2077 _cleanup_free_ char *t = NULL;
2084 t = unit_name_change_suffix(u->id, type);
2088 assert(!unit_has_name(u, t));
2090 found = manager_get_unit(u->manager, t);
2098 int unit_watch_bus_name(Unit *u, const char *name) {
2102 /* Watch a specific name on the bus. We only support one unit
2103 * watching each name for now. */
2105 return hashmap_put(u->manager->watch_bus, name, u);
2108 void unit_unwatch_bus_name(Unit *u, const char *name) {
2112 hashmap_remove_value(u->manager->watch_bus, name, u);
2115 bool unit_can_serialize(Unit *u) {
2118 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2121 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2128 if (!unit_can_serialize(u))
2131 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2135 if (serialize_jobs) {
2137 fprintf(f, "job\n");
2138 job_serialize(u->job, f, fds);
2142 fprintf(f, "job\n");
2143 job_serialize(u->nop_job, f, fds);
2147 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2148 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2149 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2150 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2151 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2153 if (dual_timestamp_is_set(&u->condition_timestamp))
2154 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2156 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2159 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2166 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2177 va_start(ap, format);
2178 vfprintf(f, format, ap);
2184 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2190 fprintf(f, "%s=%s\n", key, value);
2193 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2200 if (!unit_can_serialize(u))
2204 char line[LINE_MAX], *l, *v;
2207 if (!fgets(line, sizeof(line), f)) {
2220 k = strcspn(l, "=");
2228 if (streq(l, "job")) {
2230 /* new-style serialized job */
2231 Job *j = job_new_raw(u);
2235 r = job_deserialize(j, f, fds);
2241 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2247 r = job_install_deserialized(j);
2249 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2254 if (j->state == JOB_RUNNING)
2255 u->manager->n_running_jobs++;
2258 JobType type = job_type_from_string(v);
2260 log_debug("Failed to parse job type value %s", v);
2262 u->deserialized_job = type;
2265 } else if (streq(l, "inactive-exit-timestamp")) {
2266 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2268 } else if (streq(l, "active-enter-timestamp")) {
2269 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2271 } else if (streq(l, "active-exit-timestamp")) {
2272 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2274 } else if (streq(l, "inactive-enter-timestamp")) {
2275 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2277 } else if (streq(l, "condition-timestamp")) {
2278 dual_timestamp_deserialize(v, &u->condition_timestamp);
2280 } else if (streq(l, "condition-result")) {
2283 b = parse_boolean(v);
2285 log_debug("Failed to parse condition result value %s", v);
2287 u->condition_result = b;
2291 } else if (streq(l, "transient")) {
2294 b = parse_boolean(v);
2296 log_debug("Failed to parse transient bool %s", v);
2301 } else if (streq(l, "cgroup")) {
2308 free(u->cgroup_path);
2313 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2319 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2329 /* Adds in links to the device node that this unit is based on */
2331 if (!is_device_path(what))
2334 e = unit_name_from_path(what, ".device");
2338 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2343 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2348 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2356 int unit_coldplug(Unit *u) {
2361 if (UNIT_VTABLE(u)->coldplug)
2362 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2366 r = job_coldplug(u->job);
2369 } else if (u->deserialized_job >= 0) {
2371 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2375 u->deserialized_job = _JOB_TYPE_INVALID;
2381 #pragma GCC diagnostic push
2382 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2383 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2384 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2386 #pragma GCC diagnostic pop
2388 bool unit_need_daemon_reload(Unit *u) {
2389 _cleanup_strv_free_ char **t = NULL;
2392 unsigned loaded_cnt, current_cnt;
2396 if (u->fragment_path) {
2398 if (stat(u->fragment_path, &st) < 0)
2399 /* What, cannot access this anymore? */
2402 if (u->fragment_mtime > 0 &&
2403 timespec_load(&st.st_mtim) != u->fragment_mtime)
2407 if (u->source_path) {
2409 if (stat(u->source_path, &st) < 0)
2412 if (u->source_mtime > 0 &&
2413 timespec_load(&st.st_mtim) != u->source_mtime)
2417 t = unit_find_dropin_paths(u);
2418 loaded_cnt = strv_length(t);
2419 current_cnt = strv_length(u->dropin_paths);
2421 if (loaded_cnt == current_cnt) {
2422 if (loaded_cnt == 0)
2425 if (strv_overlap(u->dropin_paths, t)) {
2426 STRV_FOREACH(path, u->dropin_paths) {
2428 if (stat(*path, &st) < 0)
2431 if (u->dropin_mtime > 0 &&
2432 timespec_load(&st.st_mtim) > u->dropin_mtime)
2443 void unit_reset_failed(Unit *u) {
2446 if (UNIT_VTABLE(u)->reset_failed)
2447 UNIT_VTABLE(u)->reset_failed(u);
2450 Unit *unit_following(Unit *u) {
2453 if (UNIT_VTABLE(u)->following)
2454 return UNIT_VTABLE(u)->following(u);
2459 bool unit_stop_pending(Unit *u) {
2462 /* This call does check the current state of the unit. It's
2463 * hence useful to be called from state change calls of the
2464 * unit itself, where the state isn't updated yet. This is
2465 * different from unit_inactive_or_pending() which checks both
2466 * the current state and for a queued job. */
2468 return u->job && u->job->type == JOB_STOP;
2471 bool unit_inactive_or_pending(Unit *u) {
2474 /* Returns true if the unit is inactive or going down */
2476 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2479 if (unit_stop_pending(u))
2485 bool unit_active_or_pending(Unit *u) {
2488 /* Returns true if the unit is active or going up */
2490 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2494 (u->job->type == JOB_START ||
2495 u->job->type == JOB_RELOAD_OR_START ||
2496 u->job->type == JOB_RESTART))
2502 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2504 assert(w >= 0 && w < _KILL_WHO_MAX);
2506 assert(signo < _NSIG);
2508 if (!UNIT_VTABLE(u)->kill)
2511 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2514 int unit_kill_common(
2524 if (who == KILL_MAIN && main_pid <= 0) {
2526 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2528 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2532 if (who == KILL_CONTROL && control_pid <= 0) {
2533 if (control_pid < 0)
2534 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2536 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2540 if (who == KILL_CONTROL || who == KILL_ALL)
2541 if (control_pid > 0)
2542 if (kill(control_pid, signo) < 0)
2545 if (who == KILL_MAIN || who == KILL_ALL)
2547 if (kill(main_pid, signo) < 0)
2550 if (who == KILL_ALL && u->cgroup_path) {
2551 _cleanup_set_free_ Set *pid_set = NULL;
2554 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2558 /* Exclude the control/main pid from being killed via the cgroup */
2559 if (control_pid > 0) {
2560 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2566 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2571 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2572 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2579 int unit_following_set(Unit *u, Set **s) {
2583 if (UNIT_VTABLE(u)->following_set)
2584 return UNIT_VTABLE(u)->following_set(u, s);
2590 UnitFileState unit_get_unit_file_state(Unit *u) {
2593 if (u->unit_file_state < 0 && u->fragment_path)
2594 u->unit_file_state = unit_file_get_state(
2595 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2596 NULL, path_get_file_name(u->fragment_path));
2598 return u->unit_file_state;
2601 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2606 unit_ref_unset(ref);
2609 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2613 void unit_ref_unset(UnitRef *ref) {
2619 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2623 int unit_add_one_mount_link(Unit *u, Mount *m) {
2629 if (u->load_state != UNIT_LOADED ||
2630 UNIT(m)->load_state != UNIT_LOADED)
2633 STRV_FOREACH(i, u->requires_mounts_for) {
2638 if (!path_startswith(*i, m->where))
2641 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2647 int unit_add_mount_links(Unit *u) {
2653 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2654 r = unit_add_one_mount_link(u, MOUNT(other));
2662 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2669 /* This only copies in the ones that need memory */
2670 for (i = 0; i < RLIMIT_NLIMITS; i++)
2671 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2672 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2677 if (u->manager->running_as == SYSTEMD_USER &&
2678 !c->working_directory) {
2680 r = get_home_dir(&c->working_directory);
2688 ExecContext *unit_get_exec_context(Unit *u) {
2692 offset = UNIT_VTABLE(u)->exec_context_offset;
2696 return (ExecContext*) ((uint8_t*) u + offset);
2699 CGroupContext *unit_get_cgroup_context(Unit *u) {
2702 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2706 return (CGroupContext*) ((uint8_t*) u + offset);
2709 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2717 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2719 if (!filename_is_safe(name))
2722 if (u->manager->running_as == SYSTEMD_USER) {
2723 _cleanup_free_ char *c = NULL;
2725 r = user_config_home(&c);
2731 p = strjoin(c, "/", u->id, ".d", NULL);
2732 } else if (mode & UNIT_PERSISTENT)
2733 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2735 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2739 q = strjoin(p, "/90-", name, ".conf", NULL);
2750 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2751 _cleanup_free_ char *p = NULL, *q = NULL;
2758 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2761 r = drop_in_file(u, mode, name, &p, &q);
2766 return write_string_file_atomic_label(q, data);
2769 int unit_write_drop_in_private_section(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2770 _cleanup_free_ char *ndata = NULL;
2776 if (!UNIT_VTABLE(u)->private_section)
2779 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2783 return unit_write_drop_in(u, mode, name, ndata);
2786 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2787 _cleanup_free_ char *p = NULL, *q = NULL;
2792 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2795 r = drop_in_file(u, mode, name, &p, &q);
2797 r = errno == ENOENT ? 0 : -errno;
2805 int unit_make_transient(Unit *u) {
2810 u->load_state = UNIT_STUB;
2812 u->transient = true;
2814 free(u->fragment_path);
2815 u->fragment_path = NULL;
2817 if (u->manager->running_as == SYSTEMD_USER) {
2818 _cleanup_free_ char *c = NULL;
2820 r = user_config_home(&c);
2826 u->fragment_path = strjoin(c, "/", u->id, NULL);
2827 if (!u->fragment_path)
2832 u->fragment_path = strappend("/run/systemd/system/", u->id);
2833 if (!u->fragment_path)
2836 mkdir_p("/run/systemd/system", 0755);
2839 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2842 int unit_kill_context(
2848 bool main_pid_alien) {
2850 int sig, wait_for_exit = 0, r;
2855 if (c->kill_mode == KILL_NONE)
2858 sig = sigkill ? SIGKILL : c->kill_signal;
2861 r = kill_and_sigcont(main_pid, sig);
2863 if (r < 0 && r != -ESRCH) {
2864 _cleanup_free_ char *comm = NULL;
2865 get_process_comm(main_pid, &comm);
2867 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2868 (long) main_pid, strna(comm), strerror(-r));
2870 wait_for_exit = !main_pid_alien;
2873 if (control_pid > 0) {
2874 r = kill_and_sigcont(control_pid, sig);
2876 if (r < 0 && r != -ESRCH) {
2877 _cleanup_free_ char *comm = NULL;
2878 get_process_comm(control_pid, &comm);
2880 log_warning_unit(u->id,
2881 "Failed to kill control process %li (%s): %s",
2882 (long) control_pid, strna(comm), strerror(-r));
2884 wait_for_exit = true;
2887 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2888 _cleanup_set_free_ Set *pid_set = NULL;
2890 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2894 /* Exclude the main/control pids from being killed via the cgroup */
2896 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2901 if (control_pid > 0) {
2902 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2907 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2909 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2910 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2912 wait_for_exit = true;
2915 return wait_for_exit;
2918 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2919 [UNIT_ACTIVE] = "active",
2920 [UNIT_RELOADING] = "reloading",
2921 [UNIT_INACTIVE] = "inactive",
2922 [UNIT_FAILED] = "failed",
2923 [UNIT_ACTIVATING] = "activating",
2924 [UNIT_DEACTIVATING] = "deactivating"
2927 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2929 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2930 [UNIT_REQUIRES] = "Requires",
2931 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2932 [UNIT_REQUISITE] = "Requisite",
2933 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2934 [UNIT_WANTS] = "Wants",
2935 [UNIT_BINDS_TO] = "BindsTo",
2936 [UNIT_PART_OF] = "PartOf",
2937 [UNIT_REQUIRED_BY] = "RequiredBy",
2938 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2939 [UNIT_WANTED_BY] = "WantedBy",
2940 [UNIT_BOUND_BY] = "BoundBy",
2941 [UNIT_CONSISTS_OF] = "ConsistsOf",
2942 [UNIT_CONFLICTS] = "Conflicts",
2943 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2944 [UNIT_BEFORE] = "Before",
2945 [UNIT_AFTER] = "After",
2946 [UNIT_ON_FAILURE] = "OnFailure",
2947 [UNIT_TRIGGERS] = "Triggers",
2948 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2949 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2950 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2951 [UNIT_REFERENCES] = "References",
2952 [UNIT_REFERENCED_BY] = "ReferencedBy",
2955 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);