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
) {
38 _cleanup_free_ Unit
**others
= NULL
;
43 if (!UNIT(t
)->default_dependencies
)
46 /* Imply ordering for requirement dependencies on target units. Note that when the user created a
47 * contradicting ordering manually we won't add anything in here to make sure we don't create a
50 * Note that quite likely iterating through these dependencies will add new dependencies, which
51 * conflicts with the hashmap-based iteration logic. Hence, instead of iterating through the
52 * dependencies and acting on them as we go, first take an "atomic snapshot" of sorts and iterate
55 n_others
= unit_get_dependency_array(UNIT(t
), UNIT_ATOM_ADD_DEFAULT_TARGET_DEPENDENCY_QUEUE
, &others
);
59 for (int i
= 0; i
< n_others
; i
++) {
60 r
= unit_add_default_target_dependency(others
[i
], UNIT(t
));
65 if (unit_has_name(UNIT(t
), SPECIAL_SHUTDOWN_TARGET
))
68 /* Make sure targets are unloaded on shutdown */
69 return unit_add_two_dependencies_by_name(UNIT(t
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, true, UNIT_DEPENDENCY_DEFAULT
);
72 static int target_load(Unit
*u
) {
73 Target
*t
= TARGET(u
);
78 r
= unit_load_fragment_and_dropin(u
, true);
82 if (u
->load_state
!= UNIT_LOADED
)
85 /* This is a new unit? Then let's add in some extras */
86 return target_add_default_dependencies(t
);
89 static int target_coldplug(Unit
*u
) {
90 Target
*t
= TARGET(u
);
93 assert(t
->state
== TARGET_DEAD
);
95 if (t
->deserialized_state
!= t
->state
)
96 target_set_state(t
, t
->deserialized_state
);
101 static void target_dump(Unit
*u
, FILE *f
, const char *prefix
) {
102 Target
*t
= TARGET(u
);
108 "%sTarget State: %s\n",
109 prefix
, target_state_to_string(t
->state
));
112 static int target_start(Unit
*u
) {
113 Target
*t
= TARGET(u
);
117 assert(t
->state
== TARGET_DEAD
);
119 r
= unit_acquire_invocation_id(u
);
123 target_set_state(t
, TARGET_ACTIVE
);
127 static int target_stop(Unit
*u
) {
128 Target
*t
= TARGET(u
);
131 assert(t
->state
== TARGET_ACTIVE
);
133 target_set_state(t
, TARGET_DEAD
);
137 static int target_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
138 Target
*s
= TARGET(u
);
144 (void) serialize_item(f
, "state", target_state_to_string(s
->state
));
148 static int target_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
149 Target
*s
= TARGET(u
);
157 if (streq(key
, "state")) {
160 state
= target_state_from_string(value
);
162 log_debug("Failed to parse state value %s", value
);
164 s
->deserialized_state
= state
;
167 log_debug("Unknown serialization key '%s'", key
);
172 _pure_
static UnitActiveState
target_active_state(Unit
*u
) {
175 return state_translation_table
[TARGET(u
)->state
];
178 _pure_
static const char *target_sub_state_to_string(Unit
*u
) {
181 return target_state_to_string(TARGET(u
)->state
);
184 const UnitVTable target_vtable
= {
185 .object_size
= sizeof(Target
),
195 .coldplug
= target_coldplug
,
199 .start
= target_start
,
202 .serialize
= target_serialize
,
203 .deserialize_item
= target_deserialize_item
,
205 .active_state
= target_active_state
,
206 .sub_state_to_string
= target_sub_state_to_string
,
208 .status_message_formats
= {
209 .finished_start_job
= {
210 [JOB_DONE
] = "Reached target %s.",
212 .finished_stop_job
= {
213 [JOB_DONE
] = "Stopped target %s.",