]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
daf71ef6 LP |
2 | |
3 | #include <unistd.h> | |
4 | ||
5 | #include "sd-login.h" | |
6 | ||
7 | #include "bus-map-properties.h" | |
8 | #include "hostname-util.h" | |
9 | #include "locale-util.h" | |
10 | #include "memory-util.h" | |
11 | #include "sort-util.h" | |
12 | #include "systemctl-list-machines.h" | |
13 | #include "systemctl-util.h" | |
14 | #include "systemctl.h" | |
15 | #include "terminal-util.h" | |
16 | ||
17 | const struct bus_properties_map machine_info_property_map[] = { | |
18 | { "SystemState", "s", NULL, offsetof(struct machine_info, state) }, | |
19 | { "NJobs", "u", NULL, offsetof(struct machine_info, n_jobs) }, | |
20 | { "NFailedUnits", "u", NULL, offsetof(struct machine_info, n_failed_units) }, | |
21 | { "ControlGroup", "s", NULL, offsetof(struct machine_info, control_group) }, | |
22 | { "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp) }, | |
23 | {} | |
24 | }; | |
25 | ||
26 | void machine_info_clear(struct machine_info *info) { | |
27 | assert(info); | |
28 | ||
29 | free(info->name); | |
30 | free(info->state); | |
31 | free(info->control_group); | |
32 | zero(*info); | |
33 | } | |
34 | ||
35 | static void free_machines_list(struct machine_info *machine_infos, int n) { | |
daf71ef6 LP |
36 | if (!machine_infos) |
37 | return; | |
38 | ||
deaf4b86 | 39 | for (int i = 0; i < n; i++) |
daf71ef6 LP |
40 | machine_info_clear(&machine_infos[i]); |
41 | ||
42 | free(machine_infos); | |
43 | } | |
44 | ||
45 | static int compare_machine_info(const struct machine_info *a, const struct machine_info *b) { | |
46 | int r; | |
47 | ||
48 | r = CMP(b->is_host, a->is_host); | |
49 | if (r != 0) | |
50 | return r; | |
51 | ||
52 | return strcasecmp(a->name, b->name); | |
53 | } | |
54 | ||
55 | static int get_machine_properties(sd_bus *bus, struct machine_info *mi) { | |
56 | _cleanup_(sd_bus_flush_close_unrefp) sd_bus *container = NULL; | |
57 | int r; | |
58 | ||
59 | assert(mi); | |
60 | ||
61 | if (!bus) { | |
62 | r = sd_bus_open_system_machine(&container, mi->name); | |
63 | if (r < 0) | |
64 | return r; | |
65 | ||
66 | bus = container; | |
67 | } | |
68 | ||
69 | r = bus_map_all_properties( | |
70 | bus, | |
71 | "org.freedesktop.systemd1", | |
72 | "/org/freedesktop/systemd1", | |
73 | machine_info_property_map, | |
74 | BUS_MAP_STRDUP, | |
75 | NULL, | |
76 | NULL, | |
77 | mi); | |
78 | if (r < 0) | |
79 | return r; | |
80 | ||
81 | return 0; | |
82 | } | |
83 | ||
84 | static bool output_show_machine(const char *name, char **patterns) { | |
85 | return strv_fnmatch_or_empty(patterns, name, FNM_NOESCAPE); | |
86 | } | |
87 | ||
88 | static int get_machine_list( | |
89 | sd_bus *bus, | |
90 | struct machine_info **_machine_infos, | |
91 | char **patterns) { | |
92 | ||
93 | struct machine_info *machine_infos = NULL; | |
94 | _cleanup_strv_free_ char **m = NULL; | |
95 | _cleanup_free_ char *hn = NULL; | |
daf71ef6 LP |
96 | int c = 0, r; |
97 | ||
98 | hn = gethostname_malloc(); | |
99 | if (!hn) | |
100 | return log_oom(); | |
101 | ||
102 | if (output_show_machine(hn, patterns)) { | |
319a4f4b | 103 | if (!GREEDY_REALLOC0(machine_infos, c+1)) |
daf71ef6 LP |
104 | return log_oom(); |
105 | ||
106 | machine_infos[c].is_host = true; | |
107 | machine_infos[c].name = TAKE_PTR(hn); | |
108 | ||
109 | (void) get_machine_properties(bus, &machine_infos[c]); | |
110 | c++; | |
111 | } | |
112 | ||
113 | r = sd_get_machine_names(&m); | |
114 | if (r < 0) | |
115 | return log_error_errno(r, "Failed to get machine list: %m"); | |
116 | ||
117 | STRV_FOREACH(i, m) { | |
118 | _cleanup_free_ char *class = NULL; | |
119 | ||
120 | if (!output_show_machine(*i, patterns)) | |
121 | continue; | |
122 | ||
123 | sd_machine_get_class(*i, &class); | |
124 | if (!streq_ptr(class, "container")) | |
125 | continue; | |
126 | ||
319a4f4b | 127 | if (!GREEDY_REALLOC0(machine_infos, c+1)) { |
daf71ef6 LP |
128 | free_machines_list(machine_infos, c); |
129 | return log_oom(); | |
130 | } | |
131 | ||
132 | machine_infos[c].is_host = false; | |
133 | machine_infos[c].name = strdup(*i); | |
134 | if (!machine_infos[c].name) { | |
135 | free_machines_list(machine_infos, c); | |
136 | return log_oom(); | |
137 | } | |
138 | ||
139 | (void) get_machine_properties(NULL, &machine_infos[c]); | |
140 | c++; | |
141 | } | |
142 | ||
143 | *_machine_infos = machine_infos; | |
144 | return c; | |
145 | } | |
146 | ||
147 | static int output_machines_list(struct machine_info *machine_infos, unsigned n) { | |
148 | _cleanup_(table_unrefp) Table *table = NULL; | |
daf71ef6 LP |
149 | bool state_missing = false; |
150 | int r; | |
151 | ||
152 | assert(machine_infos || n == 0); | |
153 | ||
154 | table = table_new("", "name", "state", "failed", "jobs"); | |
155 | if (!table) | |
156 | return log_oom(); | |
157 | ||
6906da26 | 158 | table_set_header(table, arg_legend != 0); |
daf71ef6 LP |
159 | if (arg_plain) { |
160 | /* Hide the 'glyph' column when --plain is requested */ | |
161 | r = table_hide_column_from_display(table, 0); | |
162 | if (r < 0) | |
163 | return log_error_errno(r, "Failed to hide column: %m"); | |
164 | } | |
165 | if (arg_full) | |
166 | table_set_width(table, 0); | |
167 | ||
168 | (void) table_set_empty_string(table, "-"); | |
169 | ||
deaf4b86 | 170 | for (struct machine_info *m = machine_infos; m < machine_infos + n; m++) { |
daf71ef6 LP |
171 | _cleanup_free_ char *mname = NULL; |
172 | const char *on_state = "", *on_failed = ""; | |
173 | bool circle = false; | |
174 | ||
175 | if (streq_ptr(m->state, "degraded")) { | |
176 | on_state = ansi_highlight_red(); | |
177 | circle = true; | |
178 | } else if (!streq_ptr(m->state, "running")) { | |
179 | on_state = ansi_highlight_yellow(); | |
180 | circle = true; | |
181 | } | |
182 | ||
183 | if (m->n_failed_units > 0) | |
184 | on_failed = ansi_highlight_red(); | |
185 | else | |
186 | on_failed = ""; | |
187 | ||
188 | if (!m->state) | |
189 | state_missing = true; | |
190 | ||
191 | if (m->is_host) | |
192 | mname = strjoin(strna(m->name), " (host)"); | |
193 | ||
194 | r = table_add_many(table, | |
195 | TABLE_STRING, circle ? special_glyph(SPECIAL_GLYPH_BLACK_CIRCLE) : " ", | |
196 | TABLE_SET_COLOR, on_state, | |
197 | TABLE_STRING, m->is_host ? mname : strna(m->name), | |
198 | TABLE_STRING, strna(m->state), | |
199 | TABLE_SET_COLOR, on_state, | |
200 | TABLE_UINT32, m->n_failed_units, | |
201 | TABLE_SET_COLOR, on_failed, | |
202 | TABLE_UINT32, m->n_jobs); | |
203 | if (r < 0) | |
204 | return table_log_add_error(r); | |
205 | } | |
206 | ||
207 | r = output_table(table); | |
208 | if (r < 0) | |
209 | return r; | |
210 | ||
6906da26 | 211 | if (arg_legend != 0) { |
daf71ef6 LP |
212 | printf("\n"); |
213 | if (state_missing && geteuid() != 0) | |
214 | printf("Notice: some information only available to privileged users was not shown.\n"); | |
215 | printf("%u machines listed.\n", n); | |
216 | } | |
217 | ||
218 | return 0; | |
219 | } | |
220 | ||
32baf64d | 221 | int verb_list_machines(int argc, char *argv[], void *userdata) { |
daf71ef6 LP |
222 | struct machine_info *machine_infos = NULL; |
223 | sd_bus *bus; | |
224 | int r, rc; | |
225 | ||
226 | r = acquire_bus(BUS_MANAGER, &bus); | |
227 | if (r < 0) | |
228 | return r; | |
229 | ||
230 | r = get_machine_list(bus, &machine_infos, strv_skip(argv, 1)); | |
231 | if (r < 0) | |
232 | return r; | |
233 | ||
384c2c32 | 234 | pager_open(arg_pager_flags); |
daf71ef6 LP |
235 | |
236 | typesafe_qsort(machine_infos, r, compare_machine_info); | |
237 | rc = output_machines_list(machine_infos, r); | |
238 | free_machines_list(machine_infos, r); | |
239 | ||
240 | return rc; | |
241 | } |