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"
31 #include "alloc-util.h"
32 #include "bus-common-errors.h"
34 #include "cgroup-util.h"
35 #include "dbus-unit.h"
40 #include "fileio-label.h"
41 #include "formats-util.h"
42 #include "load-dropin.h"
43 #include "load-fragment.h"
48 #include "parse-util.h"
49 #include "path-util.h"
50 #include "process-util.h"
53 #include "stat-util.h"
54 #include "string-util.h"
56 #include "unit-name.h"
58 #include "user-util.h"
61 const UnitVTable
* const unit_vtable
[_UNIT_TYPE_MAX
] = {
62 [UNIT_SERVICE
] = &service_vtable
,
63 [UNIT_SOCKET
] = &socket_vtable
,
64 [UNIT_BUSNAME
] = &busname_vtable
,
65 [UNIT_TARGET
] = &target_vtable
,
66 [UNIT_DEVICE
] = &device_vtable
,
67 [UNIT_MOUNT
] = &mount_vtable
,
68 [UNIT_AUTOMOUNT
] = &automount_vtable
,
69 [UNIT_SWAP
] = &swap_vtable
,
70 [UNIT_TIMER
] = &timer_vtable
,
71 [UNIT_PATH
] = &path_vtable
,
72 [UNIT_SLICE
] = &slice_vtable
,
73 [UNIT_SCOPE
] = &scope_vtable
76 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
);
78 Unit
*unit_new(Manager
*m
, size_t size
) {
82 assert(size
>= sizeof(Unit
));
88 u
->names
= set_new(&string_hash_ops
);
95 u
->type
= _UNIT_TYPE_INVALID
;
96 u
->default_dependencies
= true;
97 u
->unit_file_state
= _UNIT_FILE_STATE_INVALID
;
98 u
->unit_file_preset
= -1;
99 u
->on_failure_job_mode
= JOB_REPLACE
;
100 u
->cgroup_inotify_wd
= -1;
102 RATELIMIT_INIT(u
->auto_stop_ratelimit
, 10 * USEC_PER_SEC
, 16);
107 bool unit_has_name(Unit
*u
, const char *name
) {
111 return !!set_get(u
->names
, (char*) name
);
114 static void unit_init(Unit
*u
) {
121 assert(u
->type
>= 0);
123 cc
= unit_get_cgroup_context(u
);
125 cgroup_context_init(cc
);
127 /* Copy in the manager defaults into the cgroup
128 * context, _before_ the rest of the settings have
129 * been initialized */
131 cc
->cpu_accounting
= u
->manager
->default_cpu_accounting
;
132 cc
->blockio_accounting
= u
->manager
->default_blockio_accounting
;
133 cc
->memory_accounting
= u
->manager
->default_memory_accounting
;
134 cc
->tasks_accounting
= u
->manager
->default_tasks_accounting
;
136 if (u
->type
!= UNIT_SLICE
)
137 cc
->tasks_max
= u
->manager
->default_tasks_max
;
140 ec
= unit_get_exec_context(u
);
142 exec_context_init(ec
);
144 kc
= unit_get_kill_context(u
);
146 kill_context_init(kc
);
148 if (UNIT_VTABLE(u
)->init
)
149 UNIT_VTABLE(u
)->init(u
);
152 int unit_add_name(Unit
*u
, const char *text
) {
153 _cleanup_free_
char *s
= NULL
, *i
= NULL
;
160 if (unit_name_is_valid(text
, UNIT_NAME_TEMPLATE
)) {
165 r
= unit_name_replace_instance(text
, u
->instance
, &s
);
174 if (set_contains(u
->names
, s
))
176 if (hashmap_contains(u
->manager
->units
, s
))
179 if (!unit_name_is_valid(s
, UNIT_NAME_PLAIN
|UNIT_NAME_INSTANCE
))
182 t
= unit_name_to_type(s
);
186 if (u
->type
!= _UNIT_TYPE_INVALID
&& t
!= u
->type
)
189 r
= unit_name_to_instance(s
, &i
);
193 if (i
&& unit_vtable
[t
]->no_instances
)
196 /* Ensure that this unit is either instanced or not instanced,
197 * but not both. Note that we do allow names with different
198 * instance names however! */
199 if (u
->type
!= _UNIT_TYPE_INVALID
&& !u
->instance
!= !i
)
202 if (unit_vtable
[t
]->no_alias
&& !set_isempty(u
->names
))
205 if (hashmap_size(u
->manager
->units
) >= MANAGER_MAX_NAMES
)
208 r
= set_put(u
->names
, s
);
213 r
= hashmap_put(u
->manager
->units
, s
, u
);
215 (void) set_remove(u
->names
, s
);
219 if (u
->type
== _UNIT_TYPE_INVALID
) {
224 LIST_PREPEND(units_by_type
, u
->manager
->units_by_type
[t
], u
);
233 unit_add_to_dbus_queue(u
);
237 int unit_choose_id(Unit
*u
, const char *name
) {
238 _cleanup_free_
char *t
= NULL
;
245 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
250 r
= unit_name_replace_instance(name
, u
->instance
, &t
);
257 /* Selects one of the names of this unit as the id */
258 s
= set_get(u
->names
, (char*) name
);
262 /* Determine the new instance from the new id */
263 r
= unit_name_to_instance(s
, &i
);
272 unit_add_to_dbus_queue(u
);
277 int unit_set_description(Unit
*u
, const char *description
) {
282 if (isempty(description
))
285 s
= strdup(description
);
290 free(u
->description
);
293 unit_add_to_dbus_queue(u
);
297 bool unit_check_gc(Unit
*u
) {
298 UnitActiveState state
;
307 state
= unit_active_state(u
);
309 /* If the unit is inactive and failed and no job is queued for
310 * it, then release its runtime resources */
311 if (UNIT_IS_INACTIVE_OR_FAILED(state
) &&
312 UNIT_VTABLE(u
)->release_resources
)
313 UNIT_VTABLE(u
)->release_resources(u
);
315 /* But we keep the unit object around for longer when it is
316 * referenced or configured to not be gc'ed */
317 if (state
!= UNIT_INACTIVE
)
326 if (UNIT_VTABLE(u
)->check_gc
)
327 if (UNIT_VTABLE(u
)->check_gc(u
))
333 void unit_add_to_load_queue(Unit
*u
) {
335 assert(u
->type
!= _UNIT_TYPE_INVALID
);
337 if (u
->load_state
!= UNIT_STUB
|| u
->in_load_queue
)
340 LIST_PREPEND(load_queue
, u
->manager
->load_queue
, u
);
341 u
->in_load_queue
= true;
344 void unit_add_to_cleanup_queue(Unit
*u
) {
347 if (u
->in_cleanup_queue
)
350 LIST_PREPEND(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
351 u
->in_cleanup_queue
= true;
354 void unit_add_to_gc_queue(Unit
*u
) {
357 if (u
->in_gc_queue
|| u
->in_cleanup_queue
)
360 if (unit_check_gc(u
))
363 LIST_PREPEND(gc_queue
, u
->manager
->gc_queue
, u
);
364 u
->in_gc_queue
= true;
366 u
->manager
->n_in_gc_queue
++;
369 void unit_add_to_dbus_queue(Unit
*u
) {
371 assert(u
->type
!= _UNIT_TYPE_INVALID
);
373 if (u
->load_state
== UNIT_STUB
|| u
->in_dbus_queue
)
376 /* Shortcut things if nobody cares */
377 if (sd_bus_track_count(u
->manager
->subscribed
) <= 0 &&
378 set_isempty(u
->manager
->private_buses
)) {
379 u
->sent_dbus_new_signal
= true;
383 LIST_PREPEND(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
384 u
->in_dbus_queue
= true;
387 static void bidi_set_free(Unit
*u
, Set
*s
) {
393 /* Frees the set and makes sure we are dropped from the
394 * inverse pointers */
396 SET_FOREACH(other
, s
, i
) {
399 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
400 set_remove(other
->dependencies
[d
], u
);
402 unit_add_to_gc_queue(other
);
408 static void unit_remove_transient(Unit
*u
) {
416 if (u
->fragment_path
)
417 (void) unlink(u
->fragment_path
);
419 STRV_FOREACH(i
, u
->dropin_paths
) {
420 _cleanup_free_
char *p
= NULL
;
424 p
= dirname_malloc(*i
);
430 static void unit_free_requires_mounts_for(Unit
*u
) {
433 STRV_FOREACH(j
, u
->requires_mounts_for
) {
434 char s
[strlen(*j
) + 1];
436 PATH_FOREACH_PREFIX_MORE(s
, *j
) {
440 x
= hashmap_get2(u
->manager
->units_requiring_mounts_for
, s
, (void**) &y
);
446 if (set_isempty(x
)) {
447 hashmap_remove(u
->manager
->units_requiring_mounts_for
, y
);
454 u
->requires_mounts_for
= strv_free(u
->requires_mounts_for
);
457 static void unit_done(Unit
*u
) {
467 if (UNIT_VTABLE(u
)->done
)
468 UNIT_VTABLE(u
)->done(u
);
470 ec
= unit_get_exec_context(u
);
472 exec_context_done(ec
);
474 cc
= unit_get_cgroup_context(u
);
476 cgroup_context_done(cc
);
478 r
= unit_remove_from_netclass_cgroup(u
);
480 log_warning_errno(r
, "Unable to remove unit from netclass group: %m");
483 void unit_free(Unit
*u
) {
490 if (u
->manager
->n_reloading
<= 0)
491 unit_remove_transient(u
);
493 bus_unit_send_removed_signal(u
);
497 sd_bus_slot_unref(u
->match_bus_slot
);
499 unit_free_requires_mounts_for(u
);
501 SET_FOREACH(t
, u
->names
, i
)
502 hashmap_remove_value(u
->manager
->units
, t
, u
);
516 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
517 bidi_set_free(u
, u
->dependencies
[d
]);
519 if (u
->type
!= _UNIT_TYPE_INVALID
)
520 LIST_REMOVE(units_by_type
, u
->manager
->units_by_type
[u
->type
], u
);
522 if (u
->in_load_queue
)
523 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
525 if (u
->in_dbus_queue
)
526 LIST_REMOVE(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
528 if (u
->in_cleanup_queue
)
529 LIST_REMOVE(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
531 if (u
->in_gc_queue
) {
532 LIST_REMOVE(gc_queue
, u
->manager
->gc_queue
, u
);
533 u
->manager
->n_in_gc_queue
--;
536 if (u
->in_cgroup_queue
)
537 LIST_REMOVE(cgroup_queue
, u
->manager
->cgroup_queue
, u
);
539 unit_release_cgroup(u
);
541 (void) manager_update_failed_units(u
->manager
, u
, false);
542 set_remove(u
->manager
->startup_units
, u
);
544 free(u
->description
);
545 strv_free(u
->documentation
);
546 free(u
->fragment_path
);
547 free(u
->source_path
);
548 strv_free(u
->dropin_paths
);
551 free(u
->job_timeout_reboot_arg
);
553 set_free_free(u
->names
);
555 unit_unwatch_all_pids(u
);
557 condition_free_list(u
->conditions
);
558 condition_free_list(u
->asserts
);
560 unit_ref_unset(&u
->slice
);
563 unit_ref_unset(u
->refs
);
568 UnitActiveState
unit_active_state(Unit
*u
) {
571 if (u
->load_state
== UNIT_MERGED
)
572 return unit_active_state(unit_follow_merge(u
));
574 /* After a reload it might happen that a unit is not correctly
575 * loaded but still has a process around. That's why we won't
576 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
578 return UNIT_VTABLE(u
)->active_state(u
);
581 const char* unit_sub_state_to_string(Unit
*u
) {
584 return UNIT_VTABLE(u
)->sub_state_to_string(u
);
587 static int complete_move(Set
**s
, Set
**other
) {
597 r
= set_move(*s
, *other
);
608 static int merge_names(Unit
*u
, Unit
*other
) {
616 r
= complete_move(&u
->names
, &other
->names
);
620 set_free_free(other
->names
);
624 SET_FOREACH(t
, u
->names
, i
)
625 assert_se(hashmap_replace(u
->manager
->units
, t
, u
) == 0);
630 static int reserve_dependencies(Unit
*u
, Unit
*other
, UnitDependency d
) {
635 assert(d
< _UNIT_DEPENDENCY_MAX
);
638 * If u does not have this dependency set allocated, there is no need
639 * to reserve anything. In that case other's set will be transferred
640 * as a whole to u by complete_move().
642 if (!u
->dependencies
[d
])
645 /* merge_dependencies() will skip a u-on-u dependency */
646 n_reserve
= set_size(other
->dependencies
[d
]) - !!set_get(other
->dependencies
[d
], u
);
648 return set_reserve(u
->dependencies
[d
], n_reserve
);
651 static void merge_dependencies(Unit
*u
, Unit
*other
, const char *other_id
, UnitDependency d
) {
658 assert(d
< _UNIT_DEPENDENCY_MAX
);
660 /* Fix backwards pointers */
661 SET_FOREACH(back
, other
->dependencies
[d
], i
) {
664 for (k
= 0; k
< _UNIT_DEPENDENCY_MAX
; k
++) {
665 /* Do not add dependencies between u and itself */
667 if (set_remove(back
->dependencies
[k
], other
))
668 maybe_warn_about_dependency(u
, other_id
, k
);
670 r
= set_remove_and_put(back
->dependencies
[k
], other
, u
);
672 set_remove(back
->dependencies
[k
], other
);
674 assert(r
>= 0 || r
== -ENOENT
);
679 /* Also do not move dependencies on u to itself */
680 back
= set_remove(other
->dependencies
[d
], u
);
682 maybe_warn_about_dependency(u
, other_id
, d
);
684 /* The move cannot fail. The caller must have performed a reservation. */
685 assert_se(complete_move(&u
->dependencies
[d
], &other
->dependencies
[d
]) == 0);
687 other
->dependencies
[d
] = set_free(other
->dependencies
[d
]);
690 int unit_merge(Unit
*u
, Unit
*other
) {
692 const char *other_id
= NULL
;
697 assert(u
->manager
== other
->manager
);
698 assert(u
->type
!= _UNIT_TYPE_INVALID
);
700 other
= unit_follow_merge(other
);
705 if (u
->type
!= other
->type
)
708 if (!u
->instance
!= !other
->instance
)
711 if (other
->load_state
!= UNIT_STUB
&&
712 other
->load_state
!= UNIT_NOT_FOUND
)
721 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
725 other_id
= strdupa(other
->id
);
727 /* Make reservations to ensure merge_dependencies() won't fail */
728 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
729 r
= reserve_dependencies(u
, other
, d
);
731 * We don't rollback reservations if we fail. We don't have
732 * a way to undo reservations. A reservation is not a leak.
739 r
= merge_names(u
, other
);
743 /* Redirect all references */
745 unit_ref_set(other
->refs
, u
);
747 /* Merge dependencies */
748 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
749 merge_dependencies(u
, other
, other_id
, d
);
751 other
->load_state
= UNIT_MERGED
;
752 other
->merged_into
= u
;
754 /* If there is still some data attached to the other node, we
755 * don't need it anymore, and can free it. */
756 if (other
->load_state
!= UNIT_STUB
)
757 if (UNIT_VTABLE(other
)->done
)
758 UNIT_VTABLE(other
)->done(other
);
760 unit_add_to_dbus_queue(u
);
761 unit_add_to_cleanup_queue(other
);
766 int unit_merge_by_name(Unit
*u
, const char *name
) {
769 _cleanup_free_
char *s
= NULL
;
774 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
778 r
= unit_name_replace_instance(name
, u
->instance
, &s
);
785 other
= manager_get_unit(u
->manager
, name
);
787 return unit_merge(u
, other
);
789 return unit_add_name(u
, name
);
792 Unit
* unit_follow_merge(Unit
*u
) {
795 while (u
->load_state
== UNIT_MERGED
)
796 assert_se(u
= u
->merged_into
);
801 int unit_add_exec_dependencies(Unit
*u
, ExecContext
*c
) {
807 if (c
->working_directory
) {
808 r
= unit_require_mounts_for(u
, c
->working_directory
);
813 if (c
->root_directory
) {
814 r
= unit_require_mounts_for(u
, c
->root_directory
);
819 if (u
->manager
->running_as
!= MANAGER_SYSTEM
)
822 if (c
->private_tmp
) {
823 r
= unit_require_mounts_for(u
, "/tmp");
827 r
= unit_require_mounts_for(u
, "/var/tmp");
832 if (c
->std_output
!= EXEC_OUTPUT_KMSG
&&
833 c
->std_output
!= EXEC_OUTPUT_SYSLOG
&&
834 c
->std_output
!= EXEC_OUTPUT_JOURNAL
&&
835 c
->std_output
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
836 c
->std_output
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
&&
837 c
->std_output
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
838 c
->std_error
!= EXEC_OUTPUT_KMSG
&&
839 c
->std_error
!= EXEC_OUTPUT_SYSLOG
&&
840 c
->std_error
!= EXEC_OUTPUT_JOURNAL
&&
841 c
->std_error
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
842 c
->std_error
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
843 c
->std_error
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
)
846 /* If syslog or kernel logging is requested, make sure our own
847 * logging daemon is run first. */
849 r
= unit_add_dependency_by_name(u
, UNIT_AFTER
, SPECIAL_JOURNALD_SOCKET
, NULL
, true);
856 const char *unit_description(Unit
*u
) {
860 return u
->description
;
865 void unit_dump(Unit
*u
, FILE *f
, const char *prefix
) {
871 timestamp1
[FORMAT_TIMESTAMP_MAX
],
872 timestamp2
[FORMAT_TIMESTAMP_MAX
],
873 timestamp3
[FORMAT_TIMESTAMP_MAX
],
874 timestamp4
[FORMAT_TIMESTAMP_MAX
],
875 timespan
[FORMAT_TIMESPAN_MAX
];
877 _cleanup_set_free_ Set
*following_set
= NULL
;
881 assert(u
->type
>= 0);
883 prefix
= strempty(prefix
);
884 prefix2
= strjoina(prefix
, "\t");
888 "%s\tDescription: %s\n"
890 "%s\tUnit Load State: %s\n"
891 "%s\tUnit Active State: %s\n"
892 "%s\tInactive Exit Timestamp: %s\n"
893 "%s\tActive Enter Timestamp: %s\n"
894 "%s\tActive Exit Timestamp: %s\n"
895 "%s\tInactive Enter Timestamp: %s\n"
896 "%s\tGC Check Good: %s\n"
897 "%s\tNeed Daemon Reload: %s\n"
898 "%s\tTransient: %s\n"
901 "%s\tCGroup realized: %s\n"
902 "%s\tCGroup mask: 0x%x\n"
903 "%s\tCGroup members mask: 0x%x\n",
905 prefix
, unit_description(u
),
906 prefix
, strna(u
->instance
),
907 prefix
, unit_load_state_to_string(u
->load_state
),
908 prefix
, unit_active_state_to_string(unit_active_state(u
)),
909 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->inactive_exit_timestamp
.realtime
)),
910 prefix
, strna(format_timestamp(timestamp2
, sizeof(timestamp2
), u
->active_enter_timestamp
.realtime
)),
911 prefix
, strna(format_timestamp(timestamp3
, sizeof(timestamp3
), u
->active_exit_timestamp
.realtime
)),
912 prefix
, strna(format_timestamp(timestamp4
, sizeof(timestamp4
), u
->inactive_enter_timestamp
.realtime
)),
913 prefix
, yes_no(unit_check_gc(u
)),
914 prefix
, yes_no(unit_need_daemon_reload(u
)),
915 prefix
, yes_no(u
->transient
),
916 prefix
, strna(unit_slice_name(u
)),
917 prefix
, strna(u
->cgroup_path
),
918 prefix
, yes_no(u
->cgroup_realized
),
919 prefix
, u
->cgroup_realized_mask
,
920 prefix
, u
->cgroup_members_mask
);
922 SET_FOREACH(t
, u
->names
, i
)
923 fprintf(f
, "%s\tName: %s\n", prefix
, t
);
925 STRV_FOREACH(j
, u
->documentation
)
926 fprintf(f
, "%s\tDocumentation: %s\n", prefix
, *j
);
928 following
= unit_following(u
);
930 fprintf(f
, "%s\tFollowing: %s\n", prefix
, following
->id
);
932 r
= unit_following_set(u
, &following_set
);
936 SET_FOREACH(other
, following_set
, i
)
937 fprintf(f
, "%s\tFollowing Set Member: %s\n", prefix
, other
->id
);
940 if (u
->fragment_path
)
941 fprintf(f
, "%s\tFragment Path: %s\n", prefix
, u
->fragment_path
);
944 fprintf(f
, "%s\tSource Path: %s\n", prefix
, u
->source_path
);
946 STRV_FOREACH(j
, u
->dropin_paths
)
947 fprintf(f
, "%s\tDropIn Path: %s\n", prefix
, *j
);
949 if (u
->job_timeout
> 0)
950 fprintf(f
, "%s\tJob Timeout: %s\n", prefix
, format_timespan(timespan
, sizeof(timespan
), u
->job_timeout
, 0));
952 if (u
->job_timeout_action
!= FAILURE_ACTION_NONE
)
953 fprintf(f
, "%s\tJob Timeout Action: %s\n", prefix
, failure_action_to_string(u
->job_timeout_action
));
955 if (u
->job_timeout_reboot_arg
)
956 fprintf(f
, "%s\tJob Timeout Reboot Argument: %s\n", prefix
, u
->job_timeout_reboot_arg
);
958 condition_dump_list(u
->conditions
, f
, prefix
, condition_type_to_string
);
959 condition_dump_list(u
->asserts
, f
, prefix
, assert_type_to_string
);
961 if (dual_timestamp_is_set(&u
->condition_timestamp
))
963 "%s\tCondition Timestamp: %s\n"
964 "%s\tCondition Result: %s\n",
965 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->condition_timestamp
.realtime
)),
966 prefix
, yes_no(u
->condition_result
));
968 if (dual_timestamp_is_set(&u
->assert_timestamp
))
970 "%s\tAssert Timestamp: %s\n"
971 "%s\tAssert Result: %s\n",
972 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->assert_timestamp
.realtime
)),
973 prefix
, yes_no(u
->assert_result
));
975 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
978 SET_FOREACH(other
, u
->dependencies
[d
], i
)
979 fprintf(f
, "%s\t%s: %s\n", prefix
, unit_dependency_to_string(d
), other
->id
);
982 if (!strv_isempty(u
->requires_mounts_for
)) {
984 "%s\tRequiresMountsFor:", prefix
);
986 STRV_FOREACH(j
, u
->requires_mounts_for
)
987 fprintf(f
, " %s", *j
);
992 if (u
->load_state
== UNIT_LOADED
) {
995 "%s\tStopWhenUnneeded: %s\n"
996 "%s\tRefuseManualStart: %s\n"
997 "%s\tRefuseManualStop: %s\n"
998 "%s\tDefaultDependencies: %s\n"
999 "%s\tOnFailureJobMode: %s\n"
1000 "%s\tIgnoreOnIsolate: %s\n",
1001 prefix
, yes_no(u
->stop_when_unneeded
),
1002 prefix
, yes_no(u
->refuse_manual_start
),
1003 prefix
, yes_no(u
->refuse_manual_stop
),
1004 prefix
, yes_no(u
->default_dependencies
),
1005 prefix
, job_mode_to_string(u
->on_failure_job_mode
),
1006 prefix
, yes_no(u
->ignore_on_isolate
));
1008 if (UNIT_VTABLE(u
)->dump
)
1009 UNIT_VTABLE(u
)->dump(u
, f
, prefix2
);
1011 } else if (u
->load_state
== UNIT_MERGED
)
1013 "%s\tMerged into: %s\n",
1014 prefix
, u
->merged_into
->id
);
1015 else if (u
->load_state
== UNIT_ERROR
)
1016 fprintf(f
, "%s\tLoad Error Code: %s\n", prefix
, strerror(-u
->load_error
));
1020 job_dump(u
->job
, f
, prefix2
);
1023 job_dump(u
->nop_job
, f
, prefix2
);
1027 /* Common implementation for multiple backends */
1028 int unit_load_fragment_and_dropin(Unit
*u
) {
1033 /* Load a .{service,socket,...} file */
1034 r
= unit_load_fragment(u
);
1038 if (u
->load_state
== UNIT_STUB
)
1041 /* Load drop-in directory data */
1042 r
= unit_load_dropin(unit_follow_merge(u
));
1049 /* Common implementation for multiple backends */
1050 int unit_load_fragment_and_dropin_optional(Unit
*u
) {
1055 /* Same as unit_load_fragment_and_dropin(), but whether
1056 * something can be loaded or not doesn't matter. */
1058 /* Load a .service file */
1059 r
= unit_load_fragment(u
);
1063 if (u
->load_state
== UNIT_STUB
)
1064 u
->load_state
= UNIT_LOADED
;
1066 /* Load drop-in directory data */
1067 r
= unit_load_dropin(unit_follow_merge(u
));
1074 int unit_add_default_target_dependency(Unit
*u
, Unit
*target
) {
1078 if (target
->type
!= UNIT_TARGET
)
1081 /* Only add the dependency if both units are loaded, so that
1082 * that loop check below is reliable */
1083 if (u
->load_state
!= UNIT_LOADED
||
1084 target
->load_state
!= UNIT_LOADED
)
1087 /* If either side wants no automatic dependencies, then let's
1089 if (!u
->default_dependencies
||
1090 !target
->default_dependencies
)
1093 /* Don't create loops */
1094 if (set_get(target
->dependencies
[UNIT_BEFORE
], u
))
1097 return unit_add_dependency(target
, UNIT_AFTER
, u
, true);
1100 static int unit_add_target_dependencies(Unit
*u
) {
1102 static const UnitDependency deps
[] = {
1116 for (k
= 0; k
< ELEMENTSOF(deps
); k
++)
1117 SET_FOREACH(target
, u
->dependencies
[deps
[k
]], i
) {
1118 r
= unit_add_default_target_dependency(u
, target
);
1126 static int unit_add_slice_dependencies(Unit
*u
) {
1129 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
1132 if (UNIT_ISSET(u
->slice
))
1133 return unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_REQUIRES
, UNIT_DEREF(u
->slice
), true);
1135 if (unit_has_name(u
, SPECIAL_ROOT_SLICE
))
1138 return unit_add_two_dependencies_by_name(u
, UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_ROOT_SLICE
, NULL
, true);
1141 static int unit_add_mount_dependencies(Unit
*u
) {
1147 STRV_FOREACH(i
, u
->requires_mounts_for
) {
1148 char prefix
[strlen(*i
) + 1];
1150 PATH_FOREACH_PREFIX_MORE(prefix
, *i
) {
1151 _cleanup_free_
char *p
= NULL
;
1154 r
= unit_name_from_path(prefix
, ".mount", &p
);
1158 m
= manager_get_unit(u
->manager
, p
);
1160 /* Make sure to load the mount unit if
1161 * it exists. If so the dependencies
1162 * on this unit will be added later
1163 * during the loading of the mount
1165 (void) manager_load_unit_prepare(u
->manager
, p
, NULL
, NULL
, &m
);
1171 if (m
->load_state
!= UNIT_LOADED
)
1174 r
= unit_add_dependency(u
, UNIT_AFTER
, m
, true);
1178 if (m
->fragment_path
) {
1179 r
= unit_add_dependency(u
, UNIT_REQUIRES
, m
, true);
1189 static int unit_add_startup_units(Unit
*u
) {
1193 c
= unit_get_cgroup_context(u
);
1197 if (c
->startup_cpu_shares
== CGROUP_CPU_SHARES_INVALID
&&
1198 c
->startup_blockio_weight
== CGROUP_BLKIO_WEIGHT_INVALID
)
1201 r
= set_ensure_allocated(&u
->manager
->startup_units
, NULL
);
1205 return set_put(u
->manager
->startup_units
, u
);
1208 int unit_load(Unit
*u
) {
1213 if (u
->in_load_queue
) {
1214 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
1215 u
->in_load_queue
= false;
1218 if (u
->type
== _UNIT_TYPE_INVALID
)
1221 if (u
->load_state
!= UNIT_STUB
)
1224 if (UNIT_VTABLE(u
)->load
) {
1225 r
= UNIT_VTABLE(u
)->load(u
);
1230 if (u
->load_state
== UNIT_STUB
) {
1235 if (u
->load_state
== UNIT_LOADED
) {
1237 r
= unit_add_target_dependencies(u
);
1241 r
= unit_add_slice_dependencies(u
);
1245 r
= unit_add_mount_dependencies(u
);
1249 r
= unit_add_startup_units(u
);
1253 if (u
->on_failure_job_mode
== JOB_ISOLATE
&& set_size(u
->dependencies
[UNIT_ON_FAILURE
]) > 1) {
1254 log_unit_error(u
, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1259 unit_update_cgroup_members_masks(u
);
1261 /* If we are reloading, we need to wait for the deserializer
1262 * to restore the net_cls ids that have been set previously */
1263 if (u
->manager
->n_reloading
<= 0) {
1264 r
= unit_add_to_netclass_cgroup(u
);
1270 assert((u
->load_state
!= UNIT_MERGED
) == !u
->merged_into
);
1272 unit_add_to_dbus_queue(unit_follow_merge(u
));
1273 unit_add_to_gc_queue(u
);
1278 u
->load_state
= u
->load_state
== UNIT_STUB
? UNIT_NOT_FOUND
: UNIT_ERROR
;
1280 unit_add_to_dbus_queue(u
);
1281 unit_add_to_gc_queue(u
);
1283 log_unit_debug_errno(u
, r
, "Failed to load configuration: %m");
1288 static bool unit_condition_test_list(Unit
*u
, Condition
*first
, const char *(*to_string
)(ConditionType t
)) {
1295 /* If the condition list is empty, then it is true */
1299 /* Otherwise, if all of the non-trigger conditions apply and
1300 * if any of the trigger conditions apply (unless there are
1301 * none) we return true */
1302 LIST_FOREACH(conditions
, c
, first
) {
1305 r
= condition_test(c
);
1308 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1310 c
->trigger
? "|" : "",
1311 c
->negate
? "!" : "",
1317 c
->trigger
? "|" : "",
1318 c
->negate
? "!" : "",
1320 condition_result_to_string(c
->result
));
1322 if (!c
->trigger
&& r
<= 0)
1325 if (c
->trigger
&& triggered
<= 0)
1329 return triggered
!= 0;
1332 static bool unit_condition_test(Unit
*u
) {
1335 dual_timestamp_get(&u
->condition_timestamp
);
1336 u
->condition_result
= unit_condition_test_list(u
, u
->conditions
, condition_type_to_string
);
1338 return u
->condition_result
;
1341 static bool unit_assert_test(Unit
*u
) {
1344 dual_timestamp_get(&u
->assert_timestamp
);
1345 u
->assert_result
= unit_condition_test_list(u
, u
->asserts
, assert_type_to_string
);
1347 return u
->assert_result
;
1350 void unit_status_printf(Unit
*u
, const char *status
, const char *unit_status_msg_format
) {
1351 DISABLE_WARNING_FORMAT_NONLITERAL
;
1352 manager_status_printf(u
->manager
, STATUS_TYPE_NORMAL
, status
, unit_status_msg_format
, unit_description(u
));
1356 _pure_
static const char* unit_get_status_message_format(Unit
*u
, JobType t
) {
1358 const UnitStatusMessageFormats
*format_table
;
1361 assert(IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
));
1363 if (t
!= JOB_RELOAD
) {
1364 format_table
= &UNIT_VTABLE(u
)->status_message_formats
;
1366 format
= format_table
->starting_stopping
[t
== JOB_STOP
];
1372 /* Return generic strings */
1374 return "Starting %s.";
1375 else if (t
== JOB_STOP
)
1376 return "Stopping %s.";
1378 return "Reloading %s.";
1381 static void unit_status_print_starting_stopping(Unit
*u
, JobType t
) {
1386 /* Reload status messages have traditionally not been printed to console. */
1387 if (!IN_SET(t
, JOB_START
, JOB_STOP
))
1390 format
= unit_get_status_message_format(u
, t
);
1392 DISABLE_WARNING_FORMAT_NONLITERAL
;
1393 unit_status_printf(u
, "", format
);
1397 static void unit_status_log_starting_stopping_reloading(Unit
*u
, JobType t
) {
1404 if (!IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
))
1407 if (log_on_console())
1410 /* We log status messages for all units and all operations. */
1412 format
= unit_get_status_message_format(u
, t
);
1414 DISABLE_WARNING_FORMAT_NONLITERAL
;
1415 snprintf(buf
, sizeof(buf
), format
, unit_description(u
));
1418 mid
= t
== JOB_START
? SD_MESSAGE_UNIT_STARTING
:
1419 t
== JOB_STOP
? SD_MESSAGE_UNIT_STOPPING
:
1420 SD_MESSAGE_UNIT_RELOADING
;
1422 /* Note that we deliberately use LOG_MESSAGE() instead of
1423 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1424 * closely what is written to screen using the status output,
1425 * which is supposed the highest level, friendliest output
1426 * possible, which means we should avoid the low-level unit
1428 log_struct(LOG_INFO
,
1429 LOG_MESSAGE_ID(mid
),
1431 LOG_MESSAGE("%s", buf
),
1435 void unit_status_emit_starting_stopping_reloading(Unit
*u
, JobType t
) {
1438 assert(t
< _JOB_TYPE_MAX
);
1440 unit_status_log_starting_stopping_reloading(u
, t
);
1441 unit_status_print_starting_stopping(u
, t
);
1445 * -EBADR: This unit type does not support starting.
1446 * -EALREADY: Unit is already started.
1447 * -EAGAIN: An operation is already in progress. Retry later.
1448 * -ECANCELED: Too many requests for now.
1449 * -EPROTO: Assert failed
1451 int unit_start(Unit
*u
) {
1452 UnitActiveState state
;
1457 /* Units that aren't loaded cannot be started */
1458 if (u
->load_state
!= UNIT_LOADED
)
1461 /* If this is already started, then this will succeed. Note
1462 * that this will even succeed if this unit is not startable
1463 * by the user. This is relied on to detect when we need to
1464 * wait for units and when waiting is finished. */
1465 state
= unit_active_state(u
);
1466 if (UNIT_IS_ACTIVE_OR_RELOADING(state
))
1469 /* If the conditions failed, don't do anything at all. If we
1470 * already are activating this call might still be useful to
1471 * speed up activation in case there is some hold-off time,
1472 * but we don't want to recheck the condition in that case. */
1473 if (state
!= UNIT_ACTIVATING
&&
1474 !unit_condition_test(u
)) {
1475 log_unit_debug(u
, "Starting requested but condition failed. Not starting unit.");
1479 /* If the asserts failed, fail the entire job */
1480 if (state
!= UNIT_ACTIVATING
&&
1481 !unit_assert_test(u
)) {
1482 log_unit_notice(u
, "Starting requested but asserts failed.");
1486 /* Units of types that aren't supported cannot be
1487 * started. Note that we do this test only after the condition
1488 * checks, so that we rather return condition check errors
1489 * (which are usually not considered a true failure) than "not
1490 * supported" errors (which are considered a failure).
1492 if (!unit_supported(u
))
1495 /* Forward to the main object, if we aren't it. */
1496 following
= unit_following(u
);
1498 log_unit_debug(u
, "Redirecting start request from %s to %s.", u
->id
, following
->id
);
1499 return unit_start(following
);
1502 /* If it is stopped, but we cannot start it, then fail */
1503 if (!UNIT_VTABLE(u
)->start
)
1506 /* We don't suppress calls to ->start() here when we are
1507 * already starting, to allow this request to be used as a
1508 * "hurry up" call, for example when the unit is in some "auto
1509 * restart" state where it waits for a holdoff timer to elapse
1510 * before it will start again. */
1512 unit_add_to_dbus_queue(u
);
1514 return UNIT_VTABLE(u
)->start(u
);
1517 bool unit_can_start(Unit
*u
) {
1520 if (u
->load_state
!= UNIT_LOADED
)
1523 if (!unit_supported(u
))
1526 return !!UNIT_VTABLE(u
)->start
;
1529 bool unit_can_isolate(Unit
*u
) {
1532 return unit_can_start(u
) &&
1537 * -EBADR: This unit type does not support stopping.
1538 * -EALREADY: Unit is already stopped.
1539 * -EAGAIN: An operation is already in progress. Retry later.
1541 int unit_stop(Unit
*u
) {
1542 UnitActiveState state
;
1547 state
= unit_active_state(u
);
1548 if (UNIT_IS_INACTIVE_OR_FAILED(state
))
1551 following
= unit_following(u
);
1553 log_unit_debug(u
, "Redirecting stop request from %s to %s.", u
->id
, following
->id
);
1554 return unit_stop(following
);
1557 if (!UNIT_VTABLE(u
)->stop
)
1560 unit_add_to_dbus_queue(u
);
1562 return UNIT_VTABLE(u
)->stop(u
);
1566 * -EBADR: This unit type does not support reloading.
1567 * -ENOEXEC: Unit is not started.
1568 * -EAGAIN: An operation is already in progress. Retry later.
1570 int unit_reload(Unit
*u
) {
1571 UnitActiveState state
;
1576 if (u
->load_state
!= UNIT_LOADED
)
1579 if (!unit_can_reload(u
))
1582 state
= unit_active_state(u
);
1583 if (state
== UNIT_RELOADING
)
1586 if (state
!= UNIT_ACTIVE
) {
1587 log_unit_warning(u
, "Unit cannot be reloaded because it is inactive.");
1591 following
= unit_following(u
);
1593 log_unit_debug(u
, "Redirecting reload request from %s to %s.", u
->id
, following
->id
);
1594 return unit_reload(following
);
1597 unit_add_to_dbus_queue(u
);
1599 return UNIT_VTABLE(u
)->reload(u
);
1602 bool unit_can_reload(Unit
*u
) {
1605 if (!UNIT_VTABLE(u
)->reload
)
1608 if (!UNIT_VTABLE(u
)->can_reload
)
1611 return UNIT_VTABLE(u
)->can_reload(u
);
1614 static void unit_check_unneeded(Unit
*u
) {
1616 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1618 static const UnitDependency needed_dependencies
[] = {
1632 /* If this service shall be shut down when unneeded then do
1635 if (!u
->stop_when_unneeded
)
1638 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
1641 for (j
= 0; j
< ELEMENTSOF(needed_dependencies
); j
++)
1642 SET_FOREACH(other
, u
->dependencies
[needed_dependencies
[j
]], i
)
1643 if (unit_active_or_pending(other
))
1646 /* If stopping a unit fails continously we might enter a stop
1647 * loop here, hence stop acting on the service being
1648 * unnecessary after a while. */
1649 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1650 log_unit_warning(u
, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1654 log_unit_info(u
, "Unit not needed anymore. Stopping.");
1656 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1657 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1659 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1662 static void unit_check_binds_to(Unit
*u
) {
1663 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1674 if (unit_active_state(u
) != UNIT_ACTIVE
)
1677 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
) {
1681 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
1691 /* If stopping a unit fails continously we might enter a stop
1692 * loop here, hence stop acting on the service being
1693 * unnecessary after a while. */
1694 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1695 log_unit_warning(u
, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other
->id
);
1700 log_unit_info(u
, "Unit is bound to inactive unit %s. Stopping, too.", other
->id
);
1702 /* A unit we need to run is gone. Sniff. Let's stop this. */
1703 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1705 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1708 static void retroactively_start_dependencies(Unit
*u
) {
1713 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)));
1715 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1716 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1717 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1718 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, NULL
, NULL
);
1720 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1721 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1722 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1723 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, NULL
, NULL
);
1725 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1726 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1727 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1728 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, NULL
, NULL
);
1730 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTS
], i
)
1731 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1732 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1734 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTED_BY
], i
)
1735 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1736 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1739 static void retroactively_stop_dependencies(Unit
*u
) {
1744 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1746 /* Pull down units which are bound to us recursively if enabled */
1747 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1748 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1749 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1752 static void check_unneeded_dependencies(Unit
*u
) {
1757 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1759 /* Garbage collect services that might not be needed anymore, if enabled */
1760 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1761 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1762 unit_check_unneeded(other
);
1763 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1764 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1765 unit_check_unneeded(other
);
1766 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1767 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1768 unit_check_unneeded(other
);
1769 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1770 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1771 unit_check_unneeded(other
);
1774 void unit_start_on_failure(Unit
*u
) {
1780 if (set_size(u
->dependencies
[UNIT_ON_FAILURE
]) <= 0)
1783 log_unit_info(u
, "Triggering OnFailure= dependencies.");
1785 SET_FOREACH(other
, u
->dependencies
[UNIT_ON_FAILURE
], i
) {
1788 r
= manager_add_job(u
->manager
, JOB_START
, other
, u
->on_failure_job_mode
, NULL
, NULL
);
1790 log_unit_error_errno(u
, r
, "Failed to enqueue OnFailure= job: %m");
1794 void unit_trigger_notify(Unit
*u
) {
1800 SET_FOREACH(other
, u
->dependencies
[UNIT_TRIGGERED_BY
], i
)
1801 if (UNIT_VTABLE(other
)->trigger_notify
)
1802 UNIT_VTABLE(other
)->trigger_notify(other
, u
);
1805 void unit_notify(Unit
*u
, UnitActiveState os
, UnitActiveState ns
, bool reload_success
) {
1810 assert(os
< _UNIT_ACTIVE_STATE_MAX
);
1811 assert(ns
< _UNIT_ACTIVE_STATE_MAX
);
1813 /* Note that this is called for all low-level state changes,
1814 * even if they might map to the same high-level
1815 * UnitActiveState! That means that ns == os is an expected
1816 * behavior here. For example: if a mount point is remounted
1817 * this function will be called too! */
1821 /* Update timestamps for state changes */
1822 if (m
->n_reloading
<= 0) {
1825 dual_timestamp_get(&ts
);
1827 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && !UNIT_IS_INACTIVE_OR_FAILED(ns
))
1828 u
->inactive_exit_timestamp
= ts
;
1829 else if (!UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_INACTIVE_OR_FAILED(ns
))
1830 u
->inactive_enter_timestamp
= ts
;
1832 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
) && UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1833 u
->active_enter_timestamp
= ts
;
1834 else if (UNIT_IS_ACTIVE_OR_RELOADING(os
) && !UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1835 u
->active_exit_timestamp
= ts
;
1838 /* Keep track of failed units */
1839 (void) manager_update_failed_units(u
->manager
, u
, ns
== UNIT_FAILED
);
1841 /* Make sure the cgroup is always removed when we become inactive */
1842 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1843 unit_prune_cgroup(u
);
1845 /* Note that this doesn't apply to RemainAfterExit services exiting
1846 * successfully, since there's no change of state in that case. Which is
1847 * why it is handled in service_set_state() */
1848 if (UNIT_IS_INACTIVE_OR_FAILED(os
) != UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1851 ec
= unit_get_exec_context(u
);
1852 if (ec
&& exec_context_may_touch_console(ec
)) {
1853 if (UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1856 if (m
->n_on_console
== 0)
1857 /* unset no_console_output flag, since the console is free */
1858 m
->no_console_output
= false;
1867 if (u
->job
->state
== JOB_WAITING
)
1869 /* So we reached a different state for this
1870 * job. Let's see if we can run it now if it
1871 * failed previously due to EAGAIN. */
1872 job_add_to_run_queue(u
->job
);
1874 /* Let's check whether this state change constitutes a
1875 * finished job, or maybe contradicts a running job and
1876 * hence needs to invalidate jobs. */
1878 switch (u
->job
->type
) {
1881 case JOB_VERIFY_ACTIVE
:
1883 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1884 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1885 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_ACTIVATING
) {
1888 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1889 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1895 case JOB_RELOAD_OR_START
:
1897 if (u
->job
->state
== JOB_RUNNING
) {
1898 if (ns
== UNIT_ACTIVE
)
1899 job_finish_and_invalidate(u
->job
, reload_success
? JOB_DONE
: JOB_FAILED
, true);
1900 else if (ns
!= UNIT_ACTIVATING
&& ns
!= UNIT_RELOADING
) {
1903 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1904 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1912 case JOB_TRY_RESTART
:
1914 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1915 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1916 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_DEACTIVATING
) {
1918 job_finish_and_invalidate(u
->job
, JOB_FAILED
, true);
1924 assert_not_reached("Job type unknown");
1930 if (m
->n_reloading
<= 0) {
1932 /* If this state change happened without being
1933 * requested by a job, then let's retroactively start
1934 * or stop dependencies. We skip that step when
1935 * deserializing, since we don't want to create any
1936 * additional jobs just because something is already
1940 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns
))
1941 retroactively_start_dependencies(u
);
1942 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1943 retroactively_stop_dependencies(u
);
1946 /* stop unneeded units regardless if going down was expected or not */
1947 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1948 check_unneeded_dependencies(u
);
1950 if (ns
!= os
&& ns
== UNIT_FAILED
) {
1951 log_unit_notice(u
, "Unit entered failed state.");
1952 unit_start_on_failure(u
);
1956 /* Some names are special */
1957 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
)) {
1959 if (unit_has_name(u
, SPECIAL_DBUS_SERVICE
))
1960 /* The bus might have just become available,
1961 * hence try to connect to it, if we aren't
1965 if (u
->type
== UNIT_SERVICE
&&
1966 !UNIT_IS_ACTIVE_OR_RELOADING(os
) &&
1967 m
->n_reloading
<= 0) {
1968 /* Write audit record if we have just finished starting up */
1969 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, true);
1973 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
))
1974 manager_send_unit_plymouth(m
, u
);
1978 /* We don't care about D-Bus here, since we'll get an
1979 * asynchronous notification for it anyway. */
1981 if (u
->type
== UNIT_SERVICE
&&
1982 UNIT_IS_INACTIVE_OR_FAILED(ns
) &&
1983 !UNIT_IS_INACTIVE_OR_FAILED(os
) &&
1984 m
->n_reloading
<= 0) {
1986 /* Hmm, if there was no start record written
1987 * write it now, so that we always have a nice
1990 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, ns
== UNIT_INACTIVE
);
1992 if (ns
== UNIT_INACTIVE
)
1993 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, true);
1995 /* Write audit record if we have just finished shutting down */
1996 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, ns
== UNIT_INACTIVE
);
1998 u
->in_audit
= false;
2002 manager_recheck_journal(m
);
2003 unit_trigger_notify(u
);
2005 if (u
->manager
->n_reloading
<= 0) {
2006 /* Maybe we finished startup and are now ready for
2007 * being stopped because unneeded? */
2008 unit_check_unneeded(u
);
2010 /* Maybe we finished startup, but something we needed
2011 * has vanished? Let's die then. (This happens when
2012 * something BindsTo= to a Type=oneshot unit, as these
2013 * units go directly from starting to inactive,
2014 * without ever entering started.) */
2015 unit_check_binds_to(u
);
2018 unit_add_to_dbus_queue(u
);
2019 unit_add_to_gc_queue(u
);
2022 int unit_watch_pid(Unit
*u
, pid_t pid
) {
2028 /* Watch a specific PID. We only support one or two units
2029 * watching each PID for now, not more. */
2031 r
= set_ensure_allocated(&u
->pids
, NULL
);
2035 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids1
, NULL
);
2039 r
= hashmap_put(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2041 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids2
, NULL
);
2045 r
= hashmap_put(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2048 q
= set_put(u
->pids
, PID_TO_PTR(pid
));
2055 void unit_unwatch_pid(Unit
*u
, pid_t pid
) {
2059 (void) hashmap_remove_value(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2060 (void) hashmap_remove_value(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2061 (void) set_remove(u
->pids
, PID_TO_PTR(pid
));
2064 void unit_unwatch_all_pids(Unit
*u
) {
2067 while (!set_isempty(u
->pids
))
2068 unit_unwatch_pid(u
, PTR_TO_PID(set_first(u
->pids
)));
2070 u
->pids
= set_free(u
->pids
);
2073 void unit_tidy_watch_pids(Unit
*u
, pid_t except1
, pid_t except2
) {
2079 /* Cleans dead PIDs from our list */
2081 SET_FOREACH(e
, u
->pids
, i
) {
2082 pid_t pid
= PTR_TO_PID(e
);
2084 if (pid
== except1
|| pid
== except2
)
2087 if (!pid_is_unwaited(pid
))
2088 unit_unwatch_pid(u
, pid
);
2092 bool unit_job_is_applicable(Unit
*u
, JobType j
) {
2094 assert(j
>= 0 && j
< _JOB_TYPE_MAX
);
2098 case JOB_VERIFY_ACTIVE
:
2105 case JOB_TRY_RESTART
:
2106 return unit_can_start(u
);
2109 return unit_can_reload(u
);
2111 case JOB_RELOAD_OR_START
:
2112 return unit_can_reload(u
) && unit_can_start(u
);
2115 assert_not_reached("Invalid job type");
2119 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
) {
2122 /* Only warn about some unit types */
2123 if (!IN_SET(dependency
, UNIT_CONFLICTS
, UNIT_CONFLICTED_BY
, UNIT_BEFORE
, UNIT_AFTER
, UNIT_ON_FAILURE
, UNIT_TRIGGERS
, UNIT_TRIGGERED_BY
))
2126 if (streq_ptr(u
->id
, other
))
2127 log_unit_warning(u
, "Dependency %s=%s dropped", unit_dependency_to_string(dependency
), u
->id
);
2129 log_unit_warning(u
, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency
), strna(other
), u
->id
);
2132 int unit_add_dependency(Unit
*u
, UnitDependency d
, Unit
*other
, bool add_reference
) {
2134 static const UnitDependency inverse_table
[_UNIT_DEPENDENCY_MAX
] = {
2135 [UNIT_REQUIRES
] = UNIT_REQUIRED_BY
,
2136 [UNIT_WANTS
] = UNIT_WANTED_BY
,
2137 [UNIT_REQUISITE
] = UNIT_REQUISITE_OF
,
2138 [UNIT_BINDS_TO
] = UNIT_BOUND_BY
,
2139 [UNIT_PART_OF
] = UNIT_CONSISTS_OF
,
2140 [UNIT_REQUIRED_BY
] = UNIT_REQUIRES
,
2141 [UNIT_REQUISITE_OF
] = UNIT_REQUISITE
,
2142 [UNIT_WANTED_BY
] = UNIT_WANTS
,
2143 [UNIT_BOUND_BY
] = UNIT_BINDS_TO
,
2144 [UNIT_CONSISTS_OF
] = UNIT_PART_OF
,
2145 [UNIT_CONFLICTS
] = UNIT_CONFLICTED_BY
,
2146 [UNIT_CONFLICTED_BY
] = UNIT_CONFLICTS
,
2147 [UNIT_BEFORE
] = UNIT_AFTER
,
2148 [UNIT_AFTER
] = UNIT_BEFORE
,
2149 [UNIT_ON_FAILURE
] = _UNIT_DEPENDENCY_INVALID
,
2150 [UNIT_REFERENCES
] = UNIT_REFERENCED_BY
,
2151 [UNIT_REFERENCED_BY
] = UNIT_REFERENCES
,
2152 [UNIT_TRIGGERS
] = UNIT_TRIGGERED_BY
,
2153 [UNIT_TRIGGERED_BY
] = UNIT_TRIGGERS
,
2154 [UNIT_PROPAGATES_RELOAD_TO
] = UNIT_RELOAD_PROPAGATED_FROM
,
2155 [UNIT_RELOAD_PROPAGATED_FROM
] = UNIT_PROPAGATES_RELOAD_TO
,
2156 [UNIT_JOINS_NAMESPACE_OF
] = UNIT_JOINS_NAMESPACE_OF
,
2158 int r
, q
= 0, v
= 0, w
= 0;
2159 Unit
*orig_u
= u
, *orig_other
= other
;
2162 assert(d
>= 0 && d
< _UNIT_DEPENDENCY_MAX
);
2165 u
= unit_follow_merge(u
);
2166 other
= unit_follow_merge(other
);
2168 /* We won't allow dependencies on ourselves. We will not
2169 * consider them an error however. */
2171 maybe_warn_about_dependency(orig_u
, orig_other
->id
, d
);
2175 r
= set_ensure_allocated(&u
->dependencies
[d
], NULL
);
2179 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
) {
2180 r
= set_ensure_allocated(&other
->dependencies
[inverse_table
[d
]], NULL
);
2185 if (add_reference
) {
2186 r
= set_ensure_allocated(&u
->dependencies
[UNIT_REFERENCES
], NULL
);
2190 r
= set_ensure_allocated(&other
->dependencies
[UNIT_REFERENCED_BY
], NULL
);
2195 q
= set_put(u
->dependencies
[d
], other
);
2199 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
&& inverse_table
[d
] != d
) {
2200 v
= set_put(other
->dependencies
[inverse_table
[d
]], u
);
2207 if (add_reference
) {
2208 w
= set_put(u
->dependencies
[UNIT_REFERENCES
], other
);
2214 r
= set_put(other
->dependencies
[UNIT_REFERENCED_BY
], u
);
2219 unit_add_to_dbus_queue(u
);
2224 set_remove(u
->dependencies
[d
], other
);
2227 set_remove(other
->dependencies
[inverse_table
[d
]], u
);
2230 set_remove(u
->dependencies
[UNIT_REFERENCES
], other
);
2235 int unit_add_two_dependencies(Unit
*u
, UnitDependency d
, UnitDependency e
, Unit
*other
, bool add_reference
) {
2240 r
= unit_add_dependency(u
, d
, other
, add_reference
);
2244 return unit_add_dependency(u
, e
, other
, add_reference
);
2247 static int resolve_template(Unit
*u
, const char *name
, const char*path
, char **buf
, const char **ret
) {
2251 assert(name
|| path
);
2256 name
= basename(path
);
2258 if (!unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
2265 r
= unit_name_replace_instance(name
, u
->instance
, buf
);
2267 _cleanup_free_
char *i
= NULL
;
2269 r
= unit_name_to_prefix(u
->id
, &i
);
2273 r
= unit_name_replace_instance(name
, i
, buf
);
2282 int unit_add_dependency_by_name(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
2283 _cleanup_free_
char *buf
= NULL
;
2288 assert(name
|| path
);
2290 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2294 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2298 return unit_add_dependency(u
, d
, other
, add_reference
);
2301 int unit_add_two_dependencies_by_name(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
2302 _cleanup_free_
char *buf
= NULL
;
2307 assert(name
|| path
);
2309 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2313 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2317 return unit_add_two_dependencies(u
, d
, e
, other
, add_reference
);
2320 int set_unit_path(const char *p
) {
2321 /* This is mostly for debug purposes */
2322 if (setenv("SYSTEMD_UNIT_PATH", p
, 1) < 0)
2328 char *unit_dbus_path(Unit
*u
) {
2334 return unit_dbus_path_from_name(u
->id
);
2337 int unit_set_slice(Unit
*u
, Unit
*slice
) {
2341 /* Sets the unit slice if it has not been set before. Is extra
2342 * careful, to only allow this for units that actually have a
2343 * cgroup context. Also, we don't allow to set this for slices
2344 * (since the parent slice is derived from the name). Make
2345 * sure the unit we set is actually a slice. */
2347 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
2350 if (u
->type
== UNIT_SLICE
)
2353 if (unit_active_state(u
) != UNIT_INACTIVE
)
2356 if (slice
->type
!= UNIT_SLICE
)
2359 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
) &&
2360 !unit_has_name(slice
, SPECIAL_ROOT_SLICE
))
2363 if (UNIT_DEREF(u
->slice
) == slice
)
2366 if (UNIT_ISSET(u
->slice
))
2369 unit_ref_set(&u
->slice
, slice
);
2373 int unit_set_default_slice(Unit
*u
) {
2374 _cleanup_free_
char *b
= NULL
;
2375 const char *slice_name
;
2381 if (UNIT_ISSET(u
->slice
))
2385 _cleanup_free_
char *prefix
= NULL
, *escaped
= NULL
;
2387 /* Implicitly place all instantiated units in their
2388 * own per-template slice */
2390 r
= unit_name_to_prefix(u
->id
, &prefix
);
2394 /* The prefix is already escaped, but it might include
2395 * "-" which has a special meaning for slice units,
2396 * hence escape it here extra. */
2397 escaped
= unit_name_escape(prefix
);
2401 if (u
->manager
->running_as
== MANAGER_SYSTEM
)
2402 b
= strjoin("system-", escaped
, ".slice", NULL
);
2404 b
= strappend(escaped
, ".slice");
2411 u
->manager
->running_as
== MANAGER_SYSTEM
&& !unit_has_name(u
, SPECIAL_INIT_SCOPE
)
2412 ? SPECIAL_SYSTEM_SLICE
2413 : SPECIAL_ROOT_SLICE
;
2415 r
= manager_load_unit(u
->manager
, slice_name
, NULL
, NULL
, &slice
);
2419 return unit_set_slice(u
, slice
);
2422 const char *unit_slice_name(Unit
*u
) {
2425 if (!UNIT_ISSET(u
->slice
))
2428 return UNIT_DEREF(u
->slice
)->id
;
2431 int unit_load_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2432 _cleanup_free_
char *t
= NULL
;
2439 r
= unit_name_change_suffix(u
->id
, type
, &t
);
2442 if (unit_has_name(u
, t
))
2445 r
= manager_load_unit(u
->manager
, t
, NULL
, NULL
, _found
);
2446 assert(r
< 0 || *_found
!= u
);
2450 static int signal_name_owner_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2451 const char *name
, *old_owner
, *new_owner
;
2458 r
= sd_bus_message_read(message
, "sss", &name
, &old_owner
, &new_owner
);
2460 bus_log_parse_error(r
);
2464 if (UNIT_VTABLE(u
)->bus_name_owner_change
)
2465 UNIT_VTABLE(u
)->bus_name_owner_change(u
, name
, old_owner
, new_owner
);
2470 int unit_install_bus_match(Unit
*u
, sd_bus
*bus
, const char *name
) {
2477 if (u
->match_bus_slot
)
2480 match
= strjoina("type='signal',"
2481 "sender='org.freedesktop.DBus',"
2482 "path='/org/freedesktop/DBus',"
2483 "interface='org.freedesktop.DBus',"
2484 "member='NameOwnerChanged',"
2485 "arg0='", name
, "'",
2488 return sd_bus_add_match(bus
, &u
->match_bus_slot
, match
, signal_name_owner_changed
, u
);
2491 int unit_watch_bus_name(Unit
*u
, const char *name
) {
2497 /* Watch a specific name on the bus. We only support one unit
2498 * watching each name for now. */
2500 if (u
->manager
->api_bus
) {
2501 /* If the bus is already available, install the match directly.
2502 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2503 r
= unit_install_bus_match(u
, u
->manager
->api_bus
, name
);
2505 return log_warning_errno(r
, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name
);
2508 r
= hashmap_put(u
->manager
->watch_bus
, name
, u
);
2510 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2511 return log_warning_errno(r
, "Failed to put bus name to hashmap: %m");
2517 void unit_unwatch_bus_name(Unit
*u
, const char *name
) {
2521 hashmap_remove_value(u
->manager
->watch_bus
, name
, u
);
2522 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2525 bool unit_can_serialize(Unit
*u
) {
2528 return UNIT_VTABLE(u
)->serialize
&& UNIT_VTABLE(u
)->deserialize_item
;
2531 int unit_serialize(Unit
*u
, FILE *f
, FDSet
*fds
, bool serialize_jobs
) {
2538 if (unit_can_serialize(u
)) {
2541 r
= UNIT_VTABLE(u
)->serialize(u
, f
, fds
);
2545 rt
= unit_get_exec_runtime(u
);
2547 r
= exec_runtime_serialize(u
, rt
, f
, fds
);
2553 dual_timestamp_serialize(f
, "inactive-exit-timestamp", &u
->inactive_exit_timestamp
);
2554 dual_timestamp_serialize(f
, "active-enter-timestamp", &u
->active_enter_timestamp
);
2555 dual_timestamp_serialize(f
, "active-exit-timestamp", &u
->active_exit_timestamp
);
2556 dual_timestamp_serialize(f
, "inactive-enter-timestamp", &u
->inactive_enter_timestamp
);
2557 dual_timestamp_serialize(f
, "condition-timestamp", &u
->condition_timestamp
);
2558 dual_timestamp_serialize(f
, "assert-timestamp", &u
->assert_timestamp
);
2560 if (dual_timestamp_is_set(&u
->condition_timestamp
))
2561 unit_serialize_item(u
, f
, "condition-result", yes_no(u
->condition_result
));
2563 if (dual_timestamp_is_set(&u
->assert_timestamp
))
2564 unit_serialize_item(u
, f
, "assert-result", yes_no(u
->assert_result
));
2566 unit_serialize_item(u
, f
, "transient", yes_no(u
->transient
));
2567 unit_serialize_item_format(u
, f
, "cpuacct-usage-base", "%" PRIu64
, u
->cpuacct_usage_base
);
2570 unit_serialize_item(u
, f
, "cgroup", u
->cgroup_path
);
2571 unit_serialize_item(u
, f
, "cgroup-realized", yes_no(u
->cgroup_realized
));
2573 if (u
->cgroup_netclass_id
)
2574 unit_serialize_item_format(u
, f
, "netclass-id", "%" PRIu32
, u
->cgroup_netclass_id
);
2576 if (serialize_jobs
) {
2578 fprintf(f
, "job\n");
2579 job_serialize(u
->job
, f
, fds
);
2583 fprintf(f
, "job\n");
2584 job_serialize(u
->nop_job
, f
, fds
);
2593 int unit_serialize_item(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2609 int unit_serialize_item_escaped(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2610 _cleanup_free_
char *c
= NULL
;
2631 int unit_serialize_item_fd(Unit
*u
, FILE *f
, FDSet
*fds
, const char *key
, int fd
) {
2641 copy
= fdset_put_dup(fds
, fd
);
2645 fprintf(f
, "%s=%i\n", key
, copy
);
2649 void unit_serialize_item_format(Unit
*u
, FILE *f
, const char *key
, const char *format
, ...) {
2660 va_start(ap
, format
);
2661 vfprintf(f
, format
, ap
);
2667 int unit_deserialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2668 ExecRuntime
**rt
= NULL
;
2676 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
2678 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
2681 char line
[LINE_MAX
], *l
, *v
;
2684 if (!fgets(line
, sizeof(line
), f
)) {
2697 k
= strcspn(l
, "=");
2705 if (streq(l
, "job")) {
2707 /* new-style serialized job */
2714 r
= job_deserialize(j
, f
, fds
);
2720 r
= hashmap_put(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
), j
);
2726 r
= job_install_deserialized(j
);
2728 hashmap_remove(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
));
2732 } else /* legacy for pre-44 */
2733 log_unit_warning(u
, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v
);
2735 } else if (streq(l
, "inactive-exit-timestamp")) {
2736 dual_timestamp_deserialize(v
, &u
->inactive_exit_timestamp
);
2738 } else if (streq(l
, "active-enter-timestamp")) {
2739 dual_timestamp_deserialize(v
, &u
->active_enter_timestamp
);
2741 } else if (streq(l
, "active-exit-timestamp")) {
2742 dual_timestamp_deserialize(v
, &u
->active_exit_timestamp
);
2744 } else if (streq(l
, "inactive-enter-timestamp")) {
2745 dual_timestamp_deserialize(v
, &u
->inactive_enter_timestamp
);
2747 } else if (streq(l
, "condition-timestamp")) {
2748 dual_timestamp_deserialize(v
, &u
->condition_timestamp
);
2750 } else if (streq(l
, "assert-timestamp")) {
2751 dual_timestamp_deserialize(v
, &u
->assert_timestamp
);
2753 } else if (streq(l
, "condition-result")) {
2755 r
= parse_boolean(v
);
2757 log_unit_debug(u
, "Failed to parse condition result value %s, ignoring.", v
);
2759 u
->condition_result
= r
;
2763 } else if (streq(l
, "assert-result")) {
2765 r
= parse_boolean(v
);
2767 log_unit_debug(u
, "Failed to parse assert result value %s, ignoring.", v
);
2769 u
->assert_result
= r
;
2773 } else if (streq(l
, "transient")) {
2775 r
= parse_boolean(v
);
2777 log_unit_debug(u
, "Failed to parse transient bool %s, ignoring.", v
);
2783 } else if (streq(l
, "cpuacct-usage-base")) {
2785 r
= safe_atou64(v
, &u
->cpuacct_usage_base
);
2787 log_unit_debug(u
, "Failed to parse CPU usage %s, ignoring.", v
);
2791 } else if (streq(l
, "cgroup")) {
2793 r
= unit_set_cgroup_path(u
, v
);
2795 log_unit_debug_errno(u
, r
, "Failed to set cgroup path %s, ignoring: %m", v
);
2797 (void) unit_watch_cgroup(u
);
2800 } else if (streq(l
, "cgroup-realized")) {
2803 b
= parse_boolean(v
);
2805 log_unit_debug(u
, "Failed to parse cgroup-realized bool %s, ignoring.", v
);
2807 u
->cgroup_realized
= b
;
2810 } else if (streq(l
, "netclass-id")) {
2811 r
= safe_atou32(v
, &u
->cgroup_netclass_id
);
2813 log_unit_debug(u
, "Failed to parse netclass ID %s, ignoring.", v
);
2815 r
= unit_add_to_netclass_cgroup(u
);
2817 log_unit_debug_errno(u
, r
, "Failed to add unit to netclass cgroup, ignoring: %m");
2823 if (unit_can_serialize(u
)) {
2825 r
= exec_runtime_deserialize_item(u
, rt
, l
, v
, fds
);
2827 log_unit_warning(u
, "Failed to deserialize runtime parameter '%s', ignoring.", l
);
2831 /* Returns positive if key was handled by the call */
2836 r
= UNIT_VTABLE(u
)->deserialize_item(u
, l
, v
, fds
);
2838 log_unit_warning(u
, "Failed to deserialize unit parameter '%s', ignoring.", l
);
2843 int unit_add_node_link(Unit
*u
, const char *what
, bool wants
) {
2845 _cleanup_free_
char *e
= NULL
;
2850 /* Adds in links to the device node that this unit is based on */
2854 if (!is_device_path(what
))
2857 /* When device units aren't supported (such as in a
2858 * container), don't create dependencies on them. */
2859 if (!unit_type_supported(UNIT_DEVICE
))
2862 r
= unit_name_from_path(what
, ".device", &e
);
2866 r
= manager_load_unit(u
->manager
, e
, NULL
, NULL
, &device
);
2870 r
= unit_add_two_dependencies(u
, UNIT_AFTER
, u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_BINDS_TO
: UNIT_WANTS
, device
, true);
2875 r
= unit_add_dependency(device
, UNIT_WANTS
, u
, false);
2883 int unit_coldplug(Unit
*u
) {
2888 /* Make sure we don't enter a loop, when coldplugging
2893 u
->coldplugged
= true;
2895 if (UNIT_VTABLE(u
)->coldplug
)
2896 r
= UNIT_VTABLE(u
)->coldplug(u
);
2899 q
= job_coldplug(u
->job
);
2909 bool unit_need_daemon_reload(Unit
*u
) {
2910 _cleanup_strv_free_
char **t
= NULL
;
2913 unsigned loaded_cnt
, current_cnt
;
2917 if (u
->fragment_path
) {
2919 if (stat(u
->fragment_path
, &st
) < 0)
2920 /* What, cannot access this anymore? */
2923 if (u
->fragment_mtime
> 0 &&
2924 timespec_load(&st
.st_mtim
) != u
->fragment_mtime
)
2928 if (u
->source_path
) {
2930 if (stat(u
->source_path
, &st
) < 0)
2933 if (u
->source_mtime
> 0 &&
2934 timespec_load(&st
.st_mtim
) != u
->source_mtime
)
2938 (void) unit_find_dropin_paths(u
, &t
);
2939 loaded_cnt
= strv_length(t
);
2940 current_cnt
= strv_length(u
->dropin_paths
);
2942 if (loaded_cnt
== current_cnt
) {
2943 if (loaded_cnt
== 0)
2946 if (strv_overlap(u
->dropin_paths
, t
)) {
2947 STRV_FOREACH(path
, u
->dropin_paths
) {
2949 if (stat(*path
, &st
) < 0)
2952 if (u
->dropin_mtime
> 0 &&
2953 timespec_load(&st
.st_mtim
) > u
->dropin_mtime
)
2964 void unit_reset_failed(Unit
*u
) {
2967 if (UNIT_VTABLE(u
)->reset_failed
)
2968 UNIT_VTABLE(u
)->reset_failed(u
);
2971 Unit
*unit_following(Unit
*u
) {
2974 if (UNIT_VTABLE(u
)->following
)
2975 return UNIT_VTABLE(u
)->following(u
);
2980 bool unit_stop_pending(Unit
*u
) {
2983 /* This call does check the current state of the unit. It's
2984 * hence useful to be called from state change calls of the
2985 * unit itself, where the state isn't updated yet. This is
2986 * different from unit_inactive_or_pending() which checks both
2987 * the current state and for a queued job. */
2989 return u
->job
&& u
->job
->type
== JOB_STOP
;
2992 bool unit_inactive_or_pending(Unit
*u
) {
2995 /* Returns true if the unit is inactive or going down */
2997 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)))
3000 if (unit_stop_pending(u
))
3006 bool unit_active_or_pending(Unit
*u
) {
3009 /* Returns true if the unit is active or going up */
3011 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
3015 (u
->job
->type
== JOB_START
||
3016 u
->job
->type
== JOB_RELOAD_OR_START
||
3017 u
->job
->type
== JOB_RESTART
))
3023 int unit_kill(Unit
*u
, KillWho w
, int signo
, sd_bus_error
*error
) {
3025 assert(w
>= 0 && w
< _KILL_WHO_MAX
);
3027 assert(signo
< _NSIG
);
3029 if (!UNIT_VTABLE(u
)->kill
)
3032 return UNIT_VTABLE(u
)->kill(u
, w
, signo
, error
);
3035 static Set
*unit_pid_set(pid_t main_pid
, pid_t control_pid
) {
3039 pid_set
= set_new(NULL
);
3043 /* Exclude the main/control pids from being killed via the cgroup */
3045 r
= set_put(pid_set
, PID_TO_PTR(main_pid
));
3050 if (control_pid
> 0) {
3051 r
= set_put(pid_set
, PID_TO_PTR(control_pid
));
3063 int unit_kill_common(
3069 sd_bus_error
*error
) {
3072 bool killed
= false;
3074 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
)) {
3076 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no main processes", unit_type_to_string(u
->type
));
3077 else if (main_pid
== 0)
3078 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No main process to kill");
3081 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
)) {
3082 if (control_pid
< 0)
3083 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no control processes", unit_type_to_string(u
->type
));
3084 else if (control_pid
== 0)
3085 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
3088 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3089 if (control_pid
> 0) {
3090 if (kill(control_pid
, signo
) < 0)
3096 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3098 if (kill(main_pid
, signo
) < 0)
3104 if (IN_SET(who
, KILL_ALL
, KILL_ALL_FAIL
) && u
->cgroup_path
) {
3105 _cleanup_set_free_ Set
*pid_set
= NULL
;
3108 /* Exclude the main/control pids from being killed via the cgroup */
3109 pid_set
= unit_pid_set(main_pid
, control_pid
);
3113 q
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, signo
, false, false, false, pid_set
);
3114 if (q
< 0 && q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
3120 if (r
== 0 && !killed
&& IN_SET(who
, KILL_ALL_FAIL
, KILL_CONTROL_FAIL
, KILL_ALL_FAIL
))
3126 int unit_following_set(Unit
*u
, Set
**s
) {
3130 if (UNIT_VTABLE(u
)->following_set
)
3131 return UNIT_VTABLE(u
)->following_set(u
, s
);
3137 UnitFileState
unit_get_unit_file_state(Unit
*u
) {
3142 if (u
->unit_file_state
< 0 && u
->fragment_path
) {
3143 r
= unit_file_get_state(
3144 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3146 basename(u
->fragment_path
),
3147 &u
->unit_file_state
);
3149 u
->unit_file_state
= UNIT_FILE_BAD
;
3152 return u
->unit_file_state
;
3155 int unit_get_unit_file_preset(Unit
*u
) {
3158 if (u
->unit_file_preset
< 0 && u
->fragment_path
)
3159 u
->unit_file_preset
= unit_file_query_preset(
3160 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3162 basename(u
->fragment_path
));
3164 return u
->unit_file_preset
;
3167 Unit
* unit_ref_set(UnitRef
*ref
, Unit
*u
) {
3172 unit_ref_unset(ref
);
3175 LIST_PREPEND(refs
, u
->refs
, ref
);
3179 void unit_ref_unset(UnitRef
*ref
) {
3185 LIST_REMOVE(refs
, ref
->unit
->refs
, ref
);
3189 int unit_patch_contexts(Unit
*u
) {
3197 /* Patch in the manager defaults into the exec and cgroup
3198 * contexts, _after_ the rest of the settings have been
3201 ec
= unit_get_exec_context(u
);
3203 /* This only copies in the ones that need memory */
3204 for (i
= 0; i
< _RLIMIT_MAX
; i
++)
3205 if (u
->manager
->rlimit
[i
] && !ec
->rlimit
[i
]) {
3206 ec
->rlimit
[i
] = newdup(struct rlimit
, u
->manager
->rlimit
[i
], 1);
3211 if (u
->manager
->running_as
== MANAGER_USER
&&
3212 !ec
->working_directory
) {
3214 r
= get_home_dir(&ec
->working_directory
);
3218 /* Allow user services to run, even if the
3219 * home directory is missing */
3220 ec
->working_directory_missing_ok
= true;
3223 if (u
->manager
->running_as
== MANAGER_USER
&&
3224 (ec
->syscall_whitelist
||
3225 !set_isempty(ec
->syscall_filter
) ||
3226 !set_isempty(ec
->syscall_archs
) ||
3227 ec
->address_families_whitelist
||
3228 !set_isempty(ec
->address_families
)))
3229 ec
->no_new_privileges
= true;
3231 if (ec
->private_devices
)
3232 ec
->capability_bounding_set_drop
|= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD
;
3235 cc
= unit_get_cgroup_context(u
);
3239 ec
->private_devices
&&
3240 cc
->device_policy
== CGROUP_AUTO
)
3241 cc
->device_policy
= CGROUP_CLOSED
;
3247 ExecContext
*unit_get_exec_context(Unit
*u
) {
3254 offset
= UNIT_VTABLE(u
)->exec_context_offset
;
3258 return (ExecContext
*) ((uint8_t*) u
+ offset
);
3261 KillContext
*unit_get_kill_context(Unit
*u
) {
3268 offset
= UNIT_VTABLE(u
)->kill_context_offset
;
3272 return (KillContext
*) ((uint8_t*) u
+ offset
);
3275 CGroupContext
*unit_get_cgroup_context(Unit
*u
) {
3281 offset
= UNIT_VTABLE(u
)->cgroup_context_offset
;
3285 return (CGroupContext
*) ((uint8_t*) u
+ offset
);
3288 ExecRuntime
*unit_get_exec_runtime(Unit
*u
) {
3294 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3298 return *(ExecRuntime
**) ((uint8_t*) u
+ offset
);
3301 static int unit_drop_in_dir(Unit
*u
, UnitSetPropertiesMode mode
, bool transient
, char **dir
) {
3304 if (u
->manager
->running_as
== MANAGER_USER
) {
3307 if (mode
== UNIT_PERSISTENT
&& !transient
)
3308 r
= user_config_home(dir
);
3310 r
= user_runtime_dir(dir
);
3317 if (mode
== UNIT_PERSISTENT
&& !transient
)
3318 *dir
= strdup("/etc/systemd/system");
3320 *dir
= strdup("/run/systemd/system");
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_make_transient(Unit
*u
) {
3428 if (!UNIT_VTABLE(u
)->can_transient
)
3431 u
->load_state
= UNIT_STUB
;
3433 u
->transient
= true;
3435 u
->fragment_path
= mfree(u
->fragment_path
);
3436 u
->source_path
= mfree(u
->source_path
);
3437 u
->dropin_paths
= strv_free(u
->dropin_paths
);
3438 u
->fragment_mtime
= u
->source_mtime
= u
->dropin_mtime
= 0;
3440 unit_add_to_dbus_queue(u
);
3441 unit_add_to_gc_queue(u
);
3442 unit_add_to_load_queue(u
);
3447 int unit_kill_context(
3453 bool main_pid_alien
) {
3455 bool wait_for_exit
= false;
3461 if (c
->kill_mode
== KILL_NONE
)
3471 case KILL_TERMINATE
:
3472 sig
= c
->kill_signal
;
3475 assert_not_reached("KillOperation unknown");
3479 r
= kill_and_sigcont(main_pid
, sig
);
3481 if (r
< 0 && r
!= -ESRCH
) {
3482 _cleanup_free_
char *comm
= NULL
;
3483 get_process_comm(main_pid
, &comm
);
3485 log_unit_warning_errno(u
, r
, "Failed to kill main process " PID_FMT
" (%s), ignoring: %m", main_pid
, strna(comm
));
3487 if (!main_pid_alien
)
3488 wait_for_exit
= true;
3490 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3491 (void) kill(main_pid
, SIGHUP
);
3495 if (control_pid
> 0) {
3496 r
= kill_and_sigcont(control_pid
, sig
);
3498 if (r
< 0 && r
!= -ESRCH
) {
3499 _cleanup_free_
char *comm
= NULL
;
3500 get_process_comm(control_pid
, &comm
);
3502 log_unit_warning_errno(u
, r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m", control_pid
, strna(comm
));
3504 wait_for_exit
= true;
3506 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3507 (void) kill(control_pid
, SIGHUP
);
3511 if (u
->cgroup_path
&&
3512 (c
->kill_mode
== KILL_CONTROL_GROUP
|| (c
->kill_mode
== KILL_MIXED
&& k
== KILL_KILL
))) {
3513 _cleanup_set_free_ Set
*pid_set
= NULL
;
3515 /* Exclude the main/control pids from being killed via the cgroup */
3516 pid_set
= unit_pid_set(main_pid
, control_pid
);
3520 r
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, sig
, true, k
!= KILL_TERMINATE
, false, pid_set
);
3522 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
3523 log_unit_warning_errno(u
, r
, "Failed to kill control group %s, ignoring: %m", u
->cgroup_path
);
3527 /* FIXME: For now, on the legacy hierarchy, we
3528 * will not wait for the cgroup members to die
3529 * if we are running in a container or if this
3530 * is a delegation unit, simply because cgroup
3531 * notification is unreliable in these
3532 * cases. It doesn't work at all in
3533 * containers, and outside of containers it
3534 * can be confused easily by left-over
3535 * directories in the cgroup -- which however
3536 * should not exist in non-delegated units. On
3537 * the unified hierarchy that's different,
3538 * there we get proper events. Hence rely on
3541 if (cg_unified() > 0 ||
3542 (detect_container() == 0 && !unit_cgroup_delegate(u
)))
3543 wait_for_exit
= true;
3545 if (c
->send_sighup
&& k
!= KILL_KILL
) {
3548 pid_set
= unit_pid_set(main_pid
, control_pid
);
3552 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, SIGHUP
, false, true, false, pid_set
);
3557 return wait_for_exit
;
3560 int unit_require_mounts_for(Unit
*u
, const char *path
) {
3561 char prefix
[strlen(path
) + 1], *p
;
3567 /* Registers a unit for requiring a certain path and all its
3568 * prefixes. We keep a simple array of these paths in the
3569 * unit, since its usually short. However, we build a prefix
3570 * table for all possible prefixes so that new appearing mount
3571 * units can easily determine which units to make themselves a
3574 if (!path_is_absolute(path
))
3581 path_kill_slashes(p
);
3583 if (!path_is_safe(p
)) {
3588 if (strv_contains(u
->requires_mounts_for
, p
)) {
3593 r
= strv_consume(&u
->requires_mounts_for
, p
);
3597 PATH_FOREACH_PREFIX_MORE(prefix
, p
) {
3600 x
= hashmap_get(u
->manager
->units_requiring_mounts_for
, prefix
);
3604 r
= hashmap_ensure_allocated(&u
->manager
->units_requiring_mounts_for
, &string_hash_ops
);
3618 r
= hashmap_put(u
->manager
->units_requiring_mounts_for
, q
, x
);
3634 int unit_setup_exec_runtime(Unit
*u
) {
3640 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3643 /* Check if there already is an ExecRuntime for this unit? */
3644 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
3648 /* Try to get it from somebody else */
3649 SET_FOREACH(other
, u
->dependencies
[UNIT_JOINS_NAMESPACE_OF
], i
) {
3651 *rt
= unit_get_exec_runtime(other
);
3653 exec_runtime_ref(*rt
);
3658 return exec_runtime_make(rt
, unit_get_exec_context(u
), u
->id
);
3661 bool unit_type_supported(UnitType t
) {
3662 if (_unlikely_(t
< 0))
3664 if (_unlikely_(t
>= _UNIT_TYPE_MAX
))
3667 if (!unit_vtable
[t
]->supported
)
3670 return unit_vtable
[t
]->supported();
3673 void unit_warn_if_dir_nonempty(Unit
*u
, const char* where
) {
3679 r
= dir_is_empty(where
);
3683 log_unit_warning_errno(u
, r
, "Failed to check directory %s: %m", where
);
3687 log_struct(LOG_NOTICE
,
3688 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3690 LOG_UNIT_MESSAGE(u
, "Directory %s to mount over is not empty, mounting anyway.", where
),
3695 int unit_fail_if_symlink(Unit
*u
, const char* where
) {
3701 r
= is_symlink(where
);
3703 log_unit_debug_errno(u
, r
, "Failed to check symlink %s, ignoring: %m", where
);
3710 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3712 LOG_UNIT_MESSAGE(u
, "Mount on symlink %s not allowed.", where
),
3719 bool unit_is_pristine(Unit
*u
) {
3722 /* Check if the unit already exists or is already around,
3723 * in a number of different ways. Note that to cater for unit
3724 * types such as slice, we are generally fine with units that
3725 * are marked UNIT_LOADED even even though nothing was
3726 * actually loaded, as those unit types don't require a file
3727 * on disk to validly load. */
3729 return !(!IN_SET(u
->load_state
, UNIT_NOT_FOUND
, UNIT_LOADED
) ||
3732 !strv_isempty(u
->dropin_paths
) ||