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 "specifier.h"
44 #include "dbus-unit.h"
46 #include "cgroup-util.h"
48 #include "cgroup-attr.h"
50 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
51 [UNIT_SERVICE] = &service_vtable,
52 [UNIT_TIMER] = &timer_vtable,
53 [UNIT_SOCKET] = &socket_vtable,
54 [UNIT_TARGET] = &target_vtable,
55 [UNIT_DEVICE] = &device_vtable,
56 [UNIT_MOUNT] = &mount_vtable,
57 [UNIT_AUTOMOUNT] = &automount_vtable,
58 [UNIT_SNAPSHOT] = &snapshot_vtable,
59 [UNIT_SWAP] = &swap_vtable,
60 [UNIT_PATH] = &path_vtable
63 Unit *unit_new(Manager *m, size_t size) {
67 assert(size >= sizeof(Unit));
73 u->names = set_new(string_hash_func, string_compare_func);
80 u->type = _UNIT_TYPE_INVALID;
81 u->deserialized_job = _JOB_TYPE_INVALID;
82 u->default_dependencies = true;
83 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
88 bool unit_has_name(Unit *u, const char *name) {
92 return !!set_get(u->names, (char*) name);
95 int unit_add_name(Unit *u, const char *text) {
103 if (unit_name_is_template(text)) {
107 s = unit_name_replace_instance(text, u->instance);
114 if (!unit_name_is_valid(s, false)) {
119 assert_se((t = unit_name_to_type(s)) >= 0);
121 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
126 if ((r = unit_name_to_instance(s, &i)) < 0)
129 if (i && unit_vtable[t]->no_instances) {
134 /* Ensure that this unit is either instanced or not instanced,
136 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
141 if (unit_vtable[t]->no_alias &&
142 !set_isempty(u->names) &&
143 !set_get(u->names, s)) {
148 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
153 if ((r = set_put(u->names, s)) < 0) {
159 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
160 set_remove(u->names, s);
164 if (u->type == _UNIT_TYPE_INVALID) {
170 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
172 if (UNIT_VTABLE(u)->init)
173 UNIT_VTABLE(u)->init(u);
177 unit_add_to_dbus_queue(u);
187 int unit_choose_id(Unit *u, const char *name) {
188 char *s, *t = NULL, *i;
194 if (unit_name_is_template(name)) {
199 if (!(t = unit_name_replace_instance(name, u->instance)))
205 /* Selects one of the names of this unit as the id */
206 s = set_get(u->names, (char*) name);
212 if ((r = unit_name_to_instance(s, &i)) < 0)
220 unit_add_to_dbus_queue(u);
225 int unit_set_description(Unit *u, const char *description) {
230 if (!(s = strdup(description)))
233 free(u->description);
236 unit_add_to_dbus_queue(u);
240 bool unit_check_gc(Unit *u) {
243 if (u->load_state == UNIT_STUB)
246 if (UNIT_VTABLE(u)->no_gc)
258 if (unit_active_state(u) != UNIT_INACTIVE)
261 if (UNIT_VTABLE(u)->check_gc)
262 if (UNIT_VTABLE(u)->check_gc(u))
268 void unit_add_to_load_queue(Unit *u) {
270 assert(u->type != _UNIT_TYPE_INVALID);
272 if (u->load_state != UNIT_STUB || u->in_load_queue)
275 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
276 u->in_load_queue = true;
279 void unit_add_to_cleanup_queue(Unit *u) {
282 if (u->in_cleanup_queue)
285 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
286 u->in_cleanup_queue = true;
289 void unit_add_to_gc_queue(Unit *u) {
292 if (u->in_gc_queue || u->in_cleanup_queue)
295 if (unit_check_gc(u))
298 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
299 u->in_gc_queue = true;
301 u->manager->n_in_gc_queue ++;
303 if (u->manager->gc_queue_timestamp <= 0)
304 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
307 void unit_add_to_dbus_queue(Unit *u) {
309 assert(u->type != _UNIT_TYPE_INVALID);
311 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
314 /* Shortcut things if nobody cares */
315 if (!bus_has_subscriber(u->manager)) {
316 u->sent_dbus_new_signal = true;
320 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
321 u->in_dbus_queue = true;
324 static void bidi_set_free(Unit *u, Set *s) {
330 /* Frees the set and makes sure we are dropped from the
331 * inverse pointers */
333 SET_FOREACH(other, s, i) {
336 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
337 set_remove(other->dependencies[d], u);
339 unit_add_to_gc_queue(other);
345 void unit_free(Unit *u) {
352 bus_unit_send_removed_signal(u);
354 if (u->load_state != UNIT_STUB)
355 if (UNIT_VTABLE(u)->done)
356 UNIT_VTABLE(u)->done(u);
358 SET_FOREACH(t, u->names, i)
359 hashmap_remove_value(u->manager->units, t, u);
373 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
374 bidi_set_free(u, u->dependencies[d]);
376 if (u->requires_mounts_for) {
377 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
378 strv_free(u->requires_mounts_for);
381 if (u->type != _UNIT_TYPE_INVALID)
382 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
384 if (u->in_load_queue)
385 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
387 if (u->in_dbus_queue)
388 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
390 if (u->in_cleanup_queue)
391 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
393 if (u->in_gc_queue) {
394 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
395 u->manager->n_in_gc_queue--;
398 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
399 cgroup_attribute_free_list(u->cgroup_attributes);
401 free(u->description);
402 strv_free(u->documentation);
403 free(u->fragment_path);
404 free(u->source_path);
407 set_free_free(u->names);
409 condition_free_list(u->conditions);
412 unit_ref_unset(u->refs);
417 UnitActiveState unit_active_state(Unit *u) {
420 if (u->load_state == UNIT_MERGED)
421 return unit_active_state(unit_follow_merge(u));
423 /* After a reload it might happen that a unit is not correctly
424 * loaded but still has a process around. That's why we won't
425 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
427 return UNIT_VTABLE(u)->active_state(u);
430 const char* unit_sub_state_to_string(Unit *u) {
433 return UNIT_VTABLE(u)->sub_state_to_string(u);
436 static void complete_move(Set **s, Set **other) {
444 set_move(*s, *other);
451 static void merge_names(Unit *u, Unit *other) {
458 complete_move(&u->names, &other->names);
460 set_free_free(other->names);
464 SET_FOREACH(t, u->names, i)
465 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
468 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
475 assert(d < _UNIT_DEPENDENCY_MAX);
477 /* Fix backwards pointers */
478 SET_FOREACH(back, other->dependencies[d], i) {
481 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
482 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
485 set_remove(back->dependencies[k], other);
487 assert(r == -ENOENT);
491 complete_move(&u->dependencies[d], &other->dependencies[d]);
493 set_free(other->dependencies[d]);
494 other->dependencies[d] = NULL;
497 int unit_merge(Unit *u, Unit *other) {
502 assert(u->manager == other->manager);
503 assert(u->type != _UNIT_TYPE_INVALID);
505 other = unit_follow_merge(other);
510 if (u->type != other->type)
513 if (!u->instance != !other->instance)
516 if (other->load_state != UNIT_STUB &&
517 other->load_state != UNIT_ERROR)
526 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
530 merge_names(u, other);
532 /* Redirect all references */
534 unit_ref_set(other->refs, u);
536 /* Merge dependencies */
537 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
538 merge_dependencies(u, other, d);
540 other->load_state = UNIT_MERGED;
541 other->merged_into = u;
543 /* If there is still some data attached to the other node, we
544 * don't need it anymore, and can free it. */
545 if (other->load_state != UNIT_STUB)
546 if (UNIT_VTABLE(other)->done)
547 UNIT_VTABLE(other)->done(other);
549 unit_add_to_dbus_queue(u);
550 unit_add_to_cleanup_queue(other);
555 int unit_merge_by_name(Unit *u, const char *name) {
563 if (unit_name_is_template(name)) {
567 if (!(s = unit_name_replace_instance(name, u->instance)))
573 if (!(other = manager_get_unit(u->manager, name)))
574 r = unit_add_name(u, name);
576 r = unit_merge(u, other);
582 Unit* unit_follow_merge(Unit *u) {
585 while (u->load_state == UNIT_MERGED)
586 assert_se(u = u->merged_into);
591 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
597 if (c->std_output != EXEC_OUTPUT_KMSG &&
598 c->std_output != EXEC_OUTPUT_SYSLOG &&
599 c->std_output != EXEC_OUTPUT_JOURNAL &&
600 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
601 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
602 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
603 c->std_error != EXEC_OUTPUT_KMSG &&
604 c->std_error != EXEC_OUTPUT_SYSLOG &&
605 c->std_error != EXEC_OUTPUT_JOURNAL &&
606 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
607 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
608 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
611 /* If syslog or kernel logging is requested, make sure our own
612 * logging daemon is run first. */
614 if (u->manager->running_as == MANAGER_SYSTEM)
615 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
621 const char *unit_description(Unit *u) {
625 return u->description;
630 void unit_dump(Unit *u, FILE *f, const char *prefix) {
637 timestamp1[FORMAT_TIMESTAMP_MAX],
638 timestamp2[FORMAT_TIMESTAMP_MAX],
639 timestamp3[FORMAT_TIMESTAMP_MAX],
640 timestamp4[FORMAT_TIMESTAMP_MAX],
641 timespan[FORMAT_TIMESPAN_MAX];
645 assert(u->type >= 0);
649 p2 = strappend(prefix, "\t");
650 prefix2 = p2 ? p2 : prefix;
654 "%s\tDescription: %s\n"
656 "%s\tUnit Load State: %s\n"
657 "%s\tUnit Active State: %s\n"
658 "%s\tInactive Exit Timestamp: %s\n"
659 "%s\tActive Enter Timestamp: %s\n"
660 "%s\tActive Exit Timestamp: %s\n"
661 "%s\tInactive Enter Timestamp: %s\n"
662 "%s\tGC Check Good: %s\n"
663 "%s\tNeed Daemon Reload: %s\n",
665 prefix, unit_description(u),
666 prefix, strna(u->instance),
667 prefix, unit_load_state_to_string(u->load_state),
668 prefix, unit_active_state_to_string(unit_active_state(u)),
669 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
670 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
671 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
672 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
673 prefix, yes_no(unit_check_gc(u)),
674 prefix, yes_no(unit_need_daemon_reload(u)));
676 SET_FOREACH(t, u->names, i)
677 fprintf(f, "%s\tName: %s\n", prefix, t);
679 STRV_FOREACH(j, u->documentation)
680 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
682 if ((following = unit_following(u)))
683 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
685 if (u->fragment_path)
686 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
689 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
691 if (u->job_timeout > 0)
692 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
694 condition_dump_list(u->conditions, f, prefix);
696 if (dual_timestamp_is_set(&u->condition_timestamp))
698 "%s\tCondition Timestamp: %s\n"
699 "%s\tCondition Result: %s\n",
700 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
701 prefix, yes_no(u->condition_result));
703 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
706 SET_FOREACH(other, u->dependencies[d], i)
707 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
710 if (!strv_isempty(u->requires_mounts_for)) {
712 "%s\tRequiresMountsFor:", prefix);
714 STRV_FOREACH(j, u->requires_mounts_for)
715 fprintf(f, " %s", *j);
720 if (u->load_state == UNIT_LOADED) {
725 "%s\tStopWhenUnneeded: %s\n"
726 "%s\tRefuseManualStart: %s\n"
727 "%s\tRefuseManualStop: %s\n"
728 "%s\tDefaultDependencies: %s\n"
729 "%s\tOnFailureIsolate: %s\n"
730 "%s\tIgnoreOnIsolate: %s\n"
731 "%s\tIgnoreOnSnapshot: %s\n",
732 prefix, yes_no(u->stop_when_unneeded),
733 prefix, yes_no(u->refuse_manual_start),
734 prefix, yes_no(u->refuse_manual_stop),
735 prefix, yes_no(u->default_dependencies),
736 prefix, yes_no(u->on_failure_isolate),
737 prefix, yes_no(u->ignore_on_isolate),
738 prefix, yes_no(u->ignore_on_snapshot));
740 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
741 fprintf(f, "%s\tControlGroup: %s:%s\n",
742 prefix, b->controller, b->path);
744 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
748 a->map_callback(a->controller, a->name, a->value, &v);
750 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
751 prefix, a->controller, a->name, v ? v : a->value);
756 if (UNIT_VTABLE(u)->dump)
757 UNIT_VTABLE(u)->dump(u, f, prefix2);
759 } else if (u->load_state == UNIT_MERGED)
761 "%s\tMerged into: %s\n",
762 prefix, u->merged_into->id);
763 else if (u->load_state == UNIT_ERROR)
764 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
768 job_dump(u->job, f, prefix2);
771 job_dump(u->nop_job, f, prefix2);
776 /* Common implementation for multiple backends */
777 int unit_load_fragment_and_dropin(Unit *u) {
782 /* Load a .service file */
783 if ((r = unit_load_fragment(u)) < 0)
786 if (u->load_state == UNIT_STUB)
789 /* Load drop-in directory data */
790 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
796 /* Common implementation for multiple backends */
797 int unit_load_fragment_and_dropin_optional(Unit *u) {
802 /* Same as unit_load_fragment_and_dropin(), but whether
803 * something can be loaded or not doesn't matter. */
805 /* Load a .service file */
806 if ((r = unit_load_fragment(u)) < 0)
809 if (u->load_state == UNIT_STUB)
810 u->load_state = UNIT_LOADED;
812 /* Load drop-in directory data */
813 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
819 int unit_add_default_target_dependency(Unit *u, Unit *target) {
823 if (target->type != UNIT_TARGET)
826 /* Only add the dependency if both units are loaded, so that
827 * that loop check below is reliable */
828 if (u->load_state != UNIT_LOADED ||
829 target->load_state != UNIT_LOADED)
832 /* If either side wants no automatic dependencies, then let's
834 if (!u->default_dependencies ||
835 !target->default_dependencies)
838 /* Don't create loops */
839 if (set_get(target->dependencies[UNIT_BEFORE], u))
842 return unit_add_dependency(target, UNIT_AFTER, u, true);
845 static int unit_add_default_dependencies(Unit *u) {
846 static const UnitDependency deps[] = {
848 UNIT_REQUIRED_BY_OVERRIDABLE,
860 for (k = 0; k < ELEMENTSOF(deps); k++)
861 SET_FOREACH(target, u->dependencies[deps[k]], i)
862 if ((r = unit_add_default_target_dependency(u, target)) < 0)
868 int unit_load(Unit *u) {
873 if (u->in_load_queue) {
874 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
875 u->in_load_queue = false;
878 if (u->type == _UNIT_TYPE_INVALID)
881 if (u->load_state != UNIT_STUB)
884 if (UNIT_VTABLE(u)->load)
885 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
888 if (u->load_state == UNIT_STUB) {
893 if (u->load_state == UNIT_LOADED &&
894 u->default_dependencies)
895 if ((r = unit_add_default_dependencies(u)) < 0)
898 if (u->load_state == UNIT_LOADED) {
899 r = unit_add_mount_links(u);
904 if (u->on_failure_isolate &&
905 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
907 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
914 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
916 unit_add_to_dbus_queue(unit_follow_merge(u));
917 unit_add_to_gc_queue(u);
922 u->load_state = UNIT_ERROR;
924 unit_add_to_dbus_queue(u);
925 unit_add_to_gc_queue(u);
927 log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
932 bool unit_condition_test(Unit *u) {
935 dual_timestamp_get(&u->condition_timestamp);
936 u->condition_result = condition_test_list(u->conditions);
938 return u->condition_result;
941 static const char* unit_get_status_message_format(Unit *u, JobType t) {
942 const UnitStatusMessageFormats *format_table;
946 assert(t < _JOB_TYPE_MAX);
948 if (t != JOB_START && t != JOB_STOP)
951 format_table = &UNIT_VTABLE(u)->status_message_formats;
955 return format_table->starting_stopping[t == JOB_STOP];
958 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
963 assert(t < _JOB_TYPE_MAX);
965 format = unit_get_status_message_format(u, t);
969 /* Return generic strings */
971 return "Starting %s.";
972 else if (t == JOB_STOP)
973 return "Stopping %s.";
974 else if (t == JOB_RELOAD)
975 return "Reloading %s.";
980 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
985 /* We only print status messages for selected units on
986 * selected operations. */
988 format = unit_get_status_message_format(u, t);
992 unit_status_printf(u, "", format, unit_description(u));
995 #pragma GCC diagnostic push
996 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
997 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1004 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1007 if (log_on_console())
1010 /* We log status messages for all units and all operations. */
1012 format = unit_get_status_message_format_try_harder(u, t);
1016 snprintf(buf, sizeof(buf), format, unit_description(u));
1019 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1020 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1021 SD_MESSAGE_UNIT_RELOADING;
1023 log_struct(LOG_INFO,
1024 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(mid),
1029 #pragma GCC diagnostic pop
1032 * -EBADR: This unit type does not support starting.
1033 * -EALREADY: Unit is already started.
1034 * -EAGAIN: An operation is already in progress. Retry later.
1035 * -ECANCELED: Too many requests for now.
1037 int unit_start(Unit *u) {
1038 UnitActiveState state;
1043 if (u->load_state != UNIT_LOADED)
1046 /* If this is already started, then this will succeed. Note
1047 * that this will even succeed if this unit is not startable
1048 * by the user. This is relied on to detect when we need to
1049 * wait for units and when waiting is finished. */
1050 state = unit_active_state(u);
1051 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1054 /* If the conditions failed, don't do anything at all. If we
1055 * already are activating this call might still be useful to
1056 * speed up activation in case there is some hold-off time,
1057 * but we don't want to recheck the condition in that case. */
1058 if (state != UNIT_ACTIVATING &&
1059 !unit_condition_test(u)) {
1060 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1064 /* Forward to the main object, if we aren't it. */
1065 if ((following = unit_following(u))) {
1066 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1067 return unit_start(following);
1070 unit_status_log_starting_stopping_reloading(u, JOB_START);
1071 unit_status_print_starting_stopping(u, JOB_START);
1073 /* If it is stopped, but we cannot start it, then fail */
1074 if (!UNIT_VTABLE(u)->start)
1077 /* We don't suppress calls to ->start() here when we are
1078 * already starting, to allow this request to be used as a
1079 * "hurry up" call, for example when the unit is in some "auto
1080 * restart" state where it waits for a holdoff timer to elapse
1081 * before it will start again. */
1083 unit_add_to_dbus_queue(u);
1085 return UNIT_VTABLE(u)->start(u);
1088 bool unit_can_start(Unit *u) {
1091 return !!UNIT_VTABLE(u)->start;
1094 bool unit_can_isolate(Unit *u) {
1097 return unit_can_start(u) &&
1102 * -EBADR: This unit type does not support stopping.
1103 * -EALREADY: Unit is already stopped.
1104 * -EAGAIN: An operation is already in progress. Retry later.
1106 int unit_stop(Unit *u) {
1107 UnitActiveState state;
1112 state = unit_active_state(u);
1113 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1116 if ((following = unit_following(u))) {
1117 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1118 return unit_stop(following);
1121 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1122 unit_status_print_starting_stopping(u, JOB_STOP);
1124 if (!UNIT_VTABLE(u)->stop)
1127 unit_add_to_dbus_queue(u);
1129 return UNIT_VTABLE(u)->stop(u);
1133 * -EBADR: This unit type does not support reloading.
1134 * -ENOEXEC: Unit is not started.
1135 * -EAGAIN: An operation is already in progress. Retry later.
1137 int unit_reload(Unit *u) {
1138 UnitActiveState state;
1143 if (u->load_state != UNIT_LOADED)
1146 if (!unit_can_reload(u))
1149 state = unit_active_state(u);
1150 if (state == UNIT_RELOADING)
1153 if (state != UNIT_ACTIVE)
1156 if ((following = unit_following(u))) {
1157 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1158 return unit_reload(following);
1161 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1163 unit_add_to_dbus_queue(u);
1164 return UNIT_VTABLE(u)->reload(u);
1167 bool unit_can_reload(Unit *u) {
1170 if (!UNIT_VTABLE(u)->reload)
1173 if (!UNIT_VTABLE(u)->can_reload)
1176 return UNIT_VTABLE(u)->can_reload(u);
1179 static void unit_check_unneeded(Unit *u) {
1185 /* If this service shall be shut down when unneeded then do
1188 if (!u->stop_when_unneeded)
1191 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1194 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1195 if (unit_pending_active(other))
1198 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1199 if (unit_pending_active(other))
1202 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1203 if (unit_pending_active(other))
1206 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1207 if (unit_pending_active(other))
1210 log_info("Service %s is not needed anymore. Stopping.", u->id);
1212 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1213 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1216 static void retroactively_start_dependencies(Unit *u) {
1221 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1223 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1224 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1225 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1226 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1228 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1229 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1230 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1231 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1233 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1234 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1235 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1236 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1238 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1239 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1240 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1241 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1243 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1244 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1245 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1246 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1248 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1249 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1250 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1252 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1253 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1254 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1257 static void retroactively_stop_dependencies(Unit *u) {
1262 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1264 /* Pull down units which are bound to us recursively if enabled */
1265 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1266 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1267 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1270 static void check_unneeded_dependencies(Unit *u) {
1275 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1277 /* Garbage collect services that might not be needed anymore, if enabled */
1278 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1279 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1280 unit_check_unneeded(other);
1281 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1282 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1283 unit_check_unneeded(other);
1284 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1285 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1286 unit_check_unneeded(other);
1287 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1288 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1289 unit_check_unneeded(other);
1290 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1291 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1292 unit_check_unneeded(other);
1293 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1294 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1295 unit_check_unneeded(other);
1298 void unit_trigger_on_failure(Unit *u) {
1304 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1307 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1309 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1312 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1313 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1317 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1321 assert(os < _UNIT_ACTIVE_STATE_MAX);
1322 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1324 /* Note that this is called for all low-level state changes,
1325 * even if they might map to the same high-level
1326 * UnitActiveState! That means that ns == os is OK an expected
1327 * behaviour here. For example: if a mount point is remounted
1328 * this function will be called too! */
1330 if (u->manager->n_reloading <= 0) {
1333 dual_timestamp_get(&ts);
1335 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1336 u->inactive_exit_timestamp = ts;
1337 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1338 u->inactive_enter_timestamp = ts;
1340 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1341 u->active_enter_timestamp = ts;
1342 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1343 u->active_exit_timestamp = ts;
1345 timer_unit_notify(u, ns);
1346 path_unit_notify(u, ns);
1349 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1350 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1355 if (u->job->state == JOB_WAITING)
1357 /* So we reached a different state for this
1358 * job. Let's see if we can run it now if it
1359 * failed previously due to EAGAIN. */
1360 job_add_to_run_queue(u->job);
1362 /* Let's check whether this state change constitutes a
1363 * finished job, or maybe contradicts a running job and
1364 * hence needs to invalidate jobs. */
1366 switch (u->job->type) {
1369 case JOB_VERIFY_ACTIVE:
1371 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1372 job_finish_and_invalidate(u->job, JOB_DONE, true);
1373 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1376 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1377 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1383 case JOB_RELOAD_OR_START:
1385 if (u->job->state == JOB_RUNNING) {
1386 if (ns == UNIT_ACTIVE)
1387 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1388 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1391 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1392 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1400 case JOB_TRY_RESTART:
1402 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1403 job_finish_and_invalidate(u->job, JOB_DONE, true);
1404 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1406 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1412 assert_not_reached("Job type unknown");
1418 if (u->manager->n_reloading <= 0) {
1420 /* If this state change happened without being
1421 * requested by a job, then let's retroactively start
1422 * or stop dependencies. We skip that step when
1423 * deserializing, since we don't want to create any
1424 * additional jobs just because something is already
1428 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1429 retroactively_start_dependencies(u);
1430 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1431 retroactively_stop_dependencies(u);
1434 /* stop unneeded units regardless if going down was expected or not */
1435 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1436 check_unneeded_dependencies(u);
1438 if (ns != os && ns == UNIT_FAILED) {
1439 log_notice("Unit %s entered failed state.", u->id);
1440 unit_trigger_on_failure(u);
1444 /* Some names are special */
1445 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1447 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1448 /* The bus just might have become available,
1449 * hence try to connect to it, if we aren't
1451 bus_init(u->manager, true);
1453 if (u->type == UNIT_SERVICE &&
1454 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1455 u->manager->n_reloading <= 0) {
1456 /* Write audit record if we have just finished starting up */
1457 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1461 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1462 manager_send_unit_plymouth(u->manager, u);
1466 /* We don't care about D-Bus here, since we'll get an
1467 * asynchronous notification for it anyway. */
1469 if (u->type == UNIT_SERVICE &&
1470 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1471 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1472 u->manager->n_reloading <= 0) {
1474 /* Hmm, if there was no start record written
1475 * write it now, so that we always have a nice
1478 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1480 if (ns == UNIT_INACTIVE)
1481 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1483 /* Write audit record if we have just finished shutting down */
1484 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1486 u->in_audit = false;
1490 manager_recheck_journal(u->manager);
1492 /* Maybe we finished startup and are now ready for being
1493 * stopped because unneeded? */
1494 unit_check_unneeded(u);
1496 unit_add_to_dbus_queue(u);
1497 unit_add_to_gc_queue(u);
1500 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1501 struct epoll_event ev;
1506 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1512 if (epoll_ctl(u->manager->epoll_fd,
1513 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1525 void unit_unwatch_fd(Unit *u, Watch *w) {
1529 if (w->type == WATCH_INVALID)
1532 assert(w->type == WATCH_FD);
1533 assert(w->data.unit == u);
1534 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1537 w->type = WATCH_INVALID;
1538 w->data.unit = NULL;
1541 int unit_watch_pid(Unit *u, pid_t pid) {
1545 /* Watch a specific PID. We only support one unit watching
1546 * each PID for now. */
1548 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1551 void unit_unwatch_pid(Unit *u, pid_t pid) {
1555 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1558 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1559 struct itimerspec its;
1565 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1567 /* This will try to reuse the old timer if there is one */
1569 if (w->type == WATCH_UNIT_TIMER) {
1570 assert(w->data.unit == u);
1575 } else if (w->type == WATCH_INVALID) {
1578 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1581 assert_not_reached("Invalid watch type");
1586 /* Set absolute time in the past, but not 0, since we
1587 * don't want to disarm the timer */
1588 its.it_value.tv_sec = 0;
1589 its.it_value.tv_nsec = 1;
1591 flags = TFD_TIMER_ABSTIME;
1593 timespec_store(&its.it_value, delay);
1597 /* This will also flush the elapse counter */
1598 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1601 if (w->type == WATCH_INVALID) {
1602 struct epoll_event ev;
1606 ev.events = EPOLLIN;
1608 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1612 w->type = WATCH_UNIT_TIMER;
1620 close_nointr_nofail(fd);
1625 void unit_unwatch_timer(Unit *u, Watch *w) {
1629 if (w->type == WATCH_INVALID)
1632 assert(w->type == WATCH_UNIT_TIMER);
1633 assert(w->data.unit == u);
1636 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1637 close_nointr_nofail(w->fd);
1640 w->type = WATCH_INVALID;
1641 w->data.unit = NULL;
1644 bool unit_job_is_applicable(Unit *u, JobType j) {
1646 assert(j >= 0 && j < _JOB_TYPE_MAX);
1650 case JOB_VERIFY_ACTIVE:
1657 case JOB_TRY_RESTART:
1658 return unit_can_start(u);
1661 return unit_can_reload(u);
1663 case JOB_RELOAD_OR_START:
1664 return unit_can_reload(u) && unit_can_start(u);
1667 assert_not_reached("Invalid job type");
1671 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1673 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1674 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1675 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1676 [UNIT_WANTS] = UNIT_WANTED_BY,
1677 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1678 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1679 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1680 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1681 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1682 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1683 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1684 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1685 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1686 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1687 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1688 [UNIT_BEFORE] = UNIT_AFTER,
1689 [UNIT_AFTER] = UNIT_BEFORE,
1690 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1691 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1692 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1693 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1694 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1695 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1696 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1698 int r, q = 0, v = 0, w = 0;
1701 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1704 u = unit_follow_merge(u);
1705 other = unit_follow_merge(other);
1707 /* We won't allow dependencies on ourselves. We will not
1708 * consider them an error however. */
1712 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1715 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1716 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1720 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1721 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1724 if ((q = set_put(u->dependencies[d], other)) < 0)
1727 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1728 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1733 if (add_reference) {
1734 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1739 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1743 unit_add_to_dbus_queue(u);
1748 set_remove(u->dependencies[d], other);
1751 set_remove(other->dependencies[inverse_table[d]], u);
1754 set_remove(u->dependencies[UNIT_REFERENCES], other);
1759 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1764 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1767 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1773 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1777 assert(name || path);
1780 name = path_get_file_name(path);
1782 if (!unit_name_is_template(name)) {
1788 s = unit_name_replace_instance(name, u->instance);
1792 if (!(i = unit_name_to_prefix(u->id)))
1795 s = unit_name_replace_instance(name, i);
1806 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1812 assert(name || path);
1814 if (!(name = resolve_template(u, name, path, &s)))
1817 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1820 r = unit_add_dependency(u, d, other, add_reference);
1827 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1833 assert(name || path);
1835 if (!(name = resolve_template(u, name, path, &s)))
1838 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1841 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1848 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1854 assert(name || path);
1856 if (!(name = resolve_template(u, name, path, &s)))
1859 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1862 r = unit_add_dependency(other, d, u, add_reference);
1869 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1875 assert(name || path);
1877 if (!(name = resolve_template(u, name, path, &s)))
1880 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1883 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1891 int set_unit_path(const char *p) {
1895 /* This is mostly for debug purposes */
1897 if (path_is_absolute(p)) {
1898 if (!(c = strdup(p)))
1901 if (!(cwd = get_current_dir_name()))
1904 r = asprintf(&c, "%s/%s", cwd, p);
1911 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1920 char *unit_dbus_path(Unit *u) {
1926 return unit_dbus_path_from_name(u->id);
1929 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1937 if (!b->controller) {
1938 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1944 /* Ensure this hasn't been added yet */
1947 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1950 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1951 LIST_PREPEND(CGroupBonding, by_path, l, b);
1953 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1954 LIST_REMOVE(CGroupBonding, by_path, l, b);
1959 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1965 static char *default_cgroup_path(Unit *u) {
1973 t = unit_name_template(u->id);
1977 p = strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1980 p = strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1985 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1986 char *controller = NULL, *path = NULL;
1987 CGroupBonding *b = NULL;
1994 if ((r = cg_split_spec(name, &controller, &path)) < 0)
1998 path = default_cgroup_path(u);
2003 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2007 if (!path || !controller) {
2014 if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
2019 if (!(b = new0(CGroupBonding, 1))) {
2024 b->controller = controller;
2027 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2029 if ((r = unit_add_cgroup(u, b)) < 0)
2042 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2043 CGroupBonding *b = NULL;
2049 controller = SYSTEMD_CGROUP_CONTROLLER;
2051 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2054 if (!(b = new0(CGroupBonding, 1)))
2057 if (!(b->controller = strdup(controller)))
2060 if (!(b->path = default_cgroup_path(u)))
2064 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2066 if ((r = unit_add_cgroup(u, b)) < 0)
2073 free(b->controller);
2079 int unit_add_default_cgroups(Unit *u) {
2086 /* Adds in the default cgroups, if they weren't specified
2089 if (!u->manager->cgroup_hierarchy)
2092 if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
2095 STRV_FOREACH(c, u->manager->default_controllers)
2096 unit_add_one_default_cgroup(u, *c);
2098 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2099 unit_add_one_default_cgroup(u, a->controller);
2104 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2107 return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
2110 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
2122 dot = strchr(name, '.');
2126 c = strndup(name, dot - name);
2133 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
2138 a = new0(CGroupAttribute, 1);
2148 a->controller = strdup(controller);
2150 a->name = strdup(name);
2151 a->value = strdup(value);
2153 if (!a->controller || !a->name || !a->value) {
2154 free(a->controller);
2162 a->map_callback = map_callback;
2164 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2173 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2181 if (!(t = unit_name_change_suffix(u->id, type)))
2184 assert(!unit_has_name(u, t));
2186 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2189 assert(r < 0 || *_found != u);
2194 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2202 if (!(t = unit_name_change_suffix(u->id, type)))
2205 assert(!unit_has_name(u, t));
2207 found = manager_get_unit(u->manager, t);
2217 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2221 return unit_name_to_prefix_and_instance(u->id);
2224 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2228 return unit_name_to_prefix(u->id);
2231 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2237 if (!(p = unit_name_to_prefix(u->id)))
2240 r = unit_name_unescape(p);
2246 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2251 return unit_name_unescape(u->instance);
2256 static char *specifier_filename(char specifier, void *data, void *userdata) {
2261 return unit_name_path_unescape(u->instance);
2263 return unit_name_to_path(u->instance);
2266 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2270 return default_cgroup_path(u);
2273 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2278 if (specifier == 'r')
2279 return strdup(u->manager->cgroup_hierarchy);
2281 if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
2284 if (streq(p, "/")) {
2292 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2296 if (u->manager->running_as == MANAGER_USER) {
2299 e = getenv("XDG_RUNTIME_DIR");
2304 return strdup("/run");
2307 static char *specifier_user_name(char specifier, void *data, void *userdata) {
2308 Service *s = userdata;
2310 const char *username;
2312 /* get USER env from our own env if set */
2313 if (!s->exec_context.user)
2314 return getusername_malloc();
2316 /* fish username from passwd */
2317 username = s->exec_context.user;
2318 r = get_user_creds(&username, NULL, NULL, NULL, NULL);
2322 return strdup(username);
2325 static char *specifier_user_home(char specifier, void *data, void *userdata) {
2326 Service *s = userdata;
2328 const char *username, *home;
2330 /* return HOME if set, otherwise from passwd */
2331 if (!s->exec_context.user) {
2334 r = get_home_dir(&h);
2341 username = s->exec_context.user;
2342 r = get_user_creds(&username, NULL, NULL, &home, NULL);
2346 return strdup(home);
2349 static char *specifier_user_shell(char specifier, void *data, void *userdata) {
2350 Service *s = userdata;
2352 const char *username, *shell;
2354 /* return HOME if set, otherwise from passwd */
2355 if (!s->exec_context.user) {
2360 return strdup("/bin/sh");
2365 username = s->exec_context.user;
2366 r = get_user_creds(&username, NULL, NULL, NULL, &shell);
2368 return strdup("/bin/sh");
2370 return strdup(shell);
2373 char *unit_name_printf(Unit *u, const char* format) {
2376 * This will use the passed string as format string and
2377 * replace the following specifiers:
2379 * %n: the full id of the unit (foo@bar.waldo)
2380 * %N: the id of the unit without the suffix (foo@bar)
2381 * %p: the prefix (foo)
2382 * %i: the instance (bar)
2385 const Specifier table[] = {
2386 { 'n', specifier_string, u->id },
2387 { 'N', specifier_prefix_and_instance, NULL },
2388 { 'p', specifier_prefix, NULL },
2389 { 'i', specifier_string, u->instance },
2396 return specifier_printf(format, table, u);
2399 char *unit_full_printf(Unit *u, const char *format) {
2401 /* This is similar to unit_name_printf() but also supports
2402 * unescaping. Also, adds a couple of additional codes:
2404 * %c cgroup path of unit
2405 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2406 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2407 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2408 * %u the username of the configured User or running user
2409 * %h the homedir of the configured User or running user
2412 const Specifier table[] = {
2413 { 'n', specifier_string, u->id },
2414 { 'N', specifier_prefix_and_instance, NULL },
2415 { 'p', specifier_prefix, NULL },
2416 { 'P', specifier_prefix_unescaped, NULL },
2417 { 'i', specifier_string, u->instance },
2418 { 'I', specifier_instance_unescaped, NULL },
2419 { 'f', specifier_filename, NULL },
2420 { 'c', specifier_cgroup, NULL },
2421 { 'r', specifier_cgroup_root, NULL },
2422 { 'R', specifier_cgroup_root, NULL },
2423 { 't', specifier_runtime, NULL },
2424 { 'u', specifier_user_name, NULL },
2425 { 'h', specifier_user_home, NULL },
2426 { 's', specifier_user_shell, NULL },
2433 return specifier_printf(format, table, u);
2436 char **unit_full_printf_strv(Unit *u, char **l) {
2440 /* Applies unit_full_printf to every entry in l */
2445 if (!(r = new(char*, n+1)))
2448 for (i = l, j = r; *i; i++, j++)
2449 if (!(*j = unit_full_printf(u, *i)))
2456 for (j--; j >= r; j--)
2464 int unit_watch_bus_name(Unit *u, const char *name) {
2468 /* Watch a specific name on the bus. We only support one unit
2469 * watching each name for now. */
2471 return hashmap_put(u->manager->watch_bus, name, u);
2474 void unit_unwatch_bus_name(Unit *u, const char *name) {
2478 hashmap_remove_value(u->manager->watch_bus, name, u);
2481 bool unit_can_serialize(Unit *u) {
2484 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2487 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2494 if (!unit_can_serialize(u))
2497 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2501 if (serialize_jobs) {
2503 fprintf(f, "job\n");
2504 job_serialize(u->job, f, fds);
2508 fprintf(f, "job\n");
2509 job_serialize(u->nop_job, f, fds);
2513 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2514 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2515 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2516 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2517 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2519 if (dual_timestamp_is_set(&u->condition_timestamp))
2520 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2527 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2538 va_start(ap, format);
2539 vfprintf(f, format, ap);
2545 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2551 fprintf(f, "%s=%s\n", key, value);
2554 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2561 if (!unit_can_serialize(u))
2565 char line[LINE_MAX], *l, *v;
2568 if (!fgets(line, sizeof(line), f)) {
2581 k = strcspn(l, "=");
2589 if (streq(l, "job")) {
2591 /* new-style serialized job */
2592 Job *j = job_new_raw(u);
2596 r = job_deserialize(j, f, fds);
2602 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2608 r = job_install_deserialized(j);
2610 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2616 JobType type = job_type_from_string(v);
2618 log_debug("Failed to parse job type value %s", v);
2620 u->deserialized_job = type;
2623 } else if (streq(l, "inactive-exit-timestamp")) {
2624 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2626 } else if (streq(l, "active-enter-timestamp")) {
2627 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2629 } else if (streq(l, "active-exit-timestamp")) {
2630 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2632 } else if (streq(l, "inactive-enter-timestamp")) {
2633 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2635 } else if (streq(l, "condition-timestamp")) {
2636 dual_timestamp_deserialize(v, &u->condition_timestamp);
2638 } else if (streq(l, "condition-result")) {
2641 if ((b = parse_boolean(v)) < 0)
2642 log_debug("Failed to parse condition result value %s", v);
2644 u->condition_result = b;
2649 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2654 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2664 /* Adds in links to the device node that this unit is based on */
2666 if (!is_device_path(what))
2669 e = unit_name_from_path(what, ".device");
2673 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2679 if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true)) < 0)
2683 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2689 int unit_coldplug(Unit *u) {
2694 if (UNIT_VTABLE(u)->coldplug)
2695 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2699 r = job_coldplug(u->job);
2702 } else if (u->deserialized_job >= 0) {
2704 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2708 u->deserialized_job = _JOB_TYPE_INVALID;
2714 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2720 if (!manager_get_show_status(u->manager))
2723 if (!manager_is_booting_or_shutting_down(u->manager))
2726 va_start(ap, format);
2727 status_vprintf(status, true, format, ap);
2731 bool unit_need_daemon_reload(Unit *u) {
2736 if (u->fragment_path) {
2738 if (stat(u->fragment_path, &st) < 0)
2739 /* What, cannot access this anymore? */
2742 if (u->fragment_mtime > 0 &&
2743 timespec_load(&st.st_mtim) != u->fragment_mtime)
2747 if (u->source_path) {
2749 if (stat(u->source_path, &st) < 0)
2752 if (u->source_mtime > 0 &&
2753 timespec_load(&st.st_mtim) != u->source_mtime)
2760 void unit_reset_failed(Unit *u) {
2763 if (UNIT_VTABLE(u)->reset_failed)
2764 UNIT_VTABLE(u)->reset_failed(u);
2767 Unit *unit_following(Unit *u) {
2770 if (UNIT_VTABLE(u)->following)
2771 return UNIT_VTABLE(u)->following(u);
2776 bool unit_pending_inactive(Unit *u) {
2779 /* Returns true if the unit is inactive or going down */
2781 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2784 if (u->job && u->job->type == JOB_STOP)
2790 bool unit_pending_active(Unit *u) {
2793 /* Returns true if the unit is active or going up */
2795 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2799 (u->job->type == JOB_START ||
2800 u->job->type == JOB_RELOAD_OR_START ||
2801 u->job->type == JOB_RESTART))
2807 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2809 assert(w >= 0 && w < _KILL_WHO_MAX);
2811 assert(signo < _NSIG);
2813 if (!UNIT_VTABLE(u)->kill)
2816 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2819 int unit_following_set(Unit *u, Set **s) {
2823 if (UNIT_VTABLE(u)->following_set)
2824 return UNIT_VTABLE(u)->following_set(u, s);
2830 UnitFileState unit_get_unit_file_state(Unit *u) {
2833 if (u->unit_file_state < 0 && u->fragment_path)
2834 u->unit_file_state = unit_file_get_state(
2835 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2836 NULL, path_get_file_name(u->fragment_path));
2838 return u->unit_file_state;
2841 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2846 unit_ref_unset(ref);
2849 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2853 void unit_ref_unset(UnitRef *ref) {
2859 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2863 int unit_add_one_mount_link(Unit *u, Mount *m) {
2869 if (u->load_state != UNIT_LOADED ||
2870 UNIT(m)->load_state != UNIT_LOADED)
2873 STRV_FOREACH(i, u->requires_mounts_for) {
2878 if (!path_startswith(*i, m->where))
2881 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2887 int unit_add_mount_links(Unit *u) {
2893 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2894 r = unit_add_one_mount_link(u, MOUNT(other));
2902 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2909 /* This only copies in the ones that need memory */
2911 for (i = 0; i < RLIMIT_NLIMITS; i++)
2912 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2913 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2918 if (u->manager->running_as == MANAGER_USER &&
2919 !c->working_directory) {
2921 r = get_home_dir(&c->working_directory);
2929 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2930 [UNIT_ACTIVE] = "active",
2931 [UNIT_RELOADING] = "reloading",
2932 [UNIT_INACTIVE] = "inactive",
2933 [UNIT_FAILED] = "failed",
2934 [UNIT_ACTIVATING] = "activating",
2935 [UNIT_DEACTIVATING] = "deactivating"
2938 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2940 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2941 [UNIT_REQUIRES] = "Requires",
2942 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2943 [UNIT_REQUISITE] = "Requisite",
2944 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2945 [UNIT_WANTS] = "Wants",
2946 [UNIT_BINDS_TO] = "BindsTo",
2947 [UNIT_PART_OF] = "PartOf",
2948 [UNIT_REQUIRED_BY] = "RequiredBy",
2949 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2950 [UNIT_WANTED_BY] = "WantedBy",
2951 [UNIT_BOUND_BY] = "BoundBy",
2952 [UNIT_CONSISTS_OF] = "ConsistsOf",
2953 [UNIT_CONFLICTS] = "Conflicts",
2954 [UNIT_CONFLICTED_BY] = "ConflictedBy",
2955 [UNIT_BEFORE] = "Before",
2956 [UNIT_AFTER] = "After",
2957 [UNIT_ON_FAILURE] = "OnFailure",
2958 [UNIT_TRIGGERS] = "Triggers",
2959 [UNIT_TRIGGERED_BY] = "TriggeredBy",
2960 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
2961 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
2962 [UNIT_REFERENCES] = "References",
2963 [UNIT_REFERENCED_BY] = "ReferencedBy",
2966 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);