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 (!(s = strdup(description)))
237 free(u->description);
240 unit_add_to_dbus_queue(u);
244 bool unit_check_gc(Unit *u) {
247 if (u->load_state == UNIT_STUB)
250 if (UNIT_VTABLE(u)->no_gc)
262 if (unit_active_state(u) != UNIT_INACTIVE)
268 if (UNIT_VTABLE(u)->check_gc)
269 if (UNIT_VTABLE(u)->check_gc(u))
275 void unit_add_to_load_queue(Unit *u) {
277 assert(u->type != _UNIT_TYPE_INVALID);
279 if (u->load_state != UNIT_STUB || u->in_load_queue)
282 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
283 u->in_load_queue = true;
286 void unit_add_to_cleanup_queue(Unit *u) {
289 if (u->in_cleanup_queue)
292 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
293 u->in_cleanup_queue = true;
296 void unit_add_to_gc_queue(Unit *u) {
299 if (u->in_gc_queue || u->in_cleanup_queue)
302 if (unit_check_gc(u))
305 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
306 u->in_gc_queue = true;
308 u->manager->n_in_gc_queue ++;
310 if (u->manager->gc_queue_timestamp <= 0)
311 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
314 void unit_add_to_dbus_queue(Unit *u) {
316 assert(u->type != _UNIT_TYPE_INVALID);
318 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
321 /* Shortcut things if nobody cares */
322 if (!bus_has_subscriber(u->manager)) {
323 u->sent_dbus_new_signal = true;
327 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
328 u->in_dbus_queue = true;
331 static void bidi_set_free(Unit *u, Set *s) {
337 /* Frees the set and makes sure we are dropped from the
338 * inverse pointers */
340 SET_FOREACH(other, s, i) {
343 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
344 set_remove(other->dependencies[d], u);
346 unit_add_to_gc_queue(other);
352 static void unit_remove_transient(Unit *u) {
360 if (u->fragment_path)
361 unlink(u->fragment_path);
363 STRV_FOREACH(i, u->dropin_paths) {
364 _cleanup_free_ char *p = NULL;
369 r = path_get_parent(*i, &p);
375 void unit_free(Unit *u) {
382 if (u->manager->n_reloading <= 0)
383 unit_remove_transient(u);
385 bus_unit_send_removed_signal(u);
387 if (u->load_state != UNIT_STUB)
388 if (UNIT_VTABLE(u)->done)
389 UNIT_VTABLE(u)->done(u);
391 SET_FOREACH(t, u->names, i)
392 hashmap_remove_value(u->manager->units, t, u);
406 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
407 bidi_set_free(u, u->dependencies[d]);
409 if (u->requires_mounts_for) {
410 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
411 strv_free(u->requires_mounts_for);
414 if (u->type != _UNIT_TYPE_INVALID)
415 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
417 if (u->in_load_queue)
418 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
420 if (u->in_dbus_queue)
421 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
423 if (u->in_cleanup_queue)
424 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
426 if (u->in_gc_queue) {
427 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
428 u->manager->n_in_gc_queue--;
431 if (u->in_cgroup_queue)
432 LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
434 free(u->cgroup_path);
435 free(u->description);
436 strv_free(u->documentation);
437 free(u->fragment_path);
438 free(u->source_path);
439 strv_free(u->dropin_paths);
442 set_free_free(u->names);
444 condition_free_list(u->conditions);
446 unit_ref_unset(&u->slice);
449 unit_ref_unset(u->refs);
454 UnitActiveState unit_active_state(Unit *u) {
457 if (u->load_state == UNIT_MERGED)
458 return unit_active_state(unit_follow_merge(u));
460 /* After a reload it might happen that a unit is not correctly
461 * loaded but still has a process around. That's why we won't
462 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
464 return UNIT_VTABLE(u)->active_state(u);
467 const char* unit_sub_state_to_string(Unit *u) {
470 return UNIT_VTABLE(u)->sub_state_to_string(u);
473 static void complete_move(Set **s, Set **other) {
481 set_move(*s, *other);
488 static void merge_names(Unit *u, Unit *other) {
495 complete_move(&u->names, &other->names);
497 set_free_free(other->names);
501 SET_FOREACH(t, u->names, i)
502 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
505 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
512 assert(d < _UNIT_DEPENDENCY_MAX);
514 /* Fix backwards pointers */
515 SET_FOREACH(back, other->dependencies[d], i) {
518 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
519 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
522 set_remove(back->dependencies[k], other);
524 assert(r == -ENOENT);
528 complete_move(&u->dependencies[d], &other->dependencies[d]);
530 set_free(other->dependencies[d]);
531 other->dependencies[d] = NULL;
534 int unit_merge(Unit *u, Unit *other) {
539 assert(u->manager == other->manager);
540 assert(u->type != _UNIT_TYPE_INVALID);
542 other = unit_follow_merge(other);
547 if (u->type != other->type)
550 if (!u->instance != !other->instance)
553 if (other->load_state != UNIT_STUB &&
554 other->load_state != UNIT_NOT_FOUND)
563 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
567 merge_names(u, other);
569 /* Redirect all references */
571 unit_ref_set(other->refs, u);
573 /* Merge dependencies */
574 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
575 merge_dependencies(u, other, d);
577 other->load_state = UNIT_MERGED;
578 other->merged_into = u;
580 /* If there is still some data attached to the other node, we
581 * don't need it anymore, and can free it. */
582 if (other->load_state != UNIT_STUB)
583 if (UNIT_VTABLE(other)->done)
584 UNIT_VTABLE(other)->done(other);
586 unit_add_to_dbus_queue(u);
587 unit_add_to_cleanup_queue(other);
592 int unit_merge_by_name(Unit *u, const char *name) {
600 if (unit_name_is_template(name)) {
604 if (!(s = unit_name_replace_instance(name, u->instance)))
610 other = manager_get_unit(u->manager, name);
612 r = unit_add_name(u, name);
614 r = unit_merge(u, other);
620 Unit* unit_follow_merge(Unit *u) {
623 while (u->load_state == UNIT_MERGED)
624 assert_se(u = u->merged_into);
629 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
635 if (c->std_output != EXEC_OUTPUT_KMSG &&
636 c->std_output != EXEC_OUTPUT_SYSLOG &&
637 c->std_output != EXEC_OUTPUT_JOURNAL &&
638 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
639 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
640 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
641 c->std_error != EXEC_OUTPUT_KMSG &&
642 c->std_error != EXEC_OUTPUT_SYSLOG &&
643 c->std_error != EXEC_OUTPUT_JOURNAL &&
644 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
645 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
646 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
649 /* If syslog or kernel logging is requested, make sure our own
650 * logging daemon is run first. */
652 if (u->manager->running_as == SYSTEMD_SYSTEM) {
653 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
661 const char *unit_description(Unit *u) {
665 return u->description;
670 void unit_dump(Unit *u, FILE *f, const char *prefix) {
677 timestamp1[FORMAT_TIMESTAMP_MAX],
678 timestamp2[FORMAT_TIMESTAMP_MAX],
679 timestamp3[FORMAT_TIMESTAMP_MAX],
680 timestamp4[FORMAT_TIMESTAMP_MAX],
681 timespan[FORMAT_TIMESPAN_MAX];
685 assert(u->type >= 0);
689 p2 = strappend(prefix, "\t");
690 prefix2 = p2 ? p2 : prefix;
694 "%s\tDescription: %s\n"
696 "%s\tUnit Load State: %s\n"
697 "%s\tUnit Active State: %s\n"
698 "%s\tInactive Exit Timestamp: %s\n"
699 "%s\tActive Enter Timestamp: %s\n"
700 "%s\tActive Exit Timestamp: %s\n"
701 "%s\tInactive Enter Timestamp: %s\n"
702 "%s\tGC Check Good: %s\n"
703 "%s\tNeed Daemon Reload: %s\n"
704 "%s\tTransient: %s\n"
707 "%s\tCGroup realized: %s\n"
708 "%s\tCGroup mask: 0x%x\n",
710 prefix, unit_description(u),
711 prefix, strna(u->instance),
712 prefix, unit_load_state_to_string(u->load_state),
713 prefix, unit_active_state_to_string(unit_active_state(u)),
714 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
715 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
716 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
717 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
718 prefix, yes_no(unit_check_gc(u)),
719 prefix, yes_no(unit_need_daemon_reload(u)),
720 prefix, yes_no(u->transient),
721 prefix, strna(unit_slice_name(u)),
722 prefix, strna(u->cgroup_path),
723 prefix, yes_no(u->cgroup_realized),
724 prefix, u->cgroup_mask);
726 SET_FOREACH(t, u->names, i)
727 fprintf(f, "%s\tName: %s\n", prefix, t);
729 STRV_FOREACH(j, u->documentation)
730 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
732 if ((following = unit_following(u)))
733 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
735 if (u->fragment_path)
736 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
739 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
741 STRV_FOREACH(j, u->dropin_paths)
742 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
744 if (u->job_timeout > 0)
745 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
747 condition_dump_list(u->conditions, f, prefix);
749 if (dual_timestamp_is_set(&u->condition_timestamp))
751 "%s\tCondition Timestamp: %s\n"
752 "%s\tCondition Result: %s\n",
753 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
754 prefix, yes_no(u->condition_result));
756 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
759 SET_FOREACH(other, u->dependencies[d], i)
760 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
763 if (!strv_isempty(u->requires_mounts_for)) {
765 "%s\tRequiresMountsFor:", prefix);
767 STRV_FOREACH(j, u->requires_mounts_for)
768 fprintf(f, " %s", *j);
773 if (u->load_state == UNIT_LOADED) {
776 "%s\tStopWhenUnneeded: %s\n"
777 "%s\tRefuseManualStart: %s\n"
778 "%s\tRefuseManualStop: %s\n"
779 "%s\tDefaultDependencies: %s\n"
780 "%s\tOnFailureIsolate: %s\n"
781 "%s\tIgnoreOnIsolate: %s\n"
782 "%s\tIgnoreOnSnapshot: %s\n",
783 prefix, yes_no(u->stop_when_unneeded),
784 prefix, yes_no(u->refuse_manual_start),
785 prefix, yes_no(u->refuse_manual_stop),
786 prefix, yes_no(u->default_dependencies),
787 prefix, yes_no(u->on_failure_isolate),
788 prefix, yes_no(u->ignore_on_isolate),
789 prefix, yes_no(u->ignore_on_snapshot));
791 if (UNIT_VTABLE(u)->dump)
792 UNIT_VTABLE(u)->dump(u, f, prefix2);
794 } else if (u->load_state == UNIT_MERGED)
796 "%s\tMerged into: %s\n",
797 prefix, u->merged_into->id);
798 else if (u->load_state == UNIT_ERROR)
799 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
803 job_dump(u->job, f, prefix2);
806 job_dump(u->nop_job, f, prefix2);
811 /* Common implementation for multiple backends */
812 int unit_load_fragment_and_dropin(Unit *u) {
817 /* Load a .service file */
818 r = unit_load_fragment(u);
822 if (u->load_state == UNIT_STUB)
825 /* Load drop-in directory data */
826 r = unit_load_dropin(unit_follow_merge(u));
833 /* Common implementation for multiple backends */
834 int unit_load_fragment_and_dropin_optional(Unit *u) {
839 /* Same as unit_load_fragment_and_dropin(), but whether
840 * something can be loaded or not doesn't matter. */
842 /* Load a .service file */
843 r = unit_load_fragment(u);
847 if (u->load_state == UNIT_STUB)
848 u->load_state = UNIT_LOADED;
850 /* Load drop-in directory data */
851 r = unit_load_dropin(unit_follow_merge(u));
858 int unit_add_default_target_dependency(Unit *u, Unit *target) {
862 if (target->type != UNIT_TARGET)
865 /* Only add the dependency if both units are loaded, so that
866 * that loop check below is reliable */
867 if (u->load_state != UNIT_LOADED ||
868 target->load_state != UNIT_LOADED)
871 /* If either side wants no automatic dependencies, then let's
873 if (!u->default_dependencies ||
874 !target->default_dependencies)
877 /* Don't create loops */
878 if (set_get(target->dependencies[UNIT_BEFORE], u))
881 return unit_add_dependency(target, UNIT_AFTER, u, true);
884 static int unit_add_default_dependencies(Unit *u) {
886 static const UnitDependency deps[] = {
888 UNIT_REQUIRED_BY_OVERRIDABLE,
900 for (k = 0; k < ELEMENTSOF(deps); k++)
901 SET_FOREACH(target, u->dependencies[deps[k]], i) {
902 r = unit_add_default_target_dependency(u, target);
907 if (u->default_dependencies && unit_get_cgroup_context(u)) {
908 if (UNIT_ISSET(u->slice))
909 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
911 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
920 int unit_load(Unit *u) {
925 if (u->in_load_queue) {
926 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
927 u->in_load_queue = false;
930 if (u->type == _UNIT_TYPE_INVALID)
933 if (u->load_state != UNIT_STUB)
936 if (UNIT_VTABLE(u)->load) {
937 r = UNIT_VTABLE(u)->load(u);
942 if (u->load_state == UNIT_STUB) {
947 if (u->load_state == UNIT_LOADED) {
949 if (u->default_dependencies) {
950 r = unit_add_default_dependencies(u);
955 r = unit_add_mount_links(u);
959 if (u->on_failure_isolate &&
960 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
962 log_error_unit(u->id,
963 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
970 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
972 unit_add_to_dbus_queue(unit_follow_merge(u));
973 unit_add_to_gc_queue(u);
978 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
980 unit_add_to_dbus_queue(u);
981 unit_add_to_gc_queue(u);
983 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
984 u->id, strerror(-r));
989 bool unit_condition_test(Unit *u) {
992 dual_timestamp_get(&u->condition_timestamp);
993 u->condition_result = condition_test_list(u->conditions);
995 return u->condition_result;
998 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
999 const UnitStatusMessageFormats *format_table;
1003 assert(t < _JOB_TYPE_MAX);
1005 if (t != JOB_START && t != JOB_STOP)
1008 format_table = &UNIT_VTABLE(u)->status_message_formats;
1012 return format_table->starting_stopping[t == JOB_STOP];
1015 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1020 assert(t < _JOB_TYPE_MAX);
1022 format = unit_get_status_message_format(u, t);
1026 /* Return generic strings */
1028 return "Starting %s.";
1029 else if (t == JOB_STOP)
1030 return "Stopping %s.";
1031 else if (t == JOB_RELOAD)
1032 return "Reloading %s.";
1037 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1042 /* We only print status messages for selected units on
1043 * selected operations. */
1045 format = unit_get_status_message_format(u, t);
1049 unit_status_printf(u, "", format);
1052 #pragma GCC diagnostic push
1053 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1054 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1061 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1064 if (log_on_console())
1067 /* We log status messages for all units and all operations. */
1069 format = unit_get_status_message_format_try_harder(u, t);
1073 snprintf(buf, sizeof(buf), format, unit_description(u));
1076 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1077 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1078 SD_MESSAGE_UNIT_RELOADING;
1080 log_struct_unit(LOG_INFO,
1086 #pragma GCC diagnostic pop
1089 * -EBADR: This unit type does not support starting.
1090 * -EALREADY: Unit is already started.
1091 * -EAGAIN: An operation is already in progress. Retry later.
1092 * -ECANCELED: Too many requests for now.
1094 int unit_start(Unit *u) {
1095 UnitActiveState state;
1100 if (u->load_state != UNIT_LOADED)
1103 /* If this is already started, then this will succeed. Note
1104 * that this will even succeed if this unit is not startable
1105 * by the user. This is relied on to detect when we need to
1106 * wait for units and when waiting is finished. */
1107 state = unit_active_state(u);
1108 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1111 /* If the conditions failed, don't do anything at all. If we
1112 * already are activating this call might still be useful to
1113 * speed up activation in case there is some hold-off time,
1114 * but we don't want to recheck the condition in that case. */
1115 if (state != UNIT_ACTIVATING &&
1116 !unit_condition_test(u)) {
1117 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1121 /* Forward to the main object, if we aren't it. */
1122 if ((following = unit_following(u))) {
1123 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1124 u->id, following->id);
1125 return unit_start(following);
1128 unit_status_log_starting_stopping_reloading(u, JOB_START);
1129 unit_status_print_starting_stopping(u, JOB_START);
1131 /* If it is stopped, but we cannot start it, then fail */
1132 if (!UNIT_VTABLE(u)->start)
1135 /* We don't suppress calls to ->start() here when we are
1136 * already starting, to allow this request to be used as a
1137 * "hurry up" call, for example when the unit is in some "auto
1138 * restart" state where it waits for a holdoff timer to elapse
1139 * before it will start again. */
1141 unit_add_to_dbus_queue(u);
1143 return UNIT_VTABLE(u)->start(u);
1146 bool unit_can_start(Unit *u) {
1149 return !!UNIT_VTABLE(u)->start;
1152 bool unit_can_isolate(Unit *u) {
1155 return unit_can_start(u) &&
1160 * -EBADR: This unit type does not support stopping.
1161 * -EALREADY: Unit is already stopped.
1162 * -EAGAIN: An operation is already in progress. Retry later.
1164 int unit_stop(Unit *u) {
1165 UnitActiveState state;
1170 state = unit_active_state(u);
1171 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1174 if ((following = unit_following(u))) {
1175 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1176 u->id, following->id);
1177 return unit_stop(following);
1180 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1181 unit_status_print_starting_stopping(u, JOB_STOP);
1183 if (!UNIT_VTABLE(u)->stop)
1186 unit_add_to_dbus_queue(u);
1188 return UNIT_VTABLE(u)->stop(u);
1192 * -EBADR: This unit type does not support reloading.
1193 * -ENOEXEC: Unit is not started.
1194 * -EAGAIN: An operation is already in progress. Retry later.
1196 int unit_reload(Unit *u) {
1197 UnitActiveState state;
1202 if (u->load_state != UNIT_LOADED)
1205 if (!unit_can_reload(u))
1208 state = unit_active_state(u);
1209 if (state == UNIT_RELOADING)
1212 if (state != UNIT_ACTIVE)
1215 if ((following = unit_following(u))) {
1216 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1217 u->id, following->id);
1218 return unit_reload(following);
1221 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1223 unit_add_to_dbus_queue(u);
1224 return UNIT_VTABLE(u)->reload(u);
1227 bool unit_can_reload(Unit *u) {
1230 if (!UNIT_VTABLE(u)->reload)
1233 if (!UNIT_VTABLE(u)->can_reload)
1236 return UNIT_VTABLE(u)->can_reload(u);
1239 static void unit_check_unneeded(Unit *u) {
1245 /* If this service shall be shut down when unneeded then do
1248 if (!u->stop_when_unneeded)
1251 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1254 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1255 if (unit_active_or_pending(other))
1258 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1259 if (unit_active_or_pending(other))
1262 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1263 if (unit_active_or_pending(other))
1266 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1267 if (unit_active_or_pending(other))
1270 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1272 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1273 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1276 static void retroactively_start_dependencies(Unit *u) {
1281 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1283 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1284 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1285 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1286 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1288 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1289 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1290 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1291 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1293 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1294 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1295 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1296 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1298 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1299 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1300 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1301 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1303 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1304 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1305 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1307 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1308 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1309 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1312 static void retroactively_stop_dependencies(Unit *u) {
1317 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1319 /* Pull down units which are bound to us recursively if enabled */
1320 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1321 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1322 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1325 static void check_unneeded_dependencies(Unit *u) {
1330 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1332 /* Garbage collect services that might not be needed anymore, if enabled */
1333 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1334 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1335 unit_check_unneeded(other);
1336 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1337 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1338 unit_check_unneeded(other);
1339 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1340 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1341 unit_check_unneeded(other);
1342 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1343 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1344 unit_check_unneeded(other);
1345 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1346 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1347 unit_check_unneeded(other);
1348 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1349 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1350 unit_check_unneeded(other);
1353 void unit_start_on_failure(Unit *u) {
1359 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1362 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1364 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1367 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1369 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1373 void unit_trigger_notify(Unit *u) {
1379 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1380 if (UNIT_VTABLE(other)->trigger_notify)
1381 UNIT_VTABLE(other)->trigger_notify(other, u);
1384 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1389 assert(os < _UNIT_ACTIVE_STATE_MAX);
1390 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1392 /* Note that this is called for all low-level state changes,
1393 * even if they might map to the same high-level
1394 * UnitActiveState! That means that ns == os is OK an expected
1395 * behavior here. For example: if a mount point is remounted
1396 * this function will be called too! */
1400 if (m->n_reloading <= 0) {
1403 dual_timestamp_get(&ts);
1405 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1406 u->inactive_exit_timestamp = ts;
1407 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1408 u->inactive_enter_timestamp = ts;
1410 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1411 u->active_enter_timestamp = ts;
1412 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1413 u->active_exit_timestamp = ts;
1416 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1417 unit_destroy_cgroup(u);
1419 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1420 ExecContext *ec = unit_get_exec_context(u);
1421 if (ec && exec_context_may_touch_console(ec)) {
1422 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1432 if (u->job->state == JOB_WAITING)
1434 /* So we reached a different state for this
1435 * job. Let's see if we can run it now if it
1436 * failed previously due to EAGAIN. */
1437 job_add_to_run_queue(u->job);
1439 /* Let's check whether this state change constitutes a
1440 * finished job, or maybe contradicts a running job and
1441 * hence needs to invalidate jobs. */
1443 switch (u->job->type) {
1446 case JOB_VERIFY_ACTIVE:
1448 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1449 job_finish_and_invalidate(u->job, JOB_DONE, true);
1450 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1453 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1454 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1460 case JOB_RELOAD_OR_START:
1462 if (u->job->state == JOB_RUNNING) {
1463 if (ns == UNIT_ACTIVE)
1464 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1465 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1468 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1469 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1477 case JOB_TRY_RESTART:
1479 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1480 job_finish_and_invalidate(u->job, JOB_DONE, true);
1481 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1483 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1489 assert_not_reached("Job type unknown");
1495 if (m->n_reloading <= 0) {
1497 /* If this state change happened without being
1498 * requested by a job, then let's retroactively start
1499 * or stop dependencies. We skip that step when
1500 * deserializing, since we don't want to create any
1501 * additional jobs just because something is already
1505 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1506 retroactively_start_dependencies(u);
1507 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1508 retroactively_stop_dependencies(u);
1511 /* stop unneeded units regardless if going down was expected or not */
1512 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1513 check_unneeded_dependencies(u);
1515 if (ns != os && ns == UNIT_FAILED) {
1516 log_notice_unit(u->id,
1517 "Unit %s entered failed state.", u->id);
1518 unit_start_on_failure(u);
1522 /* Some names are special */
1523 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1525 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1526 /* The bus just might have become available,
1527 * hence try to connect to it, if we aren't
1531 if (u->type == UNIT_SERVICE &&
1532 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1533 m->n_reloading <= 0) {
1534 /* Write audit record if we have just finished starting up */
1535 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1539 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1540 manager_send_unit_plymouth(m, u);
1544 /* We don't care about D-Bus here, since we'll get an
1545 * asynchronous notification for it anyway. */
1547 if (u->type == UNIT_SERVICE &&
1548 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1549 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1550 m->n_reloading <= 0) {
1552 /* Hmm, if there was no start record written
1553 * write it now, so that we always have a nice
1556 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1558 if (ns == UNIT_INACTIVE)
1559 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1561 /* Write audit record if we have just finished shutting down */
1562 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1564 u->in_audit = false;
1568 manager_recheck_journal(m);
1569 unit_trigger_notify(u);
1571 /* Maybe we finished startup and are now ready for being
1572 * stopped because unneeded? */
1573 if (u->manager->n_reloading <= 0)
1574 unit_check_unneeded(u);
1576 unit_add_to_dbus_queue(u);
1577 unit_add_to_gc_queue(u);
1580 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1581 struct epoll_event ev = {
1589 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1591 if (epoll_ctl(u->manager->epoll_fd,
1592 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1604 void unit_unwatch_fd(Unit *u, Watch *w) {
1608 if (w->type == WATCH_INVALID)
1611 assert(w->type == WATCH_FD);
1612 assert(w->data.unit == u);
1613 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1616 w->type = WATCH_INVALID;
1617 w->data.unit = NULL;
1620 int unit_watch_pid(Unit *u, pid_t pid) {
1624 /* Watch a specific PID. We only support one unit watching
1625 * each PID for now. */
1627 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1630 void unit_unwatch_pid(Unit *u, pid_t pid) {
1634 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1637 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1638 struct itimerspec its = {};
1644 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1646 /* This will try to reuse the old timer if there is one */
1648 if (w->type == WATCH_UNIT_TIMER) {
1649 assert(w->data.unit == u);
1654 } else if (w->type == WATCH_INVALID) {
1657 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1661 assert_not_reached("Invalid watch type");
1664 /* Set absolute time in the past, but not 0, since we
1665 * don't want to disarm the timer */
1666 its.it_value.tv_sec = 0;
1667 its.it_value.tv_nsec = 1;
1669 flags = TFD_TIMER_ABSTIME;
1671 timespec_store(&its.it_value, usec);
1672 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1675 /* This will also flush the elapse counter */
1676 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1679 if (w->type == WATCH_INVALID) {
1680 struct epoll_event ev = {
1685 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1689 w->type = WATCH_UNIT_TIMER;
1697 close_nointr_nofail(fd);
1702 void unit_unwatch_timer(Unit *u, Watch *w) {
1706 if (w->type == WATCH_INVALID)
1709 assert(w->type == WATCH_UNIT_TIMER);
1710 assert(w->data.unit == u);
1713 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1714 close_nointr_nofail(w->fd);
1717 w->type = WATCH_INVALID;
1718 w->data.unit = NULL;
1721 bool unit_job_is_applicable(Unit *u, JobType j) {
1723 assert(j >= 0 && j < _JOB_TYPE_MAX);
1727 case JOB_VERIFY_ACTIVE:
1734 case JOB_TRY_RESTART:
1735 return unit_can_start(u);
1738 return unit_can_reload(u);
1740 case JOB_RELOAD_OR_START:
1741 return unit_can_reload(u) && unit_can_start(u);
1744 assert_not_reached("Invalid job type");
1748 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1750 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1751 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1752 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1753 [UNIT_WANTS] = UNIT_WANTED_BY,
1754 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1755 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1756 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1757 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1758 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1759 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1760 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1761 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1762 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1763 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1764 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1765 [UNIT_BEFORE] = UNIT_AFTER,
1766 [UNIT_AFTER] = UNIT_BEFORE,
1767 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1768 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1769 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1770 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1771 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1772 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1773 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1775 int r, q = 0, v = 0, w = 0;
1778 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1781 u = unit_follow_merge(u);
1782 other = unit_follow_merge(other);
1784 /* We won't allow dependencies on ourselves. We will not
1785 * consider them an error however. */
1789 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1792 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1793 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1797 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1798 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1801 if ((q = set_put(u->dependencies[d], other)) < 0)
1804 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1805 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1810 if (add_reference) {
1811 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1816 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1820 unit_add_to_dbus_queue(u);
1825 set_remove(u->dependencies[d], other);
1828 set_remove(other->dependencies[inverse_table[d]], u);
1831 set_remove(u->dependencies[UNIT_REFERENCES], other);
1836 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1841 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1844 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1850 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1854 assert(name || path);
1858 name = path_get_file_name(path);
1860 if (!unit_name_is_template(name)) {
1866 s = unit_name_replace_instance(name, u->instance);
1868 _cleanup_free_ char *i = NULL;
1870 i = unit_name_to_prefix(u->id);
1874 s = unit_name_replace_instance(name, i);
1884 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1887 _cleanup_free_ char *s = NULL;
1890 assert(name || path);
1892 name = resolve_template(u, name, path, &s);
1896 r = manager_load_unit(u->manager, name, path, NULL, &other);
1900 return unit_add_dependency(u, d, other, add_reference);
1903 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1909 assert(name || path);
1911 if (!(name = resolve_template(u, name, path, &s)))
1914 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1917 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1924 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1930 assert(name || path);
1932 if (!(name = resolve_template(u, name, path, &s)))
1935 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1938 r = unit_add_dependency(other, d, u, add_reference);
1945 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1951 assert(name || path);
1953 if (!(name = resolve_template(u, name, path, &s)))
1956 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1959 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1967 int set_unit_path(const char *p) {
1968 _cleanup_free_ char *c = NULL;
1970 /* This is mostly for debug purposes */
1971 c = path_make_absolute_cwd(p);
1972 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1978 char *unit_dbus_path(Unit *u) {
1984 return unit_dbus_path_from_name(u->id);
1987 char *unit_default_cgroup_path(Unit *u) {
1988 _cleanup_free_ char *escaped_instance = NULL, *slice = NULL;
1993 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1994 return strdup(u->manager->cgroup_root);
1996 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1997 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2002 escaped_instance = cg_escape(u->id);
2003 if (!escaped_instance)
2007 _cleanup_free_ char *t = NULL, *escaped_template = NULL;
2009 t = unit_name_template(u->id);
2013 escaped_template = cg_escape(t);
2014 if (!escaped_template)
2017 return strjoin(u->manager->cgroup_root, "/",
2018 slice ? slice : "", slice ? "/" : "",
2019 escaped_template, "/", escaped_instance, NULL);
2021 return strjoin(u->manager->cgroup_root, "/",
2022 slice ? slice : "", slice ? "/" : "",
2023 escaped_instance, NULL);
2026 int unit_add_default_slice(Unit *u) {
2032 if (UNIT_ISSET(u->slice))
2035 if (!unit_get_cgroup_context(u))
2038 r = manager_load_unit(u->manager, u->manager->running_as == SYSTEMD_SYSTEM ? SPECIAL_SYSTEM_SLICE : SPECIAL_ROOT_SLICE, NULL, NULL, &slice);
2042 unit_ref_set(&u->slice, slice);
2046 const char *unit_slice_name(Unit *u) {
2049 if (!UNIT_ISSET(u->slice))
2052 return UNIT_DEREF(u->slice)->id;
2055 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2056 _cleanup_free_ char *t = NULL;
2063 t = unit_name_change_suffix(u->id, type);
2067 assert(!unit_has_name(u, t));
2069 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2070 assert(r < 0 || *_found != u);
2074 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2075 _cleanup_free_ char *t = NULL;
2082 t = unit_name_change_suffix(u->id, type);
2086 assert(!unit_has_name(u, t));
2088 found = manager_get_unit(u->manager, t);
2096 int unit_watch_bus_name(Unit *u, const char *name) {
2100 /* Watch a specific name on the bus. We only support one unit
2101 * watching each name for now. */
2103 return hashmap_put(u->manager->watch_bus, name, u);
2106 void unit_unwatch_bus_name(Unit *u, const char *name) {
2110 hashmap_remove_value(u->manager->watch_bus, name, u);
2113 bool unit_can_serialize(Unit *u) {
2116 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2119 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2126 if (!unit_can_serialize(u))
2129 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2133 if (serialize_jobs) {
2135 fprintf(f, "job\n");
2136 job_serialize(u->job, f, fds);
2140 fprintf(f, "job\n");
2141 job_serialize(u->nop_job, f, fds);
2145 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2146 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2147 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2148 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2149 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2151 if (dual_timestamp_is_set(&u->condition_timestamp))
2152 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2154 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2157 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2164 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2175 va_start(ap, format);
2176 vfprintf(f, format, ap);
2182 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2188 fprintf(f, "%s=%s\n", key, value);
2191 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2198 if (!unit_can_serialize(u))
2202 char line[LINE_MAX], *l, *v;
2205 if (!fgets(line, sizeof(line), f)) {
2218 k = strcspn(l, "=");
2226 if (streq(l, "job")) {
2228 /* new-style serialized job */
2229 Job *j = job_new_raw(u);
2233 r = job_deserialize(j, f, fds);
2239 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2245 r = job_install_deserialized(j);
2247 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2252 if (j->state == JOB_RUNNING)
2253 u->manager->n_running_jobs++;
2256 JobType type = job_type_from_string(v);
2258 log_debug("Failed to parse job type value %s", v);
2260 u->deserialized_job = type;
2263 } else if (streq(l, "inactive-exit-timestamp")) {
2264 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2266 } else if (streq(l, "active-enter-timestamp")) {
2267 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2269 } else if (streq(l, "active-exit-timestamp")) {
2270 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2272 } else if (streq(l, "inactive-enter-timestamp")) {
2273 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2275 } else if (streq(l, "condition-timestamp")) {
2276 dual_timestamp_deserialize(v, &u->condition_timestamp);
2278 } else if (streq(l, "condition-result")) {
2281 b = parse_boolean(v);
2283 log_debug("Failed to parse condition result value %s", v);
2285 u->condition_result = b;
2289 } else if (streq(l, "transient")) {
2292 b = parse_boolean(v);
2294 log_debug("Failed to parse transient bool %s", v);
2299 } else if (streq(l, "cgroup")) {
2306 free(u->cgroup_path);
2311 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2317 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2327 /* Adds in links to the device node that this unit is based on */
2329 if (!is_device_path(what))
2332 e = unit_name_from_path(what, ".device");
2336 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2341 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2346 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2354 int unit_coldplug(Unit *u) {
2359 if (UNIT_VTABLE(u)->coldplug)
2360 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2364 r = job_coldplug(u->job);
2367 } else if (u->deserialized_job >= 0) {
2369 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2373 u->deserialized_job = _JOB_TYPE_INVALID;
2379 #pragma GCC diagnostic push
2380 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2381 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2382 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2384 #pragma GCC diagnostic pop
2386 bool unit_need_daemon_reload(Unit *u) {
2387 _cleanup_strv_free_ char **t = NULL;
2390 unsigned loaded_cnt, current_cnt;
2394 if (u->fragment_path) {
2396 if (stat(u->fragment_path, &st) < 0)
2397 /* What, cannot access this anymore? */
2400 if (u->fragment_mtime > 0 &&
2401 timespec_load(&st.st_mtim) != u->fragment_mtime)
2405 if (u->source_path) {
2407 if (stat(u->source_path, &st) < 0)
2410 if (u->source_mtime > 0 &&
2411 timespec_load(&st.st_mtim) != u->source_mtime)
2415 t = unit_find_dropin_paths(u);
2416 loaded_cnt = strv_length(t);
2417 current_cnt = strv_length(u->dropin_paths);
2419 if (loaded_cnt == current_cnt) {
2420 if (loaded_cnt == 0)
2423 if (strv_overlap(u->dropin_paths, t)) {
2424 STRV_FOREACH(path, u->dropin_paths) {
2426 if (stat(*path, &st) < 0)
2429 if (u->dropin_mtime > 0 &&
2430 timespec_load(&st.st_mtim) > u->dropin_mtime)
2441 void unit_reset_failed(Unit *u) {
2444 if (UNIT_VTABLE(u)->reset_failed)
2445 UNIT_VTABLE(u)->reset_failed(u);
2448 Unit *unit_following(Unit *u) {
2451 if (UNIT_VTABLE(u)->following)
2452 return UNIT_VTABLE(u)->following(u);
2457 bool unit_stop_pending(Unit *u) {
2460 /* This call does check the current state of the unit. It's
2461 * hence useful to be called from state change calls of the
2462 * unit itself, where the state isn't updated yet. This is
2463 * different from unit_inactive_or_pending() which checks both
2464 * the current state and for a queued job. */
2466 return u->job && u->job->type == JOB_STOP;
2469 bool unit_inactive_or_pending(Unit *u) {
2472 /* Returns true if the unit is inactive or going down */
2474 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2477 if (unit_stop_pending(u))
2483 bool unit_active_or_pending(Unit *u) {
2486 /* Returns true if the unit is active or going up */
2488 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2492 (u->job->type == JOB_START ||
2493 u->job->type == JOB_RELOAD_OR_START ||
2494 u->job->type == JOB_RESTART))
2500 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2502 assert(w >= 0 && w < _KILL_WHO_MAX);
2504 assert(signo < _NSIG);
2506 if (!UNIT_VTABLE(u)->kill)
2509 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2512 int unit_kill_common(
2522 if (who == KILL_MAIN && main_pid <= 0) {
2524 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2526 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2530 if (who == KILL_CONTROL && control_pid <= 0) {
2531 if (control_pid < 0)
2532 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2534 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2538 if (who == KILL_CONTROL || who == KILL_ALL)
2539 if (control_pid > 0)
2540 if (kill(control_pid, signo) < 0)
2543 if (who == KILL_MAIN || who == KILL_ALL)
2545 if (kill(main_pid, signo) < 0)
2548 if (who == KILL_ALL && u->cgroup_path) {
2549 _cleanup_set_free_ Set *pid_set = NULL;
2552 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2556 /* Exclude the control/main pid from being killed via the cgroup */
2557 if (control_pid > 0) {
2558 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2564 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2569 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2570 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2577 int unit_following_set(Unit *u, Set **s) {
2581 if (UNIT_VTABLE(u)->following_set)
2582 return UNIT_VTABLE(u)->following_set(u, s);
2588 UnitFileState unit_get_unit_file_state(Unit *u) {
2591 if (u->unit_file_state < 0 && u->fragment_path)
2592 u->unit_file_state = unit_file_get_state(
2593 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2594 NULL, path_get_file_name(u->fragment_path));
2596 return u->unit_file_state;
2599 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2604 unit_ref_unset(ref);
2607 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2611 void unit_ref_unset(UnitRef *ref) {
2617 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2621 int unit_add_one_mount_link(Unit *u, Mount *m) {
2627 if (u->load_state != UNIT_LOADED ||
2628 UNIT(m)->load_state != UNIT_LOADED)
2631 STRV_FOREACH(i, u->requires_mounts_for) {
2636 if (!path_startswith(*i, m->where))
2639 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2645 int unit_add_mount_links(Unit *u) {
2651 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2652 r = unit_add_one_mount_link(u, MOUNT(other));
2660 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2667 /* This only copies in the ones that need memory */
2668 for (i = 0; i < RLIMIT_NLIMITS; i++)
2669 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2670 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2675 if (u->manager->running_as == SYSTEMD_USER &&
2676 !c->working_directory) {
2678 r = get_home_dir(&c->working_directory);
2686 ExecContext *unit_get_exec_context(Unit *u) {
2690 offset = UNIT_VTABLE(u)->exec_context_offset;
2694 return (ExecContext*) ((uint8_t*) u + offset);
2697 CGroupContext *unit_get_cgroup_context(Unit *u) {
2700 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2704 return (CGroupContext*) ((uint8_t*) u + offset);
2707 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2715 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2717 if (!filename_is_safe(name))
2720 if (u->manager->running_as == SYSTEMD_USER) {
2721 _cleanup_free_ char *c = NULL;
2723 r = user_config_home(&c);
2729 p = strjoin(c, "/", u->id, ".d", NULL);
2730 } else if (mode & UNIT_PERSISTENT)
2731 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2733 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2737 q = strjoin(p, "/90-", name, ".conf", NULL);
2748 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2749 _cleanup_free_ char *p = NULL, *q = NULL;
2756 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2759 r = drop_in_file(u, mode, name, &p, &q);
2764 return write_string_file_atomic_label(q, data);
2767 int unit_write_drop_in_private_section(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2768 _cleanup_free_ char *ndata = NULL;
2774 if (!UNIT_VTABLE(u)->private_section)
2777 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2781 return unit_write_drop_in(u, mode, name, ndata);
2784 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2785 _cleanup_free_ char *p = NULL, *q = NULL;
2790 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2793 r = drop_in_file(u, mode, name, &p, &q);
2795 r = errno == ENOENT ? 0 : -errno;
2803 int unit_make_transient(Unit *u) {
2808 u->load_state = UNIT_STUB;
2810 u->transient = true;
2812 free(u->fragment_path);
2813 u->fragment_path = NULL;
2815 if (u->manager->running_as == SYSTEMD_USER) {
2816 _cleanup_free_ char *c = NULL;
2818 r = user_config_home(&c);
2824 u->fragment_path = strjoin(c, "/", u->id, NULL);
2825 if (!u->fragment_path)
2830 u->fragment_path = strappend("/run/systemd/system/", u->id);
2831 if (!u->fragment_path)
2834 mkdir_p("/run/systemd/system", 0755);
2837 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2840 int unit_kill_context(
2846 bool main_pid_alien) {
2848 int sig, wait_for_exit = 0, r;
2853 if (c->kill_mode == KILL_NONE)
2856 sig = sigkill ? SIGKILL : c->kill_signal;
2859 r = kill_and_sigcont(main_pid, sig);
2861 if (r < 0 && r != -ESRCH) {
2862 _cleanup_free_ char *comm = NULL;
2863 get_process_comm(main_pid, &comm);
2865 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2866 (long) main_pid, strna(comm), strerror(-r));
2868 wait_for_exit = !main_pid_alien;
2871 if (control_pid > 0) {
2872 r = kill_and_sigcont(control_pid, sig);
2874 if (r < 0 && r != -ESRCH) {
2875 _cleanup_free_ char *comm = NULL;
2876 get_process_comm(control_pid, &comm);
2878 log_warning_unit(u->id,
2879 "Failed to kill control process %li (%s): %s",
2880 (long) control_pid, strna(comm), strerror(-r));
2882 wait_for_exit = true;
2885 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2886 _cleanup_set_free_ Set *pid_set = NULL;
2888 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2892 /* Exclude the main/control pids from being killed via the cgroup */
2894 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2899 if (control_pid > 0) {
2900 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2905 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2907 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2908 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2910 wait_for_exit = true;
2913 return wait_for_exit;
2916 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2917 [UNIT_ACTIVE] = "active",
2918 [UNIT_RELOADING] = "reloading",
2919 [UNIT_INACTIVE] = "inactive",
2920 [UNIT_FAILED] = "failed",
2921 [UNIT_ACTIVATING] = "activating",
2922 [UNIT_DEACTIVATING] = "deactivating"
2925 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2927 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2928 [UNIT_REQUIRES] = "Requires",
2929 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2930 [UNIT_REQUISITE] = "Requisite",
2931 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2932 [UNIT_WANTS] = "Wants",
2933 [UNIT_BINDS_TO] = "BindsTo",
2934 [UNIT_PART_OF] = "PartOf",
2935 [UNIT_REQUIRED_BY] = "RequiredBy",
2936 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2937 [UNIT_WANTED_BY] = "WantedBy",
2938 [UNIT_BOUND_BY] = "BoundBy",
2939 [UNIT_CONSISTS_OF] = "ConsistsOf",
2940 [UNIT_CONFLICTS] = "Conflicts",
2941 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2942 [UNIT_BEFORE] = "Before",
2943 [UNIT_AFTER] = "After",
2944 [UNIT_ON_FAILURE] = "OnFailure",
2945 [UNIT_TRIGGERS] = "Triggers",
2946 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2947 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2948 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2949 [UNIT_REFERENCES] = "References",
2950 [UNIT_REFERENCED_BY] = "ReferencedBy",
2953 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);