2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include "sd-messages.h"
29 #include "alloc-util.h"
30 #include "bus-common-errors.h"
32 #include "cgroup-util.h"
33 #include "dbus-unit.h"
38 #include "fileio-label.h"
39 #include "formats-util.h"
40 #include "load-dropin.h"
41 #include "load-fragment.h"
46 #include "parse-util.h"
47 #include "path-util.h"
48 #include "process-util.h"
51 #include "stat-util.h"
52 #include "stdio-util.h"
53 #include "string-util.h"
55 #include "unit-name.h"
57 #include "user-util.h"
60 const UnitVTable
* const unit_vtable
[_UNIT_TYPE_MAX
] = {
61 [UNIT_SERVICE
] = &service_vtable
,
62 [UNIT_SOCKET
] = &socket_vtable
,
63 [UNIT_BUSNAME
] = &busname_vtable
,
64 [UNIT_TARGET
] = &target_vtable
,
65 [UNIT_DEVICE
] = &device_vtable
,
66 [UNIT_MOUNT
] = &mount_vtable
,
67 [UNIT_AUTOMOUNT
] = &automount_vtable
,
68 [UNIT_SWAP
] = &swap_vtable
,
69 [UNIT_TIMER
] = &timer_vtable
,
70 [UNIT_PATH
] = &path_vtable
,
71 [UNIT_SLICE
] = &slice_vtable
,
72 [UNIT_SCOPE
] = &scope_vtable
75 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
);
77 Unit
*unit_new(Manager
*m
, size_t size
) {
81 assert(size
>= sizeof(Unit
));
87 u
->names
= set_new(&string_hash_ops
);
94 u
->type
= _UNIT_TYPE_INVALID
;
95 u
->default_dependencies
= true;
96 u
->unit_file_state
= _UNIT_FILE_STATE_INVALID
;
97 u
->unit_file_preset
= -1;
98 u
->on_failure_job_mode
= JOB_REPLACE
;
99 u
->cgroup_inotify_wd
= -1;
100 u
->job_timeout
= USEC_INFINITY
;
102 RATELIMIT_INIT(u
->start_limit
, m
->default_start_limit_interval
, m
->default_start_limit_burst
);
103 RATELIMIT_INIT(u
->auto_stop_ratelimit
, 10 * USEC_PER_SEC
, 16);
108 bool unit_has_name(Unit
*u
, const char *name
) {
112 return !!set_get(u
->names
, (char*) name
);
115 static void unit_init(Unit
*u
) {
122 assert(u
->type
>= 0);
124 cc
= unit_get_cgroup_context(u
);
126 cgroup_context_init(cc
);
128 /* Copy in the manager defaults into the cgroup
129 * context, _before_ the rest of the settings have
130 * been initialized */
132 cc
->cpu_accounting
= u
->manager
->default_cpu_accounting
;
133 cc
->blockio_accounting
= u
->manager
->default_blockio_accounting
;
134 cc
->memory_accounting
= u
->manager
->default_memory_accounting
;
135 cc
->tasks_accounting
= u
->manager
->default_tasks_accounting
;
137 if (u
->type
!= UNIT_SLICE
)
138 cc
->tasks_max
= u
->manager
->default_tasks_max
;
141 ec
= unit_get_exec_context(u
);
143 exec_context_init(ec
);
145 kc
= unit_get_kill_context(u
);
147 kill_context_init(kc
);
149 if (UNIT_VTABLE(u
)->init
)
150 UNIT_VTABLE(u
)->init(u
);
153 int unit_add_name(Unit
*u
, const char *text
) {
154 _cleanup_free_
char *s
= NULL
, *i
= NULL
;
161 if (unit_name_is_valid(text
, UNIT_NAME_TEMPLATE
)) {
166 r
= unit_name_replace_instance(text
, u
->instance
, &s
);
175 if (set_contains(u
->names
, s
))
177 if (hashmap_contains(u
->manager
->units
, s
))
180 if (!unit_name_is_valid(s
, UNIT_NAME_PLAIN
|UNIT_NAME_INSTANCE
))
183 t
= unit_name_to_type(s
);
187 if (u
->type
!= _UNIT_TYPE_INVALID
&& t
!= u
->type
)
190 r
= unit_name_to_instance(s
, &i
);
194 if (i
&& unit_vtable
[t
]->no_instances
)
197 /* Ensure that this unit is either instanced or not instanced,
198 * but not both. Note that we do allow names with different
199 * instance names however! */
200 if (u
->type
!= _UNIT_TYPE_INVALID
&& !u
->instance
!= !i
)
203 if (unit_vtable
[t
]->no_alias
&& !set_isempty(u
->names
))
206 if (hashmap_size(u
->manager
->units
) >= MANAGER_MAX_NAMES
)
209 r
= set_put(u
->names
, s
);
214 r
= hashmap_put(u
->manager
->units
, s
, u
);
216 (void) set_remove(u
->names
, s
);
220 if (u
->type
== _UNIT_TYPE_INVALID
) {
225 LIST_PREPEND(units_by_type
, u
->manager
->units_by_type
[t
], u
);
234 unit_add_to_dbus_queue(u
);
238 int unit_choose_id(Unit
*u
, const char *name
) {
239 _cleanup_free_
char *t
= NULL
;
246 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
251 r
= unit_name_replace_instance(name
, u
->instance
, &t
);
258 /* Selects one of the names of this unit as the id */
259 s
= set_get(u
->names
, (char*) name
);
263 /* Determine the new instance from the new id */
264 r
= unit_name_to_instance(s
, &i
);
273 unit_add_to_dbus_queue(u
);
278 int unit_set_description(Unit
*u
, const char *description
) {
283 if (isempty(description
))
286 s
= strdup(description
);
291 free(u
->description
);
294 unit_add_to_dbus_queue(u
);
298 bool unit_check_gc(Unit
*u
) {
299 UnitActiveState state
;
308 state
= unit_active_state(u
);
310 /* If the unit is inactive and failed and no job is queued for
311 * it, then release its runtime resources */
312 if (UNIT_IS_INACTIVE_OR_FAILED(state
) &&
313 UNIT_VTABLE(u
)->release_resources
)
314 UNIT_VTABLE(u
)->release_resources(u
);
316 /* But we keep the unit object around for longer when it is
317 * referenced or configured to not be gc'ed */
318 if (state
!= UNIT_INACTIVE
)
327 if (UNIT_VTABLE(u
)->check_gc
)
328 if (UNIT_VTABLE(u
)->check_gc(u
))
334 void unit_add_to_load_queue(Unit
*u
) {
336 assert(u
->type
!= _UNIT_TYPE_INVALID
);
338 if (u
->load_state
!= UNIT_STUB
|| u
->in_load_queue
)
341 LIST_PREPEND(load_queue
, u
->manager
->load_queue
, u
);
342 u
->in_load_queue
= true;
345 void unit_add_to_cleanup_queue(Unit
*u
) {
348 if (u
->in_cleanup_queue
)
351 LIST_PREPEND(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
352 u
->in_cleanup_queue
= true;
355 void unit_add_to_gc_queue(Unit
*u
) {
358 if (u
->in_gc_queue
|| u
->in_cleanup_queue
)
361 if (unit_check_gc(u
))
364 LIST_PREPEND(gc_queue
, u
->manager
->gc_queue
, u
);
365 u
->in_gc_queue
= true;
367 u
->manager
->n_in_gc_queue
++;
370 void unit_add_to_dbus_queue(Unit
*u
) {
372 assert(u
->type
!= _UNIT_TYPE_INVALID
);
374 if (u
->load_state
== UNIT_STUB
|| u
->in_dbus_queue
)
377 /* Shortcut things if nobody cares */
378 if (sd_bus_track_count(u
->manager
->subscribed
) <= 0 &&
379 set_isempty(u
->manager
->private_buses
)) {
380 u
->sent_dbus_new_signal
= true;
384 LIST_PREPEND(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
385 u
->in_dbus_queue
= true;
388 static void bidi_set_free(Unit
*u
, Set
*s
) {
394 /* Frees the set and makes sure we are dropped from the
395 * inverse pointers */
397 SET_FOREACH(other
, s
, i
) {
400 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
401 set_remove(other
->dependencies
[d
], u
);
403 unit_add_to_gc_queue(other
);
409 static void unit_remove_transient(Unit
*u
) {
417 if (u
->fragment_path
)
418 (void) unlink(u
->fragment_path
);
420 STRV_FOREACH(i
, u
->dropin_paths
) {
421 _cleanup_free_
char *p
= NULL
;
425 p
= dirname_malloc(*i
);
431 static void unit_free_requires_mounts_for(Unit
*u
) {
434 STRV_FOREACH(j
, u
->requires_mounts_for
) {
435 char s
[strlen(*j
) + 1];
437 PATH_FOREACH_PREFIX_MORE(s
, *j
) {
441 x
= hashmap_get2(u
->manager
->units_requiring_mounts_for
, s
, (void**) &y
);
447 if (set_isempty(x
)) {
448 hashmap_remove(u
->manager
->units_requiring_mounts_for
, y
);
455 u
->requires_mounts_for
= strv_free(u
->requires_mounts_for
);
458 static void unit_done(Unit
*u
) {
468 if (UNIT_VTABLE(u
)->done
)
469 UNIT_VTABLE(u
)->done(u
);
471 ec
= unit_get_exec_context(u
);
473 exec_context_done(ec
);
475 cc
= unit_get_cgroup_context(u
);
477 cgroup_context_done(cc
);
479 r
= unit_remove_from_netclass_cgroup(u
);
481 log_warning_errno(r
, "Unable to remove unit from netclass group: %m");
484 void unit_free(Unit
*u
) {
491 if (u
->manager
->n_reloading
<= 0)
492 unit_remove_transient(u
);
494 bus_unit_send_removed_signal(u
);
498 sd_bus_slot_unref(u
->match_bus_slot
);
500 unit_free_requires_mounts_for(u
);
502 SET_FOREACH(t
, u
->names
, i
)
503 hashmap_remove_value(u
->manager
->units
, t
, u
);
517 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
518 bidi_set_free(u
, u
->dependencies
[d
]);
520 if (u
->type
!= _UNIT_TYPE_INVALID
)
521 LIST_REMOVE(units_by_type
, u
->manager
->units_by_type
[u
->type
], u
);
523 if (u
->in_load_queue
)
524 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
526 if (u
->in_dbus_queue
)
527 LIST_REMOVE(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
529 if (u
->in_cleanup_queue
)
530 LIST_REMOVE(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
532 if (u
->in_gc_queue
) {
533 LIST_REMOVE(gc_queue
, u
->manager
->gc_queue
, u
);
534 u
->manager
->n_in_gc_queue
--;
537 if (u
->in_cgroup_queue
)
538 LIST_REMOVE(cgroup_queue
, u
->manager
->cgroup_queue
, u
);
540 unit_release_cgroup(u
);
542 (void) manager_update_failed_units(u
->manager
, u
, false);
543 set_remove(u
->manager
->startup_units
, u
);
545 free(u
->description
);
546 strv_free(u
->documentation
);
547 free(u
->fragment_path
);
548 free(u
->source_path
);
549 strv_free(u
->dropin_paths
);
552 free(u
->job_timeout_reboot_arg
);
554 set_free_free(u
->names
);
556 unit_unwatch_all_pids(u
);
558 condition_free_list(u
->conditions
);
559 condition_free_list(u
->asserts
);
563 unit_ref_unset(&u
->slice
);
566 unit_ref_unset(u
->refs
);
571 UnitActiveState
unit_active_state(Unit
*u
) {
574 if (u
->load_state
== UNIT_MERGED
)
575 return unit_active_state(unit_follow_merge(u
));
577 /* After a reload it might happen that a unit is not correctly
578 * loaded but still has a process around. That's why we won't
579 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
581 return UNIT_VTABLE(u
)->active_state(u
);
584 const char* unit_sub_state_to_string(Unit
*u
) {
587 return UNIT_VTABLE(u
)->sub_state_to_string(u
);
590 static int complete_move(Set
**s
, Set
**other
) {
600 r
= set_move(*s
, *other
);
611 static int merge_names(Unit
*u
, Unit
*other
) {
619 r
= complete_move(&u
->names
, &other
->names
);
623 set_free_free(other
->names
);
627 SET_FOREACH(t
, u
->names
, i
)
628 assert_se(hashmap_replace(u
->manager
->units
, t
, u
) == 0);
633 static int reserve_dependencies(Unit
*u
, Unit
*other
, UnitDependency d
) {
638 assert(d
< _UNIT_DEPENDENCY_MAX
);
641 * If u does not have this dependency set allocated, there is no need
642 * to reserve anything. In that case other's set will be transferred
643 * as a whole to u by complete_move().
645 if (!u
->dependencies
[d
])
648 /* merge_dependencies() will skip a u-on-u dependency */
649 n_reserve
= set_size(other
->dependencies
[d
]) - !!set_get(other
->dependencies
[d
], u
);
651 return set_reserve(u
->dependencies
[d
], n_reserve
);
654 static void merge_dependencies(Unit
*u
, Unit
*other
, const char *other_id
, UnitDependency d
) {
661 assert(d
< _UNIT_DEPENDENCY_MAX
);
663 /* Fix backwards pointers */
664 SET_FOREACH(back
, other
->dependencies
[d
], i
) {
667 for (k
= 0; k
< _UNIT_DEPENDENCY_MAX
; k
++) {
668 /* Do not add dependencies between u and itself */
670 if (set_remove(back
->dependencies
[k
], other
))
671 maybe_warn_about_dependency(u
, other_id
, k
);
673 r
= set_remove_and_put(back
->dependencies
[k
], other
, u
);
675 set_remove(back
->dependencies
[k
], other
);
677 assert(r
>= 0 || r
== -ENOENT
);
682 /* Also do not move dependencies on u to itself */
683 back
= set_remove(other
->dependencies
[d
], u
);
685 maybe_warn_about_dependency(u
, other_id
, d
);
687 /* The move cannot fail. The caller must have performed a reservation. */
688 assert_se(complete_move(&u
->dependencies
[d
], &other
->dependencies
[d
]) == 0);
690 other
->dependencies
[d
] = set_free(other
->dependencies
[d
]);
693 int unit_merge(Unit
*u
, Unit
*other
) {
695 const char *other_id
= NULL
;
700 assert(u
->manager
== other
->manager
);
701 assert(u
->type
!= _UNIT_TYPE_INVALID
);
703 other
= unit_follow_merge(other
);
708 if (u
->type
!= other
->type
)
711 if (!u
->instance
!= !other
->instance
)
714 if (other
->load_state
!= UNIT_STUB
&&
715 other
->load_state
!= UNIT_NOT_FOUND
)
724 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
728 other_id
= strdupa(other
->id
);
730 /* Make reservations to ensure merge_dependencies() won't fail */
731 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
732 r
= reserve_dependencies(u
, other
, d
);
734 * We don't rollback reservations if we fail. We don't have
735 * a way to undo reservations. A reservation is not a leak.
742 r
= merge_names(u
, other
);
746 /* Redirect all references */
748 unit_ref_set(other
->refs
, u
);
750 /* Merge dependencies */
751 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
752 merge_dependencies(u
, other
, other_id
, d
);
754 other
->load_state
= UNIT_MERGED
;
755 other
->merged_into
= u
;
757 /* If there is still some data attached to the other node, we
758 * don't need it anymore, and can free it. */
759 if (other
->load_state
!= UNIT_STUB
)
760 if (UNIT_VTABLE(other
)->done
)
761 UNIT_VTABLE(other
)->done(other
);
763 unit_add_to_dbus_queue(u
);
764 unit_add_to_cleanup_queue(other
);
769 int unit_merge_by_name(Unit
*u
, const char *name
) {
772 _cleanup_free_
char *s
= NULL
;
777 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
781 r
= unit_name_replace_instance(name
, u
->instance
, &s
);
788 other
= manager_get_unit(u
->manager
, name
);
790 return unit_merge(u
, other
);
792 return unit_add_name(u
, name
);
795 Unit
* unit_follow_merge(Unit
*u
) {
798 while (u
->load_state
== UNIT_MERGED
)
799 assert_se(u
= u
->merged_into
);
804 int unit_add_exec_dependencies(Unit
*u
, ExecContext
*c
) {
810 if (c
->working_directory
) {
811 r
= unit_require_mounts_for(u
, c
->working_directory
);
816 if (c
->root_directory
) {
817 r
= unit_require_mounts_for(u
, c
->root_directory
);
822 if (u
->manager
->running_as
!= MANAGER_SYSTEM
)
825 if (c
->private_tmp
) {
826 r
= unit_require_mounts_for(u
, "/tmp");
830 r
= unit_require_mounts_for(u
, "/var/tmp");
835 if (c
->std_output
!= EXEC_OUTPUT_KMSG
&&
836 c
->std_output
!= EXEC_OUTPUT_SYSLOG
&&
837 c
->std_output
!= EXEC_OUTPUT_JOURNAL
&&
838 c
->std_output
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
839 c
->std_output
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
&&
840 c
->std_output
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
841 c
->std_error
!= EXEC_OUTPUT_KMSG
&&
842 c
->std_error
!= EXEC_OUTPUT_SYSLOG
&&
843 c
->std_error
!= EXEC_OUTPUT_JOURNAL
&&
844 c
->std_error
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
845 c
->std_error
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
846 c
->std_error
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
)
849 /* If syslog or kernel logging is requested, make sure our own
850 * logging daemon is run first. */
852 r
= unit_add_dependency_by_name(u
, UNIT_AFTER
, SPECIAL_JOURNALD_SOCKET
, NULL
, true);
859 const char *unit_description(Unit
*u
) {
863 return u
->description
;
868 void unit_dump(Unit
*u
, FILE *f
, const char *prefix
) {
874 timestamp0
[FORMAT_TIMESTAMP_MAX
],
875 timestamp1
[FORMAT_TIMESTAMP_MAX
],
876 timestamp2
[FORMAT_TIMESTAMP_MAX
],
877 timestamp3
[FORMAT_TIMESTAMP_MAX
],
878 timestamp4
[FORMAT_TIMESTAMP_MAX
],
879 timespan
[FORMAT_TIMESPAN_MAX
];
881 _cleanup_set_free_ Set
*following_set
= NULL
;
885 assert(u
->type
>= 0);
887 prefix
= strempty(prefix
);
888 prefix2
= strjoina(prefix
, "\t");
892 "%s\tDescription: %s\n"
894 "%s\tUnit Load State: %s\n"
895 "%s\tUnit Active State: %s\n"
896 "%s\nState Change Timestamp: %s\n"
897 "%s\tInactive Exit Timestamp: %s\n"
898 "%s\tActive Enter Timestamp: %s\n"
899 "%s\tActive Exit Timestamp: %s\n"
900 "%s\tInactive Enter Timestamp: %s\n"
901 "%s\tGC Check Good: %s\n"
902 "%s\tNeed Daemon Reload: %s\n"
903 "%s\tTransient: %s\n"
906 "%s\tCGroup realized: %s\n"
907 "%s\tCGroup mask: 0x%x\n"
908 "%s\tCGroup members mask: 0x%x\n",
910 prefix
, unit_description(u
),
911 prefix
, strna(u
->instance
),
912 prefix
, unit_load_state_to_string(u
->load_state
),
913 prefix
, unit_active_state_to_string(unit_active_state(u
)),
914 prefix
, strna(format_timestamp(timestamp0
, sizeof(timestamp0
), u
->state_change_timestamp
.realtime
)),
915 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->inactive_exit_timestamp
.realtime
)),
916 prefix
, strna(format_timestamp(timestamp2
, sizeof(timestamp2
), u
->active_enter_timestamp
.realtime
)),
917 prefix
, strna(format_timestamp(timestamp3
, sizeof(timestamp3
), u
->active_exit_timestamp
.realtime
)),
918 prefix
, strna(format_timestamp(timestamp4
, sizeof(timestamp4
), u
->inactive_enter_timestamp
.realtime
)),
919 prefix
, yes_no(unit_check_gc(u
)),
920 prefix
, yes_no(unit_need_daemon_reload(u
)),
921 prefix
, yes_no(u
->transient
),
922 prefix
, strna(unit_slice_name(u
)),
923 prefix
, strna(u
->cgroup_path
),
924 prefix
, yes_no(u
->cgroup_realized
),
925 prefix
, u
->cgroup_realized_mask
,
926 prefix
, u
->cgroup_members_mask
);
928 SET_FOREACH(t
, u
->names
, i
)
929 fprintf(f
, "%s\tName: %s\n", prefix
, t
);
931 STRV_FOREACH(j
, u
->documentation
)
932 fprintf(f
, "%s\tDocumentation: %s\n", prefix
, *j
);
934 following
= unit_following(u
);
936 fprintf(f
, "%s\tFollowing: %s\n", prefix
, following
->id
);
938 r
= unit_following_set(u
, &following_set
);
942 SET_FOREACH(other
, following_set
, i
)
943 fprintf(f
, "%s\tFollowing Set Member: %s\n", prefix
, other
->id
);
946 if (u
->fragment_path
)
947 fprintf(f
, "%s\tFragment Path: %s\n", prefix
, u
->fragment_path
);
950 fprintf(f
, "%s\tSource Path: %s\n", prefix
, u
->source_path
);
952 STRV_FOREACH(j
, u
->dropin_paths
)
953 fprintf(f
, "%s\tDropIn Path: %s\n", prefix
, *j
);
955 if (u
->job_timeout
!= USEC_INFINITY
)
956 fprintf(f
, "%s\tJob Timeout: %s\n", prefix
, format_timespan(timespan
, sizeof(timespan
), u
->job_timeout
, 0));
958 if (u
->job_timeout_action
!= FAILURE_ACTION_NONE
)
959 fprintf(f
, "%s\tJob Timeout Action: %s\n", prefix
, failure_action_to_string(u
->job_timeout_action
));
961 if (u
->job_timeout_reboot_arg
)
962 fprintf(f
, "%s\tJob Timeout Reboot Argument: %s\n", prefix
, u
->job_timeout_reboot_arg
);
964 condition_dump_list(u
->conditions
, f
, prefix
, condition_type_to_string
);
965 condition_dump_list(u
->asserts
, f
, prefix
, assert_type_to_string
);
967 if (dual_timestamp_is_set(&u
->condition_timestamp
))
969 "%s\tCondition Timestamp: %s\n"
970 "%s\tCondition Result: %s\n",
971 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->condition_timestamp
.realtime
)),
972 prefix
, yes_no(u
->condition_result
));
974 if (dual_timestamp_is_set(&u
->assert_timestamp
))
976 "%s\tAssert Timestamp: %s\n"
977 "%s\tAssert Result: %s\n",
978 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->assert_timestamp
.realtime
)),
979 prefix
, yes_no(u
->assert_result
));
981 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
984 SET_FOREACH(other
, u
->dependencies
[d
], i
)
985 fprintf(f
, "%s\t%s: %s\n", prefix
, unit_dependency_to_string(d
), other
->id
);
988 if (!strv_isempty(u
->requires_mounts_for
)) {
990 "%s\tRequiresMountsFor:", prefix
);
992 STRV_FOREACH(j
, u
->requires_mounts_for
)
993 fprintf(f
, " %s", *j
);
998 if (u
->load_state
== UNIT_LOADED
) {
1001 "%s\tStopWhenUnneeded: %s\n"
1002 "%s\tRefuseManualStart: %s\n"
1003 "%s\tRefuseManualStop: %s\n"
1004 "%s\tDefaultDependencies: %s\n"
1005 "%s\tOnFailureJobMode: %s\n"
1006 "%s\tIgnoreOnIsolate: %s\n",
1007 prefix
, yes_no(u
->stop_when_unneeded
),
1008 prefix
, yes_no(u
->refuse_manual_start
),
1009 prefix
, yes_no(u
->refuse_manual_stop
),
1010 prefix
, yes_no(u
->default_dependencies
),
1011 prefix
, job_mode_to_string(u
->on_failure_job_mode
),
1012 prefix
, yes_no(u
->ignore_on_isolate
));
1014 if (UNIT_VTABLE(u
)->dump
)
1015 UNIT_VTABLE(u
)->dump(u
, f
, prefix2
);
1017 } else if (u
->load_state
== UNIT_MERGED
)
1019 "%s\tMerged into: %s\n",
1020 prefix
, u
->merged_into
->id
);
1021 else if (u
->load_state
== UNIT_ERROR
)
1022 fprintf(f
, "%s\tLoad Error Code: %s\n", prefix
, strerror(-u
->load_error
));
1026 job_dump(u
->job
, f
, prefix2
);
1029 job_dump(u
->nop_job
, f
, prefix2
);
1033 /* Common implementation for multiple backends */
1034 int unit_load_fragment_and_dropin(Unit
*u
) {
1039 /* Load a .{service,socket,...} file */
1040 r
= unit_load_fragment(u
);
1044 if (u
->load_state
== UNIT_STUB
)
1047 /* Load drop-in directory data */
1048 r
= unit_load_dropin(unit_follow_merge(u
));
1055 /* Common implementation for multiple backends */
1056 int unit_load_fragment_and_dropin_optional(Unit
*u
) {
1061 /* Same as unit_load_fragment_and_dropin(), but whether
1062 * something can be loaded or not doesn't matter. */
1064 /* Load a .service file */
1065 r
= unit_load_fragment(u
);
1069 if (u
->load_state
== UNIT_STUB
)
1070 u
->load_state
= UNIT_LOADED
;
1072 /* Load drop-in directory data */
1073 r
= unit_load_dropin(unit_follow_merge(u
));
1080 int unit_add_default_target_dependency(Unit
*u
, Unit
*target
) {
1084 if (target
->type
!= UNIT_TARGET
)
1087 /* Only add the dependency if both units are loaded, so that
1088 * that loop check below is reliable */
1089 if (u
->load_state
!= UNIT_LOADED
||
1090 target
->load_state
!= UNIT_LOADED
)
1093 /* If either side wants no automatic dependencies, then let's
1095 if (!u
->default_dependencies
||
1096 !target
->default_dependencies
)
1099 /* Don't create loops */
1100 if (set_get(target
->dependencies
[UNIT_BEFORE
], u
))
1103 return unit_add_dependency(target
, UNIT_AFTER
, u
, true);
1106 static int unit_add_target_dependencies(Unit
*u
) {
1108 static const UnitDependency deps
[] = {
1122 for (k
= 0; k
< ELEMENTSOF(deps
); k
++)
1123 SET_FOREACH(target
, u
->dependencies
[deps
[k
]], i
) {
1124 r
= unit_add_default_target_dependency(u
, target
);
1132 static int unit_add_slice_dependencies(Unit
*u
) {
1135 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
1138 if (UNIT_ISSET(u
->slice
))
1139 return unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_REQUIRES
, UNIT_DEREF(u
->slice
), true);
1141 if (unit_has_name(u
, SPECIAL_ROOT_SLICE
))
1144 return unit_add_two_dependencies_by_name(u
, UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_ROOT_SLICE
, NULL
, true);
1147 static int unit_add_mount_dependencies(Unit
*u
) {
1153 STRV_FOREACH(i
, u
->requires_mounts_for
) {
1154 char prefix
[strlen(*i
) + 1];
1156 PATH_FOREACH_PREFIX_MORE(prefix
, *i
) {
1157 _cleanup_free_
char *p
= NULL
;
1160 r
= unit_name_from_path(prefix
, ".mount", &p
);
1164 m
= manager_get_unit(u
->manager
, p
);
1166 /* Make sure to load the mount unit if
1167 * it exists. If so the dependencies
1168 * on this unit will be added later
1169 * during the loading of the mount
1171 (void) manager_load_unit_prepare(u
->manager
, p
, NULL
, NULL
, &m
);
1177 if (m
->load_state
!= UNIT_LOADED
)
1180 r
= unit_add_dependency(u
, UNIT_AFTER
, m
, true);
1184 if (m
->fragment_path
) {
1185 r
= unit_add_dependency(u
, UNIT_REQUIRES
, m
, true);
1195 static int unit_add_startup_units(Unit
*u
) {
1199 c
= unit_get_cgroup_context(u
);
1203 if (c
->startup_cpu_shares
== CGROUP_CPU_SHARES_INVALID
&&
1204 c
->startup_blockio_weight
== CGROUP_BLKIO_WEIGHT_INVALID
)
1207 r
= set_ensure_allocated(&u
->manager
->startup_units
, NULL
);
1211 return set_put(u
->manager
->startup_units
, u
);
1214 int unit_load(Unit
*u
) {
1219 if (u
->in_load_queue
) {
1220 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
1221 u
->in_load_queue
= false;
1224 if (u
->type
== _UNIT_TYPE_INVALID
)
1227 if (u
->load_state
!= UNIT_STUB
)
1230 if (UNIT_VTABLE(u
)->load
) {
1231 r
= UNIT_VTABLE(u
)->load(u
);
1236 if (u
->load_state
== UNIT_STUB
) {
1241 if (u
->load_state
== UNIT_LOADED
) {
1243 r
= unit_add_target_dependencies(u
);
1247 r
= unit_add_slice_dependencies(u
);
1251 r
= unit_add_mount_dependencies(u
);
1255 r
= unit_add_startup_units(u
);
1259 if (u
->on_failure_job_mode
== JOB_ISOLATE
&& set_size(u
->dependencies
[UNIT_ON_FAILURE
]) > 1) {
1260 log_unit_error(u
, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1265 unit_update_cgroup_members_masks(u
);
1267 /* If we are reloading, we need to wait for the deserializer
1268 * to restore the net_cls ids that have been set previously */
1269 if (u
->manager
->n_reloading
<= 0) {
1270 r
= unit_add_to_netclass_cgroup(u
);
1276 assert((u
->load_state
!= UNIT_MERGED
) == !u
->merged_into
);
1278 unit_add_to_dbus_queue(unit_follow_merge(u
));
1279 unit_add_to_gc_queue(u
);
1284 u
->load_state
= u
->load_state
== UNIT_STUB
? UNIT_NOT_FOUND
: UNIT_ERROR
;
1286 unit_add_to_dbus_queue(u
);
1287 unit_add_to_gc_queue(u
);
1289 log_unit_debug_errno(u
, r
, "Failed to load configuration: %m");
1294 static bool unit_condition_test_list(Unit
*u
, Condition
*first
, const char *(*to_string
)(ConditionType t
)) {
1301 /* If the condition list is empty, then it is true */
1305 /* Otherwise, if all of the non-trigger conditions apply and
1306 * if any of the trigger conditions apply (unless there are
1307 * none) we return true */
1308 LIST_FOREACH(conditions
, c
, first
) {
1311 r
= condition_test(c
);
1314 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1316 c
->trigger
? "|" : "",
1317 c
->negate
? "!" : "",
1323 c
->trigger
? "|" : "",
1324 c
->negate
? "!" : "",
1326 condition_result_to_string(c
->result
));
1328 if (!c
->trigger
&& r
<= 0)
1331 if (c
->trigger
&& triggered
<= 0)
1335 return triggered
!= 0;
1338 static bool unit_condition_test(Unit
*u
) {
1341 dual_timestamp_get(&u
->condition_timestamp
);
1342 u
->condition_result
= unit_condition_test_list(u
, u
->conditions
, condition_type_to_string
);
1344 return u
->condition_result
;
1347 static bool unit_assert_test(Unit
*u
) {
1350 dual_timestamp_get(&u
->assert_timestamp
);
1351 u
->assert_result
= unit_condition_test_list(u
, u
->asserts
, assert_type_to_string
);
1353 return u
->assert_result
;
1356 void unit_status_printf(Unit
*u
, const char *status
, const char *unit_status_msg_format
) {
1357 DISABLE_WARNING_FORMAT_NONLITERAL
;
1358 manager_status_printf(u
->manager
, STATUS_TYPE_NORMAL
, status
, unit_status_msg_format
, unit_description(u
));
1362 _pure_
static const char* unit_get_status_message_format(Unit
*u
, JobType t
) {
1364 const UnitStatusMessageFormats
*format_table
;
1367 assert(IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
));
1369 if (t
!= JOB_RELOAD
) {
1370 format_table
= &UNIT_VTABLE(u
)->status_message_formats
;
1372 format
= format_table
->starting_stopping
[t
== JOB_STOP
];
1378 /* Return generic strings */
1380 return "Starting %s.";
1381 else if (t
== JOB_STOP
)
1382 return "Stopping %s.";
1384 return "Reloading %s.";
1387 static void unit_status_print_starting_stopping(Unit
*u
, JobType t
) {
1392 /* Reload status messages have traditionally not been printed to console. */
1393 if (!IN_SET(t
, JOB_START
, JOB_STOP
))
1396 format
= unit_get_status_message_format(u
, t
);
1398 DISABLE_WARNING_FORMAT_NONLITERAL
;
1399 unit_status_printf(u
, "", format
);
1403 static void unit_status_log_starting_stopping_reloading(Unit
*u
, JobType t
) {
1410 if (!IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
))
1413 if (log_on_console())
1416 /* We log status messages for all units and all operations. */
1418 format
= unit_get_status_message_format(u
, t
);
1420 DISABLE_WARNING_FORMAT_NONLITERAL
;
1421 xsprintf(buf
, format
, unit_description(u
));
1424 mid
= t
== JOB_START
? SD_MESSAGE_UNIT_STARTING
:
1425 t
== JOB_STOP
? SD_MESSAGE_UNIT_STOPPING
:
1426 SD_MESSAGE_UNIT_RELOADING
;
1428 /* Note that we deliberately use LOG_MESSAGE() instead of
1429 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1430 * closely what is written to screen using the status output,
1431 * which is supposed the highest level, friendliest output
1432 * possible, which means we should avoid the low-level unit
1434 log_struct(LOG_INFO
,
1435 LOG_MESSAGE_ID(mid
),
1437 LOG_MESSAGE("%s", buf
),
1441 void unit_status_emit_starting_stopping_reloading(Unit
*u
, JobType t
) {
1444 assert(t
< _JOB_TYPE_MAX
);
1446 unit_status_log_starting_stopping_reloading(u
, t
);
1447 unit_status_print_starting_stopping(u
, t
);
1450 static int unit_start_limit_test(Unit
*u
) {
1453 if (ratelimit_test(&u
->start_limit
)) {
1454 u
->start_limit_hit
= false;
1458 log_unit_warning(u
, "Start request repeated too quickly.");
1459 u
->start_limit_hit
= true;
1461 return failure_action(u
->manager
, u
->start_limit_action
, u
->reboot_arg
);
1465 * -EBADR: This unit type does not support starting.
1466 * -EALREADY: Unit is already started.
1467 * -EAGAIN: An operation is already in progress. Retry later.
1468 * -ECANCELED: Too many requests for now.
1469 * -EPROTO: Assert failed
1470 * -EINVAL: Unit not loaded
1471 * -EOPNOTSUPP: Unit type not supported
1473 int unit_start(Unit
*u
) {
1474 UnitActiveState state
;
1480 /* If this is already started, then this will succeed. Note
1481 * that this will even succeed if this unit is not startable
1482 * by the user. This is relied on to detect when we need to
1483 * wait for units and when waiting is finished. */
1484 state
= unit_active_state(u
);
1485 if (UNIT_IS_ACTIVE_OR_RELOADING(state
))
1488 /* Make sure we don't enter a busy loop of some kind. */
1489 r
= unit_start_limit_test(u
);
1493 /* Units that aren't loaded cannot be started */
1494 if (u
->load_state
!= UNIT_LOADED
)
1497 /* If the conditions failed, don't do anything at all. If we
1498 * already are activating this call might still be useful to
1499 * speed up activation in case there is some hold-off time,
1500 * but we don't want to recheck the condition in that case. */
1501 if (state
!= UNIT_ACTIVATING
&&
1502 !unit_condition_test(u
)) {
1503 log_unit_debug(u
, "Starting requested but condition failed. Not starting unit.");
1507 /* If the asserts failed, fail the entire job */
1508 if (state
!= UNIT_ACTIVATING
&&
1509 !unit_assert_test(u
)) {
1510 log_unit_notice(u
, "Starting requested but asserts failed.");
1514 /* Units of types that aren't supported cannot be
1515 * started. Note that we do this test only after the condition
1516 * checks, so that we rather return condition check errors
1517 * (which are usually not considered a true failure) than "not
1518 * supported" errors (which are considered a failure).
1520 if (!unit_supported(u
))
1523 /* Forward to the main object, if we aren't it. */
1524 following
= unit_following(u
);
1526 log_unit_debug(u
, "Redirecting start request from %s to %s.", u
->id
, following
->id
);
1527 return unit_start(following
);
1530 /* If it is stopped, but we cannot start it, then fail */
1531 if (!UNIT_VTABLE(u
)->start
)
1534 /* We don't suppress calls to ->start() here when we are
1535 * already starting, to allow this request to be used as a
1536 * "hurry up" call, for example when the unit is in some "auto
1537 * restart" state where it waits for a holdoff timer to elapse
1538 * before it will start again. */
1540 unit_add_to_dbus_queue(u
);
1542 return UNIT_VTABLE(u
)->start(u
);
1545 bool unit_can_start(Unit
*u
) {
1548 if (u
->load_state
!= UNIT_LOADED
)
1551 if (!unit_supported(u
))
1554 return !!UNIT_VTABLE(u
)->start
;
1557 bool unit_can_isolate(Unit
*u
) {
1560 return unit_can_start(u
) &&
1565 * -EBADR: This unit type does not support stopping.
1566 * -EALREADY: Unit is already stopped.
1567 * -EAGAIN: An operation is already in progress. Retry later.
1569 int unit_stop(Unit
*u
) {
1570 UnitActiveState state
;
1575 state
= unit_active_state(u
);
1576 if (UNIT_IS_INACTIVE_OR_FAILED(state
))
1579 following
= unit_following(u
);
1581 log_unit_debug(u
, "Redirecting stop request from %s to %s.", u
->id
, following
->id
);
1582 return unit_stop(following
);
1585 if (!UNIT_VTABLE(u
)->stop
)
1588 unit_add_to_dbus_queue(u
);
1590 return UNIT_VTABLE(u
)->stop(u
);
1594 * -EBADR: This unit type does not support reloading.
1595 * -ENOEXEC: Unit is not started.
1596 * -EAGAIN: An operation is already in progress. Retry later.
1598 int unit_reload(Unit
*u
) {
1599 UnitActiveState state
;
1604 if (u
->load_state
!= UNIT_LOADED
)
1607 if (!unit_can_reload(u
))
1610 state
= unit_active_state(u
);
1611 if (state
== UNIT_RELOADING
)
1614 if (state
!= UNIT_ACTIVE
) {
1615 log_unit_warning(u
, "Unit cannot be reloaded because it is inactive.");
1619 following
= unit_following(u
);
1621 log_unit_debug(u
, "Redirecting reload request from %s to %s.", u
->id
, following
->id
);
1622 return unit_reload(following
);
1625 unit_add_to_dbus_queue(u
);
1627 return UNIT_VTABLE(u
)->reload(u
);
1630 bool unit_can_reload(Unit
*u
) {
1633 if (!UNIT_VTABLE(u
)->reload
)
1636 if (!UNIT_VTABLE(u
)->can_reload
)
1639 return UNIT_VTABLE(u
)->can_reload(u
);
1642 static void unit_check_unneeded(Unit
*u
) {
1644 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1646 static const UnitDependency needed_dependencies
[] = {
1660 /* If this service shall be shut down when unneeded then do
1663 if (!u
->stop_when_unneeded
)
1666 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
1669 for (j
= 0; j
< ELEMENTSOF(needed_dependencies
); j
++)
1670 SET_FOREACH(other
, u
->dependencies
[needed_dependencies
[j
]], i
)
1671 if (unit_active_or_pending(other
))
1674 /* If stopping a unit fails continously we might enter a stop
1675 * loop here, hence stop acting on the service being
1676 * unnecessary after a while. */
1677 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1678 log_unit_warning(u
, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1682 log_unit_info(u
, "Unit not needed anymore. Stopping.");
1684 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1685 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1687 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1690 static void unit_check_binds_to(Unit
*u
) {
1691 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1702 if (unit_active_state(u
) != UNIT_ACTIVE
)
1705 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
) {
1709 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
1719 /* If stopping a unit fails continously we might enter a stop
1720 * loop here, hence stop acting on the service being
1721 * unnecessary after a while. */
1722 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1723 log_unit_warning(u
, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other
->id
);
1728 log_unit_info(u
, "Unit is bound to inactive unit %s. Stopping, too.", other
->id
);
1730 /* A unit we need to run is gone. Sniff. Let's stop this. */
1731 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1733 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1736 static void retroactively_start_dependencies(Unit
*u
) {
1741 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)));
1743 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1744 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1745 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1746 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, NULL
, NULL
);
1748 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1749 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1750 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1751 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, NULL
, NULL
);
1753 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1754 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1755 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1756 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, NULL
, NULL
);
1758 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTS
], i
)
1759 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1760 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1762 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTED_BY
], i
)
1763 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1764 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1767 static void retroactively_stop_dependencies(Unit
*u
) {
1772 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1774 /* Pull down units which are bound to us recursively if enabled */
1775 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1776 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1777 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1780 static void check_unneeded_dependencies(Unit
*u
) {
1785 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1787 /* Garbage collect services that might not be needed anymore, if enabled */
1788 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1789 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1790 unit_check_unneeded(other
);
1791 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1792 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1793 unit_check_unneeded(other
);
1794 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1795 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1796 unit_check_unneeded(other
);
1797 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1798 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1799 unit_check_unneeded(other
);
1802 void unit_start_on_failure(Unit
*u
) {
1808 if (set_size(u
->dependencies
[UNIT_ON_FAILURE
]) <= 0)
1811 log_unit_info(u
, "Triggering OnFailure= dependencies.");
1813 SET_FOREACH(other
, u
->dependencies
[UNIT_ON_FAILURE
], i
) {
1816 r
= manager_add_job(u
->manager
, JOB_START
, other
, u
->on_failure_job_mode
, NULL
, NULL
);
1818 log_unit_error_errno(u
, r
, "Failed to enqueue OnFailure= job: %m");
1822 void unit_trigger_notify(Unit
*u
) {
1828 SET_FOREACH(other
, u
->dependencies
[UNIT_TRIGGERED_BY
], i
)
1829 if (UNIT_VTABLE(other
)->trigger_notify
)
1830 UNIT_VTABLE(other
)->trigger_notify(other
, u
);
1833 void unit_notify(Unit
*u
, UnitActiveState os
, UnitActiveState ns
, bool reload_success
) {
1838 assert(os
< _UNIT_ACTIVE_STATE_MAX
);
1839 assert(ns
< _UNIT_ACTIVE_STATE_MAX
);
1841 /* Note that this is called for all low-level state changes,
1842 * even if they might map to the same high-level
1843 * UnitActiveState! That means that ns == os is an expected
1844 * behavior here. For example: if a mount point is remounted
1845 * this function will be called too! */
1849 /* Update timestamps for state changes */
1850 if (m
->n_reloading
<= 0) {
1851 dual_timestamp_get(&u
->state_change_timestamp
);
1853 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && !UNIT_IS_INACTIVE_OR_FAILED(ns
))
1854 u
->inactive_exit_timestamp
= u
->state_change_timestamp
;
1855 else if (!UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_INACTIVE_OR_FAILED(ns
))
1856 u
->inactive_enter_timestamp
= u
->state_change_timestamp
;
1858 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
) && UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1859 u
->active_enter_timestamp
= u
->state_change_timestamp
;
1860 else if (UNIT_IS_ACTIVE_OR_RELOADING(os
) && !UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1861 u
->active_exit_timestamp
= u
->state_change_timestamp
;
1864 /* Keep track of failed units */
1865 (void) manager_update_failed_units(u
->manager
, u
, ns
== UNIT_FAILED
);
1867 /* Make sure the cgroup is always removed when we become inactive */
1868 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1869 unit_prune_cgroup(u
);
1871 /* Note that this doesn't apply to RemainAfterExit services exiting
1872 * successfully, since there's no change of state in that case. Which is
1873 * why it is handled in service_set_state() */
1874 if (UNIT_IS_INACTIVE_OR_FAILED(os
) != UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1877 ec
= unit_get_exec_context(u
);
1878 if (ec
&& exec_context_may_touch_console(ec
)) {
1879 if (UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1882 if (m
->n_on_console
== 0)
1883 /* unset no_console_output flag, since the console is free */
1884 m
->no_console_output
= false;
1893 if (u
->job
->state
== JOB_WAITING
)
1895 /* So we reached a different state for this
1896 * job. Let's see if we can run it now if it
1897 * failed previously due to EAGAIN. */
1898 job_add_to_run_queue(u
->job
);
1900 /* Let's check whether this state change constitutes a
1901 * finished job, or maybe contradicts a running job and
1902 * hence needs to invalidate jobs. */
1904 switch (u
->job
->type
) {
1907 case JOB_VERIFY_ACTIVE
:
1909 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1910 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1911 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_ACTIVATING
) {
1914 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1915 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1921 case JOB_RELOAD_OR_START
:
1922 case JOB_TRY_RELOAD
:
1924 if (u
->job
->state
== JOB_RUNNING
) {
1925 if (ns
== UNIT_ACTIVE
)
1926 job_finish_and_invalidate(u
->job
, reload_success
? JOB_DONE
: JOB_FAILED
, true);
1927 else if (ns
!= UNIT_ACTIVATING
&& ns
!= UNIT_RELOADING
) {
1930 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1931 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1939 case JOB_TRY_RESTART
:
1941 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1942 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1943 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_DEACTIVATING
) {
1945 job_finish_and_invalidate(u
->job
, JOB_FAILED
, true);
1951 assert_not_reached("Job type unknown");
1957 if (m
->n_reloading
<= 0) {
1959 /* If this state change happened without being
1960 * requested by a job, then let's retroactively start
1961 * or stop dependencies. We skip that step when
1962 * deserializing, since we don't want to create any
1963 * additional jobs just because something is already
1967 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns
))
1968 retroactively_start_dependencies(u
);
1969 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1970 retroactively_stop_dependencies(u
);
1973 /* stop unneeded units regardless if going down was expected or not */
1974 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1975 check_unneeded_dependencies(u
);
1977 if (ns
!= os
&& ns
== UNIT_FAILED
) {
1978 log_unit_notice(u
, "Unit entered failed state.");
1979 unit_start_on_failure(u
);
1983 /* Some names are special */
1984 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
)) {
1986 if (unit_has_name(u
, SPECIAL_DBUS_SERVICE
))
1987 /* The bus might have just become available,
1988 * hence try to connect to it, if we aren't
1992 if (u
->type
== UNIT_SERVICE
&&
1993 !UNIT_IS_ACTIVE_OR_RELOADING(os
) &&
1994 m
->n_reloading
<= 0) {
1995 /* Write audit record if we have just finished starting up */
1996 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, true);
2000 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
))
2001 manager_send_unit_plymouth(m
, u
);
2005 /* We don't care about D-Bus here, since we'll get an
2006 * asynchronous notification for it anyway. */
2008 if (u
->type
== UNIT_SERVICE
&&
2009 UNIT_IS_INACTIVE_OR_FAILED(ns
) &&
2010 !UNIT_IS_INACTIVE_OR_FAILED(os
) &&
2011 m
->n_reloading
<= 0) {
2013 /* Hmm, if there was no start record written
2014 * write it now, so that we always have a nice
2017 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, ns
== UNIT_INACTIVE
);
2019 if (ns
== UNIT_INACTIVE
)
2020 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, true);
2022 /* Write audit record if we have just finished shutting down */
2023 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, ns
== UNIT_INACTIVE
);
2025 u
->in_audit
= false;
2029 manager_recheck_journal(m
);
2030 unit_trigger_notify(u
);
2032 if (u
->manager
->n_reloading
<= 0) {
2033 /* Maybe we finished startup and are now ready for
2034 * being stopped because unneeded? */
2035 unit_check_unneeded(u
);
2037 /* Maybe we finished startup, but something we needed
2038 * has vanished? Let's die then. (This happens when
2039 * something BindsTo= to a Type=oneshot unit, as these
2040 * units go directly from starting to inactive,
2041 * without ever entering started.) */
2042 unit_check_binds_to(u
);
2045 unit_add_to_dbus_queue(u
);
2046 unit_add_to_gc_queue(u
);
2049 int unit_watch_pid(Unit
*u
, pid_t pid
) {
2055 /* Watch a specific PID. We only support one or two units
2056 * watching each PID for now, not more. */
2058 r
= set_ensure_allocated(&u
->pids
, NULL
);
2062 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids1
, NULL
);
2066 r
= hashmap_put(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2068 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids2
, NULL
);
2072 r
= hashmap_put(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2075 q
= set_put(u
->pids
, PID_TO_PTR(pid
));
2082 void unit_unwatch_pid(Unit
*u
, pid_t pid
) {
2086 (void) hashmap_remove_value(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2087 (void) hashmap_remove_value(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2088 (void) set_remove(u
->pids
, PID_TO_PTR(pid
));
2091 void unit_unwatch_all_pids(Unit
*u
) {
2094 while (!set_isempty(u
->pids
))
2095 unit_unwatch_pid(u
, PTR_TO_PID(set_first(u
->pids
)));
2097 u
->pids
= set_free(u
->pids
);
2100 void unit_tidy_watch_pids(Unit
*u
, pid_t except1
, pid_t except2
) {
2106 /* Cleans dead PIDs from our list */
2108 SET_FOREACH(e
, u
->pids
, i
) {
2109 pid_t pid
= PTR_TO_PID(e
);
2111 if (pid
== except1
|| pid
== except2
)
2114 if (!pid_is_unwaited(pid
))
2115 unit_unwatch_pid(u
, pid
);
2119 bool unit_job_is_applicable(Unit
*u
, JobType j
) {
2121 assert(j
>= 0 && j
< _JOB_TYPE_MAX
);
2125 case JOB_VERIFY_ACTIVE
:
2132 case JOB_TRY_RESTART
:
2133 return unit_can_start(u
);
2136 case JOB_TRY_RELOAD
:
2137 return unit_can_reload(u
);
2139 case JOB_RELOAD_OR_START
:
2140 return unit_can_reload(u
) && unit_can_start(u
);
2143 assert_not_reached("Invalid job type");
2147 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
) {
2150 /* Only warn about some unit types */
2151 if (!IN_SET(dependency
, UNIT_CONFLICTS
, UNIT_CONFLICTED_BY
, UNIT_BEFORE
, UNIT_AFTER
, UNIT_ON_FAILURE
, UNIT_TRIGGERS
, UNIT_TRIGGERED_BY
))
2154 if (streq_ptr(u
->id
, other
))
2155 log_unit_warning(u
, "Dependency %s=%s dropped", unit_dependency_to_string(dependency
), u
->id
);
2157 log_unit_warning(u
, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency
), strna(other
), u
->id
);
2160 int unit_add_dependency(Unit
*u
, UnitDependency d
, Unit
*other
, bool add_reference
) {
2162 static const UnitDependency inverse_table
[_UNIT_DEPENDENCY_MAX
] = {
2163 [UNIT_REQUIRES
] = UNIT_REQUIRED_BY
,
2164 [UNIT_WANTS
] = UNIT_WANTED_BY
,
2165 [UNIT_REQUISITE
] = UNIT_REQUISITE_OF
,
2166 [UNIT_BINDS_TO
] = UNIT_BOUND_BY
,
2167 [UNIT_PART_OF
] = UNIT_CONSISTS_OF
,
2168 [UNIT_REQUIRED_BY
] = UNIT_REQUIRES
,
2169 [UNIT_REQUISITE_OF
] = UNIT_REQUISITE
,
2170 [UNIT_WANTED_BY
] = UNIT_WANTS
,
2171 [UNIT_BOUND_BY
] = UNIT_BINDS_TO
,
2172 [UNIT_CONSISTS_OF
] = UNIT_PART_OF
,
2173 [UNIT_CONFLICTS
] = UNIT_CONFLICTED_BY
,
2174 [UNIT_CONFLICTED_BY
] = UNIT_CONFLICTS
,
2175 [UNIT_BEFORE
] = UNIT_AFTER
,
2176 [UNIT_AFTER
] = UNIT_BEFORE
,
2177 [UNIT_ON_FAILURE
] = _UNIT_DEPENDENCY_INVALID
,
2178 [UNIT_REFERENCES
] = UNIT_REFERENCED_BY
,
2179 [UNIT_REFERENCED_BY
] = UNIT_REFERENCES
,
2180 [UNIT_TRIGGERS
] = UNIT_TRIGGERED_BY
,
2181 [UNIT_TRIGGERED_BY
] = UNIT_TRIGGERS
,
2182 [UNIT_PROPAGATES_RELOAD_TO
] = UNIT_RELOAD_PROPAGATED_FROM
,
2183 [UNIT_RELOAD_PROPAGATED_FROM
] = UNIT_PROPAGATES_RELOAD_TO
,
2184 [UNIT_JOINS_NAMESPACE_OF
] = UNIT_JOINS_NAMESPACE_OF
,
2186 int r
, q
= 0, v
= 0, w
= 0;
2187 Unit
*orig_u
= u
, *orig_other
= other
;
2190 assert(d
>= 0 && d
< _UNIT_DEPENDENCY_MAX
);
2193 u
= unit_follow_merge(u
);
2194 other
= unit_follow_merge(other
);
2196 /* We won't allow dependencies on ourselves. We will not
2197 * consider them an error however. */
2199 maybe_warn_about_dependency(orig_u
, orig_other
->id
, d
);
2203 r
= set_ensure_allocated(&u
->dependencies
[d
], NULL
);
2207 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
) {
2208 r
= set_ensure_allocated(&other
->dependencies
[inverse_table
[d
]], NULL
);
2213 if (add_reference
) {
2214 r
= set_ensure_allocated(&u
->dependencies
[UNIT_REFERENCES
], NULL
);
2218 r
= set_ensure_allocated(&other
->dependencies
[UNIT_REFERENCED_BY
], NULL
);
2223 q
= set_put(u
->dependencies
[d
], other
);
2227 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
&& inverse_table
[d
] != d
) {
2228 v
= set_put(other
->dependencies
[inverse_table
[d
]], u
);
2235 if (add_reference
) {
2236 w
= set_put(u
->dependencies
[UNIT_REFERENCES
], other
);
2242 r
= set_put(other
->dependencies
[UNIT_REFERENCED_BY
], u
);
2247 unit_add_to_dbus_queue(u
);
2252 set_remove(u
->dependencies
[d
], other
);
2255 set_remove(other
->dependencies
[inverse_table
[d
]], u
);
2258 set_remove(u
->dependencies
[UNIT_REFERENCES
], other
);
2263 int unit_add_two_dependencies(Unit
*u
, UnitDependency d
, UnitDependency e
, Unit
*other
, bool add_reference
) {
2268 r
= unit_add_dependency(u
, d
, other
, add_reference
);
2272 return unit_add_dependency(u
, e
, other
, add_reference
);
2275 static int resolve_template(Unit
*u
, const char *name
, const char*path
, char **buf
, const char **ret
) {
2279 assert(name
|| path
);
2284 name
= basename(path
);
2286 if (!unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
2293 r
= unit_name_replace_instance(name
, u
->instance
, buf
);
2295 _cleanup_free_
char *i
= NULL
;
2297 r
= unit_name_to_prefix(u
->id
, &i
);
2301 r
= unit_name_replace_instance(name
, i
, buf
);
2310 int unit_add_dependency_by_name(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
2311 _cleanup_free_
char *buf
= NULL
;
2316 assert(name
|| path
);
2318 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2322 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2326 return unit_add_dependency(u
, d
, other
, add_reference
);
2329 int unit_add_two_dependencies_by_name(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
2330 _cleanup_free_
char *buf
= NULL
;
2335 assert(name
|| path
);
2337 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2341 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2345 return unit_add_two_dependencies(u
, d
, e
, other
, add_reference
);
2348 int set_unit_path(const char *p
) {
2349 /* This is mostly for debug purposes */
2350 if (setenv("SYSTEMD_UNIT_PATH", p
, 1) < 0)
2356 char *unit_dbus_path(Unit
*u
) {
2362 return unit_dbus_path_from_name(u
->id
);
2365 int unit_set_slice(Unit
*u
, Unit
*slice
) {
2369 /* Sets the unit slice if it has not been set before. Is extra
2370 * careful, to only allow this for units that actually have a
2371 * cgroup context. Also, we don't allow to set this for slices
2372 * (since the parent slice is derived from the name). Make
2373 * sure the unit we set is actually a slice. */
2375 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
2378 if (u
->type
== UNIT_SLICE
)
2381 if (unit_active_state(u
) != UNIT_INACTIVE
)
2384 if (slice
->type
!= UNIT_SLICE
)
2387 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
) &&
2388 !unit_has_name(slice
, SPECIAL_ROOT_SLICE
))
2391 if (UNIT_DEREF(u
->slice
) == slice
)
2394 if (UNIT_ISSET(u
->slice
))
2397 unit_ref_set(&u
->slice
, slice
);
2401 int unit_set_default_slice(Unit
*u
) {
2402 _cleanup_free_
char *b
= NULL
;
2403 const char *slice_name
;
2409 if (UNIT_ISSET(u
->slice
))
2413 _cleanup_free_
char *prefix
= NULL
, *escaped
= NULL
;
2415 /* Implicitly place all instantiated units in their
2416 * own per-template slice */
2418 r
= unit_name_to_prefix(u
->id
, &prefix
);
2422 /* The prefix is already escaped, but it might include
2423 * "-" which has a special meaning for slice units,
2424 * hence escape it here extra. */
2425 escaped
= unit_name_escape(prefix
);
2429 if (u
->manager
->running_as
== MANAGER_SYSTEM
)
2430 b
= strjoin("system-", escaped
, ".slice", NULL
);
2432 b
= strappend(escaped
, ".slice");
2439 u
->manager
->running_as
== MANAGER_SYSTEM
&& !unit_has_name(u
, SPECIAL_INIT_SCOPE
)
2440 ? SPECIAL_SYSTEM_SLICE
2441 : SPECIAL_ROOT_SLICE
;
2443 r
= manager_load_unit(u
->manager
, slice_name
, NULL
, NULL
, &slice
);
2447 return unit_set_slice(u
, slice
);
2450 const char *unit_slice_name(Unit
*u
) {
2453 if (!UNIT_ISSET(u
->slice
))
2456 return UNIT_DEREF(u
->slice
)->id
;
2459 int unit_load_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2460 _cleanup_free_
char *t
= NULL
;
2467 r
= unit_name_change_suffix(u
->id
, type
, &t
);
2470 if (unit_has_name(u
, t
))
2473 r
= manager_load_unit(u
->manager
, t
, NULL
, NULL
, _found
);
2474 assert(r
< 0 || *_found
!= u
);
2478 static int signal_name_owner_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2479 const char *name
, *old_owner
, *new_owner
;
2486 r
= sd_bus_message_read(message
, "sss", &name
, &old_owner
, &new_owner
);
2488 bus_log_parse_error(r
);
2492 if (UNIT_VTABLE(u
)->bus_name_owner_change
)
2493 UNIT_VTABLE(u
)->bus_name_owner_change(u
, name
, old_owner
, new_owner
);
2498 int unit_install_bus_match(Unit
*u
, sd_bus
*bus
, const char *name
) {
2505 if (u
->match_bus_slot
)
2508 match
= strjoina("type='signal',"
2509 "sender='org.freedesktop.DBus',"
2510 "path='/org/freedesktop/DBus',"
2511 "interface='org.freedesktop.DBus',"
2512 "member='NameOwnerChanged',"
2513 "arg0='", name
, "'",
2516 return sd_bus_add_match(bus
, &u
->match_bus_slot
, match
, signal_name_owner_changed
, u
);
2519 int unit_watch_bus_name(Unit
*u
, const char *name
) {
2525 /* Watch a specific name on the bus. We only support one unit
2526 * watching each name for now. */
2528 if (u
->manager
->api_bus
) {
2529 /* If the bus is already available, install the match directly.
2530 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2531 r
= unit_install_bus_match(u
, u
->manager
->api_bus
, name
);
2533 return log_warning_errno(r
, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name
);
2536 r
= hashmap_put(u
->manager
->watch_bus
, name
, u
);
2538 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2539 return log_warning_errno(r
, "Failed to put bus name to hashmap: %m");
2545 void unit_unwatch_bus_name(Unit
*u
, const char *name
) {
2549 hashmap_remove_value(u
->manager
->watch_bus
, name
, u
);
2550 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2553 bool unit_can_serialize(Unit
*u
) {
2556 return UNIT_VTABLE(u
)->serialize
&& UNIT_VTABLE(u
)->deserialize_item
;
2559 int unit_serialize(Unit
*u
, FILE *f
, FDSet
*fds
, bool serialize_jobs
) {
2566 if (unit_can_serialize(u
)) {
2569 r
= UNIT_VTABLE(u
)->serialize(u
, f
, fds
);
2573 rt
= unit_get_exec_runtime(u
);
2575 r
= exec_runtime_serialize(u
, rt
, f
, fds
);
2581 dual_timestamp_serialize(f
, "state-change-timestamp", &u
->state_change_timestamp
);
2583 dual_timestamp_serialize(f
, "inactive-exit-timestamp", &u
->inactive_exit_timestamp
);
2584 dual_timestamp_serialize(f
, "active-enter-timestamp", &u
->active_enter_timestamp
);
2585 dual_timestamp_serialize(f
, "active-exit-timestamp", &u
->active_exit_timestamp
);
2586 dual_timestamp_serialize(f
, "inactive-enter-timestamp", &u
->inactive_enter_timestamp
);
2588 dual_timestamp_serialize(f
, "condition-timestamp", &u
->condition_timestamp
);
2589 dual_timestamp_serialize(f
, "assert-timestamp", &u
->assert_timestamp
);
2591 if (dual_timestamp_is_set(&u
->condition_timestamp
))
2592 unit_serialize_item(u
, f
, "condition-result", yes_no(u
->condition_result
));
2594 if (dual_timestamp_is_set(&u
->assert_timestamp
))
2595 unit_serialize_item(u
, f
, "assert-result", yes_no(u
->assert_result
));
2597 unit_serialize_item(u
, f
, "transient", yes_no(u
->transient
));
2598 unit_serialize_item_format(u
, f
, "cpuacct-usage-base", "%" PRIu64
, u
->cpuacct_usage_base
);
2601 unit_serialize_item(u
, f
, "cgroup", u
->cgroup_path
);
2602 unit_serialize_item(u
, f
, "cgroup-realized", yes_no(u
->cgroup_realized
));
2604 if (u
->cgroup_netclass_id
)
2605 unit_serialize_item_format(u
, f
, "netclass-id", "%" PRIu32
, u
->cgroup_netclass_id
);
2607 if (serialize_jobs
) {
2609 fprintf(f
, "job\n");
2610 job_serialize(u
->job
, f
, fds
);
2614 fprintf(f
, "job\n");
2615 job_serialize(u
->nop_job
, f
, fds
);
2624 int unit_serialize_item(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2640 int unit_serialize_item_escaped(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2641 _cleanup_free_
char *c
= NULL
;
2662 int unit_serialize_item_fd(Unit
*u
, FILE *f
, FDSet
*fds
, const char *key
, int fd
) {
2672 copy
= fdset_put_dup(fds
, fd
);
2676 fprintf(f
, "%s=%i\n", key
, copy
);
2680 void unit_serialize_item_format(Unit
*u
, FILE *f
, const char *key
, const char *format
, ...) {
2691 va_start(ap
, format
);
2692 vfprintf(f
, format
, ap
);
2698 int unit_deserialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2699 ExecRuntime
**rt
= NULL
;
2707 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
2709 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
2712 char line
[LINE_MAX
], *l
, *v
;
2715 if (!fgets(line
, sizeof(line
), f
)) {
2728 k
= strcspn(l
, "=");
2736 if (streq(l
, "job")) {
2738 /* new-style serialized job */
2745 r
= job_deserialize(j
, f
, fds
);
2751 r
= hashmap_put(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
), j
);
2757 r
= job_install_deserialized(j
);
2759 hashmap_remove(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
));
2763 } else /* legacy for pre-44 */
2764 log_unit_warning(u
, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v
);
2766 } else if (streq(l
, "state-change-timestamp")) {
2767 dual_timestamp_deserialize(v
, &u
->state_change_timestamp
);
2769 } else if (streq(l
, "inactive-exit-timestamp")) {
2770 dual_timestamp_deserialize(v
, &u
->inactive_exit_timestamp
);
2772 } else if (streq(l
, "active-enter-timestamp")) {
2773 dual_timestamp_deserialize(v
, &u
->active_enter_timestamp
);
2775 } else if (streq(l
, "active-exit-timestamp")) {
2776 dual_timestamp_deserialize(v
, &u
->active_exit_timestamp
);
2778 } else if (streq(l
, "inactive-enter-timestamp")) {
2779 dual_timestamp_deserialize(v
, &u
->inactive_enter_timestamp
);
2781 } else if (streq(l
, "condition-timestamp")) {
2782 dual_timestamp_deserialize(v
, &u
->condition_timestamp
);
2784 } else if (streq(l
, "assert-timestamp")) {
2785 dual_timestamp_deserialize(v
, &u
->assert_timestamp
);
2787 } else if (streq(l
, "condition-result")) {
2789 r
= parse_boolean(v
);
2791 log_unit_debug(u
, "Failed to parse condition result value %s, ignoring.", v
);
2793 u
->condition_result
= r
;
2797 } else if (streq(l
, "assert-result")) {
2799 r
= parse_boolean(v
);
2801 log_unit_debug(u
, "Failed to parse assert result value %s, ignoring.", v
);
2803 u
->assert_result
= r
;
2807 } else if (streq(l
, "transient")) {
2809 r
= parse_boolean(v
);
2811 log_unit_debug(u
, "Failed to parse transient bool %s, ignoring.", v
);
2817 } else if (streq(l
, "cpuacct-usage-base")) {
2819 r
= safe_atou64(v
, &u
->cpuacct_usage_base
);
2821 log_unit_debug(u
, "Failed to parse CPU usage %s, ignoring.", v
);
2825 } else if (streq(l
, "cgroup")) {
2827 r
= unit_set_cgroup_path(u
, v
);
2829 log_unit_debug_errno(u
, r
, "Failed to set cgroup path %s, ignoring: %m", v
);
2831 (void) unit_watch_cgroup(u
);
2834 } else if (streq(l
, "cgroup-realized")) {
2837 b
= parse_boolean(v
);
2839 log_unit_debug(u
, "Failed to parse cgroup-realized bool %s, ignoring.", v
);
2841 u
->cgroup_realized
= b
;
2844 } else if (streq(l
, "netclass-id")) {
2845 r
= safe_atou32(v
, &u
->cgroup_netclass_id
);
2847 log_unit_debug(u
, "Failed to parse netclass ID %s, ignoring.", v
);
2849 r
= unit_add_to_netclass_cgroup(u
);
2851 log_unit_debug_errno(u
, r
, "Failed to add unit to netclass cgroup, ignoring: %m");
2857 if (unit_can_serialize(u
)) {
2859 r
= exec_runtime_deserialize_item(u
, rt
, l
, v
, fds
);
2861 log_unit_warning(u
, "Failed to deserialize runtime parameter '%s', ignoring.", l
);
2865 /* Returns positive if key was handled by the call */
2870 r
= UNIT_VTABLE(u
)->deserialize_item(u
, l
, v
, fds
);
2872 log_unit_warning(u
, "Failed to deserialize unit parameter '%s', ignoring.", l
);
2876 /* Versions before 228 did not carry a state change timestamp. In this case, take the current time. This is
2877 * useful, so that timeouts based on this timestamp don't trigger too early, and is in-line with the logic from
2878 * before 228 where the base for timeouts was not persistent across reboots. */
2880 if (!dual_timestamp_is_set(&u
->state_change_timestamp
))
2881 dual_timestamp_get(&u
->state_change_timestamp
);
2886 int unit_add_node_link(Unit
*u
, const char *what
, bool wants
, UnitDependency dep
) {
2888 _cleanup_free_
char *e
= NULL
;
2893 /* Adds in links to the device node that this unit is based on */
2897 if (!is_device_path(what
))
2900 /* When device units aren't supported (such as in a
2901 * container), don't create dependencies on them. */
2902 if (!unit_type_supported(UNIT_DEVICE
))
2905 r
= unit_name_from_path(what
, ".device", &e
);
2909 r
= manager_load_unit(u
->manager
, e
, NULL
, NULL
, &device
);
2913 r
= unit_add_two_dependencies(u
, UNIT_AFTER
,
2914 u
->manager
->running_as
== MANAGER_SYSTEM
? dep
: UNIT_WANTS
,
2920 r
= unit_add_dependency(device
, UNIT_WANTS
, u
, false);
2928 int unit_coldplug(Unit
*u
) {
2933 /* Make sure we don't enter a loop, when coldplugging
2938 u
->coldplugged
= true;
2940 if (UNIT_VTABLE(u
)->coldplug
)
2941 r
= UNIT_VTABLE(u
)->coldplug(u
);
2944 q
= job_coldplug(u
->job
);
2954 bool unit_need_daemon_reload(Unit
*u
) {
2955 _cleanup_strv_free_
char **t
= NULL
;
2958 unsigned loaded_cnt
, current_cnt
;
2962 if (u
->fragment_path
) {
2964 if (stat(u
->fragment_path
, &st
) < 0)
2965 /* What, cannot access this anymore? */
2968 if (u
->fragment_mtime
> 0 &&
2969 timespec_load(&st
.st_mtim
) != u
->fragment_mtime
)
2973 if (u
->source_path
) {
2975 if (stat(u
->source_path
, &st
) < 0)
2978 if (u
->source_mtime
> 0 &&
2979 timespec_load(&st
.st_mtim
) != u
->source_mtime
)
2983 (void) unit_find_dropin_paths(u
, &t
);
2984 loaded_cnt
= strv_length(t
);
2985 current_cnt
= strv_length(u
->dropin_paths
);
2987 if (loaded_cnt
== current_cnt
) {
2988 if (loaded_cnt
== 0)
2991 if (strv_overlap(u
->dropin_paths
, t
)) {
2992 STRV_FOREACH(path
, u
->dropin_paths
) {
2994 if (stat(*path
, &st
) < 0)
2997 if (u
->dropin_mtime
> 0 &&
2998 timespec_load(&st
.st_mtim
) > u
->dropin_mtime
)
3009 void unit_reset_failed(Unit
*u
) {
3012 if (UNIT_VTABLE(u
)->reset_failed
)
3013 UNIT_VTABLE(u
)->reset_failed(u
);
3015 RATELIMIT_RESET(u
->start_limit
);
3016 u
->start_limit_hit
= false;
3019 Unit
*unit_following(Unit
*u
) {
3022 if (UNIT_VTABLE(u
)->following
)
3023 return UNIT_VTABLE(u
)->following(u
);
3028 bool unit_stop_pending(Unit
*u
) {
3031 /* This call does check the current state of the unit. It's
3032 * hence useful to be called from state change calls of the
3033 * unit itself, where the state isn't updated yet. This is
3034 * different from unit_inactive_or_pending() which checks both
3035 * the current state and for a queued job. */
3037 return u
->job
&& u
->job
->type
== JOB_STOP
;
3040 bool unit_inactive_or_pending(Unit
*u
) {
3043 /* Returns true if the unit is inactive or going down */
3045 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)))
3048 if (unit_stop_pending(u
))
3054 bool unit_active_or_pending(Unit
*u
) {
3057 /* Returns true if the unit is active or going up */
3059 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
3063 (u
->job
->type
== JOB_START
||
3064 u
->job
->type
== JOB_RELOAD_OR_START
||
3065 u
->job
->type
== JOB_RESTART
))
3071 int unit_kill(Unit
*u
, KillWho w
, int signo
, sd_bus_error
*error
) {
3073 assert(w
>= 0 && w
< _KILL_WHO_MAX
);
3075 assert(signo
< _NSIG
);
3077 if (!UNIT_VTABLE(u
)->kill
)
3080 return UNIT_VTABLE(u
)->kill(u
, w
, signo
, error
);
3083 static Set
*unit_pid_set(pid_t main_pid
, pid_t control_pid
) {
3087 pid_set
= set_new(NULL
);
3091 /* Exclude the main/control pids from being killed via the cgroup */
3093 r
= set_put(pid_set
, PID_TO_PTR(main_pid
));
3098 if (control_pid
> 0) {
3099 r
= set_put(pid_set
, PID_TO_PTR(control_pid
));
3111 int unit_kill_common(
3117 sd_bus_error
*error
) {
3120 bool killed
= false;
3122 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
)) {
3124 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no main processes", unit_type_to_string(u
->type
));
3125 else if (main_pid
== 0)
3126 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No main process to kill");
3129 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
)) {
3130 if (control_pid
< 0)
3131 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no control processes", unit_type_to_string(u
->type
));
3132 else if (control_pid
== 0)
3133 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
3136 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3137 if (control_pid
> 0) {
3138 if (kill(control_pid
, signo
) < 0)
3144 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3146 if (kill(main_pid
, signo
) < 0)
3152 if (IN_SET(who
, KILL_ALL
, KILL_ALL_FAIL
) && u
->cgroup_path
) {
3153 _cleanup_set_free_ Set
*pid_set
= NULL
;
3156 /* Exclude the main/control pids from being killed via the cgroup */
3157 pid_set
= unit_pid_set(main_pid
, control_pid
);
3161 q
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, signo
, false, false, false, pid_set
);
3162 if (q
< 0 && q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
3168 if (r
== 0 && !killed
&& IN_SET(who
, KILL_ALL_FAIL
, KILL_CONTROL_FAIL
))
3174 int unit_following_set(Unit
*u
, Set
**s
) {
3178 if (UNIT_VTABLE(u
)->following_set
)
3179 return UNIT_VTABLE(u
)->following_set(u
, s
);
3185 UnitFileState
unit_get_unit_file_state(Unit
*u
) {
3190 if (u
->unit_file_state
< 0 && u
->fragment_path
) {
3191 r
= unit_file_get_state(
3192 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3194 basename(u
->fragment_path
),
3195 &u
->unit_file_state
);
3197 u
->unit_file_state
= UNIT_FILE_BAD
;
3200 return u
->unit_file_state
;
3203 int unit_get_unit_file_preset(Unit
*u
) {
3206 if (u
->unit_file_preset
< 0 && u
->fragment_path
)
3207 u
->unit_file_preset
= unit_file_query_preset(
3208 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3210 basename(u
->fragment_path
));
3212 return u
->unit_file_preset
;
3215 Unit
* unit_ref_set(UnitRef
*ref
, Unit
*u
) {
3220 unit_ref_unset(ref
);
3223 LIST_PREPEND(refs
, u
->refs
, ref
);
3227 void unit_ref_unset(UnitRef
*ref
) {
3233 LIST_REMOVE(refs
, ref
->unit
->refs
, ref
);
3237 int unit_patch_contexts(Unit
*u
) {
3245 /* Patch in the manager defaults into the exec and cgroup
3246 * contexts, _after_ the rest of the settings have been
3249 ec
= unit_get_exec_context(u
);
3251 /* This only copies in the ones that need memory */
3252 for (i
= 0; i
< _RLIMIT_MAX
; i
++)
3253 if (u
->manager
->rlimit
[i
] && !ec
->rlimit
[i
]) {
3254 ec
->rlimit
[i
] = newdup(struct rlimit
, u
->manager
->rlimit
[i
], 1);
3259 if (u
->manager
->running_as
== MANAGER_USER
&&
3260 !ec
->working_directory
) {
3262 r
= get_home_dir(&ec
->working_directory
);
3266 /* Allow user services to run, even if the
3267 * home directory is missing */
3268 ec
->working_directory_missing_ok
= true;
3271 if (u
->manager
->running_as
== MANAGER_USER
&&
3272 (ec
->syscall_whitelist
||
3273 !set_isempty(ec
->syscall_filter
) ||
3274 !set_isempty(ec
->syscall_archs
) ||
3275 ec
->address_families_whitelist
||
3276 !set_isempty(ec
->address_families
)))
3277 ec
->no_new_privileges
= true;
3279 if (ec
->private_devices
)
3280 ec
->capability_bounding_set
&= ~(UINT64_C(1) << CAP_MKNOD
);
3283 cc
= unit_get_cgroup_context(u
);
3287 ec
->private_devices
&&
3288 cc
->device_policy
== CGROUP_AUTO
)
3289 cc
->device_policy
= CGROUP_CLOSED
;
3295 ExecContext
*unit_get_exec_context(Unit
*u
) {
3302 offset
= UNIT_VTABLE(u
)->exec_context_offset
;
3306 return (ExecContext
*) ((uint8_t*) u
+ offset
);
3309 KillContext
*unit_get_kill_context(Unit
*u
) {
3316 offset
= UNIT_VTABLE(u
)->kill_context_offset
;
3320 return (KillContext
*) ((uint8_t*) u
+ offset
);
3323 CGroupContext
*unit_get_cgroup_context(Unit
*u
) {
3329 offset
= UNIT_VTABLE(u
)->cgroup_context_offset
;
3333 return (CGroupContext
*) ((uint8_t*) u
+ offset
);
3336 ExecRuntime
*unit_get_exec_runtime(Unit
*u
) {
3342 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3346 return *(ExecRuntime
**) ((uint8_t*) u
+ offset
);
3349 static int unit_drop_in_dir(Unit
*u
, UnitSetPropertiesMode mode
, bool transient
, char **dir
) {
3352 if (u
->manager
->running_as
== MANAGER_USER
) {
3355 if (mode
== UNIT_PERSISTENT
&& !transient
)
3356 r
= user_config_home(dir
);
3358 r
= user_runtime_dir(dir
);
3365 if (mode
== UNIT_PERSISTENT
&& !transient
)
3366 *dir
= strdup("/etc/systemd/system");
3368 *dir
= strdup("/run/systemd/system");
3375 int unit_write_drop_in(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3377 _cleanup_free_
char *dir
= NULL
, *p
= NULL
, *q
= NULL
;
3382 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3385 r
= unit_drop_in_dir(u
, mode
, u
->transient
, &dir
);
3389 r
= write_drop_in(dir
, u
->id
, 50, name
, data
);
3393 r
= drop_in_file(dir
, u
->id
, 50, name
, &p
, &q
);
3397 r
= strv_extend(&u
->dropin_paths
, q
);
3401 strv_sort(u
->dropin_paths
);
3402 strv_uniq(u
->dropin_paths
);
3404 u
->dropin_mtime
= now(CLOCK_REALTIME
);
3409 int unit_write_drop_in_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3410 _cleanup_free_
char *p
= NULL
;
3418 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3421 va_start(ap
, format
);
3422 r
= vasprintf(&p
, format
, ap
);
3428 return unit_write_drop_in(u
, mode
, name
, p
);
3431 int unit_write_drop_in_private(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3432 _cleanup_free_
char *ndata
= NULL
;
3438 if (!UNIT_VTABLE(u
)->private_section
)
3441 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3444 ndata
= strjoin("[", UNIT_VTABLE(u
)->private_section
, "]\n", data
, NULL
);
3448 return unit_write_drop_in(u
, mode
, name
, ndata
);
3451 int unit_write_drop_in_private_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3452 _cleanup_free_
char *p
= NULL
;
3460 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3463 va_start(ap
, format
);
3464 r
= vasprintf(&p
, format
, ap
);
3470 return unit_write_drop_in_private(u
, mode
, name
, p
);
3473 int unit_make_transient(Unit
*u
) {
3476 if (!UNIT_VTABLE(u
)->can_transient
)
3479 u
->load_state
= UNIT_STUB
;
3481 u
->transient
= true;
3483 u
->fragment_path
= mfree(u
->fragment_path
);
3484 u
->source_path
= mfree(u
->source_path
);
3485 u
->dropin_paths
= strv_free(u
->dropin_paths
);
3486 u
->fragment_mtime
= u
->source_mtime
= u
->dropin_mtime
= 0;
3488 unit_add_to_dbus_queue(u
);
3489 unit_add_to_gc_queue(u
);
3490 unit_add_to_load_queue(u
);
3495 int unit_kill_context(
3501 bool main_pid_alien
) {
3503 bool wait_for_exit
= false;
3509 if (c
->kill_mode
== KILL_NONE
)
3519 case KILL_TERMINATE
:
3520 sig
= c
->kill_signal
;
3523 assert_not_reached("KillOperation unknown");
3527 r
= kill_and_sigcont(main_pid
, sig
);
3529 if (r
< 0 && r
!= -ESRCH
) {
3530 _cleanup_free_
char *comm
= NULL
;
3531 get_process_comm(main_pid
, &comm
);
3533 log_unit_warning_errno(u
, r
, "Failed to kill main process " PID_FMT
" (%s), ignoring: %m", main_pid
, strna(comm
));
3535 if (!main_pid_alien
)
3536 wait_for_exit
= true;
3538 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3539 (void) kill(main_pid
, SIGHUP
);
3543 if (control_pid
> 0) {
3544 r
= kill_and_sigcont(control_pid
, sig
);
3546 if (r
< 0 && r
!= -ESRCH
) {
3547 _cleanup_free_
char *comm
= NULL
;
3548 get_process_comm(control_pid
, &comm
);
3550 log_unit_warning_errno(u
, r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m", control_pid
, strna(comm
));
3552 wait_for_exit
= true;
3554 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3555 (void) kill(control_pid
, SIGHUP
);
3559 if (u
->cgroup_path
&&
3560 (c
->kill_mode
== KILL_CONTROL_GROUP
|| (c
->kill_mode
== KILL_MIXED
&& k
== KILL_KILL
))) {
3561 _cleanup_set_free_ Set
*pid_set
= NULL
;
3563 /* Exclude the main/control pids from being killed via the cgroup */
3564 pid_set
= unit_pid_set(main_pid
, control_pid
);
3568 r
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, sig
, true, k
!= KILL_TERMINATE
, false, pid_set
);
3570 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
3571 log_unit_warning_errno(u
, r
, "Failed to kill control group %s, ignoring: %m", u
->cgroup_path
);
3575 /* FIXME: For now, on the legacy hierarchy, we
3576 * will not wait for the cgroup members to die
3577 * if we are running in a container or if this
3578 * is a delegation unit, simply because cgroup
3579 * notification is unreliable in these
3580 * cases. It doesn't work at all in
3581 * containers, and outside of containers it
3582 * can be confused easily by left-over
3583 * directories in the cgroup -- which however
3584 * should not exist in non-delegated units. On
3585 * the unified hierarchy that's different,
3586 * there we get proper events. Hence rely on
3589 if (cg_unified() > 0 ||
3590 (detect_container() == 0 && !unit_cgroup_delegate(u
)))
3591 wait_for_exit
= true;
3593 if (c
->send_sighup
&& k
!= KILL_KILL
) {
3596 pid_set
= unit_pid_set(main_pid
, control_pid
);
3600 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, SIGHUP
, false, true, false, pid_set
);
3605 return wait_for_exit
;
3608 int unit_require_mounts_for(Unit
*u
, const char *path
) {
3609 char prefix
[strlen(path
) + 1], *p
;
3615 /* Registers a unit for requiring a certain path and all its
3616 * prefixes. We keep a simple array of these paths in the
3617 * unit, since its usually short. However, we build a prefix
3618 * table for all possible prefixes so that new appearing mount
3619 * units can easily determine which units to make themselves a
3622 if (!path_is_absolute(path
))
3629 path_kill_slashes(p
);
3631 if (!path_is_safe(p
)) {
3636 if (strv_contains(u
->requires_mounts_for
, p
)) {
3641 r
= strv_consume(&u
->requires_mounts_for
, p
);
3645 PATH_FOREACH_PREFIX_MORE(prefix
, p
) {
3648 x
= hashmap_get(u
->manager
->units_requiring_mounts_for
, prefix
);
3652 r
= hashmap_ensure_allocated(&u
->manager
->units_requiring_mounts_for
, &string_hash_ops
);
3666 r
= hashmap_put(u
->manager
->units_requiring_mounts_for
, q
, x
);
3682 int unit_setup_exec_runtime(Unit
*u
) {
3688 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3691 /* Check if there already is an ExecRuntime for this unit? */
3692 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
3696 /* Try to get it from somebody else */
3697 SET_FOREACH(other
, u
->dependencies
[UNIT_JOINS_NAMESPACE_OF
], i
) {
3699 *rt
= unit_get_exec_runtime(other
);
3701 exec_runtime_ref(*rt
);
3706 return exec_runtime_make(rt
, unit_get_exec_context(u
), u
->id
);
3709 bool unit_type_supported(UnitType t
) {
3710 if (_unlikely_(t
< 0))
3712 if (_unlikely_(t
>= _UNIT_TYPE_MAX
))
3715 if (!unit_vtable
[t
]->supported
)
3718 return unit_vtable
[t
]->supported();
3721 void unit_warn_if_dir_nonempty(Unit
*u
, const char* where
) {
3727 r
= dir_is_empty(where
);
3731 log_unit_warning_errno(u
, r
, "Failed to check directory %s: %m", where
);
3735 log_struct(LOG_NOTICE
,
3736 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3738 LOG_UNIT_MESSAGE(u
, "Directory %s to mount over is not empty, mounting anyway.", where
),
3743 int unit_fail_if_symlink(Unit
*u
, const char* where
) {
3749 r
= is_symlink(where
);
3751 log_unit_debug_errno(u
, r
, "Failed to check symlink %s, ignoring: %m", where
);
3758 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3760 LOG_UNIT_MESSAGE(u
, "Mount on symlink %s not allowed.", where
),
3767 bool unit_is_pristine(Unit
*u
) {
3770 /* Check if the unit already exists or is already around,
3771 * in a number of different ways. Note that to cater for unit
3772 * types such as slice, we are generally fine with units that
3773 * are marked UNIT_LOADED even even though nothing was
3774 * actually loaded, as those unit types don't require a file
3775 * on disk to validly load. */
3777 return !(!IN_SET(u
->load_state
, UNIT_NOT_FOUND
, UNIT_LOADED
) ||
3780 !strv_isempty(u
->dropin_paths
) ||