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
66 Unit *unit_new(Manager *m, size_t size) {
70 assert(size >= sizeof(Unit));
76 u->names = set_new(string_hash_func, string_compare_func);
83 u->type = _UNIT_TYPE_INVALID;
84 u->deserialized_job = _JOB_TYPE_INVALID;
85 u->default_dependencies = true;
86 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
91 bool unit_has_name(Unit *u, const char *name) {
95 return !!set_get(u->names, (char*) name);
98 int unit_add_name(Unit *u, const char *text) {
106 if (unit_name_is_template(text)) {
110 s = unit_name_replace_instance(text, u->instance);
117 if (!unit_name_is_valid(s, false)) {
122 assert_se((t = unit_name_to_type(s)) >= 0);
124 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
129 if ((r = unit_name_to_instance(s, &i)) < 0)
132 if (i && unit_vtable[t]->no_instances) {
137 /* Ensure that this unit is either instanced or not instanced,
139 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
144 if (unit_vtable[t]->no_alias &&
145 !set_isempty(u->names) &&
146 !set_get(u->names, s)) {
151 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
156 if ((r = set_put(u->names, s)) < 0) {
162 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
163 set_remove(u->names, s);
167 if (u->type == _UNIT_TYPE_INVALID) {
173 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
175 if (UNIT_VTABLE(u)->init)
176 UNIT_VTABLE(u)->init(u);
180 unit_add_to_dbus_queue(u);
190 int unit_choose_id(Unit *u, const char *name) {
191 char *s, *t = NULL, *i;
197 if (unit_name_is_template(name)) {
202 if (!(t = unit_name_replace_instance(name, u->instance)))
208 /* Selects one of the names of this unit as the id */
209 s = set_get(u->names, (char*) name);
215 if ((r = unit_name_to_instance(s, &i)) < 0)
223 unit_add_to_dbus_queue(u);
228 int unit_set_description(Unit *u, const char *description) {
233 if (!(s = strdup(description)))
236 free(u->description);
239 unit_add_to_dbus_queue(u);
243 bool unit_check_gc(Unit *u) {
246 if (u->load_state == UNIT_STUB)
249 if (UNIT_VTABLE(u)->no_gc)
261 if (unit_active_state(u) != UNIT_INACTIVE)
267 if (UNIT_VTABLE(u)->check_gc)
268 if (UNIT_VTABLE(u)->check_gc(u))
274 void unit_add_to_load_queue(Unit *u) {
276 assert(u->type != _UNIT_TYPE_INVALID);
278 if (u->load_state != UNIT_STUB || u->in_load_queue)
281 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
282 u->in_load_queue = true;
285 void unit_add_to_cleanup_queue(Unit *u) {
288 if (u->in_cleanup_queue)
291 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
292 u->in_cleanup_queue = true;
295 void unit_add_to_gc_queue(Unit *u) {
298 if (u->in_gc_queue || u->in_cleanup_queue)
301 if (unit_check_gc(u))
304 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
305 u->in_gc_queue = true;
307 u->manager->n_in_gc_queue ++;
309 if (u->manager->gc_queue_timestamp <= 0)
310 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
313 void unit_add_to_dbus_queue(Unit *u) {
315 assert(u->type != _UNIT_TYPE_INVALID);
317 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
320 /* Shortcut things if nobody cares */
321 if (!bus_has_subscriber(u->manager)) {
322 u->sent_dbus_new_signal = true;
326 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
327 u->in_dbus_queue = true;
330 static void bidi_set_free(Unit *u, Set *s) {
336 /* Frees the set and makes sure we are dropped from the
337 * inverse pointers */
339 SET_FOREACH(other, s, i) {
342 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
343 set_remove(other->dependencies[d], u);
345 unit_add_to_gc_queue(other);
351 static void unit_remove_transient(Unit *u) {
359 if (u->fragment_path)
360 unlink(u->fragment_path);
362 STRV_FOREACH(i, u->dropin_paths) {
363 _cleanup_free_ char *p = NULL;
368 r = path_get_parent(*i, &p);
374 void unit_free(Unit *u) {
381 if (u->manager->n_reloading <= 0)
382 unit_remove_transient(u);
384 bus_unit_send_removed_signal(u);
386 if (u->load_state != UNIT_STUB)
387 if (UNIT_VTABLE(u)->done)
388 UNIT_VTABLE(u)->done(u);
390 SET_FOREACH(t, u->names, i)
391 hashmap_remove_value(u->manager->units, t, u);
405 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
406 bidi_set_free(u, u->dependencies[d]);
408 if (u->requires_mounts_for) {
409 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
410 strv_free(u->requires_mounts_for);
413 if (u->type != _UNIT_TYPE_INVALID)
414 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
416 if (u->in_load_queue)
417 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
419 if (u->in_dbus_queue)
420 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
422 if (u->in_cleanup_queue)
423 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
425 if (u->in_gc_queue) {
426 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
427 u->manager->n_in_gc_queue--;
430 if (u->in_cgroup_queue)
431 LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
433 free(u->cgroup_path);
434 free(u->description);
435 strv_free(u->documentation);
436 free(u->fragment_path);
437 free(u->source_path);
438 strv_free(u->dropin_paths);
441 set_free_free(u->names);
443 condition_free_list(u->conditions);
445 unit_ref_unset(&u->slice);
448 unit_ref_unset(u->refs);
453 UnitActiveState unit_active_state(Unit *u) {
456 if (u->load_state == UNIT_MERGED)
457 return unit_active_state(unit_follow_merge(u));
459 /* After a reload it might happen that a unit is not correctly
460 * loaded but still has a process around. That's why we won't
461 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
463 return UNIT_VTABLE(u)->active_state(u);
466 const char* unit_sub_state_to_string(Unit *u) {
469 return UNIT_VTABLE(u)->sub_state_to_string(u);
472 static void complete_move(Set **s, Set **other) {
480 set_move(*s, *other);
487 static void merge_names(Unit *u, Unit *other) {
494 complete_move(&u->names, &other->names);
496 set_free_free(other->names);
500 SET_FOREACH(t, u->names, i)
501 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
504 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
511 assert(d < _UNIT_DEPENDENCY_MAX);
513 /* Fix backwards pointers */
514 SET_FOREACH(back, other->dependencies[d], i) {
517 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
518 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
521 set_remove(back->dependencies[k], other);
523 assert(r == -ENOENT);
527 complete_move(&u->dependencies[d], &other->dependencies[d]);
529 set_free(other->dependencies[d]);
530 other->dependencies[d] = NULL;
533 int unit_merge(Unit *u, Unit *other) {
538 assert(u->manager == other->manager);
539 assert(u->type != _UNIT_TYPE_INVALID);
541 other = unit_follow_merge(other);
546 if (u->type != other->type)
549 if (!u->instance != !other->instance)
552 if (other->load_state != UNIT_STUB &&
553 other->load_state != UNIT_NOT_FOUND)
562 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
566 merge_names(u, other);
568 /* Redirect all references */
570 unit_ref_set(other->refs, u);
572 /* Merge dependencies */
573 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
574 merge_dependencies(u, other, d);
576 other->load_state = UNIT_MERGED;
577 other->merged_into = u;
579 /* If there is still some data attached to the other node, we
580 * don't need it anymore, and can free it. */
581 if (other->load_state != UNIT_STUB)
582 if (UNIT_VTABLE(other)->done)
583 UNIT_VTABLE(other)->done(other);
585 unit_add_to_dbus_queue(u);
586 unit_add_to_cleanup_queue(other);
591 int unit_merge_by_name(Unit *u, const char *name) {
599 if (unit_name_is_template(name)) {
603 if (!(s = unit_name_replace_instance(name, u->instance)))
609 other = manager_get_unit(u->manager, name);
611 r = unit_add_name(u, name);
613 r = unit_merge(u, other);
619 Unit* unit_follow_merge(Unit *u) {
622 while (u->load_state == UNIT_MERGED)
623 assert_se(u = u->merged_into);
628 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
634 if (c->std_output != EXEC_OUTPUT_KMSG &&
635 c->std_output != EXEC_OUTPUT_SYSLOG &&
636 c->std_output != EXEC_OUTPUT_JOURNAL &&
637 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
638 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
639 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
640 c->std_error != EXEC_OUTPUT_KMSG &&
641 c->std_error != EXEC_OUTPUT_SYSLOG &&
642 c->std_error != EXEC_OUTPUT_JOURNAL &&
643 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
644 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
645 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
648 /* If syslog or kernel logging is requested, make sure our own
649 * logging daemon is run first. */
651 if (u->manager->running_as == SYSTEMD_SYSTEM) {
652 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
660 const char *unit_description(Unit *u) {
664 return u->description;
669 void unit_dump(Unit *u, FILE *f, const char *prefix) {
676 timestamp1[FORMAT_TIMESTAMP_MAX],
677 timestamp2[FORMAT_TIMESTAMP_MAX],
678 timestamp3[FORMAT_TIMESTAMP_MAX],
679 timestamp4[FORMAT_TIMESTAMP_MAX],
680 timespan[FORMAT_TIMESPAN_MAX];
684 assert(u->type >= 0);
688 p2 = strappend(prefix, "\t");
689 prefix2 = p2 ? p2 : prefix;
693 "%s\tDescription: %s\n"
695 "%s\tUnit Load State: %s\n"
696 "%s\tUnit Active State: %s\n"
697 "%s\tInactive Exit Timestamp: %s\n"
698 "%s\tActive Enter Timestamp: %s\n"
699 "%s\tActive Exit Timestamp: %s\n"
700 "%s\tInactive Enter Timestamp: %s\n"
701 "%s\tGC Check Good: %s\n"
702 "%s\tNeed Daemon Reload: %s\n"
703 "%s\tTransient: %s\n"
706 "%s\tCGroup realized: %s\n"
707 "%s\tCGroup mask: 0x%x\n",
709 prefix, unit_description(u),
710 prefix, strna(u->instance),
711 prefix, unit_load_state_to_string(u->load_state),
712 prefix, unit_active_state_to_string(unit_active_state(u)),
713 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
714 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
715 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
716 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
717 prefix, yes_no(unit_check_gc(u)),
718 prefix, yes_no(unit_need_daemon_reload(u)),
719 prefix, yes_no(u->transient),
720 prefix, strna(unit_slice_name(u)),
721 prefix, strna(u->cgroup_path),
722 prefix, yes_no(u->cgroup_realized),
723 prefix, u->cgroup_mask);
725 SET_FOREACH(t, u->names, i)
726 fprintf(f, "%s\tName: %s\n", prefix, t);
728 STRV_FOREACH(j, u->documentation)
729 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
731 if ((following = unit_following(u)))
732 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
734 if (u->fragment_path)
735 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
738 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
740 STRV_FOREACH(j, u->dropin_paths)
741 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
743 if (u->job_timeout > 0)
744 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
746 condition_dump_list(u->conditions, f, prefix);
748 if (dual_timestamp_is_set(&u->condition_timestamp))
750 "%s\tCondition Timestamp: %s\n"
751 "%s\tCondition Result: %s\n",
752 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
753 prefix, yes_no(u->condition_result));
755 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
758 SET_FOREACH(other, u->dependencies[d], i)
759 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
762 if (!strv_isempty(u->requires_mounts_for)) {
764 "%s\tRequiresMountsFor:", prefix);
766 STRV_FOREACH(j, u->requires_mounts_for)
767 fprintf(f, " %s", *j);
772 if (u->load_state == UNIT_LOADED) {
775 "%s\tStopWhenUnneeded: %s\n"
776 "%s\tRefuseManualStart: %s\n"
777 "%s\tRefuseManualStop: %s\n"
778 "%s\tDefaultDependencies: %s\n"
779 "%s\tOnFailureIsolate: %s\n"
780 "%s\tIgnoreOnIsolate: %s\n"
781 "%s\tIgnoreOnSnapshot: %s\n",
782 prefix, yes_no(u->stop_when_unneeded),
783 prefix, yes_no(u->refuse_manual_start),
784 prefix, yes_no(u->refuse_manual_stop),
785 prefix, yes_no(u->default_dependencies),
786 prefix, yes_no(u->on_failure_isolate),
787 prefix, yes_no(u->ignore_on_isolate),
788 prefix, yes_no(u->ignore_on_snapshot));
790 if (UNIT_VTABLE(u)->dump)
791 UNIT_VTABLE(u)->dump(u, f, prefix2);
793 } else if (u->load_state == UNIT_MERGED)
795 "%s\tMerged into: %s\n",
796 prefix, u->merged_into->id);
797 else if (u->load_state == UNIT_ERROR)
798 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
802 job_dump(u->job, f, prefix2);
805 job_dump(u->nop_job, f, prefix2);
810 /* Common implementation for multiple backends */
811 int unit_load_fragment_and_dropin(Unit *u) {
816 /* Load a .service file */
817 r = unit_load_fragment(u);
821 if (u->load_state == UNIT_STUB)
824 /* Load drop-in directory data */
825 r = unit_load_dropin(unit_follow_merge(u));
832 /* Common implementation for multiple backends */
833 int unit_load_fragment_and_dropin_optional(Unit *u) {
838 /* Same as unit_load_fragment_and_dropin(), but whether
839 * something can be loaded or not doesn't matter. */
841 /* Load a .service file */
842 r = unit_load_fragment(u);
846 if (u->load_state == UNIT_STUB)
847 u->load_state = UNIT_LOADED;
849 /* Load drop-in directory data */
850 r = unit_load_dropin(unit_follow_merge(u));
857 int unit_add_default_target_dependency(Unit *u, Unit *target) {
861 if (target->type != UNIT_TARGET)
864 /* Only add the dependency if both units are loaded, so that
865 * that loop check below is reliable */
866 if (u->load_state != UNIT_LOADED ||
867 target->load_state != UNIT_LOADED)
870 /* If either side wants no automatic dependencies, then let's
872 if (!u->default_dependencies ||
873 !target->default_dependencies)
876 /* Don't create loops */
877 if (set_get(target->dependencies[UNIT_BEFORE], u))
880 return unit_add_dependency(target, UNIT_AFTER, u, true);
883 static int unit_add_default_dependencies(Unit *u) {
885 static const UnitDependency deps[] = {
887 UNIT_REQUIRED_BY_OVERRIDABLE,
899 for (k = 0; k < ELEMENTSOF(deps); k++)
900 SET_FOREACH(target, u->dependencies[deps[k]], i) {
901 r = unit_add_default_target_dependency(u, target);
906 if (u->default_dependencies && unit_get_cgroup_context(u)) {
907 if (UNIT_ISSET(u->slice))
908 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
910 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
919 int unit_load(Unit *u) {
924 if (u->in_load_queue) {
925 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
926 u->in_load_queue = false;
929 if (u->type == _UNIT_TYPE_INVALID)
932 if (u->load_state != UNIT_STUB)
935 if (UNIT_VTABLE(u)->load) {
936 r = UNIT_VTABLE(u)->load(u);
941 if (u->load_state == UNIT_STUB) {
946 if (u->load_state == UNIT_LOADED) {
948 if (u->default_dependencies) {
949 r = unit_add_default_dependencies(u);
954 r = unit_add_mount_links(u);
958 if (u->on_failure_isolate &&
959 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
961 log_error_unit(u->id,
962 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
969 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
971 unit_add_to_dbus_queue(unit_follow_merge(u));
972 unit_add_to_gc_queue(u);
977 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
979 unit_add_to_dbus_queue(u);
980 unit_add_to_gc_queue(u);
982 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
983 u->id, strerror(-r));
988 bool unit_condition_test(Unit *u) {
991 dual_timestamp_get(&u->condition_timestamp);
992 u->condition_result = condition_test_list(u->conditions);
994 return u->condition_result;
997 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
998 const UnitStatusMessageFormats *format_table;
1002 assert(t < _JOB_TYPE_MAX);
1004 if (t != JOB_START && t != JOB_STOP)
1007 format_table = &UNIT_VTABLE(u)->status_message_formats;
1011 return format_table->starting_stopping[t == JOB_STOP];
1014 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1019 assert(t < _JOB_TYPE_MAX);
1021 format = unit_get_status_message_format(u, t);
1025 /* Return generic strings */
1027 return "Starting %s.";
1028 else if (t == JOB_STOP)
1029 return "Stopping %s.";
1030 else if (t == JOB_RELOAD)
1031 return "Reloading %s.";
1036 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1041 /* We only print status messages for selected units on
1042 * selected operations. */
1044 format = unit_get_status_message_format(u, t);
1048 unit_status_printf(u, "", format);
1051 #pragma GCC diagnostic push
1052 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1053 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1060 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1063 if (log_on_console())
1066 /* We log status messages for all units and all operations. */
1068 format = unit_get_status_message_format_try_harder(u, t);
1072 snprintf(buf, sizeof(buf), format, unit_description(u));
1075 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1076 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1077 SD_MESSAGE_UNIT_RELOADING;
1079 log_struct_unit(LOG_INFO,
1085 #pragma GCC diagnostic pop
1088 * -EBADR: This unit type does not support starting.
1089 * -EALREADY: Unit is already started.
1090 * -EAGAIN: An operation is already in progress. Retry later.
1091 * -ECANCELED: Too many requests for now.
1093 int unit_start(Unit *u) {
1094 UnitActiveState state;
1099 if (u->load_state != UNIT_LOADED)
1102 /* If this is already started, then this will succeed. Note
1103 * that this will even succeed if this unit is not startable
1104 * by the user. This is relied on to detect when we need to
1105 * wait for units and when waiting is finished. */
1106 state = unit_active_state(u);
1107 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1110 /* If the conditions failed, don't do anything at all. If we
1111 * already are activating this call might still be useful to
1112 * speed up activation in case there is some hold-off time,
1113 * but we don't want to recheck the condition in that case. */
1114 if (state != UNIT_ACTIVATING &&
1115 !unit_condition_test(u)) {
1116 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1120 /* Forward to the main object, if we aren't it. */
1121 if ((following = unit_following(u))) {
1122 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1123 u->id, following->id);
1124 return unit_start(following);
1127 unit_status_log_starting_stopping_reloading(u, JOB_START);
1128 unit_status_print_starting_stopping(u, JOB_START);
1130 /* If it is stopped, but we cannot start it, then fail */
1131 if (!UNIT_VTABLE(u)->start)
1134 /* We don't suppress calls to ->start() here when we are
1135 * already starting, to allow this request to be used as a
1136 * "hurry up" call, for example when the unit is in some "auto
1137 * restart" state where it waits for a holdoff timer to elapse
1138 * before it will start again. */
1140 unit_add_to_dbus_queue(u);
1142 return UNIT_VTABLE(u)->start(u);
1145 bool unit_can_start(Unit *u) {
1148 return !!UNIT_VTABLE(u)->start;
1151 bool unit_can_isolate(Unit *u) {
1154 return unit_can_start(u) &&
1159 * -EBADR: This unit type does not support stopping.
1160 * -EALREADY: Unit is already stopped.
1161 * -EAGAIN: An operation is already in progress. Retry later.
1163 int unit_stop(Unit *u) {
1164 UnitActiveState state;
1169 state = unit_active_state(u);
1170 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1173 if ((following = unit_following(u))) {
1174 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1175 u->id, following->id);
1176 return unit_stop(following);
1179 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1180 unit_status_print_starting_stopping(u, JOB_STOP);
1182 if (!UNIT_VTABLE(u)->stop)
1185 unit_add_to_dbus_queue(u);
1187 return UNIT_VTABLE(u)->stop(u);
1191 * -EBADR: This unit type does not support reloading.
1192 * -ENOEXEC: Unit is not started.
1193 * -EAGAIN: An operation is already in progress. Retry later.
1195 int unit_reload(Unit *u) {
1196 UnitActiveState state;
1201 if (u->load_state != UNIT_LOADED)
1204 if (!unit_can_reload(u))
1207 state = unit_active_state(u);
1208 if (state == UNIT_RELOADING)
1211 if (state != UNIT_ACTIVE)
1214 if ((following = unit_following(u))) {
1215 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1216 u->id, following->id);
1217 return unit_reload(following);
1220 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1222 unit_add_to_dbus_queue(u);
1223 return UNIT_VTABLE(u)->reload(u);
1226 bool unit_can_reload(Unit *u) {
1229 if (!UNIT_VTABLE(u)->reload)
1232 if (!UNIT_VTABLE(u)->can_reload)
1235 return UNIT_VTABLE(u)->can_reload(u);
1238 static void unit_check_unneeded(Unit *u) {
1244 /* If this service shall be shut down when unneeded then do
1247 if (!u->stop_when_unneeded)
1250 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1253 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1254 if (unit_active_or_pending(other))
1257 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1258 if (unit_active_or_pending(other))
1261 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1262 if (unit_active_or_pending(other))
1265 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1266 if (unit_active_or_pending(other))
1269 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1271 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1272 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1275 static void retroactively_start_dependencies(Unit *u) {
1280 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1282 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1283 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1284 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1285 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1287 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1288 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1289 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1290 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1292 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1293 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1294 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1295 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1297 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1298 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1299 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1300 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1302 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1303 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1304 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1306 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1307 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1308 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1311 static void retroactively_stop_dependencies(Unit *u) {
1316 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1318 /* Pull down units which are bound to us recursively if enabled */
1319 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1320 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1321 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1324 static void check_unneeded_dependencies(Unit *u) {
1329 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1331 /* Garbage collect services that might not be needed anymore, if enabled */
1332 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1333 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1334 unit_check_unneeded(other);
1335 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1336 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1337 unit_check_unneeded(other);
1338 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1339 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1340 unit_check_unneeded(other);
1341 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], 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_OVERRIDABLE], i)
1345 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1346 unit_check_unneeded(other);
1347 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1348 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1349 unit_check_unneeded(other);
1352 void unit_start_on_failure(Unit *u) {
1358 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1361 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1363 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1366 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1368 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1372 void unit_trigger_notify(Unit *u) {
1378 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1379 if (UNIT_VTABLE(other)->trigger_notify)
1380 UNIT_VTABLE(other)->trigger_notify(other, u);
1383 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1388 assert(os < _UNIT_ACTIVE_STATE_MAX);
1389 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1391 /* Note that this is called for all low-level state changes,
1392 * even if they might map to the same high-level
1393 * UnitActiveState! That means that ns == os is OK an expected
1394 * behavior here. For example: if a mount point is remounted
1395 * this function will be called too! */
1399 if (m->n_reloading <= 0) {
1402 dual_timestamp_get(&ts);
1404 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1405 u->inactive_exit_timestamp = ts;
1406 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1407 u->inactive_enter_timestamp = ts;
1409 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1410 u->active_enter_timestamp = ts;
1411 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1412 u->active_exit_timestamp = ts;
1415 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1416 unit_destroy_cgroup(u);
1418 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1419 ExecContext *ec = unit_get_exec_context(u);
1420 if (ec && exec_context_may_touch_console(ec)) {
1421 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1431 if (u->job->state == JOB_WAITING)
1433 /* So we reached a different state for this
1434 * job. Let's see if we can run it now if it
1435 * failed previously due to EAGAIN. */
1436 job_add_to_run_queue(u->job);
1438 /* Let's check whether this state change constitutes a
1439 * finished job, or maybe contradicts a running job and
1440 * hence needs to invalidate jobs. */
1442 switch (u->job->type) {
1445 case JOB_VERIFY_ACTIVE:
1447 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1448 job_finish_and_invalidate(u->job, JOB_DONE, true);
1449 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1452 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1453 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1459 case JOB_RELOAD_OR_START:
1461 if (u->job->state == JOB_RUNNING) {
1462 if (ns == UNIT_ACTIVE)
1463 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1464 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1467 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1468 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1476 case JOB_TRY_RESTART:
1478 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1479 job_finish_and_invalidate(u->job, JOB_DONE, true);
1480 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1482 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1488 assert_not_reached("Job type unknown");
1494 if (m->n_reloading <= 0) {
1496 /* If this state change happened without being
1497 * requested by a job, then let's retroactively start
1498 * or stop dependencies. We skip that step when
1499 * deserializing, since we don't want to create any
1500 * additional jobs just because something is already
1504 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1505 retroactively_start_dependencies(u);
1506 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1507 retroactively_stop_dependencies(u);
1510 /* stop unneeded units regardless if going down was expected or not */
1511 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1512 check_unneeded_dependencies(u);
1514 if (ns != os && ns == UNIT_FAILED) {
1515 log_notice_unit(u->id,
1516 "Unit %s entered failed state.", u->id);
1517 unit_start_on_failure(u);
1521 /* Some names are special */
1522 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1524 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1525 /* The bus just might have become available,
1526 * hence try to connect to it, if we aren't
1530 if (u->type == UNIT_SERVICE &&
1531 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1532 m->n_reloading <= 0) {
1533 /* Write audit record if we have just finished starting up */
1534 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1538 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1539 manager_send_unit_plymouth(m, u);
1543 /* We don't care about D-Bus here, since we'll get an
1544 * asynchronous notification for it anyway. */
1546 if (u->type == UNIT_SERVICE &&
1547 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1548 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1549 m->n_reloading <= 0) {
1551 /* Hmm, if there was no start record written
1552 * write it now, so that we always have a nice
1555 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1557 if (ns == UNIT_INACTIVE)
1558 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1560 /* Write audit record if we have just finished shutting down */
1561 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1563 u->in_audit = false;
1567 manager_recheck_journal(m);
1568 unit_trigger_notify(u);
1570 /* Maybe we finished startup and are now ready for being
1571 * stopped because unneeded? */
1572 if (u->manager->n_reloading <= 0)
1573 unit_check_unneeded(u);
1575 unit_add_to_dbus_queue(u);
1576 unit_add_to_gc_queue(u);
1579 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1580 struct epoll_event ev = {
1588 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1590 if (epoll_ctl(u->manager->epoll_fd,
1591 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1603 void unit_unwatch_fd(Unit *u, Watch *w) {
1607 if (w->type == WATCH_INVALID)
1610 assert(w->type == WATCH_FD);
1611 assert(w->data.unit == u);
1612 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1615 w->type = WATCH_INVALID;
1616 w->data.unit = NULL;
1619 int unit_watch_pid(Unit *u, pid_t pid) {
1623 /* Watch a specific PID. We only support one unit watching
1624 * each PID for now. */
1626 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1629 void unit_unwatch_pid(Unit *u, pid_t pid) {
1633 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1636 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1637 struct itimerspec its = {};
1643 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1645 /* This will try to reuse the old timer if there is one */
1647 if (w->type == WATCH_UNIT_TIMER) {
1648 assert(w->data.unit == u);
1653 } else if (w->type == WATCH_INVALID) {
1656 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1660 assert_not_reached("Invalid watch type");
1663 /* Set absolute time in the past, but not 0, since we
1664 * don't want to disarm the timer */
1665 its.it_value.tv_sec = 0;
1666 its.it_value.tv_nsec = 1;
1668 flags = TFD_TIMER_ABSTIME;
1670 timespec_store(&its.it_value, usec);
1671 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1674 /* This will also flush the elapse counter */
1675 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1678 if (w->type == WATCH_INVALID) {
1679 struct epoll_event ev = {
1684 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1688 w->type = WATCH_UNIT_TIMER;
1696 close_nointr_nofail(fd);
1701 void unit_unwatch_timer(Unit *u, Watch *w) {
1705 if (w->type == WATCH_INVALID)
1708 assert(w->type == WATCH_UNIT_TIMER);
1709 assert(w->data.unit == u);
1712 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1713 close_nointr_nofail(w->fd);
1716 w->type = WATCH_INVALID;
1717 w->data.unit = NULL;
1720 bool unit_job_is_applicable(Unit *u, JobType j) {
1722 assert(j >= 0 && j < _JOB_TYPE_MAX);
1726 case JOB_VERIFY_ACTIVE:
1733 case JOB_TRY_RESTART:
1734 return unit_can_start(u);
1737 return unit_can_reload(u);
1739 case JOB_RELOAD_OR_START:
1740 return unit_can_reload(u) && unit_can_start(u);
1743 assert_not_reached("Invalid job type");
1747 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1749 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1750 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1751 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1752 [UNIT_WANTS] = UNIT_WANTED_BY,
1753 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1754 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1755 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1756 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1757 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1758 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1759 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1760 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1761 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1762 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1763 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1764 [UNIT_BEFORE] = UNIT_AFTER,
1765 [UNIT_AFTER] = UNIT_BEFORE,
1766 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1767 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1768 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1769 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1770 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1771 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1772 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1774 int r, q = 0, v = 0, w = 0;
1777 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1780 u = unit_follow_merge(u);
1781 other = unit_follow_merge(other);
1783 /* We won't allow dependencies on ourselves. We will not
1784 * consider them an error however. */
1788 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1791 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1792 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1796 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1797 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1800 if ((q = set_put(u->dependencies[d], other)) < 0)
1803 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1804 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1809 if (add_reference) {
1810 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1815 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1819 unit_add_to_dbus_queue(u);
1824 set_remove(u->dependencies[d], other);
1827 set_remove(other->dependencies[inverse_table[d]], u);
1830 set_remove(u->dependencies[UNIT_REFERENCES], other);
1835 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1840 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1843 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1849 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1853 assert(name || path);
1857 name = path_get_file_name(path);
1859 if (!unit_name_is_template(name)) {
1865 s = unit_name_replace_instance(name, u->instance);
1867 _cleanup_free_ char *i = NULL;
1869 i = unit_name_to_prefix(u->id);
1873 s = unit_name_replace_instance(name, i);
1883 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1886 _cleanup_free_ char *s = NULL;
1889 assert(name || path);
1891 name = resolve_template(u, name, path, &s);
1895 r = manager_load_unit(u->manager, name, path, NULL, &other);
1899 return unit_add_dependency(u, d, other, add_reference);
1902 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1908 assert(name || path);
1910 if (!(name = resolve_template(u, name, path, &s)))
1913 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1916 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1923 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1929 assert(name || path);
1931 if (!(name = resolve_template(u, name, path, &s)))
1934 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1937 r = unit_add_dependency(other, d, u, add_reference);
1944 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1950 assert(name || path);
1952 if (!(name = resolve_template(u, name, path, &s)))
1955 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1958 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1966 int set_unit_path(const char *p) {
1967 _cleanup_free_ char *c = NULL;
1969 /* This is mostly for debug purposes */
1970 c = path_make_absolute_cwd(p);
1971 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1977 char *unit_dbus_path(Unit *u) {
1983 return unit_dbus_path_from_name(u->id);
1986 char *unit_default_cgroup_path(Unit *u) {
1987 _cleanup_free_ char *escaped_instance = NULL, *slice = NULL;
1992 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1993 return strdup(u->manager->cgroup_root);
1995 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1996 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2001 escaped_instance = cg_escape(u->id);
2002 if (!escaped_instance)
2006 _cleanup_free_ char *t = NULL, *escaped_template = NULL;
2008 t = unit_name_template(u->id);
2012 escaped_template = cg_escape(t);
2013 if (!escaped_template)
2016 return strjoin(u->manager->cgroup_root, "/",
2017 slice ? slice : "", slice ? "/" : "",
2018 escaped_template, "/", escaped_instance, NULL);
2020 return strjoin(u->manager->cgroup_root, "/",
2021 slice ? slice : "", slice ? "/" : "",
2022 escaped_instance, NULL);
2025 int unit_add_default_slice(Unit *u) {
2031 if (UNIT_ISSET(u->slice))
2034 if (!unit_get_cgroup_context(u))
2037 r = manager_load_unit(u->manager, u->manager->running_as == SYSTEMD_SYSTEM ? SPECIAL_SYSTEM_SLICE : SPECIAL_ROOT_SLICE, NULL, NULL, &slice);
2041 unit_ref_set(&u->slice, slice);
2045 const char *unit_slice_name(Unit *u) {
2048 if (!UNIT_ISSET(u->slice))
2051 return UNIT_DEREF(u->slice)->id;
2054 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2055 _cleanup_free_ char *t = NULL;
2062 t = unit_name_change_suffix(u->id, type);
2066 assert(!unit_has_name(u, t));
2068 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2069 assert(r < 0 || *_found != u);
2073 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2074 _cleanup_free_ char *t = NULL;
2081 t = unit_name_change_suffix(u->id, type);
2085 assert(!unit_has_name(u, t));
2087 found = manager_get_unit(u->manager, t);
2095 int unit_watch_bus_name(Unit *u, const char *name) {
2099 /* Watch a specific name on the bus. We only support one unit
2100 * watching each name for now. */
2102 return hashmap_put(u->manager->watch_bus, name, u);
2105 void unit_unwatch_bus_name(Unit *u, const char *name) {
2109 hashmap_remove_value(u->manager->watch_bus, name, u);
2112 bool unit_can_serialize(Unit *u) {
2115 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2118 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2125 if (!unit_can_serialize(u))
2128 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2132 if (serialize_jobs) {
2134 fprintf(f, "job\n");
2135 job_serialize(u->job, f, fds);
2139 fprintf(f, "job\n");
2140 job_serialize(u->nop_job, f, fds);
2144 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2145 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2146 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2147 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2148 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2150 if (dual_timestamp_is_set(&u->condition_timestamp))
2151 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2153 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2156 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2163 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2174 va_start(ap, format);
2175 vfprintf(f, format, ap);
2181 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2187 fprintf(f, "%s=%s\n", key, value);
2190 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2197 if (!unit_can_serialize(u))
2201 char line[LINE_MAX], *l, *v;
2204 if (!fgets(line, sizeof(line), f)) {
2217 k = strcspn(l, "=");
2225 if (streq(l, "job")) {
2227 /* new-style serialized job */
2228 Job *j = job_new_raw(u);
2232 r = job_deserialize(j, f, fds);
2238 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2244 r = job_install_deserialized(j);
2246 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2251 if (j->state == JOB_RUNNING)
2252 u->manager->n_running_jobs++;
2255 JobType type = job_type_from_string(v);
2257 log_debug("Failed to parse job type value %s", v);
2259 u->deserialized_job = type;
2262 } else if (streq(l, "inactive-exit-timestamp")) {
2263 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2265 } else if (streq(l, "active-enter-timestamp")) {
2266 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2268 } else if (streq(l, "active-exit-timestamp")) {
2269 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2271 } else if (streq(l, "inactive-enter-timestamp")) {
2272 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2274 } else if (streq(l, "condition-timestamp")) {
2275 dual_timestamp_deserialize(v, &u->condition_timestamp);
2277 } else if (streq(l, "condition-result")) {
2280 b = parse_boolean(v);
2282 log_debug("Failed to parse condition result value %s", v);
2284 u->condition_result = b;
2288 } else if (streq(l, "transient")) {
2291 b = parse_boolean(v);
2293 log_debug("Failed to parse transient bool %s", v);
2298 } else if (streq(l, "cgroup")) {
2305 free(u->cgroup_path);
2310 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2316 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2326 /* Adds in links to the device node that this unit is based on */
2328 if (!is_device_path(what))
2331 e = unit_name_from_path(what, ".device");
2335 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2340 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2345 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2353 int unit_coldplug(Unit *u) {
2358 if (UNIT_VTABLE(u)->coldplug)
2359 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2363 r = job_coldplug(u->job);
2366 } else if (u->deserialized_job >= 0) {
2368 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2372 u->deserialized_job = _JOB_TYPE_INVALID;
2378 #pragma GCC diagnostic push
2379 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2380 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2381 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2383 #pragma GCC diagnostic pop
2385 bool unit_need_daemon_reload(Unit *u) {
2386 _cleanup_strv_free_ char **t = NULL;
2389 unsigned loaded_cnt, current_cnt;
2393 if (u->fragment_path) {
2395 if (stat(u->fragment_path, &st) < 0)
2396 /* What, cannot access this anymore? */
2399 if (u->fragment_mtime > 0 &&
2400 timespec_load(&st.st_mtim) != u->fragment_mtime)
2404 if (u->source_path) {
2406 if (stat(u->source_path, &st) < 0)
2409 if (u->source_mtime > 0 &&
2410 timespec_load(&st.st_mtim) != u->source_mtime)
2414 t = unit_find_dropin_paths(u);
2415 loaded_cnt = strv_length(t);
2416 current_cnt = strv_length(u->dropin_paths);
2418 if (loaded_cnt == current_cnt) {
2419 if (loaded_cnt == 0)
2422 if (strv_overlap(u->dropin_paths, t)) {
2423 STRV_FOREACH(path, u->dropin_paths) {
2425 if (stat(*path, &st) < 0)
2428 if (u->dropin_mtime > 0 &&
2429 timespec_load(&st.st_mtim) > u->dropin_mtime)
2440 void unit_reset_failed(Unit *u) {
2443 if (UNIT_VTABLE(u)->reset_failed)
2444 UNIT_VTABLE(u)->reset_failed(u);
2447 Unit *unit_following(Unit *u) {
2450 if (UNIT_VTABLE(u)->following)
2451 return UNIT_VTABLE(u)->following(u);
2456 bool unit_stop_pending(Unit *u) {
2459 /* This call does check the current state of the unit. It's
2460 * hence useful to be called from state change calls of the
2461 * unit itself, where the state isn't updated yet. This is
2462 * different from unit_inactive_or_pending() which checks both
2463 * the current state and for a queued job. */
2465 return u->job && u->job->type == JOB_STOP;
2468 bool unit_inactive_or_pending(Unit *u) {
2471 /* Returns true if the unit is inactive or going down */
2473 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2476 if (unit_stop_pending(u))
2482 bool unit_active_or_pending(Unit *u) {
2485 /* Returns true if the unit is active or going up */
2487 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2491 (u->job->type == JOB_START ||
2492 u->job->type == JOB_RELOAD_OR_START ||
2493 u->job->type == JOB_RESTART))
2499 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2501 assert(w >= 0 && w < _KILL_WHO_MAX);
2503 assert(signo < _NSIG);
2505 if (!UNIT_VTABLE(u)->kill)
2508 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2511 int unit_kill_common(
2521 if (who == KILL_MAIN && main_pid <= 0) {
2523 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2525 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2529 if (who == KILL_CONTROL && control_pid <= 0) {
2530 if (control_pid < 0)
2531 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2533 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2537 if (who == KILL_CONTROL || who == KILL_ALL)
2538 if (control_pid > 0)
2539 if (kill(control_pid, signo) < 0)
2542 if (who == KILL_MAIN || who == KILL_ALL)
2544 if (kill(main_pid, signo) < 0)
2547 if (who == KILL_ALL && u->cgroup_path) {
2548 _cleanup_set_free_ Set *pid_set = NULL;
2551 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2555 /* Exclude the control/main pid from being killed via the cgroup */
2556 if (control_pid > 0) {
2557 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2563 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2568 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2569 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2576 int unit_following_set(Unit *u, Set **s) {
2580 if (UNIT_VTABLE(u)->following_set)
2581 return UNIT_VTABLE(u)->following_set(u, s);
2587 UnitFileState unit_get_unit_file_state(Unit *u) {
2590 if (u->unit_file_state < 0 && u->fragment_path)
2591 u->unit_file_state = unit_file_get_state(
2592 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2593 NULL, path_get_file_name(u->fragment_path));
2595 return u->unit_file_state;
2598 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2603 unit_ref_unset(ref);
2606 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2610 void unit_ref_unset(UnitRef *ref) {
2616 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2620 int unit_add_one_mount_link(Unit *u, Mount *m) {
2626 if (u->load_state != UNIT_LOADED ||
2627 UNIT(m)->load_state != UNIT_LOADED)
2630 STRV_FOREACH(i, u->requires_mounts_for) {
2635 if (!path_startswith(*i, m->where))
2638 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2644 int unit_add_mount_links(Unit *u) {
2650 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2651 r = unit_add_one_mount_link(u, MOUNT(other));
2659 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2666 /* This only copies in the ones that need memory */
2667 for (i = 0; i < RLIMIT_NLIMITS; i++)
2668 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2669 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2674 if (u->manager->running_as == SYSTEMD_USER &&
2675 !c->working_directory) {
2677 r = get_home_dir(&c->working_directory);
2685 ExecContext *unit_get_exec_context(Unit *u) {
2689 offset = UNIT_VTABLE(u)->exec_context_offset;
2693 return (ExecContext*) ((uint8_t*) u + offset);
2696 CGroupContext *unit_get_cgroup_context(Unit *u) {
2699 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2703 return (CGroupContext*) ((uint8_t*) u + offset);
2706 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2714 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2716 if (!filename_is_safe(name))
2719 if (u->manager->running_as == SYSTEMD_USER) {
2720 _cleanup_free_ char *c = NULL;
2722 r = user_config_home(&c);
2728 p = strjoin(c, "/", u->id, ".d", NULL);
2729 } else if (mode & UNIT_PERSISTENT)
2730 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2732 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2736 q = strjoin(p, "/90-", name, ".conf", NULL);
2747 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2748 _cleanup_free_ char *p = NULL, *q = NULL;
2755 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2758 r = drop_in_file(u, mode, name, &p, &q);
2763 return write_string_file_atomic_label(q, data);
2766 int unit_write_drop_in_private_section(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2767 _cleanup_free_ char *ndata = NULL;
2773 if (!UNIT_VTABLE(u)->private_section)
2776 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2780 return unit_write_drop_in(u, mode, name, ndata);
2783 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2784 _cleanup_free_ char *p = NULL, *q = NULL;
2789 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2792 r = drop_in_file(u, mode, name, &p, &q);
2794 r = errno == ENOENT ? 0 : -errno;
2802 int unit_make_transient(Unit *u) {
2807 u->load_state = UNIT_STUB;
2809 u->transient = true;
2811 free(u->fragment_path);
2812 u->fragment_path = NULL;
2814 if (u->manager->running_as == SYSTEMD_USER) {
2815 _cleanup_free_ char *c = NULL;
2817 r = user_config_home(&c);
2823 u->fragment_path = strjoin(c, "/", u->id, NULL);
2824 if (!u->fragment_path)
2829 u->fragment_path = strappend("/run/systemd/system/", u->id);
2830 if (!u->fragment_path)
2833 mkdir_p("/run/systemd/system", 0755);
2836 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2839 int unit_kill_context(
2845 bool main_pid_alien) {
2847 int sig, wait_for_exit = 0, r;
2852 if (c->kill_mode == KILL_NONE)
2855 sig = sigkill ? SIGKILL : c->kill_signal;
2858 r = kill_and_sigcont(main_pid, sig);
2860 if (r < 0 && r != -ESRCH) {
2861 _cleanup_free_ char *comm = NULL;
2862 get_process_comm(main_pid, &comm);
2864 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2865 (long) main_pid, strna(comm), strerror(-r));
2867 wait_for_exit = !main_pid_alien;
2870 if (control_pid > 0) {
2871 r = kill_and_sigcont(control_pid, sig);
2873 if (r < 0 && r != -ESRCH) {
2874 _cleanup_free_ char *comm = NULL;
2875 get_process_comm(control_pid, &comm);
2877 log_warning_unit(u->id,
2878 "Failed to kill control process %li (%s): %s",
2879 (long) control_pid, strna(comm), strerror(-r));
2881 wait_for_exit = true;
2884 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2885 _cleanup_set_free_ Set *pid_set = NULL;
2887 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2891 /* Exclude the main/control pids from being killed via the cgroup */
2893 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2898 if (control_pid > 0) {
2899 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2904 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2906 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2907 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2909 wait_for_exit = true;
2912 return wait_for_exit;
2915 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2916 [UNIT_ACTIVE] = "active",
2917 [UNIT_RELOADING] = "reloading",
2918 [UNIT_INACTIVE] = "inactive",
2919 [UNIT_FAILED] = "failed",
2920 [UNIT_ACTIVATING] = "activating",
2921 [UNIT_DEACTIVATING] = "deactivating"
2924 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2926 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2927 [UNIT_REQUIRES] = "Requires",
2928 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2929 [UNIT_REQUISITE] = "Requisite",
2930 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2931 [UNIT_WANTS] = "Wants",
2932 [UNIT_BINDS_TO] = "BindsTo",
2933 [UNIT_PART_OF] = "PartOf",
2934 [UNIT_REQUIRED_BY] = "RequiredBy",
2935 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2936 [UNIT_WANTED_BY] = "WantedBy",
2937 [UNIT_BOUND_BY] = "BoundBy",
2938 [UNIT_CONSISTS_OF] = "ConsistsOf",
2939 [UNIT_CONFLICTS] = "Conflicts",
2940 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2941 [UNIT_BEFORE] = "Before",
2942 [UNIT_AFTER] = "After",
2943 [UNIT_ON_FAILURE] = "OnFailure",
2944 [UNIT_TRIGGERS] = "Triggers",
2945 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2946 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2947 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2948 [UNIT_REFERENCES] = "References",
2949 [UNIT_REFERENCED_BY] = "ReferencedBy",
2952 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);