Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include "bus-util.h"
4 : : #include "bus-wait-for-units.h"
5 : : #include "hashmap.h"
6 : : #include "string-util.h"
7 : : #include "strv.h"
8 : : #include "unit-def.h"
9 : :
10 : : typedef struct WaitForItem {
11 : : BusWaitForUnits *parent;
12 : :
13 : : BusWaitForUnitsFlags flags;
14 : :
15 : : char *bus_path;
16 : :
17 : : sd_bus_slot *slot_get_all;
18 : : sd_bus_slot *slot_properties_changed;
19 : :
20 : : bus_wait_for_units_unit_callback unit_callback;
21 : : void *userdata;
22 : :
23 : : char *active_state;
24 : : uint32_t job_id;
25 : : char *clean_result;
26 : : } WaitForItem;
27 : :
28 : : typedef struct BusWaitForUnits {
29 : : sd_bus *bus;
30 : : sd_bus_slot *slot_disconnected;
31 : :
32 : : Hashmap *items;
33 : :
34 : : bus_wait_for_units_ready_callback ready_callback;
35 : : void *userdata;
36 : :
37 : : WaitForItem *current;
38 : :
39 : : BusWaitForUnitsState state;
40 : : bool has_failed:1;
41 : : } BusWaitForUnits;
42 : :
43 : 0 : static WaitForItem *wait_for_item_free(WaitForItem *item) {
44 : : int r;
45 : :
46 [ # # ]: 0 : if (!item)
47 : 0 : return NULL;
48 : :
49 [ # # ]: 0 : if (item->parent) {
50 [ # # # # : 0 : if (FLAGS_SET(item->flags, BUS_WAIT_REFFED) && item->bus_path && item->parent->bus) {
# # ]
51 : 0 : r = sd_bus_call_method_async(
52 : 0 : item->parent->bus,
53 : : NULL,
54 : : "org.freedesktop.systemd1",
55 : 0 : item->bus_path,
56 : : "org.freedesktop.systemd1.Unit",
57 : : "Unref",
58 : : NULL,
59 : : NULL,
60 : : NULL);
61 [ # # ]: 0 : if (r < 0)
62 [ # # ]: 0 : log_debug_errno(r, "Failed to drop reference to unit %s, ignoring: %m", item->bus_path);
63 : : }
64 : :
65 [ # # ]: 0 : assert_se(hashmap_remove(item->parent->items, item->bus_path) == item);
66 : :
67 [ # # ]: 0 : if (item->parent->current == item)
68 : 0 : item->parent->current = NULL;
69 : : }
70 : :
71 : 0 : sd_bus_slot_unref(item->slot_properties_changed);
72 : 0 : sd_bus_slot_unref(item->slot_get_all);
73 : :
74 : 0 : free(item->bus_path);
75 : 0 : free(item->active_state);
76 : 0 : free(item->clean_result);
77 : :
78 : 0 : return mfree(item);
79 : : }
80 : :
81 [ # # ]: 0 : DEFINE_TRIVIAL_CLEANUP_FUNC(WaitForItem*, wait_for_item_free);
82 : :
83 : 0 : static void bus_wait_for_units_clear(BusWaitForUnits *d) {
84 : : WaitForItem *item;
85 : :
86 [ # # ]: 0 : assert(d);
87 : :
88 : 0 : d->slot_disconnected = sd_bus_slot_unref(d->slot_disconnected);
89 : 0 : d->bus = sd_bus_unref(d->bus);
90 : :
91 [ # # ]: 0 : while ((item = hashmap_first(d->items))) {
92 : 0 : d->current = item;
93 : :
94 : 0 : item->unit_callback(d, item->bus_path, false, item->userdata);
95 : 0 : wait_for_item_free(item);
96 : : }
97 : :
98 : 0 : d->items = hashmap_free(d->items);
99 : 0 : }
100 : :
101 : 0 : static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *error) {
102 : 0 : BusWaitForUnits *d = userdata;
103 : :
104 [ # # ]: 0 : assert(m);
105 [ # # ]: 0 : assert(d);
106 : :
107 [ # # ]: 0 : log_error("Warning! D-Bus connection terminated.");
108 : :
109 : 0 : bus_wait_for_units_clear(d);
110 : :
111 [ # # ]: 0 : if (d->ready_callback)
112 : 0 : d->ready_callback(d, false, d->userdata);
113 : : else /* If no ready callback is specified close the connection so that the event loop exits */
114 : 0 : sd_bus_close(sd_bus_message_get_bus(m));
115 : :
116 : 0 : return 0;
117 : : }
118 : :
119 : 0 : int bus_wait_for_units_new(sd_bus *bus, BusWaitForUnits **ret) {
120 : 0 : _cleanup_(bus_wait_for_units_freep) BusWaitForUnits *d = NULL;
121 : : int r;
122 : :
123 [ # # ]: 0 : assert(bus);
124 [ # # ]: 0 : assert(ret);
125 : :
126 : 0 : d = new(BusWaitForUnits, 1);
127 [ # # ]: 0 : if (!d)
128 : 0 : return -ENOMEM;
129 : :
130 : 0 : *d = (BusWaitForUnits) {
131 : : .state = BUS_WAIT_SUCCESS,
132 : 0 : .bus = sd_bus_ref(bus),
133 : : };
134 : :
135 : 0 : r = sd_bus_match_signal_async(
136 : : bus,
137 : 0 : &d->slot_disconnected,
138 : : "org.freedesktop.DBus.Local",
139 : : NULL,
140 : : "org.freedesktop.DBus.Local",
141 : : "Disconnected",
142 : : match_disconnected, NULL, d);
143 [ # # ]: 0 : if (r < 0)
144 : 0 : return r;
145 : :
146 : 0 : *ret = TAKE_PTR(d);
147 : 0 : return 0;
148 : : }
149 : :
150 : 0 : BusWaitForUnits* bus_wait_for_units_free(BusWaitForUnits *d) {
151 [ # # ]: 0 : if (!d)
152 : 0 : return NULL;
153 : :
154 : 0 : bus_wait_for_units_clear(d);
155 : 0 : sd_bus_slot_unref(d->slot_disconnected);
156 : 0 : sd_bus_unref(d->bus);
157 : :
158 : 0 : return mfree(d);
159 : : }
160 : :
161 : 0 : static bool bus_wait_for_units_is_ready(BusWaitForUnits *d) {
162 [ # # ]: 0 : assert(d);
163 : :
164 [ # # ]: 0 : if (!d->bus) /* Disconnected? */
165 : 0 : return true;
166 : :
167 : 0 : return hashmap_isempty(d->items);
168 : : }
169 : :
170 : 0 : void bus_wait_for_units_set_ready_callback(BusWaitForUnits *d, bus_wait_for_units_ready_callback callback, void *userdata) {
171 [ # # ]: 0 : assert(d);
172 : :
173 : 0 : d->ready_callback = callback;
174 : 0 : d->userdata = userdata;
175 : 0 : }
176 : :
177 : 0 : static void bus_wait_for_units_check_ready(BusWaitForUnits *d) {
178 [ # # ]: 0 : assert(d);
179 : :
180 [ # # ]: 0 : if (!bus_wait_for_units_is_ready(d))
181 : 0 : return;
182 : :
183 : 0 : d->state = d->has_failed ? BUS_WAIT_FAILURE : BUS_WAIT_SUCCESS;
184 : :
185 [ # # ]: 0 : if (d->ready_callback)
186 : 0 : d->ready_callback(d, d->state, d->userdata);
187 : : }
188 : :
189 : 0 : static void wait_for_item_check_ready(WaitForItem *item) {
190 : : BusWaitForUnits *d;
191 : :
192 [ # # ]: 0 : assert(item);
193 [ # # ]: 0 : assert_se(d = item->parent);
194 : :
195 [ # # ]: 0 : if (FLAGS_SET(item->flags, BUS_WAIT_FOR_MAINTENANCE_END)) {
196 : :
197 [ # # # # ]: 0 : if (item->clean_result && !streq(item->clean_result, "success"))
198 : 0 : d->has_failed = true;
199 : :
200 [ # # # # ]: 0 : if (!item->active_state || streq(item->active_state, "maintenance"))
201 : 0 : return;
202 : : }
203 : :
204 [ # # # # ]: 0 : if (FLAGS_SET(item->flags, BUS_WAIT_NO_JOB) && item->job_id != 0)
205 : 0 : return;
206 : :
207 [ # # ]: 0 : if (FLAGS_SET(item->flags, BUS_WAIT_FOR_INACTIVE)) {
208 : :
209 [ # # ]: 0 : if (streq_ptr(item->active_state, "failed"))
210 : 0 : d->has_failed = true;
211 [ # # ]: 0 : else if (!streq_ptr(item->active_state, "inactive"))
212 : 0 : return;
213 : : }
214 : :
215 [ # # ]: 0 : if (item->unit_callback) {
216 : 0 : d->current = item;
217 : 0 : item->unit_callback(d, item->bus_path, true, item->userdata);
218 : : }
219 : :
220 : 0 : wait_for_item_free(item);
221 : :
222 : 0 : bus_wait_for_units_check_ready(d);
223 : : }
224 : :
225 : 0 : static int property_map_job(
226 : : sd_bus *bus,
227 : : const char *member,
228 : : sd_bus_message *m,
229 : : sd_bus_error *error,
230 : : void *userdata) {
231 : :
232 : 0 : WaitForItem *item = userdata;
233 : : const char *path;
234 : : uint32_t id;
235 : : int r;
236 : :
237 [ # # ]: 0 : assert(item);
238 : :
239 : 0 : r = sd_bus_message_read(m, "(uo)", &id, &path);
240 [ # # ]: 0 : if (r < 0)
241 : 0 : return r;
242 : :
243 : 0 : item->job_id = id;
244 : 0 : return 0;
245 : : }
246 : :
247 : 0 : static int wait_for_item_parse_properties(WaitForItem *item, sd_bus_message *m) {
248 : :
249 : : static const struct bus_properties_map map[] = {
250 : : { "ActiveState", "s", NULL, offsetof(WaitForItem, active_state) },
251 : : { "Job", "(uo)", property_map_job, 0 },
252 : : { "CleanResult", "s", NULL, offsetof(WaitForItem, clean_result) },
253 : : {}
254 : : };
255 : :
256 : : int r;
257 : :
258 [ # # ]: 0 : assert(item);
259 [ # # ]: 0 : assert(m);
260 : :
261 : 0 : r = bus_message_map_all_properties(m, map, BUS_MAP_STRDUP, NULL, item);
262 [ # # ]: 0 : if (r < 0)
263 : 0 : return r;
264 : :
265 : 0 : wait_for_item_check_ready(item);
266 : 0 : return 0;
267 : : }
268 : :
269 : 0 : static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
270 : 0 : WaitForItem *item = userdata;
271 : : const char *interface;
272 : : int r;
273 : :
274 [ # # ]: 0 : assert(item);
275 : :
276 : 0 : r = sd_bus_message_read(m, "s", &interface);
277 [ # # ]: 0 : if (r < 0) {
278 [ # # ]: 0 : log_debug_errno(r, "Failed to parse PropertiesChanged signal: %m");
279 : 0 : return 0;
280 : : }
281 : :
282 [ # # ]: 0 : if (!streq(interface, "org.freedesktop.systemd1.Unit"))
283 : 0 : return 0;
284 : :
285 : 0 : r = wait_for_item_parse_properties(item, m);
286 [ # # ]: 0 : if (r < 0)
287 [ # # ]: 0 : log_debug_errno(r, "Failed to process PropertiesChanged signal: %m");
288 : :
289 : 0 : return 0;
290 : : }
291 : :
292 : 0 : static int on_get_all_properties(sd_bus_message *m, void *userdata, sd_bus_error *error) {
293 : 0 : WaitForItem *item = userdata;
294 : : int r;
295 : :
296 [ # # ]: 0 : assert(item);
297 : :
298 [ # # ]: 0 : if (sd_bus_error_is_set(error)) {
299 : 0 : BusWaitForUnits *d = item->parent;
300 : :
301 : 0 : d->has_failed = true;
302 : :
303 [ # # ]: 0 : log_debug_errno(sd_bus_error_get_errno(error), "GetAll() failed for %s: %s",
304 : : item->bus_path, error->message);
305 : :
306 : 0 : d->current = item;
307 : 0 : item->unit_callback(d, item->bus_path, false, item->userdata);
308 : 0 : wait_for_item_free(item);
309 : :
310 : 0 : bus_wait_for_units_check_ready(d);
311 : 0 : return 0;
312 : : }
313 : :
314 : 0 : r = wait_for_item_parse_properties(item, m);
315 [ # # ]: 0 : if (r < 0)
316 [ # # ]: 0 : log_debug_errno(r, "Failed to process GetAll method reply: %m");
317 : :
318 : 0 : return 0;
319 : : }
320 : :
321 : 0 : int bus_wait_for_units_add_unit(
322 : : BusWaitForUnits *d,
323 : : const char *unit,
324 : : BusWaitForUnitsFlags flags,
325 : : bus_wait_for_units_unit_callback callback,
326 : : void *userdata) {
327 : :
328 : 0 : _cleanup_(wait_for_item_freep) WaitForItem *item = NULL;
329 : : int r;
330 : :
331 [ # # ]: 0 : assert(d);
332 [ # # ]: 0 : assert(unit);
333 : :
334 [ # # ]: 0 : assert(flags != 0);
335 : :
336 : 0 : r = hashmap_ensure_allocated(&d->items, &string_hash_ops);
337 [ # # ]: 0 : if (r < 0)
338 : 0 : return r;
339 : :
340 : 0 : item = new(WaitForItem, 1);
341 [ # # ]: 0 : if (!item)
342 : 0 : return -ENOMEM;
343 : :
344 : 0 : *item = (WaitForItem) {
345 : : .flags = flags,
346 : 0 : .bus_path = unit_dbus_path_from_name(unit),
347 : : .unit_callback = callback,
348 : : .userdata = userdata,
349 : : .job_id = UINT32_MAX,
350 : : };
351 : :
352 [ # # ]: 0 : if (!item->bus_path)
353 : 0 : return -ENOMEM;
354 : :
355 [ # # ]: 0 : if (!FLAGS_SET(item->flags, BUS_WAIT_REFFED)) {
356 : 0 : r = sd_bus_call_method_async(
357 : : d->bus,
358 : : NULL,
359 : : "org.freedesktop.systemd1",
360 : 0 : item->bus_path,
361 : : "org.freedesktop.systemd1.Unit",
362 : : "Ref",
363 : : NULL,
364 : : NULL,
365 : : NULL);
366 [ # # ]: 0 : if (r < 0)
367 [ # # ]: 0 : return log_debug_errno(r, "Failed to add reference to unit %s: %m", unit);
368 : :
369 : 0 : item->flags |= BUS_WAIT_REFFED;
370 : : }
371 : :
372 : 0 : r = sd_bus_match_signal_async(
373 : : d->bus,
374 : 0 : &item->slot_properties_changed,
375 : : "org.freedesktop.systemd1",
376 : 0 : item->bus_path,
377 : : "org.freedesktop.DBus.Properties",
378 : : "PropertiesChanged",
379 : : on_properties_changed,
380 : : NULL,
381 : : item);
382 [ # # ]: 0 : if (r < 0)
383 [ # # ]: 0 : return log_debug_errno(r, "Failed to request match for PropertiesChanged signal: %m");
384 : :
385 : 0 : r = sd_bus_call_method_async(
386 : : d->bus,
387 : 0 : &item->slot_get_all,
388 : : "org.freedesktop.systemd1",
389 : 0 : item->bus_path,
390 : : "org.freedesktop.DBus.Properties",
391 : : "GetAll",
392 : : on_get_all_properties,
393 : : item,
394 [ # # ]: 0 : "s", FLAGS_SET(item->flags, BUS_WAIT_FOR_MAINTENANCE_END) ? NULL : "org.freedesktop.systemd1.Unit");
395 [ # # ]: 0 : if (r < 0)
396 [ # # ]: 0 : return log_debug_errno(r, "Failed to request properties of unit %s: %m", unit);
397 : :
398 : 0 : r = hashmap_put(d->items, item->bus_path, item);
399 [ # # ]: 0 : if (r < 0)
400 : 0 : return r;
401 : :
402 : 0 : d->state = BUS_WAIT_RUNNING;
403 : 0 : item->parent = d;
404 : 0 : TAKE_PTR(item);
405 : 0 : return 0;
406 : : }
407 : :
408 : 0 : int bus_wait_for_units_run(BusWaitForUnits *d) {
409 : : int r;
410 : :
411 [ # # ]: 0 : assert(d);
412 : :
413 [ # # ]: 0 : while (d->state == BUS_WAIT_RUNNING) {
414 : :
415 : 0 : r = sd_bus_process(d->bus, NULL);
416 [ # # ]: 0 : if (r < 0)
417 : 0 : return r;
418 [ # # ]: 0 : if (r > 0)
419 : 0 : continue;
420 : :
421 : 0 : r = sd_bus_wait(d->bus, (uint64_t) -1);
422 [ # # ]: 0 : if (r < 0)
423 : 0 : return r;
424 : : }
425 : :
426 : 0 : return d->state;
427 : : }
428 : :
429 : 0 : BusWaitForUnitsState bus_wait_for_units_state(BusWaitForUnits *d) {
430 [ # # ]: 0 : assert(d);
431 : :
432 : 0 : return d->state;
433 : : }
|
