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/>.
29 #include "sd-messages.h"
33 #include "path-util.h"
35 #include "cgroup-util.h"
38 #include "fileio-label.h"
39 #include "formats-util.h"
40 #include "process-util.h"
42 #include "bus-common-errors.h"
45 #include "unit-name.h"
48 #include "load-fragment.h"
49 #include "load-dropin.h"
51 #include "dbus-unit.h"
54 const UnitVTable
* const unit_vtable
[_UNIT_TYPE_MAX
] = {
55 [UNIT_SERVICE
] = &service_vtable
,
56 [UNIT_SOCKET
] = &socket_vtable
,
57 [UNIT_BUSNAME
] = &busname_vtable
,
58 [UNIT_TARGET
] = &target_vtable
,
59 [UNIT_SNAPSHOT
] = &snapshot_vtable
,
60 [UNIT_DEVICE
] = &device_vtable
,
61 [UNIT_MOUNT
] = &mount_vtable
,
62 [UNIT_AUTOMOUNT
] = &automount_vtable
,
63 [UNIT_SWAP
] = &swap_vtable
,
64 [UNIT_TIMER
] = &timer_vtable
,
65 [UNIT_PATH
] = &path_vtable
,
66 [UNIT_SLICE
] = &slice_vtable
,
67 [UNIT_SCOPE
] = &scope_vtable
70 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
);
72 Unit
*unit_new(Manager
*m
, size_t size
) {
76 assert(size
>= sizeof(Unit
));
82 u
->names
= set_new(&string_hash_ops
);
89 u
->type
= _UNIT_TYPE_INVALID
;
90 u
->default_dependencies
= true;
91 u
->unit_file_state
= _UNIT_FILE_STATE_INVALID
;
92 u
->unit_file_preset
= -1;
93 u
->on_failure_job_mode
= JOB_REPLACE
;
94 u
->cgroup_inotify_wd
= -1;
96 RATELIMIT_INIT(u
->auto_stop_ratelimit
, 10 * USEC_PER_SEC
, 16);
101 bool unit_has_name(Unit
*u
, const char *name
) {
105 return !!set_get(u
->names
, (char*) name
);
108 static void unit_init(Unit
*u
) {
115 assert(u
->type
>= 0);
117 cc
= unit_get_cgroup_context(u
);
119 cgroup_context_init(cc
);
121 /* Copy in the manager defaults into the cgroup
122 * context, _before_ the rest of the settings have
123 * been initialized */
125 cc
->cpu_accounting
= u
->manager
->default_cpu_accounting
;
126 cc
->blockio_accounting
= u
->manager
->default_blockio_accounting
;
127 cc
->memory_accounting
= u
->manager
->default_memory_accounting
;
128 cc
->tasks_accounting
= u
->manager
->default_tasks_accounting
;
131 ec
= unit_get_exec_context(u
);
133 exec_context_init(ec
);
135 kc
= unit_get_kill_context(u
);
137 kill_context_init(kc
);
139 if (UNIT_VTABLE(u
)->init
)
140 UNIT_VTABLE(u
)->init(u
);
143 int unit_add_name(Unit
*u
, const char *text
) {
144 _cleanup_free_
char *s
= NULL
, *i
= NULL
;
151 if (unit_name_is_valid(text
, UNIT_NAME_TEMPLATE
)) {
156 r
= unit_name_replace_instance(text
, u
->instance
, &s
);
165 if (set_contains(u
->names
, s
))
167 if (hashmap_contains(u
->manager
->units
, s
))
170 if (!unit_name_is_valid(s
, UNIT_NAME_PLAIN
|UNIT_NAME_INSTANCE
))
173 t
= unit_name_to_type(s
);
177 if (u
->type
!= _UNIT_TYPE_INVALID
&& t
!= u
->type
)
180 r
= unit_name_to_instance(s
, &i
);
184 if (i
&& unit_vtable
[t
]->no_instances
)
187 /* Ensure that this unit is either instanced or not instanced,
188 * but not both. Note that we do allow names with different
189 * instance names however! */
190 if (u
->type
!= _UNIT_TYPE_INVALID
&& !u
->instance
!= !i
)
193 if (unit_vtable
[t
]->no_alias
&& !set_isempty(u
->names
))
196 if (hashmap_size(u
->manager
->units
) >= MANAGER_MAX_NAMES
)
199 r
= set_put(u
->names
, s
);
204 r
= hashmap_put(u
->manager
->units
, s
, u
);
206 (void) set_remove(u
->names
, s
);
210 if (u
->type
== _UNIT_TYPE_INVALID
) {
215 LIST_PREPEND(units_by_type
, u
->manager
->units_by_type
[t
], u
);
224 unit_add_to_dbus_queue(u
);
228 int unit_choose_id(Unit
*u
, const char *name
) {
229 _cleanup_free_
char *t
= NULL
;
236 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
241 r
= unit_name_replace_instance(name
, u
->instance
, &t
);
248 /* Selects one of the names of this unit as the id */
249 s
= set_get(u
->names
, (char*) name
);
253 /* Determine the new instance from the new id */
254 r
= unit_name_to_instance(s
, &i
);
263 unit_add_to_dbus_queue(u
);
268 int unit_set_description(Unit
*u
, const char *description
) {
273 if (isempty(description
))
276 s
= strdup(description
);
281 free(u
->description
);
284 unit_add_to_dbus_queue(u
);
288 bool unit_check_gc(Unit
*u
) {
289 UnitActiveState state
;
298 state
= unit_active_state(u
);
300 /* If the unit is inactive and failed and no job is queued for
301 * it, then release its runtime resources */
302 if (UNIT_IS_INACTIVE_OR_FAILED(state
) &&
303 UNIT_VTABLE(u
)->release_resources
)
304 UNIT_VTABLE(u
)->release_resources(u
);
306 /* But we keep the unit object around for longer when it is
307 * referenced or configured to not be gc'ed */
308 if (state
!= UNIT_INACTIVE
)
311 if (UNIT_VTABLE(u
)->no_gc
)
320 if (UNIT_VTABLE(u
)->check_gc
)
321 if (UNIT_VTABLE(u
)->check_gc(u
))
327 void unit_add_to_load_queue(Unit
*u
) {
329 assert(u
->type
!= _UNIT_TYPE_INVALID
);
331 if (u
->load_state
!= UNIT_STUB
|| u
->in_load_queue
)
334 LIST_PREPEND(load_queue
, u
->manager
->load_queue
, u
);
335 u
->in_load_queue
= true;
338 void unit_add_to_cleanup_queue(Unit
*u
) {
341 if (u
->in_cleanup_queue
)
344 LIST_PREPEND(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
345 u
->in_cleanup_queue
= true;
348 void unit_add_to_gc_queue(Unit
*u
) {
351 if (u
->in_gc_queue
|| u
->in_cleanup_queue
)
354 if (unit_check_gc(u
))
357 LIST_PREPEND(gc_queue
, u
->manager
->gc_queue
, u
);
358 u
->in_gc_queue
= true;
360 u
->manager
->n_in_gc_queue
++;
363 void unit_add_to_dbus_queue(Unit
*u
) {
365 assert(u
->type
!= _UNIT_TYPE_INVALID
);
367 if (u
->load_state
== UNIT_STUB
|| u
->in_dbus_queue
)
370 /* Shortcut things if nobody cares */
371 if (sd_bus_track_count(u
->manager
->subscribed
) <= 0 &&
372 set_isempty(u
->manager
->private_buses
)) {
373 u
->sent_dbus_new_signal
= true;
377 LIST_PREPEND(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
378 u
->in_dbus_queue
= true;
381 static void bidi_set_free(Unit
*u
, Set
*s
) {
387 /* Frees the set and makes sure we are dropped from the
388 * inverse pointers */
390 SET_FOREACH(other
, s
, i
) {
393 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
394 set_remove(other
->dependencies
[d
], u
);
396 unit_add_to_gc_queue(other
);
402 static void unit_remove_transient(Unit
*u
) {
410 if (u
->fragment_path
)
411 (void) unlink(u
->fragment_path
);
413 STRV_FOREACH(i
, u
->dropin_paths
) {
414 _cleanup_free_
char *p
= NULL
;
419 r
= path_get_parent(*i
, &p
);
425 static void unit_free_requires_mounts_for(Unit
*u
) {
428 STRV_FOREACH(j
, u
->requires_mounts_for
) {
429 char s
[strlen(*j
) + 1];
431 PATH_FOREACH_PREFIX_MORE(s
, *j
) {
435 x
= hashmap_get2(u
->manager
->units_requiring_mounts_for
, s
, (void**) &y
);
441 if (set_isempty(x
)) {
442 hashmap_remove(u
->manager
->units_requiring_mounts_for
, y
);
449 u
->requires_mounts_for
= strv_free(u
->requires_mounts_for
);
452 static void unit_done(Unit
*u
) {
462 if (UNIT_VTABLE(u
)->done
)
463 UNIT_VTABLE(u
)->done(u
);
465 ec
= unit_get_exec_context(u
);
467 exec_context_done(ec
);
469 cc
= unit_get_cgroup_context(u
);
471 cgroup_context_done(cc
);
473 r
= unit_remove_from_netclass_cgroup(u
);
475 log_warning_errno(r
, "Unable to remove unit from netclass group: %m");
478 void unit_free(Unit
*u
) {
485 if (u
->manager
->n_reloading
<= 0)
486 unit_remove_transient(u
);
488 bus_unit_send_removed_signal(u
);
492 sd_bus_slot_unref(u
->match_bus_slot
);
494 unit_free_requires_mounts_for(u
);
496 SET_FOREACH(t
, u
->names
, i
)
497 hashmap_remove_value(u
->manager
->units
, t
, u
);
511 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
512 bidi_set_free(u
, u
->dependencies
[d
]);
514 if (u
->type
!= _UNIT_TYPE_INVALID
)
515 LIST_REMOVE(units_by_type
, u
->manager
->units_by_type
[u
->type
], u
);
517 if (u
->in_load_queue
)
518 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
520 if (u
->in_dbus_queue
)
521 LIST_REMOVE(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
523 if (u
->in_cleanup_queue
)
524 LIST_REMOVE(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
526 if (u
->in_gc_queue
) {
527 LIST_REMOVE(gc_queue
, u
->manager
->gc_queue
, u
);
528 u
->manager
->n_in_gc_queue
--;
531 if (u
->in_cgroup_queue
)
532 LIST_REMOVE(cgroup_queue
, u
->manager
->cgroup_queue
, u
);
534 unit_release_cgroup(u
);
536 (void) manager_update_failed_units(u
->manager
, u
, false);
537 set_remove(u
->manager
->startup_units
, u
);
539 free(u
->description
);
540 strv_free(u
->documentation
);
541 free(u
->fragment_path
);
542 free(u
->source_path
);
543 strv_free(u
->dropin_paths
);
546 free(u
->job_timeout_reboot_arg
);
548 set_free_free(u
->names
);
550 unit_unwatch_all_pids(u
);
552 condition_free_list(u
->conditions
);
553 condition_free_list(u
->asserts
);
555 unit_ref_unset(&u
->slice
);
558 unit_ref_unset(u
->refs
);
563 UnitActiveState
unit_active_state(Unit
*u
) {
566 if (u
->load_state
== UNIT_MERGED
)
567 return unit_active_state(unit_follow_merge(u
));
569 /* After a reload it might happen that a unit is not correctly
570 * loaded but still has a process around. That's why we won't
571 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
573 return UNIT_VTABLE(u
)->active_state(u
);
576 const char* unit_sub_state_to_string(Unit
*u
) {
579 return UNIT_VTABLE(u
)->sub_state_to_string(u
);
582 static int complete_move(Set
**s
, Set
**other
) {
592 r
= set_move(*s
, *other
);
603 static int merge_names(Unit
*u
, Unit
*other
) {
611 r
= complete_move(&u
->names
, &other
->names
);
615 set_free_free(other
->names
);
619 SET_FOREACH(t
, u
->names
, i
)
620 assert_se(hashmap_replace(u
->manager
->units
, t
, u
) == 0);
625 static int reserve_dependencies(Unit
*u
, Unit
*other
, UnitDependency d
) {
630 assert(d
< _UNIT_DEPENDENCY_MAX
);
633 * If u does not have this dependency set allocated, there is no need
634 * to reserve anything. In that case other's set will be transferred
635 * as a whole to u by complete_move().
637 if (!u
->dependencies
[d
])
640 /* merge_dependencies() will skip a u-on-u dependency */
641 n_reserve
= set_size(other
->dependencies
[d
]) - !!set_get(other
->dependencies
[d
], u
);
643 return set_reserve(u
->dependencies
[d
], n_reserve
);
646 static void merge_dependencies(Unit
*u
, Unit
*other
, const char *other_id
, UnitDependency d
) {
653 assert(d
< _UNIT_DEPENDENCY_MAX
);
655 /* Fix backwards pointers */
656 SET_FOREACH(back
, other
->dependencies
[d
], i
) {
659 for (k
= 0; k
< _UNIT_DEPENDENCY_MAX
; k
++) {
660 /* Do not add dependencies between u and itself */
662 if (set_remove(back
->dependencies
[k
], other
))
663 maybe_warn_about_dependency(u
, other_id
, k
);
665 r
= set_remove_and_put(back
->dependencies
[k
], other
, u
);
667 set_remove(back
->dependencies
[k
], other
);
669 assert(r
>= 0 || r
== -ENOENT
);
674 /* Also do not move dependencies on u to itself */
675 back
= set_remove(other
->dependencies
[d
], u
);
677 maybe_warn_about_dependency(u
, other_id
, d
);
679 /* The move cannot fail. The caller must have performed a reservation. */
680 assert_se(complete_move(&u
->dependencies
[d
], &other
->dependencies
[d
]) == 0);
682 other
->dependencies
[d
] = set_free(other
->dependencies
[d
]);
685 int unit_merge(Unit
*u
, Unit
*other
) {
687 const char *other_id
= NULL
;
692 assert(u
->manager
== other
->manager
);
693 assert(u
->type
!= _UNIT_TYPE_INVALID
);
695 other
= unit_follow_merge(other
);
700 if (u
->type
!= other
->type
)
703 if (!u
->instance
!= !other
->instance
)
706 if (other
->load_state
!= UNIT_STUB
&&
707 other
->load_state
!= UNIT_NOT_FOUND
)
716 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
720 other_id
= strdupa(other
->id
);
722 /* Make reservations to ensure merge_dependencies() won't fail */
723 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
724 r
= reserve_dependencies(u
, other
, d
);
726 * We don't rollback reservations if we fail. We don't have
727 * a way to undo reservations. A reservation is not a leak.
734 r
= merge_names(u
, other
);
738 /* Redirect all references */
740 unit_ref_set(other
->refs
, u
);
742 /* Merge dependencies */
743 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
744 merge_dependencies(u
, other
, other_id
, d
);
746 other
->load_state
= UNIT_MERGED
;
747 other
->merged_into
= u
;
749 /* If there is still some data attached to the other node, we
750 * don't need it anymore, and can free it. */
751 if (other
->load_state
!= UNIT_STUB
)
752 if (UNIT_VTABLE(other
)->done
)
753 UNIT_VTABLE(other
)->done(other
);
755 unit_add_to_dbus_queue(u
);
756 unit_add_to_cleanup_queue(other
);
761 int unit_merge_by_name(Unit
*u
, const char *name
) {
764 _cleanup_free_
char *s
= NULL
;
769 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
773 r
= unit_name_replace_instance(name
, u
->instance
, &s
);
780 other
= manager_get_unit(u
->manager
, name
);
782 return unit_merge(u
, other
);
784 return unit_add_name(u
, name
);
787 Unit
* unit_follow_merge(Unit
*u
) {
790 while (u
->load_state
== UNIT_MERGED
)
791 assert_se(u
= u
->merged_into
);
796 int unit_add_exec_dependencies(Unit
*u
, ExecContext
*c
) {
802 if (c
->working_directory
) {
803 r
= unit_require_mounts_for(u
, c
->working_directory
);
808 if (c
->root_directory
) {
809 r
= unit_require_mounts_for(u
, c
->root_directory
);
814 if (u
->manager
->running_as
!= MANAGER_SYSTEM
)
817 if (c
->private_tmp
) {
818 r
= unit_require_mounts_for(u
, "/tmp");
822 r
= unit_require_mounts_for(u
, "/var/tmp");
827 if (c
->std_output
!= EXEC_OUTPUT_KMSG
&&
828 c
->std_output
!= EXEC_OUTPUT_SYSLOG
&&
829 c
->std_output
!= EXEC_OUTPUT_JOURNAL
&&
830 c
->std_output
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
831 c
->std_output
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
&&
832 c
->std_output
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
833 c
->std_error
!= EXEC_OUTPUT_KMSG
&&
834 c
->std_error
!= EXEC_OUTPUT_SYSLOG
&&
835 c
->std_error
!= EXEC_OUTPUT_JOURNAL
&&
836 c
->std_error
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
837 c
->std_error
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
838 c
->std_error
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
)
841 /* If syslog or kernel logging is requested, make sure our own
842 * logging daemon is run first. */
844 r
= unit_add_dependency_by_name(u
, UNIT_AFTER
, SPECIAL_JOURNALD_SOCKET
, NULL
, true);
851 const char *unit_description(Unit
*u
) {
855 return u
->description
;
860 void unit_dump(Unit
*u
, FILE *f
, const char *prefix
) {
866 timestamp1
[FORMAT_TIMESTAMP_MAX
],
867 timestamp2
[FORMAT_TIMESTAMP_MAX
],
868 timestamp3
[FORMAT_TIMESTAMP_MAX
],
869 timestamp4
[FORMAT_TIMESTAMP_MAX
],
870 timespan
[FORMAT_TIMESPAN_MAX
];
872 _cleanup_set_free_ Set
*following_set
= NULL
;
876 assert(u
->type
>= 0);
878 prefix
= strempty(prefix
);
879 prefix2
= strjoina(prefix
, "\t");
883 "%s\tDescription: %s\n"
885 "%s\tUnit Load State: %s\n"
886 "%s\tUnit Active State: %s\n"
887 "%s\tInactive Exit Timestamp: %s\n"
888 "%s\tActive Enter Timestamp: %s\n"
889 "%s\tActive Exit Timestamp: %s\n"
890 "%s\tInactive Enter Timestamp: %s\n"
891 "%s\tGC Check Good: %s\n"
892 "%s\tNeed Daemon Reload: %s\n"
893 "%s\tTransient: %s\n"
896 "%s\tCGroup realized: %s\n"
897 "%s\tCGroup mask: 0x%x\n"
898 "%s\tCGroup members mask: 0x%x\n",
900 prefix
, unit_description(u
),
901 prefix
, strna(u
->instance
),
902 prefix
, unit_load_state_to_string(u
->load_state
),
903 prefix
, unit_active_state_to_string(unit_active_state(u
)),
904 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->inactive_exit_timestamp
.realtime
)),
905 prefix
, strna(format_timestamp(timestamp2
, sizeof(timestamp2
), u
->active_enter_timestamp
.realtime
)),
906 prefix
, strna(format_timestamp(timestamp3
, sizeof(timestamp3
), u
->active_exit_timestamp
.realtime
)),
907 prefix
, strna(format_timestamp(timestamp4
, sizeof(timestamp4
), u
->inactive_enter_timestamp
.realtime
)),
908 prefix
, yes_no(unit_check_gc(u
)),
909 prefix
, yes_no(unit_need_daemon_reload(u
)),
910 prefix
, yes_no(u
->transient
),
911 prefix
, strna(unit_slice_name(u
)),
912 prefix
, strna(u
->cgroup_path
),
913 prefix
, yes_no(u
->cgroup_realized
),
914 prefix
, u
->cgroup_realized_mask
,
915 prefix
, u
->cgroup_members_mask
);
917 SET_FOREACH(t
, u
->names
, i
)
918 fprintf(f
, "%s\tName: %s\n", prefix
, t
);
920 STRV_FOREACH(j
, u
->documentation
)
921 fprintf(f
, "%s\tDocumentation: %s\n", prefix
, *j
);
923 following
= unit_following(u
);
925 fprintf(f
, "%s\tFollowing: %s\n", prefix
, following
->id
);
927 r
= unit_following_set(u
, &following_set
);
931 SET_FOREACH(other
, following_set
, i
)
932 fprintf(f
, "%s\tFollowing Set Member: %s\n", prefix
, other
->id
);
935 if (u
->fragment_path
)
936 fprintf(f
, "%s\tFragment Path: %s\n", prefix
, u
->fragment_path
);
939 fprintf(f
, "%s\tSource Path: %s\n", prefix
, u
->source_path
);
941 STRV_FOREACH(j
, u
->dropin_paths
)
942 fprintf(f
, "%s\tDropIn Path: %s\n", prefix
, *j
);
944 if (u
->job_timeout
> 0)
945 fprintf(f
, "%s\tJob Timeout: %s\n", prefix
, format_timespan(timespan
, sizeof(timespan
), u
->job_timeout
, 0));
947 if (u
->job_timeout_action
!= FAILURE_ACTION_NONE
)
948 fprintf(f
, "%s\tJob Timeout Action: %s\n", prefix
, failure_action_to_string(u
->job_timeout_action
));
950 if (u
->job_timeout_reboot_arg
)
951 fprintf(f
, "%s\tJob Timeout Reboot Argument: %s\n", prefix
, u
->job_timeout_reboot_arg
);
953 condition_dump_list(u
->conditions
, f
, prefix
, condition_type_to_string
);
954 condition_dump_list(u
->asserts
, f
, prefix
, assert_type_to_string
);
956 if (dual_timestamp_is_set(&u
->condition_timestamp
))
958 "%s\tCondition Timestamp: %s\n"
959 "%s\tCondition Result: %s\n",
960 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->condition_timestamp
.realtime
)),
961 prefix
, yes_no(u
->condition_result
));
963 if (dual_timestamp_is_set(&u
->assert_timestamp
))
965 "%s\tAssert Timestamp: %s\n"
966 "%s\tAssert Result: %s\n",
967 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->assert_timestamp
.realtime
)),
968 prefix
, yes_no(u
->assert_result
));
970 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
973 SET_FOREACH(other
, u
->dependencies
[d
], i
)
974 fprintf(f
, "%s\t%s: %s\n", prefix
, unit_dependency_to_string(d
), other
->id
);
977 if (!strv_isempty(u
->requires_mounts_for
)) {
979 "%s\tRequiresMountsFor:", prefix
);
981 STRV_FOREACH(j
, u
->requires_mounts_for
)
982 fprintf(f
, " %s", *j
);
987 if (u
->load_state
== UNIT_LOADED
) {
990 "%s\tStopWhenUnneeded: %s\n"
991 "%s\tRefuseManualStart: %s\n"
992 "%s\tRefuseManualStop: %s\n"
993 "%s\tDefaultDependencies: %s\n"
994 "%s\tOnFailureJobMode: %s\n"
995 "%s\tIgnoreOnIsolate: %s\n"
996 "%s\tIgnoreOnSnapshot: %s\n",
997 prefix
, yes_no(u
->stop_when_unneeded
),
998 prefix
, yes_no(u
->refuse_manual_start
),
999 prefix
, yes_no(u
->refuse_manual_stop
),
1000 prefix
, yes_no(u
->default_dependencies
),
1001 prefix
, job_mode_to_string(u
->on_failure_job_mode
),
1002 prefix
, yes_no(u
->ignore_on_isolate
),
1003 prefix
, yes_no(u
->ignore_on_snapshot
));
1005 if (UNIT_VTABLE(u
)->dump
)
1006 UNIT_VTABLE(u
)->dump(u
, f
, prefix2
);
1008 } else if (u
->load_state
== UNIT_MERGED
)
1010 "%s\tMerged into: %s\n",
1011 prefix
, u
->merged_into
->id
);
1012 else if (u
->load_state
== UNIT_ERROR
)
1013 fprintf(f
, "%s\tLoad Error Code: %s\n", prefix
, strerror(-u
->load_error
));
1017 job_dump(u
->job
, f
, prefix2
);
1020 job_dump(u
->nop_job
, f
, prefix2
);
1024 /* Common implementation for multiple backends */
1025 int unit_load_fragment_and_dropin(Unit
*u
) {
1030 /* Load a .{service,socket,...} file */
1031 r
= unit_load_fragment(u
);
1035 if (u
->load_state
== UNIT_STUB
)
1038 /* Load drop-in directory data */
1039 r
= unit_load_dropin(unit_follow_merge(u
));
1046 /* Common implementation for multiple backends */
1047 int unit_load_fragment_and_dropin_optional(Unit
*u
) {
1052 /* Same as unit_load_fragment_and_dropin(), but whether
1053 * something can be loaded or not doesn't matter. */
1055 /* Load a .service file */
1056 r
= unit_load_fragment(u
);
1060 if (u
->load_state
== UNIT_STUB
)
1061 u
->load_state
= UNIT_LOADED
;
1063 /* Load drop-in directory data */
1064 r
= unit_load_dropin(unit_follow_merge(u
));
1071 int unit_add_default_target_dependency(Unit
*u
, Unit
*target
) {
1075 if (target
->type
!= UNIT_TARGET
)
1078 /* Only add the dependency if both units are loaded, so that
1079 * that loop check below is reliable */
1080 if (u
->load_state
!= UNIT_LOADED
||
1081 target
->load_state
!= UNIT_LOADED
)
1084 /* If either side wants no automatic dependencies, then let's
1086 if (!u
->default_dependencies
||
1087 !target
->default_dependencies
)
1090 /* Don't create loops */
1091 if (set_get(target
->dependencies
[UNIT_BEFORE
], u
))
1094 return unit_add_dependency(target
, UNIT_AFTER
, u
, true);
1097 static int unit_add_target_dependencies(Unit
*u
) {
1099 static const UnitDependency deps
[] = {
1101 UNIT_REQUIRED_BY_OVERRIDABLE
,
1103 UNIT_REQUISITE_OF_OVERRIDABLE
,
1115 for (k
= 0; k
< ELEMENTSOF(deps
); k
++)
1116 SET_FOREACH(target
, u
->dependencies
[deps
[k
]], i
) {
1117 r
= unit_add_default_target_dependency(u
, target
);
1125 static int unit_add_slice_dependencies(Unit
*u
) {
1128 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
1131 if (UNIT_ISSET(u
->slice
))
1132 return unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_WANTS
, UNIT_DEREF(u
->slice
), true);
1134 if (streq(u
->id
, SPECIAL_ROOT_SLICE
))
1137 return unit_add_two_dependencies_by_name(u
, UNIT_AFTER
, UNIT_WANTS
, SPECIAL_ROOT_SLICE
, NULL
, true);
1140 static int unit_add_mount_dependencies(Unit
*u
) {
1146 STRV_FOREACH(i
, u
->requires_mounts_for
) {
1147 char prefix
[strlen(*i
) + 1];
1149 PATH_FOREACH_PREFIX_MORE(prefix
, *i
) {
1152 r
= manager_get_unit_by_path(u
->manager
, prefix
, ".mount", &m
);
1160 if (m
->load_state
!= UNIT_LOADED
)
1163 r
= unit_add_dependency(u
, UNIT_AFTER
, m
, true);
1167 if (m
->fragment_path
) {
1168 r
= unit_add_dependency(u
, UNIT_REQUIRES
, m
, true);
1178 static int unit_add_startup_units(Unit
*u
) {
1182 c
= unit_get_cgroup_context(u
);
1186 if (c
->startup_cpu_shares
== CGROUP_CPU_SHARES_INVALID
&&
1187 c
->startup_blockio_weight
== CGROUP_BLKIO_WEIGHT_INVALID
)
1190 r
= set_ensure_allocated(&u
->manager
->startup_units
, NULL
);
1194 return set_put(u
->manager
->startup_units
, u
);
1197 int unit_load(Unit
*u
) {
1202 if (u
->in_load_queue
) {
1203 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
1204 u
->in_load_queue
= false;
1207 if (u
->type
== _UNIT_TYPE_INVALID
)
1210 if (u
->load_state
!= UNIT_STUB
)
1213 if (UNIT_VTABLE(u
)->load
) {
1214 r
= UNIT_VTABLE(u
)->load(u
);
1219 if (u
->load_state
== UNIT_STUB
) {
1224 if (u
->load_state
== UNIT_LOADED
) {
1226 r
= unit_add_target_dependencies(u
);
1230 r
= unit_add_slice_dependencies(u
);
1234 r
= unit_add_mount_dependencies(u
);
1238 r
= unit_add_startup_units(u
);
1242 if (u
->on_failure_job_mode
== JOB_ISOLATE
&& set_size(u
->dependencies
[UNIT_ON_FAILURE
]) > 1) {
1243 log_unit_error(u
, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1248 unit_update_cgroup_members_masks(u
);
1250 /* If we are reloading, we need to wait for the deserializer
1251 * to restore the net_cls ids that have been set previously */
1252 if (u
->manager
->n_reloading
<= 0) {
1253 r
= unit_add_to_netclass_cgroup(u
);
1259 assert((u
->load_state
!= UNIT_MERGED
) == !u
->merged_into
);
1261 unit_add_to_dbus_queue(unit_follow_merge(u
));
1262 unit_add_to_gc_queue(u
);
1267 u
->load_state
= u
->load_state
== UNIT_STUB
? UNIT_NOT_FOUND
: UNIT_ERROR
;
1269 unit_add_to_dbus_queue(u
);
1270 unit_add_to_gc_queue(u
);
1272 log_unit_debug_errno(u
, r
, "Failed to load configuration: %m");
1277 static bool unit_condition_test_list(Unit
*u
, Condition
*first
, const char *(*to_string
)(ConditionType t
)) {
1284 /* If the condition list is empty, then it is true */
1288 /* Otherwise, if all of the non-trigger conditions apply and
1289 * if any of the trigger conditions apply (unless there are
1290 * none) we return true */
1291 LIST_FOREACH(conditions
, c
, first
) {
1294 r
= condition_test(c
);
1297 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1299 c
->trigger
? "|" : "",
1300 c
->negate
? "!" : "",
1306 c
->trigger
? "|" : "",
1307 c
->negate
? "!" : "",
1309 condition_result_to_string(c
->result
));
1311 if (!c
->trigger
&& r
<= 0)
1314 if (c
->trigger
&& triggered
<= 0)
1318 return triggered
!= 0;
1321 static bool unit_condition_test(Unit
*u
) {
1324 dual_timestamp_get(&u
->condition_timestamp
);
1325 u
->condition_result
= unit_condition_test_list(u
, u
->conditions
, condition_type_to_string
);
1327 return u
->condition_result
;
1330 static bool unit_assert_test(Unit
*u
) {
1333 dual_timestamp_get(&u
->assert_timestamp
);
1334 u
->assert_result
= unit_condition_test_list(u
, u
->asserts
, assert_type_to_string
);
1336 return u
->assert_result
;
1339 _pure_
static const char* unit_get_status_message_format(Unit
*u
, JobType t
) {
1341 const UnitStatusMessageFormats
*format_table
;
1344 assert(t
== JOB_START
|| t
== JOB_STOP
|| t
== JOB_RELOAD
);
1346 if (t
!= JOB_RELOAD
) {
1347 format_table
= &UNIT_VTABLE(u
)->status_message_formats
;
1349 format
= format_table
->starting_stopping
[t
== JOB_STOP
];
1355 /* Return generic strings */
1357 return "Starting %s.";
1358 else if (t
== JOB_STOP
)
1359 return "Stopping %s.";
1361 return "Reloading %s.";
1364 static void unit_status_print_starting_stopping(Unit
*u
, JobType t
) {
1369 format
= unit_get_status_message_format(u
, t
);
1371 DISABLE_WARNING_FORMAT_NONLITERAL
;
1372 unit_status_printf(u
, "", format
);
1376 static void unit_status_log_starting_stopping_reloading(Unit
*u
, JobType t
) {
1383 if (t
!= JOB_START
&& t
!= JOB_STOP
&& t
!= JOB_RELOAD
)
1386 if (log_on_console())
1389 /* We log status messages for all units and all operations. */
1391 format
= unit_get_status_message_format(u
, t
);
1393 DISABLE_WARNING_FORMAT_NONLITERAL
;
1394 snprintf(buf
, sizeof(buf
), format
, unit_description(u
));
1397 mid
= t
== JOB_START
? SD_MESSAGE_UNIT_STARTING
:
1398 t
== JOB_STOP
? SD_MESSAGE_UNIT_STOPPING
:
1399 SD_MESSAGE_UNIT_RELOADING
;
1401 /* Note that we deliberately use LOG_MESSAGE() instead of
1402 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1403 * closely what is written to screen using the status output,
1404 * which is supposed the highest level, friendliest output
1405 * possible, which means we should avoid the low-level unit
1407 log_struct(LOG_INFO
,
1408 LOG_MESSAGE_ID(mid
),
1410 LOG_MESSAGE("%s", buf
),
1414 void unit_status_emit_starting_stopping_reloading(Unit
*u
, JobType t
) {
1416 unit_status_log_starting_stopping_reloading(u
, t
);
1418 /* Reload status messages have traditionally not been printed to console. */
1419 if (t
!= JOB_RELOAD
)
1420 unit_status_print_starting_stopping(u
, t
);
1424 * -EBADR: This unit type does not support starting.
1425 * -EALREADY: Unit is already started.
1426 * -EAGAIN: An operation is already in progress. Retry later.
1427 * -ECANCELED: Too many requests for now.
1428 * -EPROTO: Assert failed
1430 int unit_start(Unit
*u
) {
1431 UnitActiveState state
;
1436 /* Units that aren't loaded cannot be started */
1437 if (u
->load_state
!= UNIT_LOADED
)
1440 /* If this is already started, then this will succeed. Note
1441 * that this will even succeed if this unit is not startable
1442 * by the user. This is relied on to detect when we need to
1443 * wait for units and when waiting is finished. */
1444 state
= unit_active_state(u
);
1445 if (UNIT_IS_ACTIVE_OR_RELOADING(state
))
1448 /* If the conditions failed, don't do anything at all. If we
1449 * already are activating this call might still be useful to
1450 * speed up activation in case there is some hold-off time,
1451 * but we don't want to recheck the condition in that case. */
1452 if (state
!= UNIT_ACTIVATING
&&
1453 !unit_condition_test(u
)) {
1454 log_unit_debug(u
, "Starting requested but condition failed. Not starting unit.");
1458 /* If the asserts failed, fail the entire job */
1459 if (state
!= UNIT_ACTIVATING
&&
1460 !unit_assert_test(u
)) {
1461 log_unit_notice(u
, "Starting requested but asserts failed.");
1465 /* Units of types that aren't supported cannot be
1466 * started. Note that we do this test only after the condition
1467 * checks, so that we rather return condition check errors
1468 * (which are usually not considered a true failure) than "not
1469 * supported" errors (which are considered a failure).
1471 if (!unit_supported(u
))
1474 /* Forward to the main object, if we aren't it. */
1475 following
= unit_following(u
);
1477 log_unit_debug(u
, "Redirecting start request from %s to %s.", u
->id
, following
->id
);
1478 return unit_start(following
);
1481 /* If it is stopped, but we cannot start it, then fail */
1482 if (!UNIT_VTABLE(u
)->start
)
1485 /* We don't suppress calls to ->start() here when we are
1486 * already starting, to allow this request to be used as a
1487 * "hurry up" call, for example when the unit is in some "auto
1488 * restart" state where it waits for a holdoff timer to elapse
1489 * before it will start again. */
1491 unit_add_to_dbus_queue(u
);
1493 return UNIT_VTABLE(u
)->start(u
);
1496 bool unit_can_start(Unit
*u
) {
1499 if (u
->load_state
!= UNIT_LOADED
)
1502 if (!unit_supported(u
))
1505 return !!UNIT_VTABLE(u
)->start
;
1508 bool unit_can_isolate(Unit
*u
) {
1511 return unit_can_start(u
) &&
1516 * -EBADR: This unit type does not support stopping.
1517 * -EALREADY: Unit is already stopped.
1518 * -EAGAIN: An operation is already in progress. Retry later.
1520 int unit_stop(Unit
*u
) {
1521 UnitActiveState state
;
1526 state
= unit_active_state(u
);
1527 if (UNIT_IS_INACTIVE_OR_FAILED(state
))
1530 following
= unit_following(u
);
1532 log_unit_debug(u
, "Redirecting stop request from %s to %s.", u
->id
, following
->id
);
1533 return unit_stop(following
);
1536 if (!UNIT_VTABLE(u
)->stop
)
1539 unit_add_to_dbus_queue(u
);
1541 return UNIT_VTABLE(u
)->stop(u
);
1545 * -EBADR: This unit type does not support reloading.
1546 * -ENOEXEC: Unit is not started.
1547 * -EAGAIN: An operation is already in progress. Retry later.
1549 int unit_reload(Unit
*u
) {
1550 UnitActiveState state
;
1555 if (u
->load_state
!= UNIT_LOADED
)
1558 if (!unit_can_reload(u
))
1561 state
= unit_active_state(u
);
1562 if (state
== UNIT_RELOADING
)
1565 if (state
!= UNIT_ACTIVE
) {
1566 log_unit_warning(u
, "Unit cannot be reloaded because it is inactive.");
1570 following
= unit_following(u
);
1572 log_unit_debug(u
, "Redirecting reload request from %s to %s.", u
->id
, following
->id
);
1573 return unit_reload(following
);
1576 unit_add_to_dbus_queue(u
);
1578 return UNIT_VTABLE(u
)->reload(u
);
1581 bool unit_can_reload(Unit
*u
) {
1584 if (!UNIT_VTABLE(u
)->reload
)
1587 if (!UNIT_VTABLE(u
)->can_reload
)
1590 return UNIT_VTABLE(u
)->can_reload(u
);
1593 static void unit_check_unneeded(Unit
*u
) {
1595 static const UnitDependency needed_dependencies
[] = {
1597 UNIT_REQUIRED_BY_OVERRIDABLE
,
1599 UNIT_REQUISITE_OF_OVERRIDABLE
,
1611 /* If this service shall be shut down when unneeded then do
1614 if (!u
->stop_when_unneeded
)
1617 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
1620 for (j
= 0; j
< ELEMENTSOF(needed_dependencies
); j
++)
1621 SET_FOREACH(other
, u
->dependencies
[needed_dependencies
[j
]], i
)
1622 if (unit_active_or_pending(other
))
1625 /* If stopping a unit fails continously we might enter a stop
1626 * loop here, hence stop acting on the service being
1627 * unnecessary after a while. */
1628 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1629 log_unit_warning(u
, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1633 log_unit_info(u
, "Unit not needed anymore. Stopping.");
1635 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1636 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, true, NULL
, NULL
);
1638 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %m");
1641 static void unit_check_binds_to(Unit
*u
) {
1652 if (unit_active_state(u
) != UNIT_ACTIVE
)
1655 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
) {
1659 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
1669 /* If stopping a unit fails continously we might enter a stop
1670 * loop here, hence stop acting on the service being
1671 * unnecessary after a while. */
1672 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1673 log_unit_warning(u
, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other
->id
);
1678 log_unit_info(u
, "Unit is bound to inactive unit %s. Stopping, too.", other
->id
);
1680 /* A unit we need to run is gone. Sniff. Let's stop this. */
1681 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, true, NULL
, NULL
);
1683 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %m");
1686 static void retroactively_start_dependencies(Unit
*u
) {
1691 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)));
1693 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1694 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1695 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1696 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1698 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1699 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1700 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1701 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1703 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES_OVERRIDABLE
], i
)
1704 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1705 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1706 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, false, NULL
, NULL
);
1708 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1709 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1710 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1711 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, false, NULL
, NULL
);
1713 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTS
], i
)
1714 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1715 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1717 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTED_BY
], i
)
1718 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1719 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1722 static void retroactively_stop_dependencies(Unit
*u
) {
1727 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1729 /* Pull down units which are bound to us recursively if enabled */
1730 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1731 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1732 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1735 static void check_unneeded_dependencies(Unit
*u
) {
1740 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1742 /* Garbage collect services that might not be needed anymore, if enabled */
1743 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1744 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1745 unit_check_unneeded(other
);
1746 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES_OVERRIDABLE
], i
)
1747 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1748 unit_check_unneeded(other
);
1749 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1750 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1751 unit_check_unneeded(other
);
1752 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1753 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1754 unit_check_unneeded(other
);
1755 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE_OVERRIDABLE
], i
)
1756 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1757 unit_check_unneeded(other
);
1758 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1759 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1760 unit_check_unneeded(other
);
1763 void unit_start_on_failure(Unit
*u
) {
1769 if (set_size(u
->dependencies
[UNIT_ON_FAILURE
]) <= 0)
1772 log_unit_info(u
, "Triggering OnFailure= dependencies.");
1774 SET_FOREACH(other
, u
->dependencies
[UNIT_ON_FAILURE
], i
) {
1777 r
= manager_add_job(u
->manager
, JOB_START
, other
, u
->on_failure_job_mode
, true, NULL
, NULL
);
1779 log_unit_error_errno(u
, r
, "Failed to enqueue OnFailure= job: %m");
1783 void unit_trigger_notify(Unit
*u
) {
1789 SET_FOREACH(other
, u
->dependencies
[UNIT_TRIGGERED_BY
], i
)
1790 if (UNIT_VTABLE(other
)->trigger_notify
)
1791 UNIT_VTABLE(other
)->trigger_notify(other
, u
);
1794 void unit_notify(Unit
*u
, UnitActiveState os
, UnitActiveState ns
, bool reload_success
) {
1799 assert(os
< _UNIT_ACTIVE_STATE_MAX
);
1800 assert(ns
< _UNIT_ACTIVE_STATE_MAX
);
1802 /* Note that this is called for all low-level state changes,
1803 * even if they might map to the same high-level
1804 * UnitActiveState! That means that ns == os is an expected
1805 * behavior here. For example: if a mount point is remounted
1806 * this function will be called too! */
1810 /* Update timestamps for state changes */
1811 if (m
->n_reloading
<= 0) {
1814 dual_timestamp_get(&ts
);
1816 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && !UNIT_IS_INACTIVE_OR_FAILED(ns
))
1817 u
->inactive_exit_timestamp
= ts
;
1818 else if (!UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_INACTIVE_OR_FAILED(ns
))
1819 u
->inactive_enter_timestamp
= ts
;
1821 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
) && UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1822 u
->active_enter_timestamp
= ts
;
1823 else if (UNIT_IS_ACTIVE_OR_RELOADING(os
) && !UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1824 u
->active_exit_timestamp
= ts
;
1827 /* Keep track of failed units */
1828 (void) manager_update_failed_units(u
->manager
, u
, ns
== UNIT_FAILED
);
1830 /* Make sure the cgroup is always removed when we become inactive */
1831 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1832 unit_prune_cgroup(u
);
1834 /* Note that this doesn't apply to RemainAfterExit services exiting
1835 * successfully, since there's no change of state in that case. Which is
1836 * why it is handled in service_set_state() */
1837 if (UNIT_IS_INACTIVE_OR_FAILED(os
) != UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1840 ec
= unit_get_exec_context(u
);
1841 if (ec
&& exec_context_may_touch_console(ec
)) {
1842 if (UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1845 if (m
->n_on_console
== 0)
1846 /* unset no_console_output flag, since the console is free */
1847 m
->no_console_output
= false;
1856 if (u
->job
->state
== JOB_WAITING
)
1858 /* So we reached a different state for this
1859 * job. Let's see if we can run it now if it
1860 * failed previously due to EAGAIN. */
1861 job_add_to_run_queue(u
->job
);
1863 /* Let's check whether this state change constitutes a
1864 * finished job, or maybe contradicts a running job and
1865 * hence needs to invalidate jobs. */
1867 switch (u
->job
->type
) {
1870 case JOB_VERIFY_ACTIVE
:
1872 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1873 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1874 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_ACTIVATING
) {
1877 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1878 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1884 case JOB_RELOAD_OR_START
:
1886 if (u
->job
->state
== JOB_RUNNING
) {
1887 if (ns
== UNIT_ACTIVE
)
1888 job_finish_and_invalidate(u
->job
, reload_success
? JOB_DONE
: JOB_FAILED
, true);
1889 else if (ns
!= UNIT_ACTIVATING
&& ns
!= UNIT_RELOADING
) {
1892 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1893 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1901 case JOB_TRY_RESTART
:
1903 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1904 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1905 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_DEACTIVATING
) {
1907 job_finish_and_invalidate(u
->job
, JOB_FAILED
, true);
1913 assert_not_reached("Job type unknown");
1919 if (m
->n_reloading
<= 0) {
1921 /* If this state change happened without being
1922 * requested by a job, then let's retroactively start
1923 * or stop dependencies. We skip that step when
1924 * deserializing, since we don't want to create any
1925 * additional jobs just because something is already
1929 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns
))
1930 retroactively_start_dependencies(u
);
1931 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1932 retroactively_stop_dependencies(u
);
1935 /* stop unneeded units regardless if going down was expected or not */
1936 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1937 check_unneeded_dependencies(u
);
1939 if (ns
!= os
&& ns
== UNIT_FAILED
) {
1940 log_unit_notice(u
, "Unit entered failed state.");
1941 unit_start_on_failure(u
);
1945 /* Some names are special */
1946 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
)) {
1948 if (unit_has_name(u
, SPECIAL_DBUS_SERVICE
))
1949 /* The bus might have just become available,
1950 * hence try to connect to it, if we aren't
1954 if (u
->type
== UNIT_SERVICE
&&
1955 !UNIT_IS_ACTIVE_OR_RELOADING(os
) &&
1956 m
->n_reloading
<= 0) {
1957 /* Write audit record if we have just finished starting up */
1958 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, true);
1962 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
))
1963 manager_send_unit_plymouth(m
, u
);
1967 /* We don't care about D-Bus here, since we'll get an
1968 * asynchronous notification for it anyway. */
1970 if (u
->type
== UNIT_SERVICE
&&
1971 UNIT_IS_INACTIVE_OR_FAILED(ns
) &&
1972 !UNIT_IS_INACTIVE_OR_FAILED(os
) &&
1973 m
->n_reloading
<= 0) {
1975 /* Hmm, if there was no start record written
1976 * write it now, so that we always have a nice
1979 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, ns
== UNIT_INACTIVE
);
1981 if (ns
== UNIT_INACTIVE
)
1982 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, true);
1984 /* Write audit record if we have just finished shutting down */
1985 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, ns
== UNIT_INACTIVE
);
1987 u
->in_audit
= false;
1991 manager_recheck_journal(m
);
1992 unit_trigger_notify(u
);
1994 if (u
->manager
->n_reloading
<= 0) {
1995 /* Maybe we finished startup and are now ready for
1996 * being stopped because unneeded? */
1997 unit_check_unneeded(u
);
1999 /* Maybe we finished startup, but something we needed
2000 * has vanished? Let's die then. (This happens when
2001 * something BindsTo= to a Type=oneshot unit, as these
2002 * units go directly from starting to inactive,
2003 * without ever entering started.) */
2004 unit_check_binds_to(u
);
2007 unit_add_to_dbus_queue(u
);
2008 unit_add_to_gc_queue(u
);
2011 int unit_watch_pid(Unit
*u
, pid_t pid
) {
2017 /* Watch a specific PID. We only support one or two units
2018 * watching each PID for now, not more. */
2020 r
= set_ensure_allocated(&u
->pids
, NULL
);
2024 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids1
, NULL
);
2028 r
= hashmap_put(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2030 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids2
, NULL
);
2034 r
= hashmap_put(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2037 q
= set_put(u
->pids
, PID_TO_PTR(pid
));
2044 void unit_unwatch_pid(Unit
*u
, pid_t pid
) {
2048 (void) hashmap_remove_value(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2049 (void) hashmap_remove_value(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2050 (void) set_remove(u
->pids
, PID_TO_PTR(pid
));
2053 void unit_unwatch_all_pids(Unit
*u
) {
2056 while (!set_isempty(u
->pids
))
2057 unit_unwatch_pid(u
, PTR_TO_PID(set_first(u
->pids
)));
2059 u
->pids
= set_free(u
->pids
);
2062 void unit_tidy_watch_pids(Unit
*u
, pid_t except1
, pid_t except2
) {
2068 /* Cleans dead PIDs from our list */
2070 SET_FOREACH(e
, u
->pids
, i
) {
2071 pid_t pid
= PTR_TO_PID(e
);
2073 if (pid
== except1
|| pid
== except2
)
2076 if (!pid_is_unwaited(pid
))
2077 unit_unwatch_pid(u
, pid
);
2081 bool unit_job_is_applicable(Unit
*u
, JobType j
) {
2083 assert(j
>= 0 && j
< _JOB_TYPE_MAX
);
2087 case JOB_VERIFY_ACTIVE
:
2094 case JOB_TRY_RESTART
:
2095 return unit_can_start(u
);
2098 return unit_can_reload(u
);
2100 case JOB_RELOAD_OR_START
:
2101 return unit_can_reload(u
) && unit_can_start(u
);
2104 assert_not_reached("Invalid job type");
2108 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
) {
2111 /* Only warn about some unit types */
2112 if (!IN_SET(dependency
, UNIT_CONFLICTS
, UNIT_CONFLICTED_BY
, UNIT_BEFORE
, UNIT_AFTER
, UNIT_ON_FAILURE
, UNIT_TRIGGERS
, UNIT_TRIGGERED_BY
))
2115 if (streq_ptr(u
->id
, other
))
2116 log_unit_warning(u
, "Dependency %s=%s dropped", unit_dependency_to_string(dependency
), u
->id
);
2118 log_unit_warning(u
, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency
), strna(other
), u
->id
);
2121 int unit_add_dependency(Unit
*u
, UnitDependency d
, Unit
*other
, bool add_reference
) {
2123 static const UnitDependency inverse_table
[_UNIT_DEPENDENCY_MAX
] = {
2124 [UNIT_REQUIRES
] = UNIT_REQUIRED_BY
,
2125 [UNIT_REQUIRES_OVERRIDABLE
] = UNIT_REQUIRED_BY_OVERRIDABLE
,
2126 [UNIT_WANTS
] = UNIT_WANTED_BY
,
2127 [UNIT_REQUISITE
] = UNIT_REQUISITE_OF
,
2128 [UNIT_REQUISITE_OVERRIDABLE
] = UNIT_REQUISITE_OF_OVERRIDABLE
,
2129 [UNIT_BINDS_TO
] = UNIT_BOUND_BY
,
2130 [UNIT_PART_OF
] = UNIT_CONSISTS_OF
,
2131 [UNIT_REQUIRED_BY
] = UNIT_REQUIRES
,
2132 [UNIT_REQUIRED_BY_OVERRIDABLE
] = UNIT_REQUIRES_OVERRIDABLE
,
2133 [UNIT_REQUISITE_OF
] = UNIT_REQUISITE
,
2134 [UNIT_REQUISITE_OF_OVERRIDABLE
] = UNIT_REQUISITE_OVERRIDABLE
,
2135 [UNIT_WANTED_BY
] = UNIT_WANTS
,
2136 [UNIT_BOUND_BY
] = UNIT_BINDS_TO
,
2137 [UNIT_CONSISTS_OF
] = UNIT_PART_OF
,
2138 [UNIT_CONFLICTS
] = UNIT_CONFLICTED_BY
,
2139 [UNIT_CONFLICTED_BY
] = UNIT_CONFLICTS
,
2140 [UNIT_BEFORE
] = UNIT_AFTER
,
2141 [UNIT_AFTER
] = UNIT_BEFORE
,
2142 [UNIT_ON_FAILURE
] = _UNIT_DEPENDENCY_INVALID
,
2143 [UNIT_REFERENCES
] = UNIT_REFERENCED_BY
,
2144 [UNIT_REFERENCED_BY
] = UNIT_REFERENCES
,
2145 [UNIT_TRIGGERS
] = UNIT_TRIGGERED_BY
,
2146 [UNIT_TRIGGERED_BY
] = UNIT_TRIGGERS
,
2147 [UNIT_PROPAGATES_RELOAD_TO
] = UNIT_RELOAD_PROPAGATED_FROM
,
2148 [UNIT_RELOAD_PROPAGATED_FROM
] = UNIT_PROPAGATES_RELOAD_TO
,
2149 [UNIT_JOINS_NAMESPACE_OF
] = UNIT_JOINS_NAMESPACE_OF
,
2151 int r
, q
= 0, v
= 0, w
= 0;
2152 Unit
*orig_u
= u
, *orig_other
= other
;
2155 assert(d
>= 0 && d
< _UNIT_DEPENDENCY_MAX
);
2158 u
= unit_follow_merge(u
);
2159 other
= unit_follow_merge(other
);
2161 /* We won't allow dependencies on ourselves. We will not
2162 * consider them an error however. */
2164 maybe_warn_about_dependency(orig_u
, orig_other
->id
, d
);
2168 r
= set_ensure_allocated(&u
->dependencies
[d
], NULL
);
2172 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
) {
2173 r
= set_ensure_allocated(&other
->dependencies
[inverse_table
[d
]], NULL
);
2178 if (add_reference
) {
2179 r
= set_ensure_allocated(&u
->dependencies
[UNIT_REFERENCES
], NULL
);
2183 r
= set_ensure_allocated(&other
->dependencies
[UNIT_REFERENCED_BY
], NULL
);
2188 q
= set_put(u
->dependencies
[d
], other
);
2192 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
&& inverse_table
[d
] != d
) {
2193 v
= set_put(other
->dependencies
[inverse_table
[d
]], u
);
2200 if (add_reference
) {
2201 w
= set_put(u
->dependencies
[UNIT_REFERENCES
], other
);
2207 r
= set_put(other
->dependencies
[UNIT_REFERENCED_BY
], u
);
2212 unit_add_to_dbus_queue(u
);
2217 set_remove(u
->dependencies
[d
], other
);
2220 set_remove(other
->dependencies
[inverse_table
[d
]], u
);
2223 set_remove(u
->dependencies
[UNIT_REFERENCES
], other
);
2228 int unit_add_two_dependencies(Unit
*u
, UnitDependency d
, UnitDependency e
, Unit
*other
, bool add_reference
) {
2233 r
= unit_add_dependency(u
, d
, other
, add_reference
);
2237 return unit_add_dependency(u
, e
, other
, add_reference
);
2240 static int resolve_template(Unit
*u
, const char *name
, const char*path
, char **buf
, const char **ret
) {
2244 assert(name
|| path
);
2249 name
= basename(path
);
2251 if (!unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
2258 r
= unit_name_replace_instance(name
, u
->instance
, buf
);
2260 _cleanup_free_
char *i
= NULL
;
2262 r
= unit_name_to_prefix(u
->id
, &i
);
2266 r
= unit_name_replace_instance(name
, i
, buf
);
2275 int unit_add_dependency_by_name(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
2276 _cleanup_free_
char *buf
= NULL
;
2281 assert(name
|| path
);
2283 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2287 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2291 return unit_add_dependency(u
, d
, other
, add_reference
);
2294 int unit_add_two_dependencies_by_name(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
2295 _cleanup_free_
char *buf
= NULL
;
2300 assert(name
|| path
);
2302 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2306 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2310 return unit_add_two_dependencies(u
, d
, e
, other
, add_reference
);
2313 int unit_add_dependency_by_name_inverse(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
2314 _cleanup_free_
char *buf
= NULL
;
2319 assert(name
|| path
);
2321 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2325 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2329 return unit_add_dependency(other
, d
, u
, add_reference
);
2332 int unit_add_two_dependencies_by_name_inverse(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
2333 _cleanup_free_
char *buf
= NULL
;
2338 assert(name
|| path
);
2340 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2344 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2348 return unit_add_two_dependencies(other
, d
, e
, u
, add_reference
);
2351 int set_unit_path(const char *p
) {
2352 /* This is mostly for debug purposes */
2353 if (setenv("SYSTEMD_UNIT_PATH", p
, 0) < 0)
2359 char *unit_dbus_path(Unit
*u
) {
2365 return unit_dbus_path_from_name(u
->id
);
2368 int unit_set_slice(Unit
*u
, Unit
*slice
) {
2372 /* Sets the unit slice if it has not been set before. Is extra
2373 * careful, to only allow this for units that actually have a
2374 * cgroup context. Also, we don't allow to set this for slices
2375 * (since the parent slice is derived from the name). Make
2376 * sure the unit we set is actually a slice. */
2378 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
2381 if (u
->type
== UNIT_SLICE
)
2384 if (unit_active_state(u
) != UNIT_INACTIVE
)
2387 if (slice
->type
!= UNIT_SLICE
)
2390 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
) &&
2391 !unit_has_name(slice
, SPECIAL_ROOT_SLICE
))
2394 if (UNIT_DEREF(u
->slice
) == slice
)
2397 if (UNIT_ISSET(u
->slice
))
2400 unit_ref_set(&u
->slice
, slice
);
2404 int unit_set_default_slice(Unit
*u
) {
2405 _cleanup_free_
char *b
= NULL
;
2406 const char *slice_name
;
2412 if (UNIT_ISSET(u
->slice
))
2416 _cleanup_free_
char *prefix
= NULL
, *escaped
= NULL
;
2418 /* Implicitly place all instantiated units in their
2419 * own per-template slice */
2421 r
= unit_name_to_prefix(u
->id
, &prefix
);
2425 /* The prefix is already escaped, but it might include
2426 * "-" which has a special meaning for slice units,
2427 * hence escape it here extra. */
2428 escaped
= unit_name_escape(prefix
);
2432 if (u
->manager
->running_as
== MANAGER_SYSTEM
)
2433 b
= strjoin("system-", escaped
, ".slice", NULL
);
2435 b
= strappend(escaped
, ".slice");
2442 u
->manager
->running_as
== MANAGER_SYSTEM
&& !unit_has_name(u
, SPECIAL_INIT_SCOPE
)
2443 ? SPECIAL_SYSTEM_SLICE
2444 : SPECIAL_ROOT_SLICE
;
2446 r
= manager_load_unit(u
->manager
, slice_name
, NULL
, NULL
, &slice
);
2450 return unit_set_slice(u
, slice
);
2453 const char *unit_slice_name(Unit
*u
) {
2456 if (!UNIT_ISSET(u
->slice
))
2459 return UNIT_DEREF(u
->slice
)->id
;
2462 int unit_load_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2463 _cleanup_free_
char *t
= NULL
;
2470 r
= unit_name_change_suffix(u
->id
, type
, &t
);
2473 if (unit_has_name(u
, t
))
2476 r
= manager_load_unit(u
->manager
, t
, NULL
, NULL
, _found
);
2477 assert(r
< 0 || *_found
!= u
);
2481 static int signal_name_owner_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2482 const char *name
, *old_owner
, *new_owner
;
2489 r
= sd_bus_message_read(message
, "sss", &name
, &old_owner
, &new_owner
);
2491 bus_log_parse_error(r
);
2495 if (UNIT_VTABLE(u
)->bus_name_owner_change
)
2496 UNIT_VTABLE(u
)->bus_name_owner_change(u
, name
, old_owner
, new_owner
);
2501 int unit_install_bus_match(sd_bus
*bus
, Unit
*u
, const char *name
) {
2502 _cleanup_free_
char *match
= NULL
;
2503 Manager
*m
= u
->manager
;
2507 if (u
->match_bus_slot
)
2510 match
= strjoin("type='signal',"
2511 "sender='org.freedesktop.DBus',"
2512 "path='/org/freedesktop/DBus',"
2513 "interface='org.freedesktop.DBus',"
2514 "member='NameOwnerChanged',"
2522 return sd_bus_add_match(bus
, &u
->match_bus_slot
, match
, signal_name_owner_changed
, u
);
2525 int unit_watch_bus_name(Unit
*u
, const char *name
) {
2531 /* Watch a specific name on the bus. We only support one unit
2532 * watching each name for now. */
2534 if (u
->manager
->api_bus
) {
2535 /* If the bus is already available, install the match directly.
2536 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2537 r
= unit_install_bus_match(u
->manager
->api_bus
, u
, name
);
2539 return log_warning_errno(r
, "Failed to subscribe to NameOwnerChanged signal: %m");
2542 r
= hashmap_put(u
->manager
->watch_bus
, name
, u
);
2544 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2545 return log_warning_errno(r
, "Failed to put bus name to hashmap: %m");
2551 void unit_unwatch_bus_name(Unit
*u
, const char *name
) {
2555 hashmap_remove_value(u
->manager
->watch_bus
, name
, u
);
2556 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2559 bool unit_can_serialize(Unit
*u
) {
2562 return UNIT_VTABLE(u
)->serialize
&& UNIT_VTABLE(u
)->deserialize_item
;
2565 int unit_serialize(Unit
*u
, FILE *f
, FDSet
*fds
, bool serialize_jobs
) {
2572 if (unit_can_serialize(u
)) {
2575 r
= UNIT_VTABLE(u
)->serialize(u
, f
, fds
);
2579 rt
= unit_get_exec_runtime(u
);
2581 r
= exec_runtime_serialize(u
, rt
, f
, fds
);
2587 dual_timestamp_serialize(f
, "inactive-exit-timestamp", &u
->inactive_exit_timestamp
);
2588 dual_timestamp_serialize(f
, "active-enter-timestamp", &u
->active_enter_timestamp
);
2589 dual_timestamp_serialize(f
, "active-exit-timestamp", &u
->active_exit_timestamp
);
2590 dual_timestamp_serialize(f
, "inactive-enter-timestamp", &u
->inactive_enter_timestamp
);
2591 dual_timestamp_serialize(f
, "condition-timestamp", &u
->condition_timestamp
);
2592 dual_timestamp_serialize(f
, "assert-timestamp", &u
->assert_timestamp
);
2594 if (dual_timestamp_is_set(&u
->condition_timestamp
))
2595 unit_serialize_item(u
, f
, "condition-result", yes_no(u
->condition_result
));
2597 if (dual_timestamp_is_set(&u
->assert_timestamp
))
2598 unit_serialize_item(u
, f
, "assert-result", yes_no(u
->assert_result
));
2600 unit_serialize_item(u
, f
, "transient", yes_no(u
->transient
));
2601 unit_serialize_item_format(u
, f
, "cpuacct-usage-base", "%" PRIu64
, u
->cpuacct_usage_base
);
2604 unit_serialize_item(u
, f
, "cgroup", u
->cgroup_path
);
2605 unit_serialize_item(u
, f
, "cgroup-realized", yes_no(u
->cgroup_realized
));
2607 if (u
->cgroup_netclass_id
)
2608 unit_serialize_item_format(u
, f
, "netclass-id", "%" PRIu32
, u
->cgroup_netclass_id
);
2610 if (serialize_jobs
) {
2612 fprintf(f
, "job\n");
2613 job_serialize(u
->job
, f
, fds
);
2617 fprintf(f
, "job\n");
2618 job_serialize(u
->nop_job
, f
, fds
);
2627 void unit_serialize_item_format(Unit
*u
, FILE *f
, const char *key
, const char *format
, ...) {
2638 va_start(ap
, format
);
2639 vfprintf(f
, format
, ap
);
2645 void unit_serialize_item(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2651 fprintf(f
, "%s=%s\n", key
, value
);
2654 int unit_deserialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2655 ExecRuntime
**rt
= NULL
;
2663 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
2665 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
2668 char line
[LINE_MAX
], *l
, *v
;
2671 if (!fgets(line
, sizeof(line
), f
)) {
2684 k
= strcspn(l
, "=");
2692 if (streq(l
, "job")) {
2694 /* new-style serialized job */
2701 r
= job_deserialize(j
, f
, fds
);
2707 r
= hashmap_put(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
), j
);
2713 r
= job_install_deserialized(j
);
2715 hashmap_remove(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
));
2719 } else /* legacy for pre-44 */
2720 log_unit_warning(u
, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v
);
2722 } else if (streq(l
, "inactive-exit-timestamp")) {
2723 dual_timestamp_deserialize(v
, &u
->inactive_exit_timestamp
);
2725 } else if (streq(l
, "active-enter-timestamp")) {
2726 dual_timestamp_deserialize(v
, &u
->active_enter_timestamp
);
2728 } else if (streq(l
, "active-exit-timestamp")) {
2729 dual_timestamp_deserialize(v
, &u
->active_exit_timestamp
);
2731 } else if (streq(l
, "inactive-enter-timestamp")) {
2732 dual_timestamp_deserialize(v
, &u
->inactive_enter_timestamp
);
2734 } else if (streq(l
, "condition-timestamp")) {
2735 dual_timestamp_deserialize(v
, &u
->condition_timestamp
);
2737 } else if (streq(l
, "assert-timestamp")) {
2738 dual_timestamp_deserialize(v
, &u
->assert_timestamp
);
2740 } else if (streq(l
, "condition-result")) {
2742 r
= parse_boolean(v
);
2744 log_unit_debug(u
, "Failed to parse condition result value %s, ignoring.", v
);
2746 u
->condition_result
= r
;
2750 } else if (streq(l
, "assert-result")) {
2752 r
= parse_boolean(v
);
2754 log_unit_debug(u
, "Failed to parse assert result value %s, ignoring.", v
);
2756 u
->assert_result
= r
;
2760 } else if (streq(l
, "transient")) {
2762 r
= parse_boolean(v
);
2764 log_unit_debug(u
, "Failed to parse transient bool %s, ignoring.", v
);
2770 } else if (streq(l
, "cpuacct-usage-base")) {
2772 r
= safe_atou64(v
, &u
->cpuacct_usage_base
);
2774 log_unit_debug(u
, "Failed to parse CPU usage %s, ignoring.", v
);
2778 } else if (streq(l
, "cgroup")) {
2780 r
= unit_set_cgroup_path(u
, v
);
2782 log_unit_debug_errno(u
, r
, "Failed to set cgroup path %s, ignoring: %m", v
);
2784 (void) unit_watch_cgroup(u
);
2787 } else if (streq(l
, "cgroup-realized")) {
2790 b
= parse_boolean(v
);
2792 log_unit_debug(u
, "Failed to parse cgroup-realized bool %s, ignoring.", v
);
2794 u
->cgroup_realized
= b
;
2797 } else if (streq(l
, "netclass-id")) {
2798 r
= safe_atou32(v
, &u
->cgroup_netclass_id
);
2800 log_unit_debug(u
, "Failed to parse netclass ID %s, ignoring.", v
);
2802 r
= unit_add_to_netclass_cgroup(u
);
2804 log_unit_debug_errno(u
, r
, "Failed to add unit to netclass cgroup, ignoring: %m");
2810 if (unit_can_serialize(u
)) {
2812 r
= exec_runtime_deserialize_item(u
, rt
, l
, v
, fds
);
2814 log_unit_warning(u
, "Failed to deserialize runtime parameter '%s', ignoring.", l
);
2818 /* Returns positive if key was handled by the call */
2823 r
= UNIT_VTABLE(u
)->deserialize_item(u
, l
, v
, fds
);
2825 log_unit_warning(u
, "Failed to deserialize unit parameter '%s', ignoring.", l
);
2830 int unit_add_node_link(Unit
*u
, const char *what
, bool wants
) {
2832 _cleanup_free_
char *e
= NULL
;
2837 /* Adds in links to the device node that this unit is based on */
2841 if (!is_device_path(what
))
2844 /* When device units aren't supported (such as in a
2845 * container), don't create dependencies on them. */
2846 if (!unit_type_supported(UNIT_DEVICE
))
2849 r
= unit_name_from_path(what
, ".device", &e
);
2853 r
= manager_load_unit(u
->manager
, e
, NULL
, NULL
, &device
);
2857 r
= unit_add_two_dependencies(u
, UNIT_AFTER
, u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_BINDS_TO
: UNIT_WANTS
, device
, true);
2862 r
= unit_add_dependency(device
, UNIT_WANTS
, u
, false);
2870 int unit_coldplug(Unit
*u
) {
2875 /* Make sure we don't enter a loop, when coldplugging
2880 u
->coldplugged
= true;
2882 if (UNIT_VTABLE(u
)->coldplug
) {
2883 r
= UNIT_VTABLE(u
)->coldplug(u
);
2889 r
= job_coldplug(u
->job
);
2897 void unit_status_printf(Unit
*u
, const char *status
, const char *unit_status_msg_format
) {
2898 DISABLE_WARNING_FORMAT_NONLITERAL
;
2899 manager_status_printf(u
->manager
, STATUS_TYPE_NORMAL
,
2900 status
, unit_status_msg_format
, unit_description(u
));
2904 bool unit_need_daemon_reload(Unit
*u
) {
2905 _cleanup_strv_free_
char **t
= NULL
;
2908 unsigned loaded_cnt
, current_cnt
;
2912 if (u
->fragment_path
) {
2914 if (stat(u
->fragment_path
, &st
) < 0)
2915 /* What, cannot access this anymore? */
2918 if (u
->fragment_mtime
> 0 &&
2919 timespec_load(&st
.st_mtim
) != u
->fragment_mtime
)
2923 if (u
->source_path
) {
2925 if (stat(u
->source_path
, &st
) < 0)
2928 if (u
->source_mtime
> 0 &&
2929 timespec_load(&st
.st_mtim
) != u
->source_mtime
)
2933 (void) unit_find_dropin_paths(u
, &t
);
2934 loaded_cnt
= strv_length(t
);
2935 current_cnt
= strv_length(u
->dropin_paths
);
2937 if (loaded_cnt
== current_cnt
) {
2938 if (loaded_cnt
== 0)
2941 if (strv_overlap(u
->dropin_paths
, t
)) {
2942 STRV_FOREACH(path
, u
->dropin_paths
) {
2944 if (stat(*path
, &st
) < 0)
2947 if (u
->dropin_mtime
> 0 &&
2948 timespec_load(&st
.st_mtim
) > u
->dropin_mtime
)
2959 void unit_reset_failed(Unit
*u
) {
2962 if (UNIT_VTABLE(u
)->reset_failed
)
2963 UNIT_VTABLE(u
)->reset_failed(u
);
2966 Unit
*unit_following(Unit
*u
) {
2969 if (UNIT_VTABLE(u
)->following
)
2970 return UNIT_VTABLE(u
)->following(u
);
2975 bool unit_stop_pending(Unit
*u
) {
2978 /* This call does check the current state of the unit. It's
2979 * hence useful to be called from state change calls of the
2980 * unit itself, where the state isn't updated yet. This is
2981 * different from unit_inactive_or_pending() which checks both
2982 * the current state and for a queued job. */
2984 return u
->job
&& u
->job
->type
== JOB_STOP
;
2987 bool unit_inactive_or_pending(Unit
*u
) {
2990 /* Returns true if the unit is inactive or going down */
2992 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)))
2995 if (unit_stop_pending(u
))
3001 bool unit_active_or_pending(Unit
*u
) {
3004 /* Returns true if the unit is active or going up */
3006 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
3010 (u
->job
->type
== JOB_START
||
3011 u
->job
->type
== JOB_RELOAD_OR_START
||
3012 u
->job
->type
== JOB_RESTART
))
3018 int unit_kill(Unit
*u
, KillWho w
, int signo
, sd_bus_error
*error
) {
3020 assert(w
>= 0 && w
< _KILL_WHO_MAX
);
3022 assert(signo
< _NSIG
);
3024 if (!UNIT_VTABLE(u
)->kill
)
3027 return UNIT_VTABLE(u
)->kill(u
, w
, signo
, error
);
3030 static Set
*unit_pid_set(pid_t main_pid
, pid_t control_pid
) {
3034 pid_set
= set_new(NULL
);
3038 /* Exclude the main/control pids from being killed via the cgroup */
3040 r
= set_put(pid_set
, PID_TO_PTR(main_pid
));
3045 if (control_pid
> 0) {
3046 r
= set_put(pid_set
, PID_TO_PTR(control_pid
));
3058 int unit_kill_common(
3064 sd_bus_error
*error
) {
3067 bool killed
= false;
3069 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
)) {
3071 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no main processes", unit_type_to_string(u
->type
));
3072 else if (main_pid
== 0)
3073 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No main process to kill");
3076 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
)) {
3077 if (control_pid
< 0)
3078 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no control processes", unit_type_to_string(u
->type
));
3079 else if (control_pid
== 0)
3080 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
3083 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3084 if (control_pid
> 0) {
3085 if (kill(control_pid
, signo
) < 0)
3091 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3093 if (kill(main_pid
, signo
) < 0)
3099 if (IN_SET(who
, KILL_ALL
, KILL_ALL_FAIL
) && u
->cgroup_path
) {
3100 _cleanup_set_free_ Set
*pid_set
= NULL
;
3103 /* Exclude the main/control pids from being killed via the cgroup */
3104 pid_set
= unit_pid_set(main_pid
, control_pid
);
3108 q
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, signo
, false, false, false, pid_set
);
3109 if (q
< 0 && q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
3115 if (r
== 0 && !killed
&& IN_SET(who
, KILL_ALL_FAIL
, KILL_CONTROL_FAIL
, KILL_ALL_FAIL
))
3121 int unit_following_set(Unit
*u
, Set
**s
) {
3125 if (UNIT_VTABLE(u
)->following_set
)
3126 return UNIT_VTABLE(u
)->following_set(u
, s
);
3132 UnitFileState
unit_get_unit_file_state(Unit
*u
) {
3135 if (u
->unit_file_state
< 0 && u
->fragment_path
)
3136 u
->unit_file_state
= unit_file_get_state(
3137 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3138 NULL
, basename(u
->fragment_path
));
3140 return u
->unit_file_state
;
3143 int unit_get_unit_file_preset(Unit
*u
) {
3146 if (u
->unit_file_preset
< 0 && u
->fragment_path
)
3147 u
->unit_file_preset
= unit_file_query_preset(
3148 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3149 NULL
, basename(u
->fragment_path
));
3151 return u
->unit_file_preset
;
3154 Unit
* unit_ref_set(UnitRef
*ref
, Unit
*u
) {
3159 unit_ref_unset(ref
);
3162 LIST_PREPEND(refs
, u
->refs
, ref
);
3166 void unit_ref_unset(UnitRef
*ref
) {
3172 LIST_REMOVE(refs
, ref
->unit
->refs
, ref
);
3176 int unit_patch_contexts(Unit
*u
) {
3184 /* Patch in the manager defaults into the exec and cgroup
3185 * contexts, _after_ the rest of the settings have been
3188 ec
= unit_get_exec_context(u
);
3190 /* This only copies in the ones that need memory */
3191 for (i
= 0; i
< _RLIMIT_MAX
; i
++)
3192 if (u
->manager
->rlimit
[i
] && !ec
->rlimit
[i
]) {
3193 ec
->rlimit
[i
] = newdup(struct rlimit
, u
->manager
->rlimit
[i
], 1);
3198 if (u
->manager
->running_as
== MANAGER_USER
&&
3199 !ec
->working_directory
) {
3201 r
= get_home_dir(&ec
->working_directory
);
3205 /* Allow user services to run, even if the
3206 * home directory is missing */
3207 ec
->working_directory_missing_ok
= true;
3210 if (u
->manager
->running_as
== MANAGER_USER
&&
3211 (ec
->syscall_whitelist
||
3212 !set_isempty(ec
->syscall_filter
) ||
3213 !set_isempty(ec
->syscall_archs
) ||
3214 ec
->address_families_whitelist
||
3215 !set_isempty(ec
->address_families
)))
3216 ec
->no_new_privileges
= true;
3218 if (ec
->private_devices
)
3219 ec
->capability_bounding_set_drop
|= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD
;
3222 cc
= unit_get_cgroup_context(u
);
3226 ec
->private_devices
&&
3227 cc
->device_policy
== CGROUP_AUTO
)
3228 cc
->device_policy
= CGROUP_CLOSED
;
3234 ExecContext
*unit_get_exec_context(Unit
*u
) {
3241 offset
= UNIT_VTABLE(u
)->exec_context_offset
;
3245 return (ExecContext
*) ((uint8_t*) u
+ offset
);
3248 KillContext
*unit_get_kill_context(Unit
*u
) {
3255 offset
= UNIT_VTABLE(u
)->kill_context_offset
;
3259 return (KillContext
*) ((uint8_t*) u
+ offset
);
3262 CGroupContext
*unit_get_cgroup_context(Unit
*u
) {
3268 offset
= UNIT_VTABLE(u
)->cgroup_context_offset
;
3272 return (CGroupContext
*) ((uint8_t*) u
+ offset
);
3275 ExecRuntime
*unit_get_exec_runtime(Unit
*u
) {
3281 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3285 return *(ExecRuntime
**) ((uint8_t*) u
+ offset
);
3288 static int unit_drop_in_dir(Unit
*u
, UnitSetPropertiesMode mode
, bool transient
, char **dir
) {
3291 if (u
->manager
->running_as
== MANAGER_USER
) {
3294 if (mode
== UNIT_PERSISTENT
&& !transient
)
3295 r
= user_config_home(dir
);
3297 r
= user_runtime_dir(dir
);
3304 if (mode
== UNIT_PERSISTENT
&& !transient
)
3305 *dir
= strdup("/etc/systemd/system");
3307 *dir
= strdup("/run/systemd/system");
3314 static int unit_drop_in_file(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, char **p
, char **q
) {
3315 _cleanup_free_
char *dir
= NULL
;
3320 r
= unit_drop_in_dir(u
, mode
, u
->transient
, &dir
);
3324 return drop_in_file(dir
, u
->id
, 50, name
, p
, q
);
3327 int unit_write_drop_in(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3329 _cleanup_free_
char *dir
= NULL
, *p
= NULL
, *q
= NULL
;
3334 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3337 r
= unit_drop_in_dir(u
, mode
, u
->transient
, &dir
);
3341 r
= write_drop_in(dir
, u
->id
, 50, name
, data
);
3345 r
= drop_in_file(dir
, u
->id
, 50, name
, &p
, &q
);
3349 r
= strv_extend(&u
->dropin_paths
, q
);
3353 strv_sort(u
->dropin_paths
);
3354 strv_uniq(u
->dropin_paths
);
3356 u
->dropin_mtime
= now(CLOCK_REALTIME
);
3361 int unit_write_drop_in_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3362 _cleanup_free_
char *p
= NULL
;
3370 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3373 va_start(ap
, format
);
3374 r
= vasprintf(&p
, format
, ap
);
3380 return unit_write_drop_in(u
, mode
, name
, p
);
3383 int unit_write_drop_in_private(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3384 _cleanup_free_
char *ndata
= NULL
;
3390 if (!UNIT_VTABLE(u
)->private_section
)
3393 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3396 ndata
= strjoin("[", UNIT_VTABLE(u
)->private_section
, "]\n", data
, NULL
);
3400 return unit_write_drop_in(u
, mode
, name
, ndata
);
3403 int unit_write_drop_in_private_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3404 _cleanup_free_
char *p
= NULL
;
3412 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3415 va_start(ap
, format
);
3416 r
= vasprintf(&p
, format
, ap
);
3422 return unit_write_drop_in_private(u
, mode
, name
, p
);
3425 int unit_remove_drop_in(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
) {
3426 _cleanup_free_
char *p
= NULL
, *q
= NULL
;
3431 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3434 r
= unit_drop_in_file(u
, mode
, name
, &p
, &q
);
3439 r
= errno
== ENOENT
? 0 : -errno
;
3447 int unit_make_transient(Unit
*u
) {
3450 if (!UNIT_VTABLE(u
)->can_transient
)
3453 u
->load_state
= UNIT_STUB
;
3455 u
->transient
= true;
3456 u
->fragment_path
= mfree(u
->fragment_path
);
3461 int unit_kill_context(
3467 bool main_pid_alien
) {
3469 bool wait_for_exit
= false;
3475 if (c
->kill_mode
== KILL_NONE
)
3485 case KILL_TERMINATE
:
3486 sig
= c
->kill_signal
;
3489 assert_not_reached("KillOperation unknown");
3493 r
= kill_and_sigcont(main_pid
, sig
);
3495 if (r
< 0 && r
!= -ESRCH
) {
3496 _cleanup_free_
char *comm
= NULL
;
3497 get_process_comm(main_pid
, &comm
);
3499 log_unit_warning_errno(u
, r
, "Failed to kill main process " PID_FMT
" (%s), ignoring: %m", main_pid
, strna(comm
));
3501 if (!main_pid_alien
)
3502 wait_for_exit
= true;
3504 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3505 (void) kill(main_pid
, SIGHUP
);
3509 if (control_pid
> 0) {
3510 r
= kill_and_sigcont(control_pid
, sig
);
3512 if (r
< 0 && r
!= -ESRCH
) {
3513 _cleanup_free_
char *comm
= NULL
;
3514 get_process_comm(control_pid
, &comm
);
3516 log_unit_warning_errno(u
, r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m", control_pid
, strna(comm
));
3518 wait_for_exit
= true;
3520 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3521 (void) kill(control_pid
, SIGHUP
);
3525 if (u
->cgroup_path
&&
3526 (c
->kill_mode
== KILL_CONTROL_GROUP
|| (c
->kill_mode
== KILL_MIXED
&& k
== KILL_KILL
))) {
3527 _cleanup_set_free_ Set
*pid_set
= NULL
;
3529 /* Exclude the main/control pids from being killed via the cgroup */
3530 pid_set
= unit_pid_set(main_pid
, control_pid
);
3534 r
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, sig
, true, k
!= KILL_TERMINATE
, false, pid_set
);
3536 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
3537 log_unit_warning_errno(u
, r
, "Failed to kill control group %s, ignoring: %m", u
->cgroup_path
);
3541 /* FIXME: For now, on the legacy hierarchy, we
3542 * will not wait for the cgroup members to die
3543 * if we are running in a container or if this
3544 * is a delegation unit, simply because cgroup
3545 * notification is unreliable in these
3546 * cases. It doesn't work at all in
3547 * containers, and outside of containers it
3548 * can be confused easily by left-over
3549 * directories in the cgroup -- which however
3550 * should not exist in non-delegated units. On
3551 * the unified hierarchy that's different,
3552 * there we get proper events. Hence rely on
3555 if (cg_unified() > 0 ||
3556 (detect_container() == 0 && !unit_cgroup_delegate(u
)))
3557 wait_for_exit
= true;
3559 if (c
->send_sighup
&& k
!= KILL_KILL
) {
3562 pid_set
= unit_pid_set(main_pid
, control_pid
);
3566 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, SIGHUP
, false, true, false, pid_set
);
3571 return wait_for_exit
;
3574 int unit_require_mounts_for(Unit
*u
, const char *path
) {
3575 char prefix
[strlen(path
) + 1], *p
;
3581 /* Registers a unit for requiring a certain path and all its
3582 * prefixes. We keep a simple array of these paths in the
3583 * unit, since its usually short. However, we build a prefix
3584 * table for all possible prefixes so that new appearing mount
3585 * units can easily determine which units to make themselves a
3588 if (!path_is_absolute(path
))
3595 path_kill_slashes(p
);
3597 if (!path_is_safe(p
)) {
3602 if (strv_contains(u
->requires_mounts_for
, p
)) {
3607 r
= strv_consume(&u
->requires_mounts_for
, p
);
3611 PATH_FOREACH_PREFIX_MORE(prefix
, p
) {
3614 x
= hashmap_get(u
->manager
->units_requiring_mounts_for
, prefix
);
3618 r
= hashmap_ensure_allocated(&u
->manager
->units_requiring_mounts_for
, &string_hash_ops
);
3632 r
= hashmap_put(u
->manager
->units_requiring_mounts_for
, q
, x
);
3648 int unit_setup_exec_runtime(Unit
*u
) {
3654 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3657 /* Check if there already is an ExecRuntime for this unit? */
3658 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
3662 /* Try to get it from somebody else */
3663 SET_FOREACH(other
, u
->dependencies
[UNIT_JOINS_NAMESPACE_OF
], i
) {
3665 *rt
= unit_get_exec_runtime(other
);
3667 exec_runtime_ref(*rt
);
3672 return exec_runtime_make(rt
, unit_get_exec_context(u
), u
->id
);
3675 bool unit_type_supported(UnitType t
) {
3676 if (_unlikely_(t
< 0))
3678 if (_unlikely_(t
>= _UNIT_TYPE_MAX
))
3681 if (!unit_vtable
[t
]->supported
)
3684 return unit_vtable
[t
]->supported();
3687 void unit_warn_if_dir_nonempty(Unit
*u
, const char* where
) {
3693 r
= dir_is_empty(where
);
3697 log_unit_warning_errno(u
, r
, "Failed to check directory %s: %m", where
);
3701 log_struct(LOG_NOTICE
,
3702 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3704 LOG_UNIT_MESSAGE(u
, "Directory %s to mount over is not empty, mounting anyway.", where
),
3709 int unit_fail_if_symlink(Unit
*u
, const char* where
) {
3715 r
= is_symlink(where
);
3717 log_unit_debug_errno(u
, r
, "Failed to check symlink %s, ignoring: %m", where
);
3724 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3726 LOG_UNIT_MESSAGE(u
, "Mount on symlink %s not allowed.", where
),
3733 static const char* const unit_active_state_table
[_UNIT_ACTIVE_STATE_MAX
] = {
3734 [UNIT_ACTIVE
] = "active",
3735 [UNIT_RELOADING
] = "reloading",
3736 [UNIT_INACTIVE
] = "inactive",
3737 [UNIT_FAILED
] = "failed",
3738 [UNIT_ACTIVATING
] = "activating",
3739 [UNIT_DEACTIVATING
] = "deactivating"
3742 DEFINE_STRING_TABLE_LOOKUP(unit_active_state
, UnitActiveState
);