1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
3 #include "dbus-target.h"
8 #include "string-util.h"
10 #include "unit-name.h"
13 static const UnitActiveState state_translation_table
[_TARGET_STATE_MAX
] = {
14 [TARGET_DEAD
] = UNIT_INACTIVE
,
15 [TARGET_ACTIVE
] = UNIT_ACTIVE
18 static void target_set_state(Target
*t
, TargetState state
) {
19 TargetState old_state
;
22 if (t
->state
!= state
)
23 bus_unit_send_pending_change_signal(UNIT(t
), false);
28 if (state
!= old_state
)
29 log_debug("%s changed %s -> %s",
31 target_state_to_string(old_state
),
32 target_state_to_string(state
));
34 unit_notify(UNIT(t
), state_translation_table
[old_state
], state_translation_table
[state
], 0);
37 static int target_add_default_dependencies(Target
*t
) {
39 static const UnitDependency deps
[] = {
51 if (!UNIT(t
)->default_dependencies
)
54 /* Imply ordering for requirement dependencies on target units. Note that when the user created a contradicting
55 * ordering manually we won't add anything in here to make sure we don't create a loop. */
57 for (size_t k
= 0; k
< ELEMENTSOF(deps
); k
++) {
61 HASHMAP_FOREACH_KEY(v
, other
, UNIT(t
)->dependencies
[deps
[k
]]) {
62 r
= unit_add_default_target_dependency(other
, UNIT(t
));
68 if (unit_has_name(UNIT(t
), SPECIAL_SHUTDOWN_TARGET
))
71 /* Make sure targets are unloaded on shutdown */
72 return unit_add_two_dependencies_by_name(UNIT(t
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, true, UNIT_DEPENDENCY_DEFAULT
);
75 static int target_load(Unit
*u
) {
76 Target
*t
= TARGET(u
);
81 r
= unit_load_fragment_and_dropin(u
, true);
85 if (u
->load_state
!= UNIT_LOADED
)
88 /* This is a new unit? Then let's add in some extras */
89 return target_add_default_dependencies(t
);
92 static int target_coldplug(Unit
*u
) {
93 Target
*t
= TARGET(u
);
96 assert(t
->state
== TARGET_DEAD
);
98 if (t
->deserialized_state
!= t
->state
)
99 target_set_state(t
, t
->deserialized_state
);
104 static void target_dump(Unit
*u
, FILE *f
, const char *prefix
) {
105 Target
*t
= TARGET(u
);
111 "%sTarget State: %s\n",
112 prefix
, target_state_to_string(t
->state
));
115 static int target_start(Unit
*u
) {
116 Target
*t
= TARGET(u
);
120 assert(t
->state
== TARGET_DEAD
);
122 r
= unit_acquire_invocation_id(u
);
126 target_set_state(t
, TARGET_ACTIVE
);
130 static int target_stop(Unit
*u
) {
131 Target
*t
= TARGET(u
);
134 assert(t
->state
== TARGET_ACTIVE
);
136 target_set_state(t
, TARGET_DEAD
);
140 static int target_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
141 Target
*s
= TARGET(u
);
147 (void) serialize_item(f
, "state", target_state_to_string(s
->state
));
151 static int target_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
152 Target
*s
= TARGET(u
);
159 if (streq(key
, "state")) {
162 state
= target_state_from_string(value
);
164 log_debug("Failed to parse state value %s", value
);
166 s
->deserialized_state
= state
;
169 log_debug("Unknown serialization key '%s'", key
);
174 _pure_
static UnitActiveState
target_active_state(Unit
*u
) {
177 return state_translation_table
[TARGET(u
)->state
];
180 _pure_
static const char *target_sub_state_to_string(Unit
*u
) {
183 return target_state_to_string(TARGET(u
)->state
);
186 const UnitVTable target_vtable
= {
187 .object_size
= sizeof(Target
),
197 .coldplug
= target_coldplug
,
201 .start
= target_start
,
204 .serialize
= target_serialize
,
205 .deserialize_item
= target_deserialize_item
,
207 .active_state
= target_active_state
,
208 .sub_state_to_string
= target_sub_state_to_string
,
210 .status_message_formats
= {
211 .finished_start_job
= {
212 [JOB_DONE
] = "Reached target %s.",
214 .finished_stop_job
= {
215 [JOB_DONE
] = "Stopped target %s.",