1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
32 #include "systemd/sd-id128.h"
33 #include "systemd/sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_TIMER] = &timer_vtable,
55 [UNIT_SOCKET] = &socket_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_DEVICE] = &device_vtable,
58 [UNIT_MOUNT] = &mount_vtable,
59 [UNIT_AUTOMOUNT] = &automount_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_PATH] = &path_vtable,
63 [UNIT_SLICE] = &slice_vtable,
64 [UNIT_SCOPE] = &scope_vtable
67 Unit *unit_new(Manager *m, size_t size) {
71 assert(size >= sizeof(Unit));
77 u->names = set_new(string_hash_func, string_compare_func);
84 u->type = _UNIT_TYPE_INVALID;
85 u->deserialized_job = _JOB_TYPE_INVALID;
86 u->default_dependencies = true;
87 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 bool unit_has_name(Unit *u, const char *name) {
96 return !!set_get(u->names, (char*) name);
99 int unit_add_name(Unit *u, const char *text) {
107 if (unit_name_is_template(text)) {
111 s = unit_name_replace_instance(text, u->instance);
118 if (!unit_name_is_valid(s, false)) {
123 assert_se((t = unit_name_to_type(s)) >= 0);
125 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
130 if ((r = unit_name_to_instance(s, &i)) < 0)
133 if (i && unit_vtable[t]->no_instances) {
138 /* Ensure that this unit is either instanced or not instanced,
140 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
145 if (unit_vtable[t]->no_alias &&
146 !set_isempty(u->names) &&
147 !set_get(u->names, s)) {
152 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
157 if ((r = set_put(u->names, s)) < 0) {
163 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
164 set_remove(u->names, s);
168 if (u->type == _UNIT_TYPE_INVALID) {
174 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
176 if (UNIT_VTABLE(u)->init)
177 UNIT_VTABLE(u)->init(u);
181 unit_add_to_dbus_queue(u);
191 int unit_choose_id(Unit *u, const char *name) {
192 char *s, *t = NULL, *i;
198 if (unit_name_is_template(name)) {
203 if (!(t = unit_name_replace_instance(name, u->instance)))
209 /* Selects one of the names of this unit as the id */
210 s = set_get(u->names, (char*) name);
216 if ((r = unit_name_to_instance(s, &i)) < 0)
224 unit_add_to_dbus_queue(u);
229 int unit_set_description(Unit *u, const char *description) {
234 if (isempty(description))
237 s = strdup(description);
242 free(u->description);
245 unit_add_to_dbus_queue(u);
249 bool unit_check_gc(Unit *u) {
252 if (u->load_state == UNIT_STUB)
255 if (UNIT_VTABLE(u)->no_gc)
267 if (unit_active_state(u) != UNIT_INACTIVE)
273 if (UNIT_VTABLE(u)->check_gc)
274 if (UNIT_VTABLE(u)->check_gc(u))
280 void unit_add_to_load_queue(Unit *u) {
282 assert(u->type != _UNIT_TYPE_INVALID);
284 if (u->load_state != UNIT_STUB || u->in_load_queue)
287 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
288 u->in_load_queue = true;
291 void unit_add_to_cleanup_queue(Unit *u) {
294 if (u->in_cleanup_queue)
297 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
298 u->in_cleanup_queue = true;
301 void unit_add_to_gc_queue(Unit *u) {
304 if (u->in_gc_queue || u->in_cleanup_queue)
307 if (unit_check_gc(u))
310 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
311 u->in_gc_queue = true;
313 u->manager->n_in_gc_queue ++;
315 if (u->manager->gc_queue_timestamp <= 0)
316 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
319 void unit_add_to_dbus_queue(Unit *u) {
321 assert(u->type != _UNIT_TYPE_INVALID);
323 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
326 /* Shortcut things if nobody cares */
327 if (!bus_has_subscriber(u->manager)) {
328 u->sent_dbus_new_signal = true;
332 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
333 u->in_dbus_queue = true;
336 static void bidi_set_free(Unit *u, Set *s) {
342 /* Frees the set and makes sure we are dropped from the
343 * inverse pointers */
345 SET_FOREACH(other, s, i) {
348 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
349 set_remove(other->dependencies[d], u);
351 unit_add_to_gc_queue(other);
357 static void unit_remove_transient(Unit *u) {
365 if (u->fragment_path)
366 unlink(u->fragment_path);
368 STRV_FOREACH(i, u->dropin_paths) {
369 _cleanup_free_ char *p = NULL;
374 r = path_get_parent(*i, &p);
380 void unit_free(Unit *u) {
387 if (u->manager->n_reloading <= 0)
388 unit_remove_transient(u);
390 bus_unit_send_removed_signal(u);
392 if (u->load_state != UNIT_STUB)
393 if (UNIT_VTABLE(u)->done)
394 UNIT_VTABLE(u)->done(u);
396 SET_FOREACH(t, u->names, i)
397 hashmap_remove_value(u->manager->units, t, u);
411 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
412 bidi_set_free(u, u->dependencies[d]);
414 if (u->requires_mounts_for) {
415 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
416 strv_free(u->requires_mounts_for);
419 if (u->type != _UNIT_TYPE_INVALID)
420 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
422 if (u->in_load_queue)
423 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
425 if (u->in_dbus_queue)
426 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
428 if (u->in_cleanup_queue)
429 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
431 if (u->in_gc_queue) {
432 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
433 u->manager->n_in_gc_queue--;
436 if (u->in_cgroup_queue)
437 LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
439 free(u->cgroup_path);
440 free(u->description);
441 strv_free(u->documentation);
442 free(u->fragment_path);
443 free(u->source_path);
444 strv_free(u->dropin_paths);
447 set_free_free(u->names);
449 condition_free_list(u->conditions);
451 unit_ref_unset(&u->slice);
454 unit_ref_unset(u->refs);
459 UnitActiveState unit_active_state(Unit *u) {
462 if (u->load_state == UNIT_MERGED)
463 return unit_active_state(unit_follow_merge(u));
465 /* After a reload it might happen that a unit is not correctly
466 * loaded but still has a process around. That's why we won't
467 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
469 return UNIT_VTABLE(u)->active_state(u);
472 const char* unit_sub_state_to_string(Unit *u) {
475 return UNIT_VTABLE(u)->sub_state_to_string(u);
478 static void complete_move(Set **s, Set **other) {
486 set_move(*s, *other);
493 static void merge_names(Unit *u, Unit *other) {
500 complete_move(&u->names, &other->names);
502 set_free_free(other->names);
506 SET_FOREACH(t, u->names, i)
507 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
510 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
517 assert(d < _UNIT_DEPENDENCY_MAX);
519 /* Fix backwards pointers */
520 SET_FOREACH(back, other->dependencies[d], i) {
523 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
524 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
527 set_remove(back->dependencies[k], other);
529 assert(r == -ENOENT);
533 complete_move(&u->dependencies[d], &other->dependencies[d]);
535 set_free(other->dependencies[d]);
536 other->dependencies[d] = NULL;
539 int unit_merge(Unit *u, Unit *other) {
544 assert(u->manager == other->manager);
545 assert(u->type != _UNIT_TYPE_INVALID);
547 other = unit_follow_merge(other);
552 if (u->type != other->type)
555 if (!u->instance != !other->instance)
558 if (other->load_state != UNIT_STUB &&
559 other->load_state != UNIT_NOT_FOUND)
568 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
572 merge_names(u, other);
574 /* Redirect all references */
576 unit_ref_set(other->refs, u);
578 /* Merge dependencies */
579 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
580 merge_dependencies(u, other, d);
582 other->load_state = UNIT_MERGED;
583 other->merged_into = u;
585 /* If there is still some data attached to the other node, we
586 * don't need it anymore, and can free it. */
587 if (other->load_state != UNIT_STUB)
588 if (UNIT_VTABLE(other)->done)
589 UNIT_VTABLE(other)->done(other);
591 unit_add_to_dbus_queue(u);
592 unit_add_to_cleanup_queue(other);
597 int unit_merge_by_name(Unit *u, const char *name) {
605 if (unit_name_is_template(name)) {
609 if (!(s = unit_name_replace_instance(name, u->instance)))
615 other = manager_get_unit(u->manager, name);
617 r = unit_add_name(u, name);
619 r = unit_merge(u, other);
625 Unit* unit_follow_merge(Unit *u) {
628 while (u->load_state == UNIT_MERGED)
629 assert_se(u = u->merged_into);
634 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
640 if (c->std_output != EXEC_OUTPUT_KMSG &&
641 c->std_output != EXEC_OUTPUT_SYSLOG &&
642 c->std_output != EXEC_OUTPUT_JOURNAL &&
643 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
644 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
645 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
646 c->std_error != EXEC_OUTPUT_KMSG &&
647 c->std_error != EXEC_OUTPUT_SYSLOG &&
648 c->std_error != EXEC_OUTPUT_JOURNAL &&
649 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
650 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
651 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
654 /* If syslog or kernel logging is requested, make sure our own
655 * logging daemon is run first. */
657 if (u->manager->running_as == SYSTEMD_SYSTEM) {
658 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
666 const char *unit_description(Unit *u) {
670 return u->description;
675 void unit_dump(Unit *u, FILE *f, const char *prefix) {
682 timestamp1[FORMAT_TIMESTAMP_MAX],
683 timestamp2[FORMAT_TIMESTAMP_MAX],
684 timestamp3[FORMAT_TIMESTAMP_MAX],
685 timestamp4[FORMAT_TIMESTAMP_MAX],
686 timespan[FORMAT_TIMESPAN_MAX];
690 assert(u->type >= 0);
694 p2 = strappend(prefix, "\t");
695 prefix2 = p2 ? p2 : prefix;
699 "%s\tDescription: %s\n"
701 "%s\tUnit Load State: %s\n"
702 "%s\tUnit Active State: %s\n"
703 "%s\tInactive Exit Timestamp: %s\n"
704 "%s\tActive Enter Timestamp: %s\n"
705 "%s\tActive Exit Timestamp: %s\n"
706 "%s\tInactive Enter Timestamp: %s\n"
707 "%s\tGC Check Good: %s\n"
708 "%s\tNeed Daemon Reload: %s\n"
709 "%s\tTransient: %s\n"
712 "%s\tCGroup realized: %s\n"
713 "%s\tCGroup mask: 0x%x\n",
715 prefix, unit_description(u),
716 prefix, strna(u->instance),
717 prefix, unit_load_state_to_string(u->load_state),
718 prefix, unit_active_state_to_string(unit_active_state(u)),
719 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
720 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
721 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
722 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
723 prefix, yes_no(unit_check_gc(u)),
724 prefix, yes_no(unit_need_daemon_reload(u)),
725 prefix, yes_no(u->transient),
726 prefix, strna(unit_slice_name(u)),
727 prefix, strna(u->cgroup_path),
728 prefix, yes_no(u->cgroup_realized),
729 prefix, u->cgroup_mask);
731 SET_FOREACH(t, u->names, i)
732 fprintf(f, "%s\tName: %s\n", prefix, t);
734 STRV_FOREACH(j, u->documentation)
735 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
737 if ((following = unit_following(u)))
738 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
740 if (u->fragment_path)
741 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
744 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
746 STRV_FOREACH(j, u->dropin_paths)
747 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
749 if (u->job_timeout > 0)
750 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
752 condition_dump_list(u->conditions, f, prefix);
754 if (dual_timestamp_is_set(&u->condition_timestamp))
756 "%s\tCondition Timestamp: %s\n"
757 "%s\tCondition Result: %s\n",
758 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
759 prefix, yes_no(u->condition_result));
761 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
764 SET_FOREACH(other, u->dependencies[d], i)
765 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
768 if (!strv_isempty(u->requires_mounts_for)) {
770 "%s\tRequiresMountsFor:", prefix);
772 STRV_FOREACH(j, u->requires_mounts_for)
773 fprintf(f, " %s", *j);
778 if (u->load_state == UNIT_LOADED) {
781 "%s\tStopWhenUnneeded: %s\n"
782 "%s\tRefuseManualStart: %s\n"
783 "%s\tRefuseManualStop: %s\n"
784 "%s\tDefaultDependencies: %s\n"
785 "%s\tOnFailureIsolate: %s\n"
786 "%s\tIgnoreOnIsolate: %s\n"
787 "%s\tIgnoreOnSnapshot: %s\n",
788 prefix, yes_no(u->stop_when_unneeded),
789 prefix, yes_no(u->refuse_manual_start),
790 prefix, yes_no(u->refuse_manual_stop),
791 prefix, yes_no(u->default_dependencies),
792 prefix, yes_no(u->on_failure_isolate),
793 prefix, yes_no(u->ignore_on_isolate),
794 prefix, yes_no(u->ignore_on_snapshot));
796 if (UNIT_VTABLE(u)->dump)
797 UNIT_VTABLE(u)->dump(u, f, prefix2);
799 } else if (u->load_state == UNIT_MERGED)
801 "%s\tMerged into: %s\n",
802 prefix, u->merged_into->id);
803 else if (u->load_state == UNIT_ERROR)
804 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
808 job_dump(u->job, f, prefix2);
811 job_dump(u->nop_job, f, prefix2);
816 /* Common implementation for multiple backends */
817 int unit_load_fragment_and_dropin(Unit *u) {
822 /* Load a .service file */
823 r = unit_load_fragment(u);
827 if (u->load_state == UNIT_STUB)
830 /* Load drop-in directory data */
831 r = unit_load_dropin(unit_follow_merge(u));
838 /* Common implementation for multiple backends */
839 int unit_load_fragment_and_dropin_optional(Unit *u) {
844 /* Same as unit_load_fragment_and_dropin(), but whether
845 * something can be loaded or not doesn't matter. */
847 /* Load a .service file */
848 r = unit_load_fragment(u);
852 if (u->load_state == UNIT_STUB)
853 u->load_state = UNIT_LOADED;
855 /* Load drop-in directory data */
856 r = unit_load_dropin(unit_follow_merge(u));
863 int unit_add_default_target_dependency(Unit *u, Unit *target) {
867 if (target->type != UNIT_TARGET)
870 /* Only add the dependency if both units are loaded, so that
871 * that loop check below is reliable */
872 if (u->load_state != UNIT_LOADED ||
873 target->load_state != UNIT_LOADED)
876 /* If either side wants no automatic dependencies, then let's
878 if (!u->default_dependencies ||
879 !target->default_dependencies)
882 /* Don't create loops */
883 if (set_get(target->dependencies[UNIT_BEFORE], u))
886 return unit_add_dependency(target, UNIT_AFTER, u, true);
889 static int unit_add_default_dependencies(Unit *u) {
891 static const UnitDependency deps[] = {
893 UNIT_REQUIRED_BY_OVERRIDABLE,
905 for (k = 0; k < ELEMENTSOF(deps); k++)
906 SET_FOREACH(target, u->dependencies[deps[k]], i) {
907 r = unit_add_default_target_dependency(u, target);
912 if (u->default_dependencies && unit_get_cgroup_context(u)) {
913 if (UNIT_ISSET(u->slice))
914 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
916 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
925 int unit_load(Unit *u) {
930 if (u->in_load_queue) {
931 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
932 u->in_load_queue = false;
935 if (u->type == _UNIT_TYPE_INVALID)
938 if (u->load_state != UNIT_STUB)
941 if (UNIT_VTABLE(u)->load) {
942 r = UNIT_VTABLE(u)->load(u);
947 if (u->load_state == UNIT_STUB) {
952 if (u->load_state == UNIT_LOADED) {
954 if (u->default_dependencies) {
955 r = unit_add_default_dependencies(u);
960 r = unit_add_mount_links(u);
964 if (u->on_failure_isolate &&
965 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
967 log_error_unit(u->id,
968 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
975 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
977 unit_add_to_dbus_queue(unit_follow_merge(u));
978 unit_add_to_gc_queue(u);
983 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
985 unit_add_to_dbus_queue(u);
986 unit_add_to_gc_queue(u);
988 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
989 u->id, strerror(-r));
994 bool unit_condition_test(Unit *u) {
997 dual_timestamp_get(&u->condition_timestamp);
998 u->condition_result = condition_test_list(u->conditions);
1000 return u->condition_result;
1003 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1004 const UnitStatusMessageFormats *format_table;
1008 assert(t < _JOB_TYPE_MAX);
1010 if (t != JOB_START && t != JOB_STOP)
1013 format_table = &UNIT_VTABLE(u)->status_message_formats;
1017 return format_table->starting_stopping[t == JOB_STOP];
1020 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1025 assert(t < _JOB_TYPE_MAX);
1027 format = unit_get_status_message_format(u, t);
1031 /* Return generic strings */
1033 return "Starting %s.";
1034 else if (t == JOB_STOP)
1035 return "Stopping %s.";
1036 else if (t == JOB_RELOAD)
1037 return "Reloading %s.";
1042 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1047 /* We only print status messages for selected units on
1048 * selected operations. */
1050 format = unit_get_status_message_format(u, t);
1054 unit_status_printf(u, "", format);
1057 #pragma GCC diagnostic push
1058 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1059 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1066 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1069 if (log_on_console())
1072 /* We log status messages for all units and all operations. */
1074 format = unit_get_status_message_format_try_harder(u, t);
1078 snprintf(buf, sizeof(buf), format, unit_description(u));
1081 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1082 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1083 SD_MESSAGE_UNIT_RELOADING;
1085 log_struct_unit(LOG_INFO,
1091 #pragma GCC diagnostic pop
1094 * -EBADR: This unit type does not support starting.
1095 * -EALREADY: Unit is already started.
1096 * -EAGAIN: An operation is already in progress. Retry later.
1097 * -ECANCELED: Too many requests for now.
1099 int unit_start(Unit *u) {
1100 UnitActiveState state;
1105 if (u->load_state != UNIT_LOADED)
1108 /* If this is already started, then this will succeed. Note
1109 * that this will even succeed if this unit is not startable
1110 * by the user. This is relied on to detect when we need to
1111 * wait for units and when waiting is finished. */
1112 state = unit_active_state(u);
1113 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1116 /* If the conditions failed, don't do anything at all. If we
1117 * already are activating this call might still be useful to
1118 * speed up activation in case there is some hold-off time,
1119 * but we don't want to recheck the condition in that case. */
1120 if (state != UNIT_ACTIVATING &&
1121 !unit_condition_test(u)) {
1122 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1126 /* Forward to the main object, if we aren't it. */
1127 if ((following = unit_following(u))) {
1128 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1129 u->id, following->id);
1130 return unit_start(following);
1133 unit_status_log_starting_stopping_reloading(u, JOB_START);
1134 unit_status_print_starting_stopping(u, JOB_START);
1136 /* If it is stopped, but we cannot start it, then fail */
1137 if (!UNIT_VTABLE(u)->start)
1140 /* We don't suppress calls to ->start() here when we are
1141 * already starting, to allow this request to be used as a
1142 * "hurry up" call, for example when the unit is in some "auto
1143 * restart" state where it waits for a holdoff timer to elapse
1144 * before it will start again. */
1146 unit_add_to_dbus_queue(u);
1148 return UNIT_VTABLE(u)->start(u);
1151 bool unit_can_start(Unit *u) {
1154 return !!UNIT_VTABLE(u)->start;
1157 bool unit_can_isolate(Unit *u) {
1160 return unit_can_start(u) &&
1165 * -EBADR: This unit type does not support stopping.
1166 * -EALREADY: Unit is already stopped.
1167 * -EAGAIN: An operation is already in progress. Retry later.
1169 int unit_stop(Unit *u) {
1170 UnitActiveState state;
1175 state = unit_active_state(u);
1176 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1179 if ((following = unit_following(u))) {
1180 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1181 u->id, following->id);
1182 return unit_stop(following);
1185 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1186 unit_status_print_starting_stopping(u, JOB_STOP);
1188 if (!UNIT_VTABLE(u)->stop)
1191 unit_add_to_dbus_queue(u);
1193 return UNIT_VTABLE(u)->stop(u);
1197 * -EBADR: This unit type does not support reloading.
1198 * -ENOEXEC: Unit is not started.
1199 * -EAGAIN: An operation is already in progress. Retry later.
1201 int unit_reload(Unit *u) {
1202 UnitActiveState state;
1207 if (u->load_state != UNIT_LOADED)
1210 if (!unit_can_reload(u))
1213 state = unit_active_state(u);
1214 if (state == UNIT_RELOADING)
1217 if (state != UNIT_ACTIVE)
1220 if ((following = unit_following(u))) {
1221 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1222 u->id, following->id);
1223 return unit_reload(following);
1226 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1228 unit_add_to_dbus_queue(u);
1229 return UNIT_VTABLE(u)->reload(u);
1232 bool unit_can_reload(Unit *u) {
1235 if (!UNIT_VTABLE(u)->reload)
1238 if (!UNIT_VTABLE(u)->can_reload)
1241 return UNIT_VTABLE(u)->can_reload(u);
1244 static void unit_check_unneeded(Unit *u) {
1250 /* If this service shall be shut down when unneeded then do
1253 if (!u->stop_when_unneeded)
1256 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1259 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1260 if (unit_active_or_pending(other))
1263 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1264 if (unit_active_or_pending(other))
1267 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1268 if (unit_active_or_pending(other))
1271 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1272 if (unit_active_or_pending(other))
1275 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1277 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1278 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1281 static void retroactively_start_dependencies(Unit *u) {
1286 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1288 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], 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_BINDS_TO], 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_REPLACE, true, NULL, NULL);
1298 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], 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_WANTS], i)
1304 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1305 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1306 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1308 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1309 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1310 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1312 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1313 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1314 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1317 static void retroactively_stop_dependencies(Unit *u) {
1322 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1324 /* Pull down units which are bound to us recursively if enabled */
1325 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1326 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1327 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1330 static void check_unneeded_dependencies(Unit *u) {
1335 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1337 /* Garbage collect services that might not be needed anymore, if enabled */
1338 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1339 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1340 unit_check_unneeded(other);
1341 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1342 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1343 unit_check_unneeded(other);
1344 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1345 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1346 unit_check_unneeded(other);
1347 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1348 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1349 unit_check_unneeded(other);
1350 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1351 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1352 unit_check_unneeded(other);
1353 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1354 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1355 unit_check_unneeded(other);
1358 void unit_start_on_failure(Unit *u) {
1364 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1367 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1369 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1372 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1374 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1378 void unit_trigger_notify(Unit *u) {
1384 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1385 if (UNIT_VTABLE(other)->trigger_notify)
1386 UNIT_VTABLE(other)->trigger_notify(other, u);
1389 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1394 assert(os < _UNIT_ACTIVE_STATE_MAX);
1395 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1397 /* Note that this is called for all low-level state changes,
1398 * even if they might map to the same high-level
1399 * UnitActiveState! That means that ns == os is OK an expected
1400 * behavior here. For example: if a mount point is remounted
1401 * this function will be called too! */
1405 if (m->n_reloading <= 0) {
1408 dual_timestamp_get(&ts);
1410 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1411 u->inactive_exit_timestamp = ts;
1412 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1413 u->inactive_enter_timestamp = ts;
1415 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1416 u->active_enter_timestamp = ts;
1417 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1418 u->active_exit_timestamp = ts;
1421 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1422 unit_destroy_cgroup(u);
1424 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1425 ExecContext *ec = unit_get_exec_context(u);
1426 if (ec && exec_context_may_touch_console(ec)) {
1427 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1437 if (u->job->state == JOB_WAITING)
1439 /* So we reached a different state for this
1440 * job. Let's see if we can run it now if it
1441 * failed previously due to EAGAIN. */
1442 job_add_to_run_queue(u->job);
1444 /* Let's check whether this state change constitutes a
1445 * finished job, or maybe contradicts a running job and
1446 * hence needs to invalidate jobs. */
1448 switch (u->job->type) {
1451 case JOB_VERIFY_ACTIVE:
1453 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1454 job_finish_and_invalidate(u->job, JOB_DONE, true);
1455 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1458 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1459 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1465 case JOB_RELOAD_OR_START:
1467 if (u->job->state == JOB_RUNNING) {
1468 if (ns == UNIT_ACTIVE)
1469 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1470 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1473 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1474 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1482 case JOB_TRY_RESTART:
1484 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1485 job_finish_and_invalidate(u->job, JOB_DONE, true);
1486 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1488 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1494 assert_not_reached("Job type unknown");
1500 if (m->n_reloading <= 0) {
1502 /* If this state change happened without being
1503 * requested by a job, then let's retroactively start
1504 * or stop dependencies. We skip that step when
1505 * deserializing, since we don't want to create any
1506 * additional jobs just because something is already
1510 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1511 retroactively_start_dependencies(u);
1512 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1513 retroactively_stop_dependencies(u);
1516 /* stop unneeded units regardless if going down was expected or not */
1517 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1518 check_unneeded_dependencies(u);
1520 if (ns != os && ns == UNIT_FAILED) {
1521 log_notice_unit(u->id,
1522 "Unit %s entered failed state.", u->id);
1523 unit_start_on_failure(u);
1527 /* Some names are special */
1528 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1530 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1531 /* The bus just might have become available,
1532 * hence try to connect to it, if we aren't
1536 if (u->type == UNIT_SERVICE &&
1537 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1538 m->n_reloading <= 0) {
1539 /* Write audit record if we have just finished starting up */
1540 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1544 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1545 manager_send_unit_plymouth(m, u);
1549 /* We don't care about D-Bus here, since we'll get an
1550 * asynchronous notification for it anyway. */
1552 if (u->type == UNIT_SERVICE &&
1553 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1554 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1555 m->n_reloading <= 0) {
1557 /* Hmm, if there was no start record written
1558 * write it now, so that we always have a nice
1561 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1563 if (ns == UNIT_INACTIVE)
1564 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1566 /* Write audit record if we have just finished shutting down */
1567 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1569 u->in_audit = false;
1573 manager_recheck_journal(m);
1574 unit_trigger_notify(u);
1576 /* Maybe we finished startup and are now ready for being
1577 * stopped because unneeded? */
1578 if (u->manager->n_reloading <= 0)
1579 unit_check_unneeded(u);
1581 unit_add_to_dbus_queue(u);
1582 unit_add_to_gc_queue(u);
1585 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1586 struct epoll_event ev = {
1594 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1596 if (epoll_ctl(u->manager->epoll_fd,
1597 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1609 void unit_unwatch_fd(Unit *u, Watch *w) {
1613 if (w->type == WATCH_INVALID)
1616 assert(w->type == WATCH_FD);
1617 assert(w->data.unit == u);
1618 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1621 w->type = WATCH_INVALID;
1622 w->data.unit = NULL;
1625 int unit_watch_pid(Unit *u, pid_t pid) {
1629 /* Watch a specific PID. We only support one unit watching
1630 * each PID for now. */
1632 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1635 void unit_unwatch_pid(Unit *u, pid_t pid) {
1639 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1642 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1643 struct itimerspec its = {};
1649 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1651 /* This will try to reuse the old timer if there is one */
1653 if (w->type == WATCH_UNIT_TIMER) {
1654 assert(w->data.unit == u);
1659 } else if (w->type == WATCH_INVALID) {
1662 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1666 assert_not_reached("Invalid watch type");
1669 /* Set absolute time in the past, but not 0, since we
1670 * don't want to disarm the timer */
1671 its.it_value.tv_sec = 0;
1672 its.it_value.tv_nsec = 1;
1674 flags = TFD_TIMER_ABSTIME;
1676 timespec_store(&its.it_value, usec);
1677 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1680 /* This will also flush the elapse counter */
1681 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1684 if (w->type == WATCH_INVALID) {
1685 struct epoll_event ev = {
1690 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1694 w->type = WATCH_UNIT_TIMER;
1702 close_nointr_nofail(fd);
1707 void unit_unwatch_timer(Unit *u, Watch *w) {
1711 if (w->type == WATCH_INVALID)
1714 assert(w->type == WATCH_UNIT_TIMER);
1715 assert(w->data.unit == u);
1718 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1719 close_nointr_nofail(w->fd);
1722 w->type = WATCH_INVALID;
1723 w->data.unit = NULL;
1726 bool unit_job_is_applicable(Unit *u, JobType j) {
1728 assert(j >= 0 && j < _JOB_TYPE_MAX);
1732 case JOB_VERIFY_ACTIVE:
1739 case JOB_TRY_RESTART:
1740 return unit_can_start(u);
1743 return unit_can_reload(u);
1745 case JOB_RELOAD_OR_START:
1746 return unit_can_reload(u) && unit_can_start(u);
1749 assert_not_reached("Invalid job type");
1753 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1755 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1756 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1757 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1758 [UNIT_WANTS] = UNIT_WANTED_BY,
1759 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1760 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1761 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1762 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1763 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1764 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1765 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1766 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1767 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1768 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1769 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1770 [UNIT_BEFORE] = UNIT_AFTER,
1771 [UNIT_AFTER] = UNIT_BEFORE,
1772 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1773 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1774 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1775 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1776 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1777 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1778 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1780 int r, q = 0, v = 0, w = 0;
1783 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1786 u = unit_follow_merge(u);
1787 other = unit_follow_merge(other);
1789 /* We won't allow dependencies on ourselves. We will not
1790 * consider them an error however. */
1794 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1797 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1798 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1802 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1803 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1806 if ((q = set_put(u->dependencies[d], other)) < 0)
1809 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1810 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1815 if (add_reference) {
1816 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1821 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1825 unit_add_to_dbus_queue(u);
1830 set_remove(u->dependencies[d], other);
1833 set_remove(other->dependencies[inverse_table[d]], u);
1836 set_remove(u->dependencies[UNIT_REFERENCES], other);
1841 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1846 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1849 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1855 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1859 assert(name || path);
1863 name = path_get_file_name(path);
1865 if (!unit_name_is_template(name)) {
1871 s = unit_name_replace_instance(name, u->instance);
1873 _cleanup_free_ char *i = NULL;
1875 i = unit_name_to_prefix(u->id);
1879 s = unit_name_replace_instance(name, i);
1889 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1892 _cleanup_free_ char *s = NULL;
1895 assert(name || path);
1897 name = resolve_template(u, name, path, &s);
1901 r = manager_load_unit(u->manager, name, path, NULL, &other);
1905 return unit_add_dependency(u, d, other, add_reference);
1908 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1914 assert(name || path);
1916 if (!(name = resolve_template(u, name, path, &s)))
1919 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1922 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1929 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1935 assert(name || path);
1937 if (!(name = resolve_template(u, name, path, &s)))
1940 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1943 r = unit_add_dependency(other, d, u, add_reference);
1950 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1956 assert(name || path);
1958 if (!(name = resolve_template(u, name, path, &s)))
1961 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1964 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1972 int set_unit_path(const char *p) {
1973 _cleanup_free_ char *c = NULL;
1975 /* This is mostly for debug purposes */
1976 c = path_make_absolute_cwd(p);
1977 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1983 char *unit_dbus_path(Unit *u) {
1989 return unit_dbus_path_from_name(u->id);
1992 char *unit_default_cgroup_path(Unit *u) {
1993 _cleanup_free_ char *escaped_instance = NULL, *slice = NULL;
1998 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1999 return strdup(u->manager->cgroup_root);
2001 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2002 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2007 escaped_instance = cg_escape(u->id);
2008 if (!escaped_instance)
2012 _cleanup_free_ char *t = NULL, *escaped_template = NULL;
2014 t = unit_name_template(u->id);
2018 escaped_template = cg_escape(t);
2019 if (!escaped_template)
2022 return strjoin(u->manager->cgroup_root, "/",
2023 slice ? slice : "", slice ? "/" : "",
2024 escaped_template, "/", escaped_instance, NULL);
2026 return strjoin(u->manager->cgroup_root, "/",
2027 slice ? slice : "", slice ? "/" : "",
2028 escaped_instance, NULL);
2031 int unit_add_default_slice(Unit *u) {
2037 if (UNIT_ISSET(u->slice))
2040 if (!unit_get_cgroup_context(u))
2043 r = manager_load_unit(u->manager, u->manager->running_as == SYSTEMD_SYSTEM ? SPECIAL_SYSTEM_SLICE : SPECIAL_ROOT_SLICE, NULL, NULL, &slice);
2047 unit_ref_set(&u->slice, slice);
2051 const char *unit_slice_name(Unit *u) {
2054 if (!UNIT_ISSET(u->slice))
2057 return UNIT_DEREF(u->slice)->id;
2060 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2061 _cleanup_free_ char *t = NULL;
2068 t = unit_name_change_suffix(u->id, type);
2072 assert(!unit_has_name(u, t));
2074 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2075 assert(r < 0 || *_found != u);
2079 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2080 _cleanup_free_ char *t = NULL;
2087 t = unit_name_change_suffix(u->id, type);
2091 assert(!unit_has_name(u, t));
2093 found = manager_get_unit(u->manager, t);
2101 int unit_watch_bus_name(Unit *u, const char *name) {
2105 /* Watch a specific name on the bus. We only support one unit
2106 * watching each name for now. */
2108 return hashmap_put(u->manager->watch_bus, name, u);
2111 void unit_unwatch_bus_name(Unit *u, const char *name) {
2115 hashmap_remove_value(u->manager->watch_bus, name, u);
2118 bool unit_can_serialize(Unit *u) {
2121 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2124 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2131 if (!unit_can_serialize(u))
2134 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2138 if (serialize_jobs) {
2140 fprintf(f, "job\n");
2141 job_serialize(u->job, f, fds);
2145 fprintf(f, "job\n");
2146 job_serialize(u->nop_job, f, fds);
2150 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2151 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2152 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2153 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2154 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2156 if (dual_timestamp_is_set(&u->condition_timestamp))
2157 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2159 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2162 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2169 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2180 va_start(ap, format);
2181 vfprintf(f, format, ap);
2187 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2193 fprintf(f, "%s=%s\n", key, value);
2196 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2203 if (!unit_can_serialize(u))
2207 char line[LINE_MAX], *l, *v;
2210 if (!fgets(line, sizeof(line), f)) {
2223 k = strcspn(l, "=");
2231 if (streq(l, "job")) {
2233 /* new-style serialized job */
2234 Job *j = job_new_raw(u);
2238 r = job_deserialize(j, f, fds);
2244 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2250 r = job_install_deserialized(j);
2252 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2257 if (j->state == JOB_RUNNING)
2258 u->manager->n_running_jobs++;
2261 JobType type = job_type_from_string(v);
2263 log_debug("Failed to parse job type value %s", v);
2265 u->deserialized_job = type;
2268 } else if (streq(l, "inactive-exit-timestamp")) {
2269 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2271 } else if (streq(l, "active-enter-timestamp")) {
2272 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2274 } else if (streq(l, "active-exit-timestamp")) {
2275 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2277 } else if (streq(l, "inactive-enter-timestamp")) {
2278 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2280 } else if (streq(l, "condition-timestamp")) {
2281 dual_timestamp_deserialize(v, &u->condition_timestamp);
2283 } else if (streq(l, "condition-result")) {
2286 b = parse_boolean(v);
2288 log_debug("Failed to parse condition result value %s", v);
2290 u->condition_result = b;
2294 } else if (streq(l, "transient")) {
2297 b = parse_boolean(v);
2299 log_debug("Failed to parse transient bool %s", v);
2304 } else if (streq(l, "cgroup")) {
2311 free(u->cgroup_path);
2316 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2322 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2332 /* Adds in links to the device node that this unit is based on */
2334 if (!is_device_path(what))
2337 e = unit_name_from_path(what, ".device");
2341 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2346 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2351 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2359 int unit_coldplug(Unit *u) {
2364 if (UNIT_VTABLE(u)->coldplug)
2365 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2369 r = job_coldplug(u->job);
2372 } else if (u->deserialized_job >= 0) {
2374 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2378 u->deserialized_job = _JOB_TYPE_INVALID;
2384 #pragma GCC diagnostic push
2385 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2386 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2387 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2389 #pragma GCC diagnostic pop
2391 bool unit_need_daemon_reload(Unit *u) {
2392 _cleanup_strv_free_ char **t = NULL;
2395 unsigned loaded_cnt, current_cnt;
2399 if (u->fragment_path) {
2401 if (stat(u->fragment_path, &st) < 0)
2402 /* What, cannot access this anymore? */
2405 if (u->fragment_mtime > 0 &&
2406 timespec_load(&st.st_mtim) != u->fragment_mtime)
2410 if (u->source_path) {
2412 if (stat(u->source_path, &st) < 0)
2415 if (u->source_mtime > 0 &&
2416 timespec_load(&st.st_mtim) != u->source_mtime)
2420 t = unit_find_dropin_paths(u);
2421 loaded_cnt = strv_length(t);
2422 current_cnt = strv_length(u->dropin_paths);
2424 if (loaded_cnt == current_cnt) {
2425 if (loaded_cnt == 0)
2428 if (strv_overlap(u->dropin_paths, t)) {
2429 STRV_FOREACH(path, u->dropin_paths) {
2431 if (stat(*path, &st) < 0)
2434 if (u->dropin_mtime > 0 &&
2435 timespec_load(&st.st_mtim) > u->dropin_mtime)
2446 void unit_reset_failed(Unit *u) {
2449 if (UNIT_VTABLE(u)->reset_failed)
2450 UNIT_VTABLE(u)->reset_failed(u);
2453 Unit *unit_following(Unit *u) {
2456 if (UNIT_VTABLE(u)->following)
2457 return UNIT_VTABLE(u)->following(u);
2462 bool unit_stop_pending(Unit *u) {
2465 /* This call does check the current state of the unit. It's
2466 * hence useful to be called from state change calls of the
2467 * unit itself, where the state isn't updated yet. This is
2468 * different from unit_inactive_or_pending() which checks both
2469 * the current state and for a queued job. */
2471 return u->job && u->job->type == JOB_STOP;
2474 bool unit_inactive_or_pending(Unit *u) {
2477 /* Returns true if the unit is inactive or going down */
2479 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2482 if (unit_stop_pending(u))
2488 bool unit_active_or_pending(Unit *u) {
2491 /* Returns true if the unit is active or going up */
2493 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2497 (u->job->type == JOB_START ||
2498 u->job->type == JOB_RELOAD_OR_START ||
2499 u->job->type == JOB_RESTART))
2505 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2507 assert(w >= 0 && w < _KILL_WHO_MAX);
2509 assert(signo < _NSIG);
2511 if (!UNIT_VTABLE(u)->kill)
2514 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2517 int unit_kill_common(
2527 if (who == KILL_MAIN && main_pid <= 0) {
2529 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2531 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2535 if (who == KILL_CONTROL && control_pid <= 0) {
2536 if (control_pid < 0)
2537 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2539 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2543 if (who == KILL_CONTROL || who == KILL_ALL)
2544 if (control_pid > 0)
2545 if (kill(control_pid, signo) < 0)
2548 if (who == KILL_MAIN || who == KILL_ALL)
2550 if (kill(main_pid, signo) < 0)
2553 if (who == KILL_ALL && u->cgroup_path) {
2554 _cleanup_set_free_ Set *pid_set = NULL;
2557 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2561 /* Exclude the control/main pid from being killed via the cgroup */
2562 if (control_pid > 0) {
2563 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2569 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2574 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2575 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2582 int unit_following_set(Unit *u, Set **s) {
2586 if (UNIT_VTABLE(u)->following_set)
2587 return UNIT_VTABLE(u)->following_set(u, s);
2593 UnitFileState unit_get_unit_file_state(Unit *u) {
2596 if (u->unit_file_state < 0 && u->fragment_path)
2597 u->unit_file_state = unit_file_get_state(
2598 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2599 NULL, path_get_file_name(u->fragment_path));
2601 return u->unit_file_state;
2604 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2609 unit_ref_unset(ref);
2612 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2616 void unit_ref_unset(UnitRef *ref) {
2622 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2626 int unit_add_one_mount_link(Unit *u, Mount *m) {
2632 if (u->load_state != UNIT_LOADED ||
2633 UNIT(m)->load_state != UNIT_LOADED)
2636 STRV_FOREACH(i, u->requires_mounts_for) {
2641 if (!path_startswith(*i, m->where))
2644 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2650 int unit_add_mount_links(Unit *u) {
2656 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2657 r = unit_add_one_mount_link(u, MOUNT(other));
2665 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2672 /* This only copies in the ones that need memory */
2673 for (i = 0; i < RLIMIT_NLIMITS; i++)
2674 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2675 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2680 if (u->manager->running_as == SYSTEMD_USER &&
2681 !c->working_directory) {
2683 r = get_home_dir(&c->working_directory);
2691 ExecContext *unit_get_exec_context(Unit *u) {
2695 offset = UNIT_VTABLE(u)->exec_context_offset;
2699 return (ExecContext*) ((uint8_t*) u + offset);
2702 CGroupContext *unit_get_cgroup_context(Unit *u) {
2705 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2709 return (CGroupContext*) ((uint8_t*) u + offset);
2712 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2720 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2722 if (!filename_is_safe(name))
2725 if (u->manager->running_as == SYSTEMD_USER) {
2726 _cleanup_free_ char *c = NULL;
2728 r = user_config_home(&c);
2734 p = strjoin(c, "/", u->id, ".d", NULL);
2735 } else if (mode & UNIT_PERSISTENT)
2736 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2738 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2742 q = strjoin(p, "/90-", name, ".conf", NULL);
2753 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2754 _cleanup_free_ char *p = NULL, *q = NULL;
2761 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2764 r = drop_in_file(u, mode, name, &p, &q);
2769 return write_string_file_atomic_label(q, data);
2772 int unit_write_drop_in_private_section(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2773 _cleanup_free_ char *ndata = NULL;
2779 if (!UNIT_VTABLE(u)->private_section)
2782 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2786 return unit_write_drop_in(u, mode, name, ndata);
2789 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2790 _cleanup_free_ char *p = NULL, *q = NULL;
2795 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2798 r = drop_in_file(u, mode, name, &p, &q);
2800 r = errno == ENOENT ? 0 : -errno;
2808 int unit_make_transient(Unit *u) {
2813 u->load_state = UNIT_STUB;
2815 u->transient = true;
2817 free(u->fragment_path);
2818 u->fragment_path = NULL;
2820 if (u->manager->running_as == SYSTEMD_USER) {
2821 _cleanup_free_ char *c = NULL;
2823 r = user_config_home(&c);
2829 u->fragment_path = strjoin(c, "/", u->id, NULL);
2830 if (!u->fragment_path)
2835 u->fragment_path = strappend("/run/systemd/system/", u->id);
2836 if (!u->fragment_path)
2839 mkdir_p("/run/systemd/system", 0755);
2842 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2845 int unit_kill_context(
2851 bool main_pid_alien) {
2853 int sig, wait_for_exit = 0, r;
2858 if (c->kill_mode == KILL_NONE)
2861 sig = sigkill ? SIGKILL : c->kill_signal;
2864 r = kill_and_sigcont(main_pid, sig);
2866 if (r < 0 && r != -ESRCH) {
2867 _cleanup_free_ char *comm = NULL;
2868 get_process_comm(main_pid, &comm);
2870 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2871 (long) main_pid, strna(comm), strerror(-r));
2873 wait_for_exit = !main_pid_alien;
2876 if (control_pid > 0) {
2877 r = kill_and_sigcont(control_pid, sig);
2879 if (r < 0 && r != -ESRCH) {
2880 _cleanup_free_ char *comm = NULL;
2881 get_process_comm(control_pid, &comm);
2883 log_warning_unit(u->id,
2884 "Failed to kill control process %li (%s): %s",
2885 (long) control_pid, strna(comm), strerror(-r));
2887 wait_for_exit = true;
2890 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2891 _cleanup_set_free_ Set *pid_set = NULL;
2893 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2897 /* Exclude the main/control pids from being killed via the cgroup */
2899 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2904 if (control_pid > 0) {
2905 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2910 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2912 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2913 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2915 wait_for_exit = true;
2918 return wait_for_exit;
2921 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2922 [UNIT_ACTIVE] = "active",
2923 [UNIT_RELOADING] = "reloading",
2924 [UNIT_INACTIVE] = "inactive",
2925 [UNIT_FAILED] = "failed",
2926 [UNIT_ACTIVATING] = "activating",
2927 [UNIT_DEACTIVATING] = "deactivating"
2930 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2932 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2933 [UNIT_REQUIRES] = "Requires",
2934 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2935 [UNIT_REQUISITE] = "Requisite",
2936 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2937 [UNIT_WANTS] = "Wants",
2938 [UNIT_BINDS_TO] = "BindsTo",
2939 [UNIT_PART_OF] = "PartOf",
2940 [UNIT_REQUIRED_BY] = "RequiredBy",
2941 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2942 [UNIT_WANTED_BY] = "WantedBy",
2943 [UNIT_BOUND_BY] = "BoundBy",
2944 [UNIT_CONSISTS_OF] = "ConsistsOf",
2945 [UNIT_CONFLICTS] = "Conflicts",
2946 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2947 [UNIT_BEFORE] = "Before",
2948 [UNIT_AFTER] = "After",
2949 [UNIT_ON_FAILURE] = "OnFailure",
2950 [UNIT_TRIGGERS] = "Triggers",
2951 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2952 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2953 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2954 [UNIT_REFERENCES] = "References",
2955 [UNIT_REFERENCED_BY] = "ReferencedBy",
2958 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);