]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/systemctl/systemctl-list-units.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
man: improve Description= documentation (#38101)
[thirdparty/systemd.git] / src / systemctl / systemctl-list-units.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include "sd-bus.h"
4#include "sd-login.h"
5
6#include "alloc-util.h"
7#include "ansi-color.h"
8#include "bus-error.h"
9#include "bus-locator.h"
10#include "bus-message-util.h"
11#include "bus-unit-util.h"
12#include "bus-util.h"
13#include "format-table.h"
14#include "glyph-util.h"
15#include "path-util.h"
16#include "set.h"
17#include "sort-util.h"
18#include "string-util.h"
19#include "strv.h"
20#include "systemctl.h"
21#include "systemctl-list-units.h"
22#include "systemctl-util.h"
23#include "unit-def.h"
24#include "unit-name.h"
25
26static int get_unit_list_recursive(
27 sd_bus *bus,
28 char **patterns,
29 UnitInfo **ret_unit_infos,
30 Set **ret_replies) {
31
32 _cleanup_free_ UnitInfo *unit_infos = NULL;
33 _cleanup_set_free_ Set *replies = NULL;
34 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
35 int c, r;
36
37 assert(bus);
38 assert(ret_replies);
39 assert(ret_unit_infos);
40
41 c = get_unit_list(bus, NULL, patterns, &unit_infos, 0, &reply);
42 if (c < 0)
43 return c;
44
45 r = set_ensure_consume(&replies, &bus_message_hash_ops, TAKE_PTR(reply));
46 if (r < 0)
47 return log_oom();
48
49 if (arg_recursive) {
50 _cleanup_strv_free_ char **machines = NULL;
51
52 r = sd_get_machine_names(&machines);
53 if (r < 0)
54 return log_error_errno(r, "Failed to get machine names: %m");
55
56 STRV_FOREACH(i, machines) {
57 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *container = NULL;
58 int k;
59
60 r = sd_bus_open_system_machine(&container, *i);
61 if (r < 0) {
62 log_warning_errno(r, "Failed to connect to container %s, ignoring: %m", *i);
63 continue;
64 }
65
66 k = get_unit_list(container, *i, patterns, &unit_infos, c, &reply);
67 if (k < 0)
68 return k;
69
70 c = k;
71
72 r = set_consume(replies, TAKE_PTR(reply));
73 if (r < 0)
74 return log_oom();
75 }
76 }
77
78 *ret_unit_infos = TAKE_PTR(unit_infos);
79 *ret_replies = TAKE_PTR(replies);
80
81 return c;
82}
83
84static void output_legend(const char *type, size_t n_items) {
85 const char *on, *off;
86
87 assert(type);
88
89 on = n_items > 0 ? ansi_highlight() : ansi_highlight_red();
90 off = ansi_normal();
91
92 printf("\n%s%zu %ss listed.%s\n", on, n_items, type, off);
93 if (!arg_all)
94 printf("Pass --all to see loaded but inactive %ss, too.\n", type);
95}
96
97static int table_add_triggered(Table *table, char **triggered) {
98 assert(table);
99
100 if (strv_isempty(triggered))
101 return table_add_cell(table, NULL, TABLE_EMPTY, NULL);
102 else if (strv_length(triggered) == 1)
103 return table_add_cell(table, NULL, TABLE_STRING, triggered[0]);
104 else
105 /* This should never happen, currently our socket units can only trigger a
106 * single unit. But let's handle this anyway, who knows what the future
107 * brings? */
108 return table_add_cell(table, NULL, TABLE_STRV, triggered);
109}
110
111static char *format_unit_id(const char *unit, const char *machine) {
112 assert(unit);
113
114 return machine ? strjoin(machine, ":", unit) : strdup(unit);
115}
116
117static int output_units_list(const UnitInfo *unit_infos, size_t c) {
118 _cleanup_(table_unrefp) Table *table = NULL;
119 size_t job_count = 0;
120 int r;
121
122 table = table_new("", "unit", "load", "active", "sub", "job", "description");
123 if (!table)
124 return log_oom();
125
126 table_set_header(table, arg_legend != 0);
127 if (arg_plain) {
128 /* Hide the 'glyph' column when --plain is requested */
129 r = table_hide_column_from_display(table, 0);
130 if (r < 0)
131 return log_error_errno(r, "Failed to hide column: %m");
132 }
133 if (arg_full)
134 table_set_width(table, 0);
135
136 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
137
138 FOREACH_ARRAY(u, unit_infos, c) {
139 const char *on_loaded = NULL, *on_active = NULL, *on_sub = NULL, *on_circle = NULL;
140 _cleanup_free_ char *id = NULL;
141 bool circle = false, underline;
142
143 underline = u + 1 < unit_infos + c && !streq(unit_type_suffix(u->id), unit_type_suffix((u + 1)->id));
144
145 if (streq(u->load_state, "not-found")) {
146 on_circle = on_loaded = ansi_highlight_yellow();
147 circle = true;
148 } else if (STR_IN_SET(u->load_state, "bad-setting", "error", "masked")) {
149 on_loaded = ansi_highlight_red();
150 on_circle = ansi_highlight_yellow();
151 circle = true;
152 }
153
154 if (streq(u->active_state, "failed")) {
155 on_sub = on_active = ansi_highlight_red();
156
157 /* Here override any load_state highlighting */
158 on_circle = ansi_highlight_red();
159 circle = true;
160 } else if (STR_IN_SET(u->active_state, "reloading", "activating", "maintenance", "refreshing", "deactivating")) {
161 on_sub = on_active = ansi_highlight();
162
163 if (!circle) { /* Here we let load_state highlighting win */
164 on_circle = ansi_highlight();
165 circle = true;
166 }
167 } else if (streq(u->active_state, "inactive"))
168 on_sub = on_active = ansi_grey();
169
170 /* As a special case, when this is a service which has not process running, let's grey out
171 * its state, to highlight that a bit */
172 if (!on_sub && endswith(u->id, ".service") && streq(u->sub_state, "exited"))
173 on_sub = ansi_grey();
174
175 if (arg_plain)
176 circle = false;
177
178 id = format_unit_id(u->id, u->machine);
179 if (!id)
180 return log_oom();
181
182 r = table_add_many(table,
183 TABLE_STRING, circle ? glyph(GLYPH_BLACK_CIRCLE) : " ",
184 TABLE_SET_COLOR, on_circle,
185 TABLE_SET_BOTH_UNDERLINES, underline,
186 TABLE_STRING, id,
187 TABLE_SET_COLOR, on_active,
188 TABLE_SET_BOTH_UNDERLINES, underline,
189 TABLE_STRING, u->load_state,
190 TABLE_SET_COLOR, on_loaded,
191 TABLE_SET_BOTH_UNDERLINES, underline,
192 TABLE_STRING, u->active_state,
193 TABLE_SET_COLOR, on_active,
194 TABLE_SET_BOTH_UNDERLINES, underline,
195 TABLE_STRING, u->sub_state,
196 TABLE_SET_COLOR, on_sub,
197 TABLE_SET_BOTH_UNDERLINES, underline,
198 TABLE_STRING, u->job_id ? u->job_type: "",
199 TABLE_SET_BOTH_UNDERLINES, underline,
200 TABLE_STRING, u->description,
201 TABLE_SET_BOTH_UNDERLINES, underline);
202 if (r < 0)
203 return table_log_add_error(r);
204
205 if (u->job_id != 0)
206 job_count++;
207 }
208
209 if (job_count == 0) {
210 /* There's no data in the JOB column, so let's hide it */
211 r = table_hide_column_from_display(table, 5);
212 if (r < 0)
213 return log_error_errno(r, "Failed to hide column: %m");
214 }
215
216 r = output_table(table);
217 if (r < 0)
218 return r;
219
220 if (arg_legend != 0) {
221 const char *on, *off;
222 size_t records = table_get_rows(table) - 1;
223
224 if (records > 0) {
225 printf("\n"
226 "%1$sLegend: LOAD %2$s Reflects whether the unit definition was properly loaded.%3$s\n"
227 "%1$s ACTIVE %2$s The high-level unit activation state, i.e. generalization of SUB.%3$s\n"
228 "%1$s SUB %2$s The low-level unit activation state, values depend on unit type.%3$s\n",
229 ansi_grey(),
230 glyph(GLYPH_ARROW_RIGHT),
231 ansi_normal());
232 if (job_count > 0)
233 printf("%s JOB %s Pending job for the unit.%s\n",
234 ansi_grey(),
235 glyph(GLYPH_ARROW_RIGHT),
236 ansi_normal());
237 }
238
239 putchar('\n');
240
241 on = records > 0 ? ansi_highlight() : ansi_highlight_red();
242 off = ansi_normal();
243
244 if (arg_all || strv_contains(arg_states, "inactive"))
245 printf("%s%zu loaded units listed.%s\n"
246 "%sTo show all installed unit files use 'systemctl list-unit-files'.%s\n",
247 on, records, off,
248 ansi_grey(), ansi_normal());
249 else if (!arg_states)
250 printf("%s%zu loaded units listed.%s %sPass --all to see loaded but inactive units, too.%s\n"
251 "%sTo show all installed unit files use 'systemctl list-unit-files'.%s\n",
252 on, records, off,
253 ansi_grey(), ansi_normal(), ansi_grey(), ansi_normal());
254 else
255 printf("%zu loaded units listed.\n", records);
256 }
257
258 return 0;
259}
260
261int verb_list_units(int argc, char *argv[], void *userdata) {
262 _cleanup_free_ UnitInfo *unit_infos = NULL;
263 _cleanup_set_free_ Set *replies = NULL;
264 sd_bus *bus;
265 int r;
266
267 r = acquire_bus(BUS_MANAGER, &bus);
268 if (r < 0)
269 return r;
270
271 pager_open(arg_pager_flags);
272
273 if (arg_with_dependencies) {
274 _cleanup_strv_free_ char **names = NULL;
275
276 r = append_unit_dependencies(bus, strv_skip(argv, 1), &names);
277 if (r < 0)
278 return r;
279
280 r = get_unit_list_recursive(bus, names, &unit_infos, &replies);
281 if (r < 0)
282 return r;
283 } else {
284 r = get_unit_list_recursive(bus, strv_skip(argv, 1), &unit_infos, &replies);
285 if (r < 0)
286 return r;
287 }
288
289 typesafe_qsort(unit_infos, r, unit_info_compare);
290 return output_units_list(unit_infos, r);
291}
292
293static int get_triggered_units(
294 sd_bus *bus,
295 const char* path,
296 char*** ret) {
297
298 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
299 int r;
300
301 assert(bus);
302 assert(path);
303 assert(ret);
304
305 r = sd_bus_get_property_strv(
306 bus,
307 "org.freedesktop.systemd1",
308 path,
309 "org.freedesktop.systemd1.Unit",
310 "Triggers",
311 &error,
312 ret);
313 if (r < 0)
314 return log_error_errno(r, "Failed to determine triggers: %s", bus_error_message(&error, r));
315
316 return 0;
317}
318
319typedef struct SocketInfo {
320 const char *machine;
321 const char* id;
322
323 char* type;
324 char* path; /* absolute path or socket address */
325
326 /* Note: triggered is a list here, although it almost certainly will always be one
327 * unit. Nevertheless, dbus API allows for multiple values, so let's follow that. */
328 char** triggered;
329} SocketInfo;
330
331static void socket_info_array_free(SocketInfo *sockets, size_t n_sockets) {
332 assert(sockets || n_sockets == 0);
333
334 FOREACH_ARRAY(s, sockets, n_sockets) {
335 free(s->type);
336 free(s->path);
337 strv_free(s->triggered);
338 }
339
340 free(sockets);
341}
342
343static int socket_info_compare(const SocketInfo *a, const SocketInfo *b) {
344 int r;
345
346 assert(a);
347 assert(b);
348
349 r = strcasecmp_ptr(a->machine, b->machine);
350 if (r != 0)
351 return r;
352
353 r = CMP(path_is_absolute(a->path), path_is_absolute(b->path));
354 if (r != 0)
355 return r;
356
357 r = path_is_absolute(a->path) ? path_compare(a->path, b->path) : strcmp(a->path, b->path);
358 if (r != 0)
359 return r;
360
361 return strcmp(a->type, b->type);
362}
363
364static int socket_info_add(
365 sd_bus *bus,
366 const UnitInfo *u,
367 SocketInfo **sockets,
368 size_t *n_sockets) {
369
370 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
371 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
372 _cleanup_strv_free_ char **triggered = NULL;
373 const char *type, *path;
374 int r;
375
376 assert(bus);
377 assert(u);
378 assert(sockets);
379 assert(n_sockets);
380
381 if (!endswith(u->id, ".socket"))
382 return 0;
383
384 r = get_triggered_units(bus, u->unit_path, &triggered);
385 if (r < 0)
386 return r;
387
388 r = sd_bus_get_property(
389 bus,
390 "org.freedesktop.systemd1",
391 u->unit_path,
392 "org.freedesktop.systemd1.Socket",
393 "Listen",
394 &error,
395 &reply,
396 "a(ss)");
397 if (r < 0)
398 return log_error_errno(r, "Failed to get list of listening sockets: %s", bus_error_message(&error, r));
399
400 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
401 if (r < 0)
402 return bus_log_parse_error(r);
403
404 while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
405 _cleanup_free_ char *type_dup = NULL, *path_dup = NULL;
406 _cleanup_strv_free_ char **triggered_dup = NULL;
407
408 type_dup = strdup(type);
409 if (!type_dup)
410 return log_oom();
411
412 path_dup = strdup(path);
413 if (!path_dup)
414 return log_oom();
415
416 triggered_dup = strv_copy(triggered);
417 if (!triggered_dup)
418 return log_oom();
419
420 if (!GREEDY_REALLOC(*sockets, *n_sockets + 1))
421 return log_oom();
422
423 (*sockets)[(*n_sockets)++] = (SocketInfo) {
424 .machine = u->machine,
425 .id = u->id,
426 .type = TAKE_PTR(type_dup),
427 .path = TAKE_PTR(path_dup),
428 .triggered = TAKE_PTR(triggered_dup),
429 };
430 }
431 if (r < 0)
432 return bus_log_parse_error(r);
433
434 r = sd_bus_message_exit_container(reply);
435 if (r < 0)
436 return bus_log_parse_error(r);
437
438 return 0;
439}
440
441static int output_sockets_list(const SocketInfo *sockets, size_t n_sockets) {
442 _cleanup_(table_unrefp) Table *table = NULL;
443 int r;
444
445 assert(sockets || n_sockets == 0);
446
447 table = table_new("listen", "type", "unit", "activates");
448 if (!table)
449 return log_oom();
450
451 if (!arg_show_types) {
452 /* Hide the second (TYPE) column */
453 r = table_set_display(table, (size_t) 0, (size_t) 2, (size_t) 3);
454 if (r < 0)
455 return log_error_errno(r, "Failed to set columns to display: %m");
456 }
457
458 table_set_header(table, arg_legend != 0);
459 if (arg_full)
460 table_set_width(table, 0);
461
462 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
463
464 FOREACH_ARRAY(s, sockets, n_sockets) {
465 _cleanup_free_ char *unit = NULL;
466
467 unit = format_unit_id(s->id, s->machine);
468 if (!unit)
469 return log_oom();
470
471 r = table_add_many(table,
472 TABLE_STRING, s->path,
473 TABLE_STRING, s->type,
474 TABLE_STRING, unit);
475 if (r < 0)
476 return table_log_add_error(r);
477
478 r = table_add_triggered(table, s->triggered);
479 if (r < 0)
480 return table_log_add_error(r);
481 }
482
483 r = output_table(table);
484 if (r < 0)
485 return r;
486
487 if (arg_legend != 0)
488 output_legend("socket", n_sockets);
489
490 return 0;
491}
492
493int verb_list_sockets(int argc, char *argv[], void *userdata) {
494 _cleanup_set_free_ Set *replies = NULL;
495 _cleanup_strv_free_ char **sockets_with_suffix = NULL;
496 _cleanup_free_ UnitInfo *unit_infos = NULL;
497 SocketInfo *sockets = NULL;
498 size_t n_sockets = 0;
499 sd_bus *bus;
500 int r;
501
502 CLEANUP_ARRAY(sockets, n_sockets, socket_info_array_free);
503
504 r = acquire_bus(BUS_MANAGER, &bus);
505 if (r < 0)
506 return r;
507
508 pager_open(arg_pager_flags);
509
510 r = expand_unit_names(bus, strv_skip(argv, 1), ".socket", &sockets_with_suffix, NULL);
511 if (r < 0)
512 return r;
513
514 if (argc == 1 || sockets_with_suffix) {
515 int n;
516
517 n = get_unit_list_recursive(bus, sockets_with_suffix, &unit_infos, &replies);
518 if (n < 0)
519 return n;
520
521 FOREACH_ARRAY(u, unit_infos, n) {
522 r = socket_info_add(bus, u, &sockets, &n_sockets);
523 if (r < 0)
524 return r;
525 }
526 }
527
528 typesafe_qsort(sockets, n_sockets, socket_info_compare);
529 output_sockets_list(sockets, n_sockets);
530
531 return 0;
532}
533
534static int get_next_elapse(
535 sd_bus *bus,
536 const char *path,
537 dual_timestamp *next) {
538
539 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
540 dual_timestamp t;
541 int r;
542
543 assert(bus);
544 assert(path);
545 assert(next);
546
547 r = sd_bus_get_property_trivial(
548 bus,
549 "org.freedesktop.systemd1",
550 path,
551 "org.freedesktop.systemd1.Timer",
552 "NextElapseUSecMonotonic",
553 &error,
554 't',
555 &t.monotonic);
556 if (r < 0)
557 return log_error_errno(r, "Failed to get next elapse time: %s", bus_error_message(&error, r));
558
559 r = sd_bus_get_property_trivial(
560 bus,
561 "org.freedesktop.systemd1",
562 path,
563 "org.freedesktop.systemd1.Timer",
564 "NextElapseUSecRealtime",
565 &error,
566 't',
567 &t.realtime);
568 if (r < 0)
569 return log_error_errno(r, "Failed to get next elapse time: %s", bus_error_message(&error, r));
570
571 *next = t;
572 return 0;
573}
574
575static int get_last_trigger(
576 sd_bus *bus,
577 const char *path,
578 dual_timestamp *last) {
579
580 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
581 dual_timestamp t;
582 int r;
583
584 assert(bus);
585 assert(path);
586 assert(last);
587
588 r = sd_bus_get_property_trivial(
589 bus,
590 "org.freedesktop.systemd1",
591 path,
592 "org.freedesktop.systemd1.Timer",
593 "LastTriggerUSec",
594 &error,
595 't',
596 &t.realtime);
597 if (r < 0)
598 return log_error_errno(r, "Failed to get last trigger time: %s", bus_error_message(&error, r));
599
600 r = sd_bus_get_property_trivial(
601 bus,
602 "org.freedesktop.systemd1",
603 path,
604 "org.freedesktop.systemd1.Timer",
605 "LastTriggerUSecMonotonic",
606 &error,
607 't',
608 &t.monotonic);
609 if (r < 0)
610 return log_error_errno(r, "Failed to get last trigger time: %s", bus_error_message(&error, r));
611
612 *last = t;
613 return 0;
614}
615
616typedef struct TimerInfo {
617 const char* machine;
618 const char* id;
619 usec_t next_elapse;
620 dual_timestamp last_trigger;
621 char **triggered;
622} TimerInfo;
623
624static void timer_info_array_free(TimerInfo *timers, size_t n_timers) {
625 assert(timers || n_timers == 0);
626
627 FOREACH_ARRAY(t, timers, n_timers)
628 strv_free(t->triggered);
629
630 free(timers);
631}
632
633static int timer_info_compare(const TimerInfo *a, const TimerInfo *b) {
634 int r;
635
636 assert(a);
637 assert(b);
638
639 r = strcasecmp_ptr(a->machine, b->machine);
640 if (r != 0)
641 return r;
642
643 r = CMP(a->next_elapse, b->next_elapse);
644 if (r != 0)
645 return r;
646
647 return strcmp(a->id, b->id);
648}
649
650static int output_timers_list(const TimerInfo *timers, size_t n_timers) {
651 _cleanup_(table_unrefp) Table *table = NULL;
652 int r;
653
654 assert(timers || n_timers == 0);
655
656 table = table_new("next", "left", "last", "passed", "unit", "activates");
657 if (!table)
658 return log_oom();
659
660 table_set_header(table, arg_legend != 0);
661 if (arg_full)
662 table_set_width(table, 0);
663
664 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
665
666 (void) table_set_align_percent(table, table_get_cell(table, 0, 1), 100);
667 (void) table_set_align_percent(table, table_get_cell(table, 0, 3), 100);
668
669 FOREACH_ARRAY(t, timers, n_timers) {
670 _cleanup_free_ char *unit = NULL;
671
672 unit = format_unit_id(t->id, t->machine);
673 if (!unit)
674 return log_oom();
675
676 r = table_add_many(table,
677 TABLE_TIMESTAMP, t->next_elapse,
678 TABLE_TIMESTAMP_LEFT, t->next_elapse,
679 TABLE_TIMESTAMP, t->last_trigger.realtime,
680 TABLE_TIMESTAMP_RELATIVE_MONOTONIC, t->last_trigger.monotonic,
681 TABLE_STRING, unit);
682 if (r < 0)
683 return table_log_add_error(r);
684
685 r = table_add_triggered(table, t->triggered);
686 if (r < 0)
687 return table_log_add_error(r);
688 }
689
690 r = output_table(table);
691 if (r < 0)
692 return r;
693
694 if (arg_legend != 0)
695 output_legend("timer", n_timers);
696
697 return 0;
698}
699
700usec_t calc_next_elapse(const dual_timestamp *nw, const dual_timestamp *next) {
701 usec_t next_elapse;
702
703 assert(nw);
704 assert(next);
705
706 if (timestamp_is_set(next->monotonic)) {
707 usec_t converted;
708
709 if (next->monotonic > nw->monotonic)
710 converted = nw->realtime + (next->monotonic - nw->monotonic);
711 else
712 converted = nw->realtime - (nw->monotonic - next->monotonic);
713
714 if (timestamp_is_set(next->realtime))
715 next_elapse = MIN(converted, next->realtime);
716 else
717 next_elapse = converted;
718
719 } else
720 next_elapse = next->realtime;
721
722 return next_elapse;
723}
724
725static int add_timer_info(
726 sd_bus *bus,
727 const UnitInfo *u,
728 const dual_timestamp *nw,
729 TimerInfo **timers,
730 size_t *n_timers) {
731
732 _cleanup_strv_free_ char **triggered = NULL;
733 dual_timestamp next, last;
734 usec_t m;
735 int r;
736
737 assert(bus);
738 assert(u);
739 assert(nw);
740 assert(timers);
741 assert(n_timers);
742
743 if (!endswith(u->id, ".timer"))
744 return 0;
745
746 r = get_triggered_units(bus, u->unit_path, &triggered);
747 if (r < 0)
748 return r;
749
750 r = get_next_elapse(bus, u->unit_path, &next);
751 if (r < 0)
752 return r;
753
754 r = get_last_trigger(bus, u->unit_path, &last);
755 if (r < 0)
756 return r;
757
758 m = calc_next_elapse(nw, &next);
759
760 if (!GREEDY_REALLOC(*timers, *n_timers + 1))
761 return log_oom();
762
763 (*timers)[(*n_timers)++] = (TimerInfo) {
764 .machine = u->machine,
765 .id = u->id,
766 .next_elapse = m,
767 .last_trigger = last,
768 .triggered = TAKE_PTR(triggered),
769 };
770
771 return 0;
772}
773
774int verb_list_timers(int argc, char *argv[], void *userdata) {
775 _cleanup_set_free_ Set *replies = NULL;
776 _cleanup_strv_free_ char **timers_with_suffix = NULL;
777 _cleanup_free_ UnitInfo *unit_infos = NULL;
778 TimerInfo *timers = NULL;
779 size_t n_timers = 0;
780 sd_bus *bus;
781 int r;
782
783 CLEANUP_ARRAY(timers, n_timers, timer_info_array_free);
784
785 r = acquire_bus(BUS_MANAGER, &bus);
786 if (r < 0)
787 return r;
788
789 pager_open(arg_pager_flags);
790
791 r = expand_unit_names(bus, strv_skip(argv, 1), ".timer", &timers_with_suffix, NULL);
792 if (r < 0)
793 return r;
794
795 if (argc == 1 || timers_with_suffix) {
796 dual_timestamp nw;
797 int n;
798
799 n = get_unit_list_recursive(bus, timers_with_suffix, &unit_infos, &replies);
800 if (n < 0)
801 return n;
802
803 dual_timestamp_now(&nw);
804
805 FOREACH_ARRAY(u, unit_infos, n) {
806 r = add_timer_info(bus, u, &nw, &timers, &n_timers);
807 if (r < 0)
808 return r;
809 }
810 }
811
812 typesafe_qsort(timers, n_timers, timer_info_compare);
813 output_timers_list(timers, n_timers);
814
815 return 0;
816}
817
818typedef struct AutomountInfo {
819 const char *machine;
820 const char *id;
821 char *what;
822 char *where;
823 usec_t timeout_idle_usec;
824 bool mounted;
825} AutomountInfo;
826
827static void automount_info_array_free(AutomountInfo *automounts, size_t n_automounts) {
828 assert(automounts || n_automounts == 0);
829
830 FOREACH_ARRAY(i, automounts, n_automounts) {
831 free(i->what);
832 free(i->where);
833 }
834
835 free(automounts);
836}
837
838static int automount_info_compare(const AutomountInfo *a, const AutomountInfo *b) {
839 int r;
840
841 assert(a);
842 assert(b);
843
844 r = strcasecmp_ptr(a->machine, b->machine);
845 if (r != 0)
846 return r;
847
848 return path_compare(a->where, b->where);
849}
850
851static int automount_info_add(
852 sd_bus* bus,
853 const UnitInfo *info,
854 AutomountInfo **automounts,
855 size_t *n_automounts) {
856
857 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
858 _cleanup_free_ char *mount = NULL, *mount_path = NULL, *where = NULL, *what = NULL, *state = NULL;
859 uint64_t timeout_idle_usec;
860 BusLocator locator;
861 int r;
862
863 assert(bus);
864 assert(info);
865 assert(automounts);
866 assert(n_automounts);
867
868 if (!endswith(info->id, ".automount"))
869 return 0;
870
871 locator = (BusLocator) {
872 .destination = "org.freedesktop.systemd1",
873 .path = info->unit_path,
874 .interface = "org.freedesktop.systemd1.Automount",
875 };
876
877 r = bus_get_property_string(bus, &locator, "Where", &error, &where);
878 if (r < 0)
879 return log_error_errno(r, "Failed to get automount target: %s", bus_error_message(&error, r));
880
881 r = bus_get_property_trivial(bus, &locator, "TimeoutIdleUSec", &error, 't', &timeout_idle_usec);
882 if (r < 0)
883 return log_error_errno(r, "Failed to get idle timeout: %s", bus_error_message(&error, r));
884
885 r = unit_name_from_path(where, ".mount", &mount);
886 if (r < 0)
887 return log_error_errno(r, "Failed to generate unit name from path: %m");
888
889 mount_path = unit_dbus_path_from_name(mount);
890 if (!mount_path)
891 return log_oom();
892
893 locator.path = mount_path;
894 locator.interface = "org.freedesktop.systemd1.Mount";
895
896 r = bus_get_property_string(bus, &locator, "What", &error, &what);
897 if (r < 0)
898 return log_error_errno(r, "Failed to get mount source: %s", bus_error_message(&error, r));
899
900 locator.interface = "org.freedesktop.systemd1.Unit";
901
902 r = bus_get_property_string(bus, &locator, "ActiveState", &error, &state);
903 if (r < 0)
904 return log_error_errno(r, "Failed to get mount state: %s", bus_error_message(&error, r));
905
906 if (!GREEDY_REALLOC(*automounts, *n_automounts + 1))
907 return log_oom();
908
909 (*automounts)[(*n_automounts)++] = (AutomountInfo) {
910 .machine = info->machine,
911 .id = info->id,
912 .what = TAKE_PTR(what),
913 .where = TAKE_PTR(where),
914 .timeout_idle_usec = timeout_idle_usec,
915 .mounted = streq_ptr(state, "active"),
916 };
917
918 return 0;
919}
920
921static int output_automounts_list(const AutomountInfo *infos, size_t n_infos) {
922 _cleanup_(table_unrefp) Table *table = NULL;
923 int r;
924
925 assert(infos || n_infos == 0);
926
927 table = table_new("what", "where", "mounted", "idle timeout", "unit");
928 if (!table)
929 return log_oom();
930
931 table_set_header(table, arg_legend != 0);
932 if (arg_full)
933 table_set_width(table, 0);
934
935 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
936
937 FOREACH_ARRAY(info, infos, n_infos) {
938 _cleanup_free_ char *unit = NULL;
939
940 unit = format_unit_id(info->id, info->machine);
941 if (!unit)
942 return log_oom();
943
944 r = table_add_many(table,
945 TABLE_STRING, info->what,
946 TABLE_STRING, info->where,
947 TABLE_BOOLEAN, info->mounted);
948 if (r < 0)
949 return table_log_add_error(r);
950
951 if (timestamp_is_set(info->timeout_idle_usec))
952 r = table_add_cell(table, NULL, TABLE_TIMESPAN_MSEC, &info->timeout_idle_usec);
953 else
954 r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
955 if (r < 0)
956 return table_log_add_error(r);
957
958 r = table_add_cell(table, NULL, TABLE_STRING, unit);
959 if (r < 0)
960 return table_log_add_error(r);
961 }
962
963 r = output_table(table);
964 if (r < 0)
965 return r;
966
967 if (arg_legend != 0)
968 output_legend("automount", n_infos);
969
970 return 0;
971}
972
973int verb_list_automounts(int argc, char *argv[], void *userdata) {
974 _cleanup_set_free_ Set *replies = NULL;
975 _cleanup_strv_free_ char **names = NULL;
976 _cleanup_free_ UnitInfo *unit_infos = NULL;
977 AutomountInfo *automounts = NULL;
978 size_t n_automounts = 0;
979 sd_bus *bus;
980 int r;
981
982 CLEANUP_ARRAY(automounts, n_automounts, automount_info_array_free);
983
984 r = acquire_bus(BUS_MANAGER, &bus);
985 if (r < 0)
986 return r;
987
988 pager_open(arg_pager_flags);
989
990 r = expand_unit_names(bus, strv_skip(argv, 1), ".automount", &names, NULL);
991 if (r < 0)
992 return r;
993
994 if (argc == 1 || automounts) {
995 int n;
996
997 n = get_unit_list_recursive(bus, names, &unit_infos, &replies);
998 if (n < 0)
999 return n;
1000
1001 FOREACH_ARRAY(u, unit_infos, n) {
1002 r = automount_info_add(bus, u, &automounts, &n_automounts);
1003 if (r < 0)
1004 return r;
1005 }
1006
1007 }
1008
1009 typesafe_qsort(automounts, n_automounts, automount_info_compare);
1010 output_automounts_list(automounts, n_automounts);
1011
1012 return 0;
1013}
1014
1015typedef struct PathInfo {
1016 const char *machine;
1017 const char *id;
1018
1019 char *path;
1020 char *condition;
1021
1022 /* Note: triggered is a list here, although it almost certainly will always be one
1023 * unit. Nevertheless, dbus API allows for multiple values, so let's follow that. */
1024 char** triggered;
1025} PathInfo;
1026
1027static int path_info_compare(const PathInfo *a, const PathInfo *b) {
1028 int r;
1029
1030 assert(a);
1031 assert(b);
1032
1033 r = strcasecmp_ptr(a->machine, b->machine);
1034 if (r != 0)
1035 return r;
1036
1037 r = path_compare(a->path, b->path);
1038 if (r != 0)
1039 return r;
1040
1041 r = strcmp(a->condition, b->condition);
1042 if (r != 0)
1043 return r;
1044
1045 return strcasecmp_ptr(a->id, b->id);
1046}
1047
1048static void path_info_array_free(PathInfo *paths, size_t n_paths) {
1049 assert(paths || n_paths == 0);
1050
1051 FOREACH_ARRAY(p, paths, n_paths) {
1052 free(p->condition);
1053 free(p->path);
1054 strv_free(p->triggered);
1055 }
1056
1057 free(paths);
1058}
1059
1060static int path_info_add(
1061 sd_bus *bus,
1062 const struct UnitInfo *u,
1063 PathInfo **paths,
1064 size_t *n_paths) {
1065
1066 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1067 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1068 _cleanup_strv_free_ char **triggered = NULL;
1069 const char *condition, *path;
1070 int r;
1071
1072 assert(bus);
1073 assert(u);
1074 assert(paths);
1075 assert(n_paths);
1076
1077 if (!endswith(u->id, ".path"))
1078 return 0;
1079
1080 r = get_triggered_units(bus, u->unit_path, &triggered);
1081 if (r < 0)
1082 return r;
1083
1084 r = sd_bus_get_property(bus,
1085 "org.freedesktop.systemd1",
1086 u->unit_path,
1087 "org.freedesktop.systemd1.Path",
1088 "Paths",
1089 &error,
1090 &reply,
1091 "a(ss)");
1092 if (r < 0)
1093 return log_error_errno(r, "Failed to get paths: %s", bus_error_message(&error, r));
1094
1095 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
1096 if (r < 0)
1097 return bus_log_parse_error(r);
1098
1099 while ((r = sd_bus_message_read(reply, "(ss)", &condition, &path)) > 0) {
1100 _cleanup_free_ char *condition_dup = NULL, *path_dup = NULL;
1101 _cleanup_strv_free_ char **triggered_dup = NULL;
1102
1103 condition_dup = strdup(condition);
1104 if (!condition_dup)
1105 return log_oom();
1106
1107 path_dup = strdup(path);
1108 if (!path_dup)
1109 return log_oom();
1110
1111 triggered_dup = strv_copy(triggered);
1112 if (!triggered_dup)
1113 return log_oom();
1114
1115 if (!GREEDY_REALLOC(*paths, *n_paths + 1))
1116 return log_oom();
1117
1118 (*paths)[(*n_paths)++] = (PathInfo) {
1119 .machine = u->machine,
1120 .id = u->id,
1121 .condition = TAKE_PTR(condition_dup),
1122 .path = TAKE_PTR(path_dup),
1123 .triggered = TAKE_PTR(triggered_dup),
1124 };
1125 }
1126 if (r < 0)
1127 return bus_log_parse_error(r);
1128
1129 r = sd_bus_message_exit_container(reply);
1130 if (r < 0)
1131 return bus_log_parse_error(r);
1132
1133 return 0;
1134}
1135
1136static int output_paths_list(const PathInfo *paths, size_t n_paths) {
1137 _cleanup_(table_unrefp) Table *table = NULL;
1138 int r;
1139
1140 assert(paths || n_paths == 0);
1141
1142 table = table_new("path", "condition", "unit", "activates");
1143 if (!table)
1144 return log_oom();
1145
1146 table_set_header(table, arg_legend != 0);
1147 if (arg_full)
1148 table_set_width(table, 0);
1149
1150 table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
1151
1152 FOREACH_ARRAY(p, paths, n_paths) {
1153 _cleanup_free_ char *unit = NULL;
1154
1155 unit = format_unit_id(p->id, p->machine);
1156 if (!unit)
1157 return log_oom();
1158
1159 r = table_add_many(table,
1160 TABLE_STRING, p->path,
1161 TABLE_STRING, p->condition,
1162 TABLE_STRING, unit);
1163 if (r < 0)
1164 return table_log_add_error(r);
1165
1166 r = table_add_triggered(table, p->triggered);
1167 if (r < 0)
1168 return table_log_add_error(r);
1169 }
1170
1171 r = output_table(table);
1172 if (r < 0)
1173 return r;
1174
1175 if (arg_legend != 0)
1176 output_legend("path", n_paths);
1177
1178 return 0;
1179}
1180
1181int verb_list_paths(int argc, char *argv[], void *userdata) {
1182 _cleanup_set_free_ Set *replies = NULL;
1183 _cleanup_strv_free_ char **units = NULL;
1184 _cleanup_free_ UnitInfo *unit_infos = NULL;
1185 PathInfo *paths = NULL;
1186 size_t n_paths = 0;
1187 sd_bus *bus;
1188 int r;
1189
1190 CLEANUP_ARRAY(paths, n_paths, path_info_array_free);
1191
1192 r = acquire_bus(BUS_MANAGER, &bus);
1193 if (r < 0)
1194 return r;
1195
1196 pager_open(arg_pager_flags);
1197
1198 r = expand_unit_names(bus, strv_skip(argv, 1), ".path", &units, NULL);
1199 if (r < 0)
1200 return r;
1201
1202 if (argc == 1 || units) {
1203 int n;
1204
1205 n = get_unit_list_recursive(bus, units, &unit_infos, &replies);
1206 if (n < 0)
1207 return n;
1208
1209 FOREACH_ARRAY(u, unit_infos, n) {
1210 r = path_info_add(bus, u, &paths, &n_paths);
1211 if (r < 0)
1212 return r;
1213 }
1214 }
1215
1216 typesafe_qsort(paths, n_paths, path_info_compare);
1217 output_paths_list(paths, n_paths);
1218
1219 return 0;
1220}
Unnamed repository; edit this file 'description' to name the repository.