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 "stdio-util.h"
55 #include "string-util.h"
57 #include "unit-name.h"
59 #include "user-util.h"
62 const UnitVTable
* const unit_vtable
[_UNIT_TYPE_MAX
] = {
63 [UNIT_SERVICE
] = &service_vtable
,
64 [UNIT_SOCKET
] = &socket_vtable
,
65 [UNIT_BUSNAME
] = &busname_vtable
,
66 [UNIT_TARGET
] = &target_vtable
,
67 [UNIT_DEVICE
] = &device_vtable
,
68 [UNIT_MOUNT
] = &mount_vtable
,
69 [UNIT_AUTOMOUNT
] = &automount_vtable
,
70 [UNIT_SWAP
] = &swap_vtable
,
71 [UNIT_TIMER
] = &timer_vtable
,
72 [UNIT_PATH
] = &path_vtable
,
73 [UNIT_SLICE
] = &slice_vtable
,
74 [UNIT_SCOPE
] = &scope_vtable
77 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
);
79 Unit
*unit_new(Manager
*m
, size_t size
) {
83 assert(size
>= sizeof(Unit
));
89 u
->names
= set_new(&string_hash_ops
);
96 u
->type
= _UNIT_TYPE_INVALID
;
97 u
->default_dependencies
= true;
98 u
->unit_file_state
= _UNIT_FILE_STATE_INVALID
;
99 u
->unit_file_preset
= -1;
100 u
->on_failure_job_mode
= JOB_REPLACE
;
101 u
->cgroup_inotify_wd
= -1;
102 u
->job_timeout
= USEC_INFINITY
;
104 RATELIMIT_INIT(u
->auto_stop_ratelimit
, 10 * USEC_PER_SEC
, 16);
109 bool unit_has_name(Unit
*u
, const char *name
) {
113 return !!set_get(u
->names
, (char*) name
);
116 static void unit_init(Unit
*u
) {
123 assert(u
->type
>= 0);
125 cc
= unit_get_cgroup_context(u
);
127 cgroup_context_init(cc
);
129 /* Copy in the manager defaults into the cgroup
130 * context, _before_ the rest of the settings have
131 * been initialized */
133 cc
->cpu_accounting
= u
->manager
->default_cpu_accounting
;
134 cc
->blockio_accounting
= u
->manager
->default_blockio_accounting
;
135 cc
->memory_accounting
= u
->manager
->default_memory_accounting
;
136 cc
->tasks_accounting
= u
->manager
->default_tasks_accounting
;
138 if (u
->type
!= UNIT_SLICE
)
139 cc
->tasks_max
= u
->manager
->default_tasks_max
;
142 ec
= unit_get_exec_context(u
);
144 exec_context_init(ec
);
146 kc
= unit_get_kill_context(u
);
148 kill_context_init(kc
);
150 if (UNIT_VTABLE(u
)->init
)
151 UNIT_VTABLE(u
)->init(u
);
154 int unit_add_name(Unit
*u
, const char *text
) {
155 _cleanup_free_
char *s
= NULL
, *i
= NULL
;
162 if (unit_name_is_valid(text
, UNIT_NAME_TEMPLATE
)) {
167 r
= unit_name_replace_instance(text
, u
->instance
, &s
);
176 if (set_contains(u
->names
, s
))
178 if (hashmap_contains(u
->manager
->units
, s
))
181 if (!unit_name_is_valid(s
, UNIT_NAME_PLAIN
|UNIT_NAME_INSTANCE
))
184 t
= unit_name_to_type(s
);
188 if (u
->type
!= _UNIT_TYPE_INVALID
&& t
!= u
->type
)
191 r
= unit_name_to_instance(s
, &i
);
195 if (i
&& unit_vtable
[t
]->no_instances
)
198 /* Ensure that this unit is either instanced or not instanced,
199 * but not both. Note that we do allow names with different
200 * instance names however! */
201 if (u
->type
!= _UNIT_TYPE_INVALID
&& !u
->instance
!= !i
)
204 if (unit_vtable
[t
]->no_alias
&& !set_isempty(u
->names
))
207 if (hashmap_size(u
->manager
->units
) >= MANAGER_MAX_NAMES
)
210 r
= set_put(u
->names
, s
);
215 r
= hashmap_put(u
->manager
->units
, s
, u
);
217 (void) set_remove(u
->names
, s
);
221 if (u
->type
== _UNIT_TYPE_INVALID
) {
226 LIST_PREPEND(units_by_type
, u
->manager
->units_by_type
[t
], u
);
235 unit_add_to_dbus_queue(u
);
239 int unit_choose_id(Unit
*u
, const char *name
) {
240 _cleanup_free_
char *t
= NULL
;
247 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
252 r
= unit_name_replace_instance(name
, u
->instance
, &t
);
259 /* Selects one of the names of this unit as the id */
260 s
= set_get(u
->names
, (char*) name
);
264 /* Determine the new instance from the new id */
265 r
= unit_name_to_instance(s
, &i
);
274 unit_add_to_dbus_queue(u
);
279 int unit_set_description(Unit
*u
, const char *description
) {
284 if (isempty(description
))
287 s
= strdup(description
);
292 free(u
->description
);
295 unit_add_to_dbus_queue(u
);
299 bool unit_check_gc(Unit
*u
) {
300 UnitActiveState state
;
309 state
= unit_active_state(u
);
311 /* If the unit is inactive and failed and no job is queued for
312 * it, then release its runtime resources */
313 if (UNIT_IS_INACTIVE_OR_FAILED(state
) &&
314 UNIT_VTABLE(u
)->release_resources
)
315 UNIT_VTABLE(u
)->release_resources(u
);
317 /* But we keep the unit object around for longer when it is
318 * referenced or configured to not be gc'ed */
319 if (state
!= UNIT_INACTIVE
)
328 if (UNIT_VTABLE(u
)->check_gc
)
329 if (UNIT_VTABLE(u
)->check_gc(u
))
335 void unit_add_to_load_queue(Unit
*u
) {
337 assert(u
->type
!= _UNIT_TYPE_INVALID
);
339 if (u
->load_state
!= UNIT_STUB
|| u
->in_load_queue
)
342 LIST_PREPEND(load_queue
, u
->manager
->load_queue
, u
);
343 u
->in_load_queue
= true;
346 void unit_add_to_cleanup_queue(Unit
*u
) {
349 if (u
->in_cleanup_queue
)
352 LIST_PREPEND(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
353 u
->in_cleanup_queue
= true;
356 void unit_add_to_gc_queue(Unit
*u
) {
359 if (u
->in_gc_queue
|| u
->in_cleanup_queue
)
362 if (unit_check_gc(u
))
365 LIST_PREPEND(gc_queue
, u
->manager
->gc_queue
, u
);
366 u
->in_gc_queue
= true;
368 u
->manager
->n_in_gc_queue
++;
371 void unit_add_to_dbus_queue(Unit
*u
) {
373 assert(u
->type
!= _UNIT_TYPE_INVALID
);
375 if (u
->load_state
== UNIT_STUB
|| u
->in_dbus_queue
)
378 /* Shortcut things if nobody cares */
379 if (sd_bus_track_count(u
->manager
->subscribed
) <= 0 &&
380 set_isempty(u
->manager
->private_buses
)) {
381 u
->sent_dbus_new_signal
= true;
385 LIST_PREPEND(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
386 u
->in_dbus_queue
= true;
389 static void bidi_set_free(Unit
*u
, Set
*s
) {
395 /* Frees the set and makes sure we are dropped from the
396 * inverse pointers */
398 SET_FOREACH(other
, s
, i
) {
401 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
402 set_remove(other
->dependencies
[d
], u
);
404 unit_add_to_gc_queue(other
);
410 static void unit_remove_transient(Unit
*u
) {
418 if (u
->fragment_path
)
419 (void) unlink(u
->fragment_path
);
421 STRV_FOREACH(i
, u
->dropin_paths
) {
422 _cleanup_free_
char *p
= NULL
;
426 p
= dirname_malloc(*i
);
432 static void unit_free_requires_mounts_for(Unit
*u
) {
435 STRV_FOREACH(j
, u
->requires_mounts_for
) {
436 char s
[strlen(*j
) + 1];
438 PATH_FOREACH_PREFIX_MORE(s
, *j
) {
442 x
= hashmap_get2(u
->manager
->units_requiring_mounts_for
, s
, (void**) &y
);
448 if (set_isempty(x
)) {
449 hashmap_remove(u
->manager
->units_requiring_mounts_for
, y
);
456 u
->requires_mounts_for
= strv_free(u
->requires_mounts_for
);
459 static void unit_done(Unit
*u
) {
469 if (UNIT_VTABLE(u
)->done
)
470 UNIT_VTABLE(u
)->done(u
);
472 ec
= unit_get_exec_context(u
);
474 exec_context_done(ec
);
476 cc
= unit_get_cgroup_context(u
);
478 cgroup_context_done(cc
);
480 r
= unit_remove_from_netclass_cgroup(u
);
482 log_warning_errno(r
, "Unable to remove unit from netclass group: %m");
485 void unit_free(Unit
*u
) {
492 if (u
->manager
->n_reloading
<= 0)
493 unit_remove_transient(u
);
495 bus_unit_send_removed_signal(u
);
499 sd_bus_slot_unref(u
->match_bus_slot
);
501 unit_free_requires_mounts_for(u
);
503 SET_FOREACH(t
, u
->names
, i
)
504 hashmap_remove_value(u
->manager
->units
, t
, u
);
518 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
519 bidi_set_free(u
, u
->dependencies
[d
]);
521 if (u
->type
!= _UNIT_TYPE_INVALID
)
522 LIST_REMOVE(units_by_type
, u
->manager
->units_by_type
[u
->type
], u
);
524 if (u
->in_load_queue
)
525 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
527 if (u
->in_dbus_queue
)
528 LIST_REMOVE(dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
530 if (u
->in_cleanup_queue
)
531 LIST_REMOVE(cleanup_queue
, u
->manager
->cleanup_queue
, u
);
533 if (u
->in_gc_queue
) {
534 LIST_REMOVE(gc_queue
, u
->manager
->gc_queue
, u
);
535 u
->manager
->n_in_gc_queue
--;
538 if (u
->in_cgroup_queue
)
539 LIST_REMOVE(cgroup_queue
, u
->manager
->cgroup_queue
, u
);
541 unit_release_cgroup(u
);
543 (void) manager_update_failed_units(u
->manager
, u
, false);
544 set_remove(u
->manager
->startup_units
, u
);
546 free(u
->description
);
547 strv_free(u
->documentation
);
548 free(u
->fragment_path
);
549 free(u
->source_path
);
550 strv_free(u
->dropin_paths
);
553 free(u
->job_timeout_reboot_arg
);
555 set_free_free(u
->names
);
557 unit_unwatch_all_pids(u
);
559 condition_free_list(u
->conditions
);
560 condition_free_list(u
->asserts
);
562 unit_ref_unset(&u
->slice
);
565 unit_ref_unset(u
->refs
);
570 UnitActiveState
unit_active_state(Unit
*u
) {
573 if (u
->load_state
== UNIT_MERGED
)
574 return unit_active_state(unit_follow_merge(u
));
576 /* After a reload it might happen that a unit is not correctly
577 * loaded but still has a process around. That's why we won't
578 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
580 return UNIT_VTABLE(u
)->active_state(u
);
583 const char* unit_sub_state_to_string(Unit
*u
) {
586 return UNIT_VTABLE(u
)->sub_state_to_string(u
);
589 static int complete_move(Set
**s
, Set
**other
) {
599 r
= set_move(*s
, *other
);
610 static int merge_names(Unit
*u
, Unit
*other
) {
618 r
= complete_move(&u
->names
, &other
->names
);
622 set_free_free(other
->names
);
626 SET_FOREACH(t
, u
->names
, i
)
627 assert_se(hashmap_replace(u
->manager
->units
, t
, u
) == 0);
632 static int reserve_dependencies(Unit
*u
, Unit
*other
, UnitDependency d
) {
637 assert(d
< _UNIT_DEPENDENCY_MAX
);
640 * If u does not have this dependency set allocated, there is no need
641 * to reserve anything. In that case other's set will be transferred
642 * as a whole to u by complete_move().
644 if (!u
->dependencies
[d
])
647 /* merge_dependencies() will skip a u-on-u dependency */
648 n_reserve
= set_size(other
->dependencies
[d
]) - !!set_get(other
->dependencies
[d
], u
);
650 return set_reserve(u
->dependencies
[d
], n_reserve
);
653 static void merge_dependencies(Unit
*u
, Unit
*other
, const char *other_id
, UnitDependency d
) {
660 assert(d
< _UNIT_DEPENDENCY_MAX
);
662 /* Fix backwards pointers */
663 SET_FOREACH(back
, other
->dependencies
[d
], i
) {
666 for (k
= 0; k
< _UNIT_DEPENDENCY_MAX
; k
++) {
667 /* Do not add dependencies between u and itself */
669 if (set_remove(back
->dependencies
[k
], other
))
670 maybe_warn_about_dependency(u
, other_id
, k
);
672 r
= set_remove_and_put(back
->dependencies
[k
], other
, u
);
674 set_remove(back
->dependencies
[k
], other
);
676 assert(r
>= 0 || r
== -ENOENT
);
681 /* Also do not move dependencies on u to itself */
682 back
= set_remove(other
->dependencies
[d
], u
);
684 maybe_warn_about_dependency(u
, other_id
, d
);
686 /* The move cannot fail. The caller must have performed a reservation. */
687 assert_se(complete_move(&u
->dependencies
[d
], &other
->dependencies
[d
]) == 0);
689 other
->dependencies
[d
] = set_free(other
->dependencies
[d
]);
692 int unit_merge(Unit
*u
, Unit
*other
) {
694 const char *other_id
= NULL
;
699 assert(u
->manager
== other
->manager
);
700 assert(u
->type
!= _UNIT_TYPE_INVALID
);
702 other
= unit_follow_merge(other
);
707 if (u
->type
!= other
->type
)
710 if (!u
->instance
!= !other
->instance
)
713 if (other
->load_state
!= UNIT_STUB
&&
714 other
->load_state
!= UNIT_NOT_FOUND
)
723 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
727 other_id
= strdupa(other
->id
);
729 /* Make reservations to ensure merge_dependencies() won't fail */
730 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
731 r
= reserve_dependencies(u
, other
, d
);
733 * We don't rollback reservations if we fail. We don't have
734 * a way to undo reservations. A reservation is not a leak.
741 r
= merge_names(u
, other
);
745 /* Redirect all references */
747 unit_ref_set(other
->refs
, u
);
749 /* Merge dependencies */
750 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
751 merge_dependencies(u
, other
, other_id
, d
);
753 other
->load_state
= UNIT_MERGED
;
754 other
->merged_into
= u
;
756 /* If there is still some data attached to the other node, we
757 * don't need it anymore, and can free it. */
758 if (other
->load_state
!= UNIT_STUB
)
759 if (UNIT_VTABLE(other
)->done
)
760 UNIT_VTABLE(other
)->done(other
);
762 unit_add_to_dbus_queue(u
);
763 unit_add_to_cleanup_queue(other
);
768 int unit_merge_by_name(Unit
*u
, const char *name
) {
771 _cleanup_free_
char *s
= NULL
;
776 if (unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
780 r
= unit_name_replace_instance(name
, u
->instance
, &s
);
787 other
= manager_get_unit(u
->manager
, name
);
789 return unit_merge(u
, other
);
791 return unit_add_name(u
, name
);
794 Unit
* unit_follow_merge(Unit
*u
) {
797 while (u
->load_state
== UNIT_MERGED
)
798 assert_se(u
= u
->merged_into
);
803 int unit_add_exec_dependencies(Unit
*u
, ExecContext
*c
) {
809 if (c
->working_directory
) {
810 r
= unit_require_mounts_for(u
, c
->working_directory
);
815 if (c
->root_directory
) {
816 r
= unit_require_mounts_for(u
, c
->root_directory
);
821 if (u
->manager
->running_as
!= MANAGER_SYSTEM
)
824 if (c
->private_tmp
) {
825 r
= unit_require_mounts_for(u
, "/tmp");
829 r
= unit_require_mounts_for(u
, "/var/tmp");
834 if (c
->std_output
!= EXEC_OUTPUT_KMSG
&&
835 c
->std_output
!= EXEC_OUTPUT_SYSLOG
&&
836 c
->std_output
!= EXEC_OUTPUT_JOURNAL
&&
837 c
->std_output
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
838 c
->std_output
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
&&
839 c
->std_output
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
840 c
->std_error
!= EXEC_OUTPUT_KMSG
&&
841 c
->std_error
!= EXEC_OUTPUT_SYSLOG
&&
842 c
->std_error
!= EXEC_OUTPUT_JOURNAL
&&
843 c
->std_error
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
844 c
->std_error
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
845 c
->std_error
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
)
848 /* If syslog or kernel logging is requested, make sure our own
849 * logging daemon is run first. */
851 r
= unit_add_dependency_by_name(u
, UNIT_AFTER
, SPECIAL_JOURNALD_SOCKET
, NULL
, true);
858 const char *unit_description(Unit
*u
) {
862 return u
->description
;
867 void unit_dump(Unit
*u
, FILE *f
, const char *prefix
) {
873 timestamp0
[FORMAT_TIMESTAMP_MAX
],
874 timestamp1
[FORMAT_TIMESTAMP_MAX
],
875 timestamp2
[FORMAT_TIMESTAMP_MAX
],
876 timestamp3
[FORMAT_TIMESTAMP_MAX
],
877 timestamp4
[FORMAT_TIMESTAMP_MAX
],
878 timespan
[FORMAT_TIMESPAN_MAX
];
880 _cleanup_set_free_ Set
*following_set
= NULL
;
884 assert(u
->type
>= 0);
886 prefix
= strempty(prefix
);
887 prefix2
= strjoina(prefix
, "\t");
891 "%s\tDescription: %s\n"
893 "%s\tUnit Load State: %s\n"
894 "%s\tUnit Active State: %s\n"
895 "%s\nState Change Timestamp: %s\n"
896 "%s\tInactive Exit Timestamp: %s\n"
897 "%s\tActive Enter Timestamp: %s\n"
898 "%s\tActive Exit Timestamp: %s\n"
899 "%s\tInactive Enter Timestamp: %s\n"
900 "%s\tGC Check Good: %s\n"
901 "%s\tNeed Daemon Reload: %s\n"
902 "%s\tTransient: %s\n"
905 "%s\tCGroup realized: %s\n"
906 "%s\tCGroup mask: 0x%x\n"
907 "%s\tCGroup members mask: 0x%x\n",
909 prefix
, unit_description(u
),
910 prefix
, strna(u
->instance
),
911 prefix
, unit_load_state_to_string(u
->load_state
),
912 prefix
, unit_active_state_to_string(unit_active_state(u
)),
913 prefix
, strna(format_timestamp(timestamp0
, sizeof(timestamp0
), u
->state_change_timestamp
.realtime
)),
914 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->inactive_exit_timestamp
.realtime
)),
915 prefix
, strna(format_timestamp(timestamp2
, sizeof(timestamp2
), u
->active_enter_timestamp
.realtime
)),
916 prefix
, strna(format_timestamp(timestamp3
, sizeof(timestamp3
), u
->active_exit_timestamp
.realtime
)),
917 prefix
, strna(format_timestamp(timestamp4
, sizeof(timestamp4
), u
->inactive_enter_timestamp
.realtime
)),
918 prefix
, yes_no(unit_check_gc(u
)),
919 prefix
, yes_no(unit_need_daemon_reload(u
)),
920 prefix
, yes_no(u
->transient
),
921 prefix
, strna(unit_slice_name(u
)),
922 prefix
, strna(u
->cgroup_path
),
923 prefix
, yes_no(u
->cgroup_realized
),
924 prefix
, u
->cgroup_realized_mask
,
925 prefix
, u
->cgroup_members_mask
);
927 SET_FOREACH(t
, u
->names
, i
)
928 fprintf(f
, "%s\tName: %s\n", prefix
, t
);
930 STRV_FOREACH(j
, u
->documentation
)
931 fprintf(f
, "%s\tDocumentation: %s\n", prefix
, *j
);
933 following
= unit_following(u
);
935 fprintf(f
, "%s\tFollowing: %s\n", prefix
, following
->id
);
937 r
= unit_following_set(u
, &following_set
);
941 SET_FOREACH(other
, following_set
, i
)
942 fprintf(f
, "%s\tFollowing Set Member: %s\n", prefix
, other
->id
);
945 if (u
->fragment_path
)
946 fprintf(f
, "%s\tFragment Path: %s\n", prefix
, u
->fragment_path
);
949 fprintf(f
, "%s\tSource Path: %s\n", prefix
, u
->source_path
);
951 STRV_FOREACH(j
, u
->dropin_paths
)
952 fprintf(f
, "%s\tDropIn Path: %s\n", prefix
, *j
);
954 if (u
->job_timeout
!= USEC_INFINITY
)
955 fprintf(f
, "%s\tJob Timeout: %s\n", prefix
, format_timespan(timespan
, sizeof(timespan
), u
->job_timeout
, 0));
957 if (u
->job_timeout_action
!= FAILURE_ACTION_NONE
)
958 fprintf(f
, "%s\tJob Timeout Action: %s\n", prefix
, failure_action_to_string(u
->job_timeout_action
));
960 if (u
->job_timeout_reboot_arg
)
961 fprintf(f
, "%s\tJob Timeout Reboot Argument: %s\n", prefix
, u
->job_timeout_reboot_arg
);
963 condition_dump_list(u
->conditions
, f
, prefix
, condition_type_to_string
);
964 condition_dump_list(u
->asserts
, f
, prefix
, assert_type_to_string
);
966 if (dual_timestamp_is_set(&u
->condition_timestamp
))
968 "%s\tCondition Timestamp: %s\n"
969 "%s\tCondition Result: %s\n",
970 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->condition_timestamp
.realtime
)),
971 prefix
, yes_no(u
->condition_result
));
973 if (dual_timestamp_is_set(&u
->assert_timestamp
))
975 "%s\tAssert Timestamp: %s\n"
976 "%s\tAssert Result: %s\n",
977 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->assert_timestamp
.realtime
)),
978 prefix
, yes_no(u
->assert_result
));
980 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
983 SET_FOREACH(other
, u
->dependencies
[d
], i
)
984 fprintf(f
, "%s\t%s: %s\n", prefix
, unit_dependency_to_string(d
), other
->id
);
987 if (!strv_isempty(u
->requires_mounts_for
)) {
989 "%s\tRequiresMountsFor:", prefix
);
991 STRV_FOREACH(j
, u
->requires_mounts_for
)
992 fprintf(f
, " %s", *j
);
997 if (u
->load_state
== UNIT_LOADED
) {
1000 "%s\tStopWhenUnneeded: %s\n"
1001 "%s\tRefuseManualStart: %s\n"
1002 "%s\tRefuseManualStop: %s\n"
1003 "%s\tDefaultDependencies: %s\n"
1004 "%s\tOnFailureJobMode: %s\n"
1005 "%s\tIgnoreOnIsolate: %s\n",
1006 prefix
, yes_no(u
->stop_when_unneeded
),
1007 prefix
, yes_no(u
->refuse_manual_start
),
1008 prefix
, yes_no(u
->refuse_manual_stop
),
1009 prefix
, yes_no(u
->default_dependencies
),
1010 prefix
, job_mode_to_string(u
->on_failure_job_mode
),
1011 prefix
, yes_no(u
->ignore_on_isolate
));
1013 if (UNIT_VTABLE(u
)->dump
)
1014 UNIT_VTABLE(u
)->dump(u
, f
, prefix2
);
1016 } else if (u
->load_state
== UNIT_MERGED
)
1018 "%s\tMerged into: %s\n",
1019 prefix
, u
->merged_into
->id
);
1020 else if (u
->load_state
== UNIT_ERROR
)
1021 fprintf(f
, "%s\tLoad Error Code: %s\n", prefix
, strerror(-u
->load_error
));
1025 job_dump(u
->job
, f
, prefix2
);
1028 job_dump(u
->nop_job
, f
, prefix2
);
1032 /* Common implementation for multiple backends */
1033 int unit_load_fragment_and_dropin(Unit
*u
) {
1038 /* Load a .{service,socket,...} file */
1039 r
= unit_load_fragment(u
);
1043 if (u
->load_state
== UNIT_STUB
)
1046 /* Load drop-in directory data */
1047 r
= unit_load_dropin(unit_follow_merge(u
));
1054 /* Common implementation for multiple backends */
1055 int unit_load_fragment_and_dropin_optional(Unit
*u
) {
1060 /* Same as unit_load_fragment_and_dropin(), but whether
1061 * something can be loaded or not doesn't matter. */
1063 /* Load a .service file */
1064 r
= unit_load_fragment(u
);
1068 if (u
->load_state
== UNIT_STUB
)
1069 u
->load_state
= UNIT_LOADED
;
1071 /* Load drop-in directory data */
1072 r
= unit_load_dropin(unit_follow_merge(u
));
1079 int unit_add_default_target_dependency(Unit
*u
, Unit
*target
) {
1083 if (target
->type
!= UNIT_TARGET
)
1086 /* Only add the dependency if both units are loaded, so that
1087 * that loop check below is reliable */
1088 if (u
->load_state
!= UNIT_LOADED
||
1089 target
->load_state
!= UNIT_LOADED
)
1092 /* If either side wants no automatic dependencies, then let's
1094 if (!u
->default_dependencies
||
1095 !target
->default_dependencies
)
1098 /* Don't create loops */
1099 if (set_get(target
->dependencies
[UNIT_BEFORE
], u
))
1102 return unit_add_dependency(target
, UNIT_AFTER
, u
, true);
1105 static int unit_add_target_dependencies(Unit
*u
) {
1107 static const UnitDependency deps
[] = {
1121 for (k
= 0; k
< ELEMENTSOF(deps
); k
++)
1122 SET_FOREACH(target
, u
->dependencies
[deps
[k
]], i
) {
1123 r
= unit_add_default_target_dependency(u
, target
);
1131 static int unit_add_slice_dependencies(Unit
*u
) {
1134 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
1137 if (UNIT_ISSET(u
->slice
))
1138 return unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_REQUIRES
, UNIT_DEREF(u
->slice
), true);
1140 if (unit_has_name(u
, SPECIAL_ROOT_SLICE
))
1143 return unit_add_two_dependencies_by_name(u
, UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_ROOT_SLICE
, NULL
, true);
1146 static int unit_add_mount_dependencies(Unit
*u
) {
1152 STRV_FOREACH(i
, u
->requires_mounts_for
) {
1153 char prefix
[strlen(*i
) + 1];
1155 PATH_FOREACH_PREFIX_MORE(prefix
, *i
) {
1156 _cleanup_free_
char *p
= NULL
;
1159 r
= unit_name_from_path(prefix
, ".mount", &p
);
1163 m
= manager_get_unit(u
->manager
, p
);
1165 /* Make sure to load the mount unit if
1166 * it exists. If so the dependencies
1167 * on this unit will be added later
1168 * during the loading of the mount
1170 (void) manager_load_unit_prepare(u
->manager
, p
, NULL
, NULL
, &m
);
1176 if (m
->load_state
!= UNIT_LOADED
)
1179 r
= unit_add_dependency(u
, UNIT_AFTER
, m
, true);
1183 if (m
->fragment_path
) {
1184 r
= unit_add_dependency(u
, UNIT_REQUIRES
, m
, true);
1194 static int unit_add_startup_units(Unit
*u
) {
1198 c
= unit_get_cgroup_context(u
);
1202 if (c
->startup_cpu_shares
== CGROUP_CPU_SHARES_INVALID
&&
1203 c
->startup_blockio_weight
== CGROUP_BLKIO_WEIGHT_INVALID
)
1206 r
= set_ensure_allocated(&u
->manager
->startup_units
, NULL
);
1210 return set_put(u
->manager
->startup_units
, u
);
1213 int unit_load(Unit
*u
) {
1218 if (u
->in_load_queue
) {
1219 LIST_REMOVE(load_queue
, u
->manager
->load_queue
, u
);
1220 u
->in_load_queue
= false;
1223 if (u
->type
== _UNIT_TYPE_INVALID
)
1226 if (u
->load_state
!= UNIT_STUB
)
1229 if (UNIT_VTABLE(u
)->load
) {
1230 r
= UNIT_VTABLE(u
)->load(u
);
1235 if (u
->load_state
== UNIT_STUB
) {
1240 if (u
->load_state
== UNIT_LOADED
) {
1242 r
= unit_add_target_dependencies(u
);
1246 r
= unit_add_slice_dependencies(u
);
1250 r
= unit_add_mount_dependencies(u
);
1254 r
= unit_add_startup_units(u
);
1258 if (u
->on_failure_job_mode
== JOB_ISOLATE
&& set_size(u
->dependencies
[UNIT_ON_FAILURE
]) > 1) {
1259 log_unit_error(u
, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1264 unit_update_cgroup_members_masks(u
);
1266 /* If we are reloading, we need to wait for the deserializer
1267 * to restore the net_cls ids that have been set previously */
1268 if (u
->manager
->n_reloading
<= 0) {
1269 r
= unit_add_to_netclass_cgroup(u
);
1275 assert((u
->load_state
!= UNIT_MERGED
) == !u
->merged_into
);
1277 unit_add_to_dbus_queue(unit_follow_merge(u
));
1278 unit_add_to_gc_queue(u
);
1283 u
->load_state
= u
->load_state
== UNIT_STUB
? UNIT_NOT_FOUND
: UNIT_ERROR
;
1285 unit_add_to_dbus_queue(u
);
1286 unit_add_to_gc_queue(u
);
1288 log_unit_debug_errno(u
, r
, "Failed to load configuration: %m");
1293 static bool unit_condition_test_list(Unit
*u
, Condition
*first
, const char *(*to_string
)(ConditionType t
)) {
1300 /* If the condition list is empty, then it is true */
1304 /* Otherwise, if all of the non-trigger conditions apply and
1305 * if any of the trigger conditions apply (unless there are
1306 * none) we return true */
1307 LIST_FOREACH(conditions
, c
, first
) {
1310 r
= condition_test(c
);
1313 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1315 c
->trigger
? "|" : "",
1316 c
->negate
? "!" : "",
1322 c
->trigger
? "|" : "",
1323 c
->negate
? "!" : "",
1325 condition_result_to_string(c
->result
));
1327 if (!c
->trigger
&& r
<= 0)
1330 if (c
->trigger
&& triggered
<= 0)
1334 return triggered
!= 0;
1337 static bool unit_condition_test(Unit
*u
) {
1340 dual_timestamp_get(&u
->condition_timestamp
);
1341 u
->condition_result
= unit_condition_test_list(u
, u
->conditions
, condition_type_to_string
);
1343 return u
->condition_result
;
1346 static bool unit_assert_test(Unit
*u
) {
1349 dual_timestamp_get(&u
->assert_timestamp
);
1350 u
->assert_result
= unit_condition_test_list(u
, u
->asserts
, assert_type_to_string
);
1352 return u
->assert_result
;
1355 void unit_status_printf(Unit
*u
, const char *status
, const char *unit_status_msg_format
) {
1356 DISABLE_WARNING_FORMAT_NONLITERAL
;
1357 manager_status_printf(u
->manager
, STATUS_TYPE_NORMAL
, status
, unit_status_msg_format
, unit_description(u
));
1361 _pure_
static const char* unit_get_status_message_format(Unit
*u
, JobType t
) {
1363 const UnitStatusMessageFormats
*format_table
;
1366 assert(IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
));
1368 if (t
!= JOB_RELOAD
) {
1369 format_table
= &UNIT_VTABLE(u
)->status_message_formats
;
1371 format
= format_table
->starting_stopping
[t
== JOB_STOP
];
1377 /* Return generic strings */
1379 return "Starting %s.";
1380 else if (t
== JOB_STOP
)
1381 return "Stopping %s.";
1383 return "Reloading %s.";
1386 static void unit_status_print_starting_stopping(Unit
*u
, JobType t
) {
1391 /* Reload status messages have traditionally not been printed to console. */
1392 if (!IN_SET(t
, JOB_START
, JOB_STOP
))
1395 format
= unit_get_status_message_format(u
, t
);
1397 DISABLE_WARNING_FORMAT_NONLITERAL
;
1398 unit_status_printf(u
, "", format
);
1402 static void unit_status_log_starting_stopping_reloading(Unit
*u
, JobType t
) {
1409 if (!IN_SET(t
, JOB_START
, JOB_STOP
, JOB_RELOAD
))
1412 if (log_on_console())
1415 /* We log status messages for all units and all operations. */
1417 format
= unit_get_status_message_format(u
, t
);
1419 DISABLE_WARNING_FORMAT_NONLITERAL
;
1420 xsprintf(buf
, format
, unit_description(u
));
1423 mid
= t
== JOB_START
? SD_MESSAGE_UNIT_STARTING
:
1424 t
== JOB_STOP
? SD_MESSAGE_UNIT_STOPPING
:
1425 SD_MESSAGE_UNIT_RELOADING
;
1427 /* Note that we deliberately use LOG_MESSAGE() instead of
1428 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1429 * closely what is written to screen using the status output,
1430 * which is supposed the highest level, friendliest output
1431 * possible, which means we should avoid the low-level unit
1433 log_struct(LOG_INFO
,
1434 LOG_MESSAGE_ID(mid
),
1436 LOG_MESSAGE("%s", buf
),
1440 void unit_status_emit_starting_stopping_reloading(Unit
*u
, JobType t
) {
1443 assert(t
< _JOB_TYPE_MAX
);
1445 unit_status_log_starting_stopping_reloading(u
, t
);
1446 unit_status_print_starting_stopping(u
, t
);
1450 * -EBADR: This unit type does not support starting.
1451 * -EALREADY: Unit is already started.
1452 * -EAGAIN: An operation is already in progress. Retry later.
1453 * -ECANCELED: Too many requests for now.
1454 * -EPROTO: Assert failed
1456 int unit_start(Unit
*u
) {
1457 UnitActiveState state
;
1462 /* Units that aren't loaded cannot be started */
1463 if (u
->load_state
!= UNIT_LOADED
)
1466 /* If this is already started, then this will succeed. Note
1467 * that this will even succeed if this unit is not startable
1468 * by the user. This is relied on to detect when we need to
1469 * wait for units and when waiting is finished. */
1470 state
= unit_active_state(u
);
1471 if (UNIT_IS_ACTIVE_OR_RELOADING(state
))
1474 /* If the conditions failed, don't do anything at all. If we
1475 * already are activating this call might still be useful to
1476 * speed up activation in case there is some hold-off time,
1477 * but we don't want to recheck the condition in that case. */
1478 if (state
!= UNIT_ACTIVATING
&&
1479 !unit_condition_test(u
)) {
1480 log_unit_debug(u
, "Starting requested but condition failed. Not starting unit.");
1484 /* If the asserts failed, fail the entire job */
1485 if (state
!= UNIT_ACTIVATING
&&
1486 !unit_assert_test(u
)) {
1487 log_unit_notice(u
, "Starting requested but asserts failed.");
1491 /* Units of types that aren't supported cannot be
1492 * started. Note that we do this test only after the condition
1493 * checks, so that we rather return condition check errors
1494 * (which are usually not considered a true failure) than "not
1495 * supported" errors (which are considered a failure).
1497 if (!unit_supported(u
))
1500 /* Forward to the main object, if we aren't it. */
1501 following
= unit_following(u
);
1503 log_unit_debug(u
, "Redirecting start request from %s to %s.", u
->id
, following
->id
);
1504 return unit_start(following
);
1507 /* If it is stopped, but we cannot start it, then fail */
1508 if (!UNIT_VTABLE(u
)->start
)
1511 /* We don't suppress calls to ->start() here when we are
1512 * already starting, to allow this request to be used as a
1513 * "hurry up" call, for example when the unit is in some "auto
1514 * restart" state where it waits for a holdoff timer to elapse
1515 * before it will start again. */
1517 unit_add_to_dbus_queue(u
);
1519 return UNIT_VTABLE(u
)->start(u
);
1522 bool unit_can_start(Unit
*u
) {
1525 if (u
->load_state
!= UNIT_LOADED
)
1528 if (!unit_supported(u
))
1531 return !!UNIT_VTABLE(u
)->start
;
1534 bool unit_can_isolate(Unit
*u
) {
1537 return unit_can_start(u
) &&
1542 * -EBADR: This unit type does not support stopping.
1543 * -EALREADY: Unit is already stopped.
1544 * -EAGAIN: An operation is already in progress. Retry later.
1546 int unit_stop(Unit
*u
) {
1547 UnitActiveState state
;
1552 state
= unit_active_state(u
);
1553 if (UNIT_IS_INACTIVE_OR_FAILED(state
))
1556 following
= unit_following(u
);
1558 log_unit_debug(u
, "Redirecting stop request from %s to %s.", u
->id
, following
->id
);
1559 return unit_stop(following
);
1562 if (!UNIT_VTABLE(u
)->stop
)
1565 unit_add_to_dbus_queue(u
);
1567 return UNIT_VTABLE(u
)->stop(u
);
1571 * -EBADR: This unit type does not support reloading.
1572 * -ENOEXEC: Unit is not started.
1573 * -EAGAIN: An operation is already in progress. Retry later.
1575 int unit_reload(Unit
*u
) {
1576 UnitActiveState state
;
1581 if (u
->load_state
!= UNIT_LOADED
)
1584 if (!unit_can_reload(u
))
1587 state
= unit_active_state(u
);
1588 if (state
== UNIT_RELOADING
)
1591 if (state
!= UNIT_ACTIVE
) {
1592 log_unit_warning(u
, "Unit cannot be reloaded because it is inactive.");
1596 following
= unit_following(u
);
1598 log_unit_debug(u
, "Redirecting reload request from %s to %s.", u
->id
, following
->id
);
1599 return unit_reload(following
);
1602 unit_add_to_dbus_queue(u
);
1604 return UNIT_VTABLE(u
)->reload(u
);
1607 bool unit_can_reload(Unit
*u
) {
1610 if (!UNIT_VTABLE(u
)->reload
)
1613 if (!UNIT_VTABLE(u
)->can_reload
)
1616 return UNIT_VTABLE(u
)->can_reload(u
);
1619 static void unit_check_unneeded(Unit
*u
) {
1621 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1623 static const UnitDependency needed_dependencies
[] = {
1637 /* If this service shall be shut down when unneeded then do
1640 if (!u
->stop_when_unneeded
)
1643 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
1646 for (j
= 0; j
< ELEMENTSOF(needed_dependencies
); j
++)
1647 SET_FOREACH(other
, u
->dependencies
[needed_dependencies
[j
]], i
)
1648 if (unit_active_or_pending(other
))
1651 /* If stopping a unit fails continously we might enter a stop
1652 * loop here, hence stop acting on the service being
1653 * unnecessary after a while. */
1654 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1655 log_unit_warning(u
, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1659 log_unit_info(u
, "Unit not needed anymore. Stopping.");
1661 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1662 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1664 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1667 static void unit_check_binds_to(Unit
*u
) {
1668 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1679 if (unit_active_state(u
) != UNIT_ACTIVE
)
1682 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
) {
1686 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
1696 /* If stopping a unit fails continously we might enter a stop
1697 * loop here, hence stop acting on the service being
1698 * unnecessary after a while. */
1699 if (!ratelimit_test(&u
->auto_stop_ratelimit
)) {
1700 log_unit_warning(u
, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other
->id
);
1705 log_unit_info(u
, "Unit is bound to inactive unit %s. Stopping, too.", other
->id
);
1707 /* A unit we need to run is gone. Sniff. Let's stop this. */
1708 r
= manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, &error
, NULL
);
1710 log_unit_warning_errno(u
, r
, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error
, r
));
1713 static void retroactively_start_dependencies(Unit
*u
) {
1718 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)));
1720 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], 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_BINDS_TO
], 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_REPLACE
, NULL
, NULL
);
1730 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1731 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1732 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1733 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, NULL
, NULL
);
1735 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTS
], i
)
1736 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1737 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1739 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTED_BY
], i
)
1740 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1741 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1744 static void retroactively_stop_dependencies(Unit
*u
) {
1749 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1751 /* Pull down units which are bound to us recursively if enabled */
1752 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1753 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1754 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, NULL
, NULL
);
1757 static void check_unneeded_dependencies(Unit
*u
) {
1762 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1764 /* Garbage collect services that might not be needed anymore, if enabled */
1765 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1766 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1767 unit_check_unneeded(other
);
1768 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1769 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1770 unit_check_unneeded(other
);
1771 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1772 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1773 unit_check_unneeded(other
);
1774 SET_FOREACH(other
, u
->dependencies
[UNIT_BINDS_TO
], i
)
1775 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1776 unit_check_unneeded(other
);
1779 void unit_start_on_failure(Unit
*u
) {
1785 if (set_size(u
->dependencies
[UNIT_ON_FAILURE
]) <= 0)
1788 log_unit_info(u
, "Triggering OnFailure= dependencies.");
1790 SET_FOREACH(other
, u
->dependencies
[UNIT_ON_FAILURE
], i
) {
1793 r
= manager_add_job(u
->manager
, JOB_START
, other
, u
->on_failure_job_mode
, NULL
, NULL
);
1795 log_unit_error_errno(u
, r
, "Failed to enqueue OnFailure= job: %m");
1799 void unit_trigger_notify(Unit
*u
) {
1805 SET_FOREACH(other
, u
->dependencies
[UNIT_TRIGGERED_BY
], i
)
1806 if (UNIT_VTABLE(other
)->trigger_notify
)
1807 UNIT_VTABLE(other
)->trigger_notify(other
, u
);
1810 void unit_notify(Unit
*u
, UnitActiveState os
, UnitActiveState ns
, bool reload_success
) {
1815 assert(os
< _UNIT_ACTIVE_STATE_MAX
);
1816 assert(ns
< _UNIT_ACTIVE_STATE_MAX
);
1818 /* Note that this is called for all low-level state changes,
1819 * even if they might map to the same high-level
1820 * UnitActiveState! That means that ns == os is an expected
1821 * behavior here. For example: if a mount point is remounted
1822 * this function will be called too! */
1826 /* Update timestamps for state changes */
1827 if (m
->n_reloading
<= 0) {
1828 dual_timestamp_get(&u
->state_change_timestamp
);
1830 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && !UNIT_IS_INACTIVE_OR_FAILED(ns
))
1831 u
->inactive_exit_timestamp
= u
->state_change_timestamp
;
1832 else if (!UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_INACTIVE_OR_FAILED(ns
))
1833 u
->inactive_enter_timestamp
= u
->state_change_timestamp
;
1835 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
) && UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1836 u
->active_enter_timestamp
= u
->state_change_timestamp
;
1837 else if (UNIT_IS_ACTIVE_OR_RELOADING(os
) && !UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1838 u
->active_exit_timestamp
= u
->state_change_timestamp
;
1841 /* Keep track of failed units */
1842 (void) manager_update_failed_units(u
->manager
, u
, ns
== UNIT_FAILED
);
1844 /* Make sure the cgroup is always removed when we become inactive */
1845 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1846 unit_prune_cgroup(u
);
1848 /* Note that this doesn't apply to RemainAfterExit services exiting
1849 * successfully, since there's no change of state in that case. Which is
1850 * why it is handled in service_set_state() */
1851 if (UNIT_IS_INACTIVE_OR_FAILED(os
) != UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1854 ec
= unit_get_exec_context(u
);
1855 if (ec
&& exec_context_may_touch_console(ec
)) {
1856 if (UNIT_IS_INACTIVE_OR_FAILED(ns
)) {
1859 if (m
->n_on_console
== 0)
1860 /* unset no_console_output flag, since the console is free */
1861 m
->no_console_output
= false;
1870 if (u
->job
->state
== JOB_WAITING
)
1872 /* So we reached a different state for this
1873 * job. Let's see if we can run it now if it
1874 * failed previously due to EAGAIN. */
1875 job_add_to_run_queue(u
->job
);
1877 /* Let's check whether this state change constitutes a
1878 * finished job, or maybe contradicts a running job and
1879 * hence needs to invalidate jobs. */
1881 switch (u
->job
->type
) {
1884 case JOB_VERIFY_ACTIVE
:
1886 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1887 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1888 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_ACTIVATING
) {
1891 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1892 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1898 case JOB_RELOAD_OR_START
:
1899 case JOB_TRY_RELOAD
:
1901 if (u
->job
->state
== JOB_RUNNING
) {
1902 if (ns
== UNIT_ACTIVE
)
1903 job_finish_and_invalidate(u
->job
, reload_success
? JOB_DONE
: JOB_FAILED
, true);
1904 else if (ns
!= UNIT_ACTIVATING
&& ns
!= UNIT_RELOADING
) {
1907 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1908 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1916 case JOB_TRY_RESTART
:
1918 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1919 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1920 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_DEACTIVATING
) {
1922 job_finish_and_invalidate(u
->job
, JOB_FAILED
, true);
1928 assert_not_reached("Job type unknown");
1934 if (m
->n_reloading
<= 0) {
1936 /* If this state change happened without being
1937 * requested by a job, then let's retroactively start
1938 * or stop dependencies. We skip that step when
1939 * deserializing, since we don't want to create any
1940 * additional jobs just because something is already
1944 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns
))
1945 retroactively_start_dependencies(u
);
1946 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1947 retroactively_stop_dependencies(u
);
1950 /* stop unneeded units regardless if going down was expected or not */
1951 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1952 check_unneeded_dependencies(u
);
1954 if (ns
!= os
&& ns
== UNIT_FAILED
) {
1955 log_unit_notice(u
, "Unit entered failed state.");
1956 unit_start_on_failure(u
);
1960 /* Some names are special */
1961 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
)) {
1963 if (unit_has_name(u
, SPECIAL_DBUS_SERVICE
))
1964 /* The bus might have just become available,
1965 * hence try to connect to it, if we aren't
1969 if (u
->type
== UNIT_SERVICE
&&
1970 !UNIT_IS_ACTIVE_OR_RELOADING(os
) &&
1971 m
->n_reloading
<= 0) {
1972 /* Write audit record if we have just finished starting up */
1973 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, true);
1977 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
))
1978 manager_send_unit_plymouth(m
, u
);
1982 /* We don't care about D-Bus here, since we'll get an
1983 * asynchronous notification for it anyway. */
1985 if (u
->type
== UNIT_SERVICE
&&
1986 UNIT_IS_INACTIVE_OR_FAILED(ns
) &&
1987 !UNIT_IS_INACTIVE_OR_FAILED(os
) &&
1988 m
->n_reloading
<= 0) {
1990 /* Hmm, if there was no start record written
1991 * write it now, so that we always have a nice
1994 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_START
, ns
== UNIT_INACTIVE
);
1996 if (ns
== UNIT_INACTIVE
)
1997 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, true);
1999 /* Write audit record if we have just finished shutting down */
2000 manager_send_unit_audit(m
, u
, AUDIT_SERVICE_STOP
, ns
== UNIT_INACTIVE
);
2002 u
->in_audit
= false;
2006 manager_recheck_journal(m
);
2007 unit_trigger_notify(u
);
2009 if (u
->manager
->n_reloading
<= 0) {
2010 /* Maybe we finished startup and are now ready for
2011 * being stopped because unneeded? */
2012 unit_check_unneeded(u
);
2014 /* Maybe we finished startup, but something we needed
2015 * has vanished? Let's die then. (This happens when
2016 * something BindsTo= to a Type=oneshot unit, as these
2017 * units go directly from starting to inactive,
2018 * without ever entering started.) */
2019 unit_check_binds_to(u
);
2022 unit_add_to_dbus_queue(u
);
2023 unit_add_to_gc_queue(u
);
2026 int unit_watch_pid(Unit
*u
, pid_t pid
) {
2032 /* Watch a specific PID. We only support one or two units
2033 * watching each PID for now, not more. */
2035 r
= set_ensure_allocated(&u
->pids
, NULL
);
2039 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids1
, NULL
);
2043 r
= hashmap_put(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2045 r
= hashmap_ensure_allocated(&u
->manager
->watch_pids2
, NULL
);
2049 r
= hashmap_put(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2052 q
= set_put(u
->pids
, PID_TO_PTR(pid
));
2059 void unit_unwatch_pid(Unit
*u
, pid_t pid
) {
2063 (void) hashmap_remove_value(u
->manager
->watch_pids1
, PID_TO_PTR(pid
), u
);
2064 (void) hashmap_remove_value(u
->manager
->watch_pids2
, PID_TO_PTR(pid
), u
);
2065 (void) set_remove(u
->pids
, PID_TO_PTR(pid
));
2068 void unit_unwatch_all_pids(Unit
*u
) {
2071 while (!set_isempty(u
->pids
))
2072 unit_unwatch_pid(u
, PTR_TO_PID(set_first(u
->pids
)));
2074 u
->pids
= set_free(u
->pids
);
2077 void unit_tidy_watch_pids(Unit
*u
, pid_t except1
, pid_t except2
) {
2083 /* Cleans dead PIDs from our list */
2085 SET_FOREACH(e
, u
->pids
, i
) {
2086 pid_t pid
= PTR_TO_PID(e
);
2088 if (pid
== except1
|| pid
== except2
)
2091 if (!pid_is_unwaited(pid
))
2092 unit_unwatch_pid(u
, pid
);
2096 bool unit_job_is_applicable(Unit
*u
, JobType j
) {
2098 assert(j
>= 0 && j
< _JOB_TYPE_MAX
);
2102 case JOB_VERIFY_ACTIVE
:
2109 case JOB_TRY_RESTART
:
2110 return unit_can_start(u
);
2113 case JOB_TRY_RELOAD
:
2114 return unit_can_reload(u
);
2116 case JOB_RELOAD_OR_START
:
2117 return unit_can_reload(u
) && unit_can_start(u
);
2120 assert_not_reached("Invalid job type");
2124 static void maybe_warn_about_dependency(Unit
*u
, const char *other
, UnitDependency dependency
) {
2127 /* Only warn about some unit types */
2128 if (!IN_SET(dependency
, UNIT_CONFLICTS
, UNIT_CONFLICTED_BY
, UNIT_BEFORE
, UNIT_AFTER
, UNIT_ON_FAILURE
, UNIT_TRIGGERS
, UNIT_TRIGGERED_BY
))
2131 if (streq_ptr(u
->id
, other
))
2132 log_unit_warning(u
, "Dependency %s=%s dropped", unit_dependency_to_string(dependency
), u
->id
);
2134 log_unit_warning(u
, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency
), strna(other
), u
->id
);
2137 int unit_add_dependency(Unit
*u
, UnitDependency d
, Unit
*other
, bool add_reference
) {
2139 static const UnitDependency inverse_table
[_UNIT_DEPENDENCY_MAX
] = {
2140 [UNIT_REQUIRES
] = UNIT_REQUIRED_BY
,
2141 [UNIT_WANTS
] = UNIT_WANTED_BY
,
2142 [UNIT_REQUISITE
] = UNIT_REQUISITE_OF
,
2143 [UNIT_BINDS_TO
] = UNIT_BOUND_BY
,
2144 [UNIT_PART_OF
] = UNIT_CONSISTS_OF
,
2145 [UNIT_REQUIRED_BY
] = UNIT_REQUIRES
,
2146 [UNIT_REQUISITE_OF
] = UNIT_REQUISITE
,
2147 [UNIT_WANTED_BY
] = UNIT_WANTS
,
2148 [UNIT_BOUND_BY
] = UNIT_BINDS_TO
,
2149 [UNIT_CONSISTS_OF
] = UNIT_PART_OF
,
2150 [UNIT_CONFLICTS
] = UNIT_CONFLICTED_BY
,
2151 [UNIT_CONFLICTED_BY
] = UNIT_CONFLICTS
,
2152 [UNIT_BEFORE
] = UNIT_AFTER
,
2153 [UNIT_AFTER
] = UNIT_BEFORE
,
2154 [UNIT_ON_FAILURE
] = _UNIT_DEPENDENCY_INVALID
,
2155 [UNIT_REFERENCES
] = UNIT_REFERENCED_BY
,
2156 [UNIT_REFERENCED_BY
] = UNIT_REFERENCES
,
2157 [UNIT_TRIGGERS
] = UNIT_TRIGGERED_BY
,
2158 [UNIT_TRIGGERED_BY
] = UNIT_TRIGGERS
,
2159 [UNIT_PROPAGATES_RELOAD_TO
] = UNIT_RELOAD_PROPAGATED_FROM
,
2160 [UNIT_RELOAD_PROPAGATED_FROM
] = UNIT_PROPAGATES_RELOAD_TO
,
2161 [UNIT_JOINS_NAMESPACE_OF
] = UNIT_JOINS_NAMESPACE_OF
,
2163 int r
, q
= 0, v
= 0, w
= 0;
2164 Unit
*orig_u
= u
, *orig_other
= other
;
2167 assert(d
>= 0 && d
< _UNIT_DEPENDENCY_MAX
);
2170 u
= unit_follow_merge(u
);
2171 other
= unit_follow_merge(other
);
2173 /* We won't allow dependencies on ourselves. We will not
2174 * consider them an error however. */
2176 maybe_warn_about_dependency(orig_u
, orig_other
->id
, d
);
2180 r
= set_ensure_allocated(&u
->dependencies
[d
], NULL
);
2184 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
) {
2185 r
= set_ensure_allocated(&other
->dependencies
[inverse_table
[d
]], NULL
);
2190 if (add_reference
) {
2191 r
= set_ensure_allocated(&u
->dependencies
[UNIT_REFERENCES
], NULL
);
2195 r
= set_ensure_allocated(&other
->dependencies
[UNIT_REFERENCED_BY
], NULL
);
2200 q
= set_put(u
->dependencies
[d
], other
);
2204 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
&& inverse_table
[d
] != d
) {
2205 v
= set_put(other
->dependencies
[inverse_table
[d
]], u
);
2212 if (add_reference
) {
2213 w
= set_put(u
->dependencies
[UNIT_REFERENCES
], other
);
2219 r
= set_put(other
->dependencies
[UNIT_REFERENCED_BY
], u
);
2224 unit_add_to_dbus_queue(u
);
2229 set_remove(u
->dependencies
[d
], other
);
2232 set_remove(other
->dependencies
[inverse_table
[d
]], u
);
2235 set_remove(u
->dependencies
[UNIT_REFERENCES
], other
);
2240 int unit_add_two_dependencies(Unit
*u
, UnitDependency d
, UnitDependency e
, Unit
*other
, bool add_reference
) {
2245 r
= unit_add_dependency(u
, d
, other
, add_reference
);
2249 return unit_add_dependency(u
, e
, other
, add_reference
);
2252 static int resolve_template(Unit
*u
, const char *name
, const char*path
, char **buf
, const char **ret
) {
2256 assert(name
|| path
);
2261 name
= basename(path
);
2263 if (!unit_name_is_valid(name
, UNIT_NAME_TEMPLATE
)) {
2270 r
= unit_name_replace_instance(name
, u
->instance
, buf
);
2272 _cleanup_free_
char *i
= NULL
;
2274 r
= unit_name_to_prefix(u
->id
, &i
);
2278 r
= unit_name_replace_instance(name
, i
, buf
);
2287 int unit_add_dependency_by_name(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
2288 _cleanup_free_
char *buf
= NULL
;
2293 assert(name
|| path
);
2295 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2299 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2303 return unit_add_dependency(u
, d
, other
, add_reference
);
2306 int unit_add_two_dependencies_by_name(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
2307 _cleanup_free_
char *buf
= NULL
;
2312 assert(name
|| path
);
2314 r
= resolve_template(u
, name
, path
, &buf
, &name
);
2318 r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
);
2322 return unit_add_two_dependencies(u
, d
, e
, other
, add_reference
);
2325 int set_unit_path(const char *p
) {
2326 /* This is mostly for debug purposes */
2327 if (setenv("SYSTEMD_UNIT_PATH", p
, 1) < 0)
2333 char *unit_dbus_path(Unit
*u
) {
2339 return unit_dbus_path_from_name(u
->id
);
2342 int unit_set_slice(Unit
*u
, Unit
*slice
) {
2346 /* Sets the unit slice if it has not been set before. Is extra
2347 * careful, to only allow this for units that actually have a
2348 * cgroup context. Also, we don't allow to set this for slices
2349 * (since the parent slice is derived from the name). Make
2350 * sure the unit we set is actually a slice. */
2352 if (!UNIT_HAS_CGROUP_CONTEXT(u
))
2355 if (u
->type
== UNIT_SLICE
)
2358 if (unit_active_state(u
) != UNIT_INACTIVE
)
2361 if (slice
->type
!= UNIT_SLICE
)
2364 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
) &&
2365 !unit_has_name(slice
, SPECIAL_ROOT_SLICE
))
2368 if (UNIT_DEREF(u
->slice
) == slice
)
2371 if (UNIT_ISSET(u
->slice
))
2374 unit_ref_set(&u
->slice
, slice
);
2378 int unit_set_default_slice(Unit
*u
) {
2379 _cleanup_free_
char *b
= NULL
;
2380 const char *slice_name
;
2386 if (UNIT_ISSET(u
->slice
))
2390 _cleanup_free_
char *prefix
= NULL
, *escaped
= NULL
;
2392 /* Implicitly place all instantiated units in their
2393 * own per-template slice */
2395 r
= unit_name_to_prefix(u
->id
, &prefix
);
2399 /* The prefix is already escaped, but it might include
2400 * "-" which has a special meaning for slice units,
2401 * hence escape it here extra. */
2402 escaped
= unit_name_escape(prefix
);
2406 if (u
->manager
->running_as
== MANAGER_SYSTEM
)
2407 b
= strjoin("system-", escaped
, ".slice", NULL
);
2409 b
= strappend(escaped
, ".slice");
2416 u
->manager
->running_as
== MANAGER_SYSTEM
&& !unit_has_name(u
, SPECIAL_INIT_SCOPE
)
2417 ? SPECIAL_SYSTEM_SLICE
2418 : SPECIAL_ROOT_SLICE
;
2420 r
= manager_load_unit(u
->manager
, slice_name
, NULL
, NULL
, &slice
);
2424 return unit_set_slice(u
, slice
);
2427 const char *unit_slice_name(Unit
*u
) {
2430 if (!UNIT_ISSET(u
->slice
))
2433 return UNIT_DEREF(u
->slice
)->id
;
2436 int unit_load_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2437 _cleanup_free_
char *t
= NULL
;
2444 r
= unit_name_change_suffix(u
->id
, type
, &t
);
2447 if (unit_has_name(u
, t
))
2450 r
= manager_load_unit(u
->manager
, t
, NULL
, NULL
, _found
);
2451 assert(r
< 0 || *_found
!= u
);
2455 static int signal_name_owner_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2456 const char *name
, *old_owner
, *new_owner
;
2463 r
= sd_bus_message_read(message
, "sss", &name
, &old_owner
, &new_owner
);
2465 bus_log_parse_error(r
);
2469 if (UNIT_VTABLE(u
)->bus_name_owner_change
)
2470 UNIT_VTABLE(u
)->bus_name_owner_change(u
, name
, old_owner
, new_owner
);
2475 int unit_install_bus_match(Unit
*u
, sd_bus
*bus
, const char *name
) {
2482 if (u
->match_bus_slot
)
2485 match
= strjoina("type='signal',"
2486 "sender='org.freedesktop.DBus',"
2487 "path='/org/freedesktop/DBus',"
2488 "interface='org.freedesktop.DBus',"
2489 "member='NameOwnerChanged',"
2490 "arg0='", name
, "'",
2493 return sd_bus_add_match(bus
, &u
->match_bus_slot
, match
, signal_name_owner_changed
, u
);
2496 int unit_watch_bus_name(Unit
*u
, const char *name
) {
2502 /* Watch a specific name on the bus. We only support one unit
2503 * watching each name for now. */
2505 if (u
->manager
->api_bus
) {
2506 /* If the bus is already available, install the match directly.
2507 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2508 r
= unit_install_bus_match(u
, u
->manager
->api_bus
, name
);
2510 return log_warning_errno(r
, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name
);
2513 r
= hashmap_put(u
->manager
->watch_bus
, name
, u
);
2515 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2516 return log_warning_errno(r
, "Failed to put bus name to hashmap: %m");
2522 void unit_unwatch_bus_name(Unit
*u
, const char *name
) {
2526 hashmap_remove_value(u
->manager
->watch_bus
, name
, u
);
2527 u
->match_bus_slot
= sd_bus_slot_unref(u
->match_bus_slot
);
2530 bool unit_can_serialize(Unit
*u
) {
2533 return UNIT_VTABLE(u
)->serialize
&& UNIT_VTABLE(u
)->deserialize_item
;
2536 int unit_serialize(Unit
*u
, FILE *f
, FDSet
*fds
, bool serialize_jobs
) {
2543 if (unit_can_serialize(u
)) {
2546 r
= UNIT_VTABLE(u
)->serialize(u
, f
, fds
);
2550 rt
= unit_get_exec_runtime(u
);
2552 r
= exec_runtime_serialize(u
, rt
, f
, fds
);
2558 dual_timestamp_serialize(f
, "state-change-timestamp", &u
->state_change_timestamp
);
2560 dual_timestamp_serialize(f
, "inactive-exit-timestamp", &u
->inactive_exit_timestamp
);
2561 dual_timestamp_serialize(f
, "active-enter-timestamp", &u
->active_enter_timestamp
);
2562 dual_timestamp_serialize(f
, "active-exit-timestamp", &u
->active_exit_timestamp
);
2563 dual_timestamp_serialize(f
, "inactive-enter-timestamp", &u
->inactive_enter_timestamp
);
2565 dual_timestamp_serialize(f
, "condition-timestamp", &u
->condition_timestamp
);
2566 dual_timestamp_serialize(f
, "assert-timestamp", &u
->assert_timestamp
);
2568 if (dual_timestamp_is_set(&u
->condition_timestamp
))
2569 unit_serialize_item(u
, f
, "condition-result", yes_no(u
->condition_result
));
2571 if (dual_timestamp_is_set(&u
->assert_timestamp
))
2572 unit_serialize_item(u
, f
, "assert-result", yes_no(u
->assert_result
));
2574 unit_serialize_item(u
, f
, "transient", yes_no(u
->transient
));
2575 unit_serialize_item_format(u
, f
, "cpuacct-usage-base", "%" PRIu64
, u
->cpuacct_usage_base
);
2578 unit_serialize_item(u
, f
, "cgroup", u
->cgroup_path
);
2579 unit_serialize_item(u
, f
, "cgroup-realized", yes_no(u
->cgroup_realized
));
2581 if (u
->cgroup_netclass_id
)
2582 unit_serialize_item_format(u
, f
, "netclass-id", "%" PRIu32
, u
->cgroup_netclass_id
);
2584 if (serialize_jobs
) {
2586 fprintf(f
, "job\n");
2587 job_serialize(u
->job
, f
, fds
);
2591 fprintf(f
, "job\n");
2592 job_serialize(u
->nop_job
, f
, fds
);
2601 int unit_serialize_item(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2617 int unit_serialize_item_escaped(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2618 _cleanup_free_
char *c
= NULL
;
2639 int unit_serialize_item_fd(Unit
*u
, FILE *f
, FDSet
*fds
, const char *key
, int fd
) {
2649 copy
= fdset_put_dup(fds
, fd
);
2653 fprintf(f
, "%s=%i\n", key
, copy
);
2657 void unit_serialize_item_format(Unit
*u
, FILE *f
, const char *key
, const char *format
, ...) {
2668 va_start(ap
, format
);
2669 vfprintf(f
, format
, ap
);
2675 int unit_deserialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2676 ExecRuntime
**rt
= NULL
;
2684 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
2686 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
2689 char line
[LINE_MAX
], *l
, *v
;
2692 if (!fgets(line
, sizeof(line
), f
)) {
2705 k
= strcspn(l
, "=");
2713 if (streq(l
, "job")) {
2715 /* new-style serialized job */
2722 r
= job_deserialize(j
, f
, fds
);
2728 r
= hashmap_put(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
), j
);
2734 r
= job_install_deserialized(j
);
2736 hashmap_remove(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
));
2740 } else /* legacy for pre-44 */
2741 log_unit_warning(u
, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v
);
2743 } else if (streq(l
, "state-change-timestamp")) {
2744 dual_timestamp_deserialize(v
, &u
->state_change_timestamp
);
2746 } else if (streq(l
, "inactive-exit-timestamp")) {
2747 dual_timestamp_deserialize(v
, &u
->inactive_exit_timestamp
);
2749 } else if (streq(l
, "active-enter-timestamp")) {
2750 dual_timestamp_deserialize(v
, &u
->active_enter_timestamp
);
2752 } else if (streq(l
, "active-exit-timestamp")) {
2753 dual_timestamp_deserialize(v
, &u
->active_exit_timestamp
);
2755 } else if (streq(l
, "inactive-enter-timestamp")) {
2756 dual_timestamp_deserialize(v
, &u
->inactive_enter_timestamp
);
2758 } else if (streq(l
, "condition-timestamp")) {
2759 dual_timestamp_deserialize(v
, &u
->condition_timestamp
);
2761 } else if (streq(l
, "assert-timestamp")) {
2762 dual_timestamp_deserialize(v
, &u
->assert_timestamp
);
2764 } else if (streq(l
, "condition-result")) {
2766 r
= parse_boolean(v
);
2768 log_unit_debug(u
, "Failed to parse condition result value %s, ignoring.", v
);
2770 u
->condition_result
= r
;
2774 } else if (streq(l
, "assert-result")) {
2776 r
= parse_boolean(v
);
2778 log_unit_debug(u
, "Failed to parse assert result value %s, ignoring.", v
);
2780 u
->assert_result
= r
;
2784 } else if (streq(l
, "transient")) {
2786 r
= parse_boolean(v
);
2788 log_unit_debug(u
, "Failed to parse transient bool %s, ignoring.", v
);
2794 } else if (streq(l
, "cpuacct-usage-base")) {
2796 r
= safe_atou64(v
, &u
->cpuacct_usage_base
);
2798 log_unit_debug(u
, "Failed to parse CPU usage %s, ignoring.", v
);
2802 } else if (streq(l
, "cgroup")) {
2804 r
= unit_set_cgroup_path(u
, v
);
2806 log_unit_debug_errno(u
, r
, "Failed to set cgroup path %s, ignoring: %m", v
);
2808 (void) unit_watch_cgroup(u
);
2811 } else if (streq(l
, "cgroup-realized")) {
2814 b
= parse_boolean(v
);
2816 log_unit_debug(u
, "Failed to parse cgroup-realized bool %s, ignoring.", v
);
2818 u
->cgroup_realized
= b
;
2821 } else if (streq(l
, "netclass-id")) {
2822 r
= safe_atou32(v
, &u
->cgroup_netclass_id
);
2824 log_unit_debug(u
, "Failed to parse netclass ID %s, ignoring.", v
);
2826 r
= unit_add_to_netclass_cgroup(u
);
2828 log_unit_debug_errno(u
, r
, "Failed to add unit to netclass cgroup, ignoring: %m");
2834 if (unit_can_serialize(u
)) {
2836 r
= exec_runtime_deserialize_item(u
, rt
, l
, v
, fds
);
2838 log_unit_warning(u
, "Failed to deserialize runtime parameter '%s', ignoring.", l
);
2842 /* Returns positive if key was handled by the call */
2847 r
= UNIT_VTABLE(u
)->deserialize_item(u
, l
, v
, fds
);
2849 log_unit_warning(u
, "Failed to deserialize unit parameter '%s', ignoring.", l
);
2853 /* Versions before 228 did not carry a state change timestamp. In this case, take the current time. This is
2854 * useful, so that timeouts based on this timestamp don't trigger too early, and is in-line with the logic from
2855 * before 228 where the base for timeouts was not peristet across reboots. */
2857 if (!dual_timestamp_is_set(&u
->state_change_timestamp
))
2858 dual_timestamp_get(&u
->state_change_timestamp
);
2863 int unit_add_node_link(Unit
*u
, const char *what
, bool wants
, UnitDependency dep
) {
2865 _cleanup_free_
char *e
= NULL
;
2870 /* Adds in links to the device node that this unit is based on */
2874 if (!is_device_path(what
))
2877 /* When device units aren't supported (such as in a
2878 * container), don't create dependencies on them. */
2879 if (!unit_type_supported(UNIT_DEVICE
))
2882 r
= unit_name_from_path(what
, ".device", &e
);
2886 r
= manager_load_unit(u
->manager
, e
, NULL
, NULL
, &device
);
2890 r
= unit_add_two_dependencies(u
, UNIT_AFTER
,
2891 u
->manager
->running_as
== MANAGER_SYSTEM
? dep
: UNIT_WANTS
,
2897 r
= unit_add_dependency(device
, UNIT_WANTS
, u
, false);
2905 int unit_coldplug(Unit
*u
) {
2910 /* Make sure we don't enter a loop, when coldplugging
2915 u
->coldplugged
= true;
2917 if (UNIT_VTABLE(u
)->coldplug
)
2918 r
= UNIT_VTABLE(u
)->coldplug(u
);
2921 q
= job_coldplug(u
->job
);
2931 bool unit_need_daemon_reload(Unit
*u
) {
2932 _cleanup_strv_free_
char **t
= NULL
;
2935 unsigned loaded_cnt
, current_cnt
;
2939 if (u
->fragment_path
) {
2941 if (stat(u
->fragment_path
, &st
) < 0)
2942 /* What, cannot access this anymore? */
2945 if (u
->fragment_mtime
> 0 &&
2946 timespec_load(&st
.st_mtim
) != u
->fragment_mtime
)
2950 if (u
->source_path
) {
2952 if (stat(u
->source_path
, &st
) < 0)
2955 if (u
->source_mtime
> 0 &&
2956 timespec_load(&st
.st_mtim
) != u
->source_mtime
)
2960 (void) unit_find_dropin_paths(u
, &t
);
2961 loaded_cnt
= strv_length(t
);
2962 current_cnt
= strv_length(u
->dropin_paths
);
2964 if (loaded_cnt
== current_cnt
) {
2965 if (loaded_cnt
== 0)
2968 if (strv_overlap(u
->dropin_paths
, t
)) {
2969 STRV_FOREACH(path
, u
->dropin_paths
) {
2971 if (stat(*path
, &st
) < 0)
2974 if (u
->dropin_mtime
> 0 &&
2975 timespec_load(&st
.st_mtim
) > u
->dropin_mtime
)
2986 void unit_reset_failed(Unit
*u
) {
2989 if (UNIT_VTABLE(u
)->reset_failed
)
2990 UNIT_VTABLE(u
)->reset_failed(u
);
2993 Unit
*unit_following(Unit
*u
) {
2996 if (UNIT_VTABLE(u
)->following
)
2997 return UNIT_VTABLE(u
)->following(u
);
3002 bool unit_stop_pending(Unit
*u
) {
3005 /* This call does check the current state of the unit. It's
3006 * hence useful to be called from state change calls of the
3007 * unit itself, where the state isn't updated yet. This is
3008 * different from unit_inactive_or_pending() which checks both
3009 * the current state and for a queued job. */
3011 return u
->job
&& u
->job
->type
== JOB_STOP
;
3014 bool unit_inactive_or_pending(Unit
*u
) {
3017 /* Returns true if the unit is inactive or going down */
3019 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)))
3022 if (unit_stop_pending(u
))
3028 bool unit_active_or_pending(Unit
*u
) {
3031 /* Returns true if the unit is active or going up */
3033 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
3037 (u
->job
->type
== JOB_START
||
3038 u
->job
->type
== JOB_RELOAD_OR_START
||
3039 u
->job
->type
== JOB_RESTART
))
3045 int unit_kill(Unit
*u
, KillWho w
, int signo
, sd_bus_error
*error
) {
3047 assert(w
>= 0 && w
< _KILL_WHO_MAX
);
3049 assert(signo
< _NSIG
);
3051 if (!UNIT_VTABLE(u
)->kill
)
3054 return UNIT_VTABLE(u
)->kill(u
, w
, signo
, error
);
3057 static Set
*unit_pid_set(pid_t main_pid
, pid_t control_pid
) {
3061 pid_set
= set_new(NULL
);
3065 /* Exclude the main/control pids from being killed via the cgroup */
3067 r
= set_put(pid_set
, PID_TO_PTR(main_pid
));
3072 if (control_pid
> 0) {
3073 r
= set_put(pid_set
, PID_TO_PTR(control_pid
));
3085 int unit_kill_common(
3091 sd_bus_error
*error
) {
3094 bool killed
= false;
3096 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
)) {
3098 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no main processes", unit_type_to_string(u
->type
));
3099 else if (main_pid
== 0)
3100 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No main process to kill");
3103 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
)) {
3104 if (control_pid
< 0)
3105 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_PROCESS
, "%s units have no control processes", unit_type_to_string(u
->type
));
3106 else if (control_pid
== 0)
3107 return sd_bus_error_set_const(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
3110 if (IN_SET(who
, KILL_CONTROL
, KILL_CONTROL_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3111 if (control_pid
> 0) {
3112 if (kill(control_pid
, signo
) < 0)
3118 if (IN_SET(who
, KILL_MAIN
, KILL_MAIN_FAIL
, KILL_ALL
, KILL_ALL_FAIL
))
3120 if (kill(main_pid
, signo
) < 0)
3126 if (IN_SET(who
, KILL_ALL
, KILL_ALL_FAIL
) && u
->cgroup_path
) {
3127 _cleanup_set_free_ Set
*pid_set
= NULL
;
3130 /* Exclude the main/control pids from being killed via the cgroup */
3131 pid_set
= unit_pid_set(main_pid
, control_pid
);
3135 q
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, signo
, false, false, false, pid_set
);
3136 if (q
< 0 && q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
3142 if (r
== 0 && !killed
&& IN_SET(who
, KILL_ALL_FAIL
, KILL_CONTROL_FAIL
))
3148 int unit_following_set(Unit
*u
, Set
**s
) {
3152 if (UNIT_VTABLE(u
)->following_set
)
3153 return UNIT_VTABLE(u
)->following_set(u
, s
);
3159 UnitFileState
unit_get_unit_file_state(Unit
*u
) {
3164 if (u
->unit_file_state
< 0 && u
->fragment_path
) {
3165 r
= unit_file_get_state(
3166 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3168 basename(u
->fragment_path
),
3169 &u
->unit_file_state
);
3171 u
->unit_file_state
= UNIT_FILE_BAD
;
3174 return u
->unit_file_state
;
3177 int unit_get_unit_file_preset(Unit
*u
) {
3180 if (u
->unit_file_preset
< 0 && u
->fragment_path
)
3181 u
->unit_file_preset
= unit_file_query_preset(
3182 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
3184 basename(u
->fragment_path
));
3186 return u
->unit_file_preset
;
3189 Unit
* unit_ref_set(UnitRef
*ref
, Unit
*u
) {
3194 unit_ref_unset(ref
);
3197 LIST_PREPEND(refs
, u
->refs
, ref
);
3201 void unit_ref_unset(UnitRef
*ref
) {
3207 LIST_REMOVE(refs
, ref
->unit
->refs
, ref
);
3211 int unit_patch_contexts(Unit
*u
) {
3219 /* Patch in the manager defaults into the exec and cgroup
3220 * contexts, _after_ the rest of the settings have been
3223 ec
= unit_get_exec_context(u
);
3225 /* This only copies in the ones that need memory */
3226 for (i
= 0; i
< _RLIMIT_MAX
; i
++)
3227 if (u
->manager
->rlimit
[i
] && !ec
->rlimit
[i
]) {
3228 ec
->rlimit
[i
] = newdup(struct rlimit
, u
->manager
->rlimit
[i
], 1);
3233 if (u
->manager
->running_as
== MANAGER_USER
&&
3234 !ec
->working_directory
) {
3236 r
= get_home_dir(&ec
->working_directory
);
3240 /* Allow user services to run, even if the
3241 * home directory is missing */
3242 ec
->working_directory_missing_ok
= true;
3245 if (u
->manager
->running_as
== MANAGER_USER
&&
3246 (ec
->syscall_whitelist
||
3247 !set_isempty(ec
->syscall_filter
) ||
3248 !set_isempty(ec
->syscall_archs
) ||
3249 ec
->address_families_whitelist
||
3250 !set_isempty(ec
->address_families
)))
3251 ec
->no_new_privileges
= true;
3253 if (ec
->private_devices
)
3254 ec
->capability_bounding_set
&= ~(UINT64_C(1) << CAP_MKNOD
);
3257 cc
= unit_get_cgroup_context(u
);
3261 ec
->private_devices
&&
3262 cc
->device_policy
== CGROUP_AUTO
)
3263 cc
->device_policy
= CGROUP_CLOSED
;
3269 ExecContext
*unit_get_exec_context(Unit
*u
) {
3276 offset
= UNIT_VTABLE(u
)->exec_context_offset
;
3280 return (ExecContext
*) ((uint8_t*) u
+ offset
);
3283 KillContext
*unit_get_kill_context(Unit
*u
) {
3290 offset
= UNIT_VTABLE(u
)->kill_context_offset
;
3294 return (KillContext
*) ((uint8_t*) u
+ offset
);
3297 CGroupContext
*unit_get_cgroup_context(Unit
*u
) {
3303 offset
= UNIT_VTABLE(u
)->cgroup_context_offset
;
3307 return (CGroupContext
*) ((uint8_t*) u
+ offset
);
3310 ExecRuntime
*unit_get_exec_runtime(Unit
*u
) {
3316 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3320 return *(ExecRuntime
**) ((uint8_t*) u
+ offset
);
3323 static int unit_drop_in_dir(Unit
*u
, UnitSetPropertiesMode mode
, bool transient
, char **dir
) {
3326 if (u
->manager
->running_as
== MANAGER_USER
) {
3329 if (mode
== UNIT_PERSISTENT
&& !transient
)
3330 r
= user_config_home(dir
);
3332 r
= user_runtime_dir(dir
);
3339 if (mode
== UNIT_PERSISTENT
&& !transient
)
3340 *dir
= strdup("/etc/systemd/system");
3342 *dir
= strdup("/run/systemd/system");
3349 int unit_write_drop_in(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3351 _cleanup_free_
char *dir
= NULL
, *p
= NULL
, *q
= NULL
;
3356 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3359 r
= unit_drop_in_dir(u
, mode
, u
->transient
, &dir
);
3363 r
= write_drop_in(dir
, u
->id
, 50, name
, data
);
3367 r
= drop_in_file(dir
, u
->id
, 50, name
, &p
, &q
);
3371 r
= strv_extend(&u
->dropin_paths
, q
);
3375 strv_sort(u
->dropin_paths
);
3376 strv_uniq(u
->dropin_paths
);
3378 u
->dropin_mtime
= now(CLOCK_REALTIME
);
3383 int unit_write_drop_in_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3384 _cleanup_free_
char *p
= NULL
;
3392 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3395 va_start(ap
, format
);
3396 r
= vasprintf(&p
, format
, ap
);
3402 return unit_write_drop_in(u
, mode
, name
, p
);
3405 int unit_write_drop_in_private(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *data
) {
3406 _cleanup_free_
char *ndata
= NULL
;
3412 if (!UNIT_VTABLE(u
)->private_section
)
3415 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3418 ndata
= strjoin("[", UNIT_VTABLE(u
)->private_section
, "]\n", data
, NULL
);
3422 return unit_write_drop_in(u
, mode
, name
, ndata
);
3425 int unit_write_drop_in_private_format(Unit
*u
, UnitSetPropertiesMode mode
, const char *name
, const char *format
, ...) {
3426 _cleanup_free_
char *p
= NULL
;
3434 if (!IN_SET(mode
, UNIT_PERSISTENT
, UNIT_RUNTIME
))
3437 va_start(ap
, format
);
3438 r
= vasprintf(&p
, format
, ap
);
3444 return unit_write_drop_in_private(u
, mode
, name
, p
);
3447 int unit_make_transient(Unit
*u
) {
3450 if (!UNIT_VTABLE(u
)->can_transient
)
3453 u
->load_state
= UNIT_STUB
;
3455 u
->transient
= true;
3457 u
->fragment_path
= mfree(u
->fragment_path
);
3458 u
->source_path
= mfree(u
->source_path
);
3459 u
->dropin_paths
= strv_free(u
->dropin_paths
);
3460 u
->fragment_mtime
= u
->source_mtime
= u
->dropin_mtime
= 0;
3462 unit_add_to_dbus_queue(u
);
3463 unit_add_to_gc_queue(u
);
3464 unit_add_to_load_queue(u
);
3469 int unit_kill_context(
3475 bool main_pid_alien
) {
3477 bool wait_for_exit
= false;
3483 if (c
->kill_mode
== KILL_NONE
)
3493 case KILL_TERMINATE
:
3494 sig
= c
->kill_signal
;
3497 assert_not_reached("KillOperation unknown");
3501 r
= kill_and_sigcont(main_pid
, sig
);
3503 if (r
< 0 && r
!= -ESRCH
) {
3504 _cleanup_free_
char *comm
= NULL
;
3505 get_process_comm(main_pid
, &comm
);
3507 log_unit_warning_errno(u
, r
, "Failed to kill main process " PID_FMT
" (%s), ignoring: %m", main_pid
, strna(comm
));
3509 if (!main_pid_alien
)
3510 wait_for_exit
= true;
3512 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3513 (void) kill(main_pid
, SIGHUP
);
3517 if (control_pid
> 0) {
3518 r
= kill_and_sigcont(control_pid
, sig
);
3520 if (r
< 0 && r
!= -ESRCH
) {
3521 _cleanup_free_
char *comm
= NULL
;
3522 get_process_comm(control_pid
, &comm
);
3524 log_unit_warning_errno(u
, r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m", control_pid
, strna(comm
));
3526 wait_for_exit
= true;
3528 if (c
->send_sighup
&& k
== KILL_TERMINATE
)
3529 (void) kill(control_pid
, SIGHUP
);
3533 if (u
->cgroup_path
&&
3534 (c
->kill_mode
== KILL_CONTROL_GROUP
|| (c
->kill_mode
== KILL_MIXED
&& k
== KILL_KILL
))) {
3535 _cleanup_set_free_ Set
*pid_set
= NULL
;
3537 /* Exclude the main/control pids from being killed via the cgroup */
3538 pid_set
= unit_pid_set(main_pid
, control_pid
);
3542 r
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, sig
, true, k
!= KILL_TERMINATE
, false, pid_set
);
3544 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
3545 log_unit_warning_errno(u
, r
, "Failed to kill control group %s, ignoring: %m", u
->cgroup_path
);
3549 /* FIXME: For now, on the legacy hierarchy, we
3550 * will not wait for the cgroup members to die
3551 * if we are running in a container or if this
3552 * is a delegation unit, simply because cgroup
3553 * notification is unreliable in these
3554 * cases. It doesn't work at all in
3555 * containers, and outside of containers it
3556 * can be confused easily by left-over
3557 * directories in the cgroup -- which however
3558 * should not exist in non-delegated units. On
3559 * the unified hierarchy that's different,
3560 * there we get proper events. Hence rely on
3563 if (cg_unified() > 0 ||
3564 (detect_container() == 0 && !unit_cgroup_delegate(u
)))
3565 wait_for_exit
= true;
3567 if (c
->send_sighup
&& k
!= KILL_KILL
) {
3570 pid_set
= unit_pid_set(main_pid
, control_pid
);
3574 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
, SIGHUP
, false, true, false, pid_set
);
3579 return wait_for_exit
;
3582 int unit_require_mounts_for(Unit
*u
, const char *path
) {
3583 char prefix
[strlen(path
) + 1], *p
;
3589 /* Registers a unit for requiring a certain path and all its
3590 * prefixes. We keep a simple array of these paths in the
3591 * unit, since its usually short. However, we build a prefix
3592 * table for all possible prefixes so that new appearing mount
3593 * units can easily determine which units to make themselves a
3596 if (!path_is_absolute(path
))
3603 path_kill_slashes(p
);
3605 if (!path_is_safe(p
)) {
3610 if (strv_contains(u
->requires_mounts_for
, p
)) {
3615 r
= strv_consume(&u
->requires_mounts_for
, p
);
3619 PATH_FOREACH_PREFIX_MORE(prefix
, p
) {
3622 x
= hashmap_get(u
->manager
->units_requiring_mounts_for
, prefix
);
3626 r
= hashmap_ensure_allocated(&u
->manager
->units_requiring_mounts_for
, &string_hash_ops
);
3640 r
= hashmap_put(u
->manager
->units_requiring_mounts_for
, q
, x
);
3656 int unit_setup_exec_runtime(Unit
*u
) {
3662 offset
= UNIT_VTABLE(u
)->exec_runtime_offset
;
3665 /* Check if there already is an ExecRuntime for this unit? */
3666 rt
= (ExecRuntime
**) ((uint8_t*) u
+ offset
);
3670 /* Try to get it from somebody else */
3671 SET_FOREACH(other
, u
->dependencies
[UNIT_JOINS_NAMESPACE_OF
], i
) {
3673 *rt
= unit_get_exec_runtime(other
);
3675 exec_runtime_ref(*rt
);
3680 return exec_runtime_make(rt
, unit_get_exec_context(u
), u
->id
);
3683 bool unit_type_supported(UnitType t
) {
3684 if (_unlikely_(t
< 0))
3686 if (_unlikely_(t
>= _UNIT_TYPE_MAX
))
3689 if (!unit_vtable
[t
]->supported
)
3692 return unit_vtable
[t
]->supported();
3695 void unit_warn_if_dir_nonempty(Unit
*u
, const char* where
) {
3701 r
= dir_is_empty(where
);
3705 log_unit_warning_errno(u
, r
, "Failed to check directory %s: %m", where
);
3709 log_struct(LOG_NOTICE
,
3710 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3712 LOG_UNIT_MESSAGE(u
, "Directory %s to mount over is not empty, mounting anyway.", where
),
3717 int unit_fail_if_symlink(Unit
*u
, const char* where
) {
3723 r
= is_symlink(where
);
3725 log_unit_debug_errno(u
, r
, "Failed to check symlink %s, ignoring: %m", where
);
3732 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING
),
3734 LOG_UNIT_MESSAGE(u
, "Mount on symlink %s not allowed.", where
),
3741 bool unit_is_pristine(Unit
*u
) {
3744 /* Check if the unit already exists or is already around,
3745 * in a number of different ways. Note that to cater for unit
3746 * types such as slice, we are generally fine with units that
3747 * are marked UNIT_LOADED even even though nothing was
3748 * actually loaded, as those unit types don't require a file
3749 * on disk to validly load. */
3751 return !(!IN_SET(u
->load_state
, UNIT_NOT_FOUND
, UNIT_LOADED
) ||
3754 !strv_isempty(u
->dropin_paths
) ||