]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/analyze/analyze.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #10694 from evverx/udev-test-in-container
[thirdparty/systemd.git] / src / analyze / analyze.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 Copyright © 2013 Simon Peeters
4 ***/
5
6 #include <getopt.h>
7 #include <inttypes.h>
8 #include <locale.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11
12 #include "sd-bus.h"
13
14 #include "alloc-util.h"
15 #include "analyze-verify.h"
16 #include "bus-error.h"
17 #include "bus-unit-util.h"
18 #include "bus-util.h"
19 #include "calendarspec.h"
20 #include "def.h"
21 #include "conf-files.h"
22 #include "copy.h"
23 #include "fd-util.h"
24 #include "glob-util.h"
25 #include "hashmap.h"
26 #include "locale-util.h"
27 #include "log.h"
28 #include "pager.h"
29 #include "parse-util.h"
30 #include "path-util.h"
31 #if HAVE_SECCOMP
32 #include "seccomp-util.h"
33 #endif
34 #include "special.h"
35 #include "strv.h"
36 #include "strxcpyx.h"
37 #include "time-util.h"
38 #include "terminal-util.h"
39 #include "unit-name.h"
40 #include "util.h"
41 #include "verbs.h"
42
43 #define SCALE_X (0.1 / 1000.0) /* pixels per us */
44 #define SCALE_Y (20.0)
45
46 #define svg(...) printf(__VA_ARGS__)
47
48 #define svg_bar(class, x1, x2, y) \
49 svg(" <rect class=\"%s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n", \
50 (class), \
51 SCALE_X * (x1), SCALE_Y * (y), \
52 SCALE_X * ((x2) - (x1)), SCALE_Y - 1.0)
53
54 #define svg_text(b, x, y, format, ...) \
55 do { \
56 svg(" <text class=\"%s\" x=\"%.03f\" y=\"%.03f\">", (b) ? "left" : "right", SCALE_X * (x) + (b ? 5.0 : -5.0), SCALE_Y * (y) + 14.0); \
57 svg(format, ## __VA_ARGS__); \
58 svg("</text>\n"); \
59 } while (false)
60
61 static enum dot {
62 DEP_ALL,
63 DEP_ORDER,
64 DEP_REQUIRE
65 } arg_dot = DEP_ALL;
66 static char** arg_dot_from_patterns = NULL;
67 static char** arg_dot_to_patterns = NULL;
68 static usec_t arg_fuzz = 0;
69 static bool arg_no_pager = false;
70 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
71 static const char *arg_host = NULL;
72 static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
73 static bool arg_man = true;
74 static bool arg_generators = false;
75 static const char *arg_root = NULL;
76
77 struct boot_times {
78 usec_t firmware_time;
79 usec_t loader_time;
80 usec_t kernel_time;
81 usec_t kernel_done_time;
82 usec_t initrd_time;
83 usec_t userspace_time;
84 usec_t finish_time;
85 usec_t security_start_time;
86 usec_t security_finish_time;
87 usec_t generators_start_time;
88 usec_t generators_finish_time;
89 usec_t unitsload_start_time;
90 usec_t unitsload_finish_time;
91 usec_t initrd_security_start_time;
92 usec_t initrd_security_finish_time;
93 usec_t initrd_generators_start_time;
94 usec_t initrd_generators_finish_time;
95 usec_t initrd_unitsload_start_time;
96 usec_t initrd_unitsload_finish_time;
97
98 /*
99 * If we're analyzing the user instance, all timestamps will be offset
100 * by its own start-up timestamp, which may be arbitrarily big.
101 * With "plot", this causes arbitrarily wide output SVG files which almost
102 * completely consist of empty space. Thus we cancel out this offset.
103 *
104 * This offset is subtracted from times above by acquire_boot_times(),
105 * but it still needs to be subtracted from unit-specific timestamps
106 * (so it is stored here for reference).
107 */
108 usec_t reverse_offset;
109 };
110
111 struct unit_times {
112 bool has_data;
113 char *name;
114 usec_t activating;
115 usec_t activated;
116 usec_t deactivated;
117 usec_t deactivating;
118 usec_t time;
119 };
120
121 struct host_info {
122 char *hostname;
123 char *kernel_name;
124 char *kernel_release;
125 char *kernel_version;
126 char *os_pretty_name;
127 char *virtualization;
128 char *architecture;
129 };
130
131 static int acquire_bus(sd_bus **bus, bool *use_full_bus) {
132 bool user = arg_scope != UNIT_FILE_SYSTEM;
133 int r;
134
135 if (use_full_bus && *use_full_bus) {
136 r = bus_connect_transport(arg_transport, arg_host, user, bus);
137 if (IN_SET(r, 0, -EHOSTDOWN))
138 return r;
139
140 *use_full_bus = false;
141 }
142
143 return bus_connect_transport_systemd(arg_transport, arg_host, user, bus);
144 }
145
146 static int bus_get_uint64_property(sd_bus *bus, const char *path, const char *interface, const char *property, uint64_t *val) {
147 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
148 int r;
149
150 assert(bus);
151 assert(path);
152 assert(interface);
153 assert(property);
154 assert(val);
155
156 r = sd_bus_get_property_trivial(
157 bus,
158 "org.freedesktop.systemd1",
159 path,
160 interface,
161 property,
162 &error,
163 't', val);
164
165 if (r < 0)
166 return log_error_errno(r, "Failed to parse reply: %s", bus_error_message(&error, -r));
167
168 return 0;
169 }
170
171 static int bus_get_unit_property_strv(sd_bus *bus, const char *path, const char *property, char ***strv) {
172 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
173 int r;
174
175 assert(bus);
176 assert(path);
177 assert(property);
178 assert(strv);
179
180 r = sd_bus_get_property_strv(
181 bus,
182 "org.freedesktop.systemd1",
183 path,
184 "org.freedesktop.systemd1.Unit",
185 property,
186 &error,
187 strv);
188 if (r < 0)
189 return log_error_errno(r, "Failed to get unit property %s: %s", property, bus_error_message(&error, -r));
190
191 return 0;
192 }
193
194 static int compare_unit_time(const struct unit_times *a, const struct unit_times *b) {
195 return CMP(b->time, a->time);
196 }
197
198 static int compare_unit_start(const struct unit_times *a, const struct unit_times *b) {
199 return CMP(a->activating, b->activating);
200 }
201
202 static void unit_times_free(struct unit_times *t) {
203 struct unit_times *p;
204
205 for (p = t; p->has_data; p++)
206 free(p->name);
207 free(t);
208 }
209
210 DEFINE_TRIVIAL_CLEANUP_FUNC(struct unit_times *, unit_times_free);
211
212 static void subtract_timestamp(usec_t *a, usec_t b) {
213 assert(a);
214
215 if (*a > 0) {
216 assert(*a >= b);
217 *a -= b;
218 }
219 }
220
221 static int acquire_boot_times(sd_bus *bus, struct boot_times **bt) {
222 static const struct bus_properties_map property_map[] = {
223 { "FirmwareTimestampMonotonic", "t", NULL, offsetof(struct boot_times, firmware_time) },
224 { "LoaderTimestampMonotonic", "t", NULL, offsetof(struct boot_times, loader_time) },
225 { "KernelTimestamp", "t", NULL, offsetof(struct boot_times, kernel_time) },
226 { "InitRDTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_time) },
227 { "UserspaceTimestampMonotonic", "t", NULL, offsetof(struct boot_times, userspace_time) },
228 { "FinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, finish_time) },
229 { "SecurityStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, security_start_time) },
230 { "SecurityFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, security_finish_time) },
231 { "GeneratorsStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, generators_start_time) },
232 { "GeneratorsFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, generators_finish_time) },
233 { "UnitsLoadStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, unitsload_start_time) },
234 { "UnitsLoadFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, unitsload_finish_time) },
235 { "InitRDSecurityStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_security_start_time) },
236 { "InitRDSecurityFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_security_finish_time) },
237 { "InitRDGeneratorsStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_generators_start_time) },
238 { "InitRDGeneratorsFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_generators_finish_time) },
239 { "InitRDUnitsLoadStartTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_unitsload_start_time) },
240 { "InitRDUnitsLoadFinishTimestampMonotonic", "t", NULL, offsetof(struct boot_times, initrd_unitsload_finish_time) },
241 {},
242 };
243 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
244 static struct boot_times times;
245 static bool cached = false;
246 int r;
247
248 if (cached)
249 goto finish;
250
251 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
252
253 r = bus_map_all_properties(
254 bus,
255 "org.freedesktop.systemd1",
256 "/org/freedesktop/systemd1",
257 property_map,
258 BUS_MAP_STRDUP,
259 &error,
260 NULL,
261 &times);
262 if (r < 0)
263 return log_error_errno(r, "Failed to get timestamp properties: %s", bus_error_message(&error, r));
264
265 if (times.finish_time <= 0) {
266 log_error("Bootup is not yet finished (org.freedesktop.systemd1.Manager.FinishTimestampMonotonic=%"PRIu64").\n"
267 "Please try again later.\n"
268 "Hint: Use 'systemctl%s list-jobs' to see active jobs",
269 times.finish_time,
270 arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
271 return -EINPROGRESS;
272 }
273
274 if (arg_scope == UNIT_FILE_SYSTEM && times.security_start_time > 0) {
275 /* security_start_time is set when systemd is not running under container environment. */
276 if (times.initrd_time > 0)
277 times.kernel_done_time = times.initrd_time;
278 else
279 times.kernel_done_time = times.userspace_time;
280 } else {
281 /*
282 * User-instance-specific or container-system-specific timestamps processing
283 * (see comment to reverse_offset in struct boot_times).
284 */
285 times.reverse_offset = times.userspace_time;
286
287 times.firmware_time = times.loader_time = times.kernel_time = times.initrd_time = times.userspace_time =
288 times.security_start_time = times.security_finish_time = 0;
289
290 subtract_timestamp(&times.finish_time, times.reverse_offset);
291
292 subtract_timestamp(&times.generators_start_time, times.reverse_offset);
293 subtract_timestamp(&times.generators_finish_time, times.reverse_offset);
294
295 subtract_timestamp(&times.unitsload_start_time, times.reverse_offset);
296 subtract_timestamp(&times.unitsload_finish_time, times.reverse_offset);
297 }
298
299 cached = true;
300
301 finish:
302 *bt = &times;
303 return 0;
304 }
305
306 static void free_host_info(struct host_info *hi) {
307
308 if (!hi)
309 return;
310
311 free(hi->hostname);
312 free(hi->kernel_name);
313 free(hi->kernel_release);
314 free(hi->kernel_version);
315 free(hi->os_pretty_name);
316 free(hi->virtualization);
317 free(hi->architecture);
318 free(hi);
319 }
320
321 DEFINE_TRIVIAL_CLEANUP_FUNC(struct host_info*, free_host_info);
322
323 static int acquire_time_data(sd_bus *bus, struct unit_times **out) {
324 static const struct bus_properties_map property_map[] = {
325 { "InactiveExitTimestampMonotonic", "t", NULL, offsetof(struct unit_times, activating) },
326 { "ActiveEnterTimestampMonotonic", "t", NULL, offsetof(struct unit_times, activated) },
327 { "ActiveExitTimestampMonotonic", "t", NULL, offsetof(struct unit_times, deactivating) },
328 { "InactiveEnterTimestampMonotonic", "t", NULL, offsetof(struct unit_times, deactivated) },
329 {},
330 };
331 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
332 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
333 _cleanup_(unit_times_freep) struct unit_times *unit_times = NULL;
334 struct boot_times *boot_times = NULL;
335 size_t allocated = 0, c = 0;
336 UnitInfo u;
337 int r;
338
339 r = acquire_boot_times(bus, &boot_times);
340 if (r < 0)
341 return r;
342
343 r = sd_bus_call_method(
344 bus,
345 "org.freedesktop.systemd1",
346 "/org/freedesktop/systemd1",
347 "org.freedesktop.systemd1.Manager",
348 "ListUnits",
349 &error, &reply,
350 NULL);
351 if (r < 0)
352 return log_error_errno(r, "Failed to list units: %s", bus_error_message(&error, -r));
353
354 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
355 if (r < 0)
356 return bus_log_parse_error(r);
357
358 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
359 struct unit_times *t;
360
361 if (!GREEDY_REALLOC(unit_times, allocated, c+2))
362 return log_oom();
363
364 unit_times[c+1].has_data = false;
365 t = &unit_times[c];
366 t->name = NULL;
367
368 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
369
370 r = bus_map_all_properties(
371 bus,
372 "org.freedesktop.systemd1",
373 u.unit_path,
374 property_map,
375 BUS_MAP_STRDUP,
376 &error,
377 NULL,
378 t);
379 if (r < 0)
380 return log_error_errno(r, "Failed to get timestamp properties of unit %s: %s", u.id, bus_error_message(&error, r));
381
382 subtract_timestamp(&t->activating, boot_times->reverse_offset);
383 subtract_timestamp(&t->activated, boot_times->reverse_offset);
384 subtract_timestamp(&t->deactivating, boot_times->reverse_offset);
385 subtract_timestamp(&t->deactivated, boot_times->reverse_offset);
386
387 if (t->activated >= t->activating)
388 t->time = t->activated - t->activating;
389 else if (t->deactivated >= t->activating)
390 t->time = t->deactivated - t->activating;
391 else
392 t->time = 0;
393
394 if (t->activating == 0)
395 continue;
396
397 t->name = strdup(u.id);
398 if (!t->name)
399 return log_oom();
400
401 t->has_data = true;
402 c++;
403 }
404 if (r < 0)
405 return bus_log_parse_error(r);
406
407 *out = TAKE_PTR(unit_times);
408 return c;
409 }
410
411 static int acquire_host_info(sd_bus *bus, struct host_info **hi) {
412 static const struct bus_properties_map hostname_map[] = {
413 { "Hostname", "s", NULL, offsetof(struct host_info, hostname) },
414 { "KernelName", "s", NULL, offsetof(struct host_info, kernel_name) },
415 { "KernelRelease", "s", NULL, offsetof(struct host_info, kernel_release) },
416 { "KernelVersion", "s", NULL, offsetof(struct host_info, kernel_version) },
417 { "OperatingSystemPrettyName", "s", NULL, offsetof(struct host_info, os_pretty_name) },
418 {}
419 };
420
421 static const struct bus_properties_map manager_map[] = {
422 { "Virtualization", "s", NULL, offsetof(struct host_info, virtualization) },
423 { "Architecture", "s", NULL, offsetof(struct host_info, architecture) },
424 {}
425 };
426
427 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
428 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *system_bus = NULL;
429 _cleanup_(free_host_infop) struct host_info *host;
430 int r;
431
432 host = new0(struct host_info, 1);
433 if (!host)
434 return log_oom();
435
436 if (arg_scope != UNIT_FILE_SYSTEM) {
437 r = bus_connect_transport(arg_transport, arg_host, false, &system_bus);
438 if (r < 0) {
439 log_debug_errno(r, "Failed to connect to system bus, ignoring: %m");
440 goto manager;
441 }
442 }
443
444 r = bus_map_all_properties(system_bus ?: bus,
445 "org.freedesktop.hostname1",
446 "/org/freedesktop/hostname1",
447 hostname_map,
448 BUS_MAP_STRDUP,
449 &error,
450 NULL,
451 host);
452 if (r < 0) {
453 log_debug_errno(r, "Failed to get host information from systemd-hostnamed, ignoring: %s", bus_error_message(&error, r));
454 sd_bus_error_free(&error);
455 }
456
457 manager:
458 r = bus_map_all_properties(bus,
459 "org.freedesktop.systemd1",
460 "/org/freedesktop/systemd1",
461 manager_map,
462 BUS_MAP_STRDUP,
463 &error,
464 NULL,
465 host);
466 if (r < 0)
467 return log_error_errno(r, "Failed to get host information from systemd: %s", bus_error_message(&error, r));
468
469 *hi = TAKE_PTR(host);
470
471 return 0;
472 }
473
474 static int pretty_boot_time(sd_bus *bus, char **_buf) {
475 char ts[FORMAT_TIMESPAN_MAX];
476 struct boot_times *t;
477 static char buf[4096];
478 size_t size;
479 char *ptr;
480 int r;
481 usec_t activated_time = USEC_INFINITY;
482 _cleanup_free_ char* path = NULL, *unit_id = NULL;
483 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
484
485 r = acquire_boot_times(bus, &t);
486 if (r < 0)
487 return r;
488
489 path = unit_dbus_path_from_name(SPECIAL_DEFAULT_TARGET);
490 if (!path)
491 return log_oom();
492
493 r = sd_bus_get_property_string(
494 bus,
495 "org.freedesktop.systemd1",
496 path,
497 "org.freedesktop.systemd1.Unit",
498 "Id",
499 &error,
500 &unit_id);
501 if (r < 0) {
502 log_error_errno(r, "default.target doesn't seem to exist: %s", bus_error_message(&error, r));
503 unit_id = NULL;
504 }
505
506 r = bus_get_uint64_property(bus, path,
507 "org.freedesktop.systemd1.Unit",
508 "ActiveEnterTimestampMonotonic",
509 &activated_time);
510 if (r < 0) {
511 log_info_errno(r, "Could not get time to reach default.target, ignoring: %m");
512 activated_time = USEC_INFINITY;
513 }
514
515 ptr = buf;
516 size = sizeof(buf);
517
518 size = strpcpyf(&ptr, size, "Startup finished in ");
519 if (t->firmware_time > 0)
520 size = strpcpyf(&ptr, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), t->firmware_time - t->loader_time, USEC_PER_MSEC));
521 if (t->loader_time > 0)
522 size = strpcpyf(&ptr, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), t->loader_time, USEC_PER_MSEC));
523 if (t->kernel_done_time > 0)
524 size = strpcpyf(&ptr, size, "%s (kernel) + ", format_timespan(ts, sizeof(ts), t->kernel_done_time, USEC_PER_MSEC));
525 if (t->initrd_time > 0)
526 size = strpcpyf(&ptr, size, "%s (initrd) + ", format_timespan(ts, sizeof(ts), t->userspace_time - t->initrd_time, USEC_PER_MSEC));
527
528 size = strpcpyf(&ptr, size, "%s (userspace) ", format_timespan(ts, sizeof(ts), t->finish_time - t->userspace_time, USEC_PER_MSEC));
529 if (t->kernel_done_time > 0)
530 strpcpyf(&ptr, size, "= %s ", format_timespan(ts, sizeof(ts), t->firmware_time + t->finish_time, USEC_PER_MSEC));
531
532 if (unit_id && activated_time > 0 && activated_time != USEC_INFINITY) {
533 usec_t base = t->userspace_time > 0 ? t->userspace_time : t->reverse_offset;
534
535 size = strpcpyf(&ptr, size, "\n%s reached after %s in userspace", unit_id,
536 format_timespan(ts, sizeof(ts), activated_time - base, USEC_PER_MSEC));
537 } else if (unit_id && activated_time == 0)
538 size = strpcpyf(&ptr, size, "\n%s was never reached", unit_id);
539 else if (unit_id && activated_time == USEC_INFINITY)
540 size = strpcpyf(&ptr, size, "\nCould not get time to reach %s.", unit_id);
541 else if (!unit_id)
542 size = strpcpyf(&ptr, size, "\ncould not find default.target");
543
544 ptr = strdup(buf);
545 if (!ptr)
546 return log_oom();
547
548 *_buf = ptr;
549 return 0;
550 }
551
552 static void svg_graph_box(double height, double begin, double end) {
553 long long i;
554
555 /* outside box, fill */
556 svg("<rect class=\"box\" x=\"0\" y=\"0\" width=\"%.03f\" height=\"%.03f\" />\n",
557 SCALE_X * (end - begin), SCALE_Y * height);
558
559 for (i = ((long long) (begin / 100000)) * 100000; i <= end; i+=100000) {
560 /* lines for each second */
561 if (i % 5000000 == 0)
562 svg(" <line class=\"sec5\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n"
563 " <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
564 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
565 else if (i % 1000000 == 0)
566 svg(" <line class=\"sec1\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n"
567 " <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
568 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
569 else
570 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
571 SCALE_X * i, SCALE_X * i, SCALE_Y * height);
572 }
573 }
574
575 static int plot_unit_times(struct unit_times *u, double width, int y) {
576 char ts[FORMAT_TIMESPAN_MAX];
577 bool b;
578
579 if (!u->name)
580 return 0;
581
582 svg_bar("activating", u->activating, u->activated, y);
583 svg_bar("active", u->activated, u->deactivating, y);
584 svg_bar("deactivating", u->deactivating, u->deactivated, y);
585
586 /* place the text on the left if we have passed the half of the svg width */
587 b = u->activating * SCALE_X < width / 2;
588 if (u->time)
589 svg_text(b, u->activating, y, "%s (%s)",
590 u->name, format_timespan(ts, sizeof(ts), u->time, USEC_PER_MSEC));
591 else
592 svg_text(b, u->activating, y, "%s", u->name);
593
594 return 1;
595 }
596
597 static int analyze_plot(int argc, char *argv[], void *userdata) {
598 _cleanup_(free_host_infop) struct host_info *host = NULL;
599 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
600 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
601 _cleanup_free_ char *pretty_times = NULL;
602 bool use_full_bus = arg_scope == UNIT_FILE_SYSTEM;
603 struct boot_times *boot;
604 struct unit_times *u;
605 int n, m = 1, y = 0, r;
606 double width;
607
608 r = acquire_bus(&bus, &use_full_bus);
609 if (r < 0)
610 return log_error_errno(r, "Failed to create bus connection: %m");
611
612 n = acquire_boot_times(bus, &boot);
613 if (n < 0)
614 return n;
615
616 n = pretty_boot_time(bus, &pretty_times);
617 if (n < 0)
618 return n;
619
620 if (use_full_bus || arg_scope != UNIT_FILE_SYSTEM) {
621 n = acquire_host_info(bus, &host);
622 if (n < 0)
623 return n;
624 }
625
626 n = acquire_time_data(bus, &times);
627 if (n <= 0)
628 return n;
629
630 typesafe_qsort(times, n, compare_unit_start);
631
632 width = SCALE_X * (boot->firmware_time + boot->finish_time);
633 if (width < 800.0)
634 width = 800.0;
635
636 if (boot->firmware_time > boot->loader_time)
637 m++;
638 if (boot->loader_time > 0) {
639 m++;
640 if (width < 1000.0)
641 width = 1000.0;
642 }
643 if (boot->initrd_time > 0)
644 m++;
645 if (boot->kernel_done_time > 0)
646 m++;
647
648 for (u = times; u->has_data; u++) {
649 double text_start, text_width;
650
651 if (u->activating > boot->finish_time) {
652 u->name = mfree(u->name);
653 continue;
654 }
655
656 /* If the text cannot fit on the left side then
657 * increase the svg width so it fits on the right.
658 * TODO: calculate the text width more accurately */
659 text_width = 8.0 * strlen(u->name);
660 text_start = (boot->firmware_time + u->activating) * SCALE_X;
661 if (text_width > text_start && text_width + text_start > width)
662 width = text_width + text_start;
663
664 if (u->deactivated > u->activating &&
665 u->deactivated <= boot->finish_time &&
666 u->activated == 0 && u->deactivating == 0)
667 u->activated = u->deactivating = u->deactivated;
668 if (u->activated < u->activating || u->activated > boot->finish_time)
669 u->activated = boot->finish_time;
670 if (u->deactivating < u->activated || u->deactivating > boot->finish_time)
671 u->deactivating = boot->finish_time;
672 if (u->deactivated < u->deactivating || u->deactivated > boot->finish_time)
673 u->deactivated = boot->finish_time;
674 m++;
675 }
676
677 svg("<?xml version=\"1.0\" standalone=\"no\"?>\n"
678 "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" "
679 "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
680
681 svg("<svg width=\"%.0fpx\" height=\"%.0fpx\" version=\"1.1\" "
682 "xmlns=\"http://www.w3.org/2000/svg\">\n\n",
683 80.0 + width, 150.0 + (m * SCALE_Y) +
684 5 * SCALE_Y /* legend */);
685
686 /* write some basic info as a comment, including some help */
687 svg("<!-- This file is a systemd-analyze SVG file. It is best rendered in a -->\n"
688 "<!-- browser such as Chrome, Chromium or Firefox. Other applications -->\n"
689 "<!-- that render these files properly but much slower are ImageMagick, -->\n"
690 "<!-- gimp, inkscape, etc. To display the files on your system, just -->\n"
691 "<!-- point your browser to this file. -->\n\n"
692 "<!-- This plot was generated by systemd-analyze version %-16.16s -->\n\n", PACKAGE_VERSION);
693
694 /* style sheet */
695 svg("<defs>\n <style type=\"text/css\">\n <![CDATA[\n"
696 " rect { stroke-width: 1; stroke-opacity: 0; }\n"
697 " rect.background { fill: rgb(255,255,255); }\n"
698 " rect.activating { fill: rgb(255,0,0); fill-opacity: 0.7; }\n"
699 " rect.active { fill: rgb(200,150,150); fill-opacity: 0.7; }\n"
700 " rect.deactivating { fill: rgb(150,100,100); fill-opacity: 0.7; }\n"
701 " rect.kernel { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
702 " rect.initrd { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
703 " rect.firmware { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
704 " rect.loader { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
705 " rect.userspace { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
706 " rect.security { fill: rgb(144,238,144); fill-opacity: 0.7; }\n"
707 " rect.generators { fill: rgb(102,204,255); fill-opacity: 0.7; }\n"
708 " rect.unitsload { fill: rgb( 82,184,255); fill-opacity: 0.7; }\n"
709 " rect.box { fill: rgb(240,240,240); stroke: rgb(192,192,192); }\n"
710 " line { stroke: rgb(64,64,64); stroke-width: 1; }\n"
711 "// line.sec1 { }\n"
712 " line.sec5 { stroke-width: 2; }\n"
713 " line.sec01 { stroke: rgb(224,224,224); stroke-width: 1; }\n"
714 " text { font-family: Verdana, Helvetica; font-size: 14px; }\n"
715 " text.left { font-family: Verdana, Helvetica; font-size: 14px; text-anchor: start; }\n"
716 " text.right { font-family: Verdana, Helvetica; font-size: 14px; text-anchor: end; }\n"
717 " text.sec { font-size: 10px; }\n"
718 " ]]>\n </style>\n</defs>\n\n");
719
720 svg("<rect class=\"background\" width=\"100%%\" height=\"100%%\" />\n");
721 svg("<text x=\"20\" y=\"50\">%s</text>", pretty_times);
722 if (host)
723 svg("<text x=\"20\" y=\"30\">%s %s (%s %s %s) %s %s</text>",
724 isempty(host->os_pretty_name) ? "Linux" : host->os_pretty_name,
725 strempty(host->hostname),
726 strempty(host->kernel_name),
727 strempty(host->kernel_release),
728 strempty(host->kernel_version),
729 strempty(host->architecture),
730 strempty(host->virtualization));
731
732 svg("<g transform=\"translate(%.3f,100)\">\n", 20.0 + (SCALE_X * boot->firmware_time));
733 svg_graph_box(m, -(double) boot->firmware_time, boot->finish_time);
734
735 if (boot->firmware_time > 0) {
736 svg_bar("firmware", -(double) boot->firmware_time, -(double) boot->loader_time, y);
737 svg_text(true, -(double) boot->firmware_time, y, "firmware");
738 y++;
739 }
740 if (boot->loader_time > 0) {
741 svg_bar("loader", -(double) boot->loader_time, 0, y);
742 svg_text(true, -(double) boot->loader_time, y, "loader");
743 y++;
744 }
745 if (boot->kernel_done_time > 0) {
746 svg_bar("kernel", 0, boot->kernel_done_time, y);
747 svg_text(true, 0, y, "kernel");
748 y++;
749 }
750 if (boot->initrd_time > 0) {
751 svg_bar("initrd", boot->initrd_time, boot->userspace_time, y);
752 if (boot->initrd_security_start_time < boot->initrd_security_finish_time)
753 svg_bar("security", boot->initrd_security_start_time, boot->initrd_security_finish_time, y);
754 if (boot->initrd_generators_start_time < boot->initrd_generators_finish_time)
755 svg_bar("generators", boot->initrd_generators_start_time, boot->initrd_generators_finish_time, y);
756 if (boot->initrd_unitsload_start_time < boot->initrd_unitsload_finish_time)
757 svg_bar("unitsload", boot->initrd_unitsload_start_time, boot->initrd_unitsload_finish_time, y);
758 svg_text(true, boot->initrd_time, y, "initrd");
759 y++;
760 }
761
762 for (u = times; u->has_data; u++) {
763 if (u->activating >= boot->userspace_time)
764 break;
765
766 y += plot_unit_times(u, width, y);
767 }
768
769 svg_bar("active", boot->userspace_time, boot->finish_time, y);
770 if (boot->security_start_time > 0)
771 svg_bar("security", boot->security_start_time, boot->security_finish_time, y);
772 svg_bar("generators", boot->generators_start_time, boot->generators_finish_time, y);
773 svg_bar("unitsload", boot->unitsload_start_time, boot->unitsload_finish_time, y);
774 svg_text(true, boot->userspace_time, y, "systemd");
775 y++;
776
777 for (; u->has_data; u++)
778 y += plot_unit_times(u, width, y);
779
780 svg("</g>\n");
781
782 /* Legend */
783 svg("<g transform=\"translate(20,100)\">\n");
784 y++;
785 svg_bar("activating", 0, 300000, y);
786 svg_text(true, 400000, y, "Activating");
787 y++;
788 svg_bar("active", 0, 300000, y);
789 svg_text(true, 400000, y, "Active");
790 y++;
791 svg_bar("deactivating", 0, 300000, y);
792 svg_text(true, 400000, y, "Deactivating");
793 y++;
794 if (boot->security_start_time > 0) {
795 svg_bar("security", 0, 300000, y);
796 svg_text(true, 400000, y, "Setting up security module");
797 y++;
798 }
799 svg_bar("generators", 0, 300000, y);
800 svg_text(true, 400000, y, "Generators");
801 y++;
802 svg_bar("unitsload", 0, 300000, y);
803 svg_text(true, 400000, y, "Loading unit files");
804 y++;
805
806 svg("</g>\n\n");
807
808 svg("</svg>\n");
809
810 return 0;
811 }
812
813 static int list_dependencies_print(const char *name, unsigned level, unsigned branches,
814 bool last, struct unit_times *times, struct boot_times *boot) {
815 unsigned i;
816 char ts[FORMAT_TIMESPAN_MAX], ts2[FORMAT_TIMESPAN_MAX];
817
818 for (i = level; i != 0; i--)
819 printf("%s", special_glyph(branches & (1 << (i-1)) ? TREE_VERTICAL : TREE_SPACE));
820
821 printf("%s", special_glyph(last ? TREE_RIGHT : TREE_BRANCH));
822
823 if (times) {
824 if (times->time > 0)
825 printf("%s%s @%s +%s%s", ansi_highlight_red(), name,
826 format_timespan(ts, sizeof(ts), times->activating - boot->userspace_time, USEC_PER_MSEC),
827 format_timespan(ts2, sizeof(ts2), times->time, USEC_PER_MSEC), ansi_normal());
828 else if (times->activated > boot->userspace_time)
829 printf("%s @%s", name, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
830 else
831 printf("%s", name);
832 } else
833 printf("%s", name);
834 printf("\n");
835
836 return 0;
837 }
838
839 static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
840 _cleanup_free_ char *path = NULL;
841
842 assert(bus);
843 assert(name);
844 assert(deps);
845
846 path = unit_dbus_path_from_name(name);
847 if (!path)
848 return -ENOMEM;
849
850 return bus_get_unit_property_strv(bus, path, "After", deps);
851 }
852
853 static Hashmap *unit_times_hashmap;
854
855 static int list_dependencies_compare(char * const *a, char * const *b) {
856 usec_t usa = 0, usb = 0;
857 struct unit_times *times;
858
859 times = hashmap_get(unit_times_hashmap, *a);
860 if (times)
861 usa = times->activated;
862 times = hashmap_get(unit_times_hashmap, *b);
863 if (times)
864 usb = times->activated;
865
866 return CMP(usb, usa);
867 }
868
869 static bool times_in_range(const struct unit_times *times, const struct boot_times *boot) {
870 return times &&
871 times->activated > 0 && times->activated <= boot->finish_time;
872 }
873
874 static int list_dependencies_one(sd_bus *bus, const char *name, unsigned level, char ***units,
875 unsigned branches) {
876 _cleanup_strv_free_ char **deps = NULL;
877 char **c;
878 int r = 0;
879 usec_t service_longest = 0;
880 int to_print = 0;
881 struct unit_times *times;
882 struct boot_times *boot;
883
884 if (strv_extend(units, name))
885 return log_oom();
886
887 r = list_dependencies_get_dependencies(bus, name, &deps);
888 if (r < 0)
889 return r;
890
891 typesafe_qsort(deps, strv_length(deps), list_dependencies_compare);
892
893 r = acquire_boot_times(bus, &boot);
894 if (r < 0)
895 return r;
896
897 STRV_FOREACH(c, deps) {
898 times = hashmap_get(unit_times_hashmap, *c);
899 if (times_in_range(times, boot) &&
900 times->activated >= service_longest)
901 service_longest = times->activated;
902 }
903
904 if (service_longest == 0)
905 return r;
906
907 STRV_FOREACH(c, deps) {
908 times = hashmap_get(unit_times_hashmap, *c);
909 if (times_in_range(times, boot) &&
910 service_longest - times->activated <= arg_fuzz)
911 to_print++;
912 }
913
914 if (!to_print)
915 return r;
916
917 STRV_FOREACH(c, deps) {
918 times = hashmap_get(unit_times_hashmap, *c);
919 if (!times_in_range(times, boot) ||
920 service_longest - times->activated > arg_fuzz)
921 continue;
922
923 to_print--;
924
925 r = list_dependencies_print(*c, level, branches, to_print == 0, times, boot);
926 if (r < 0)
927 return r;
928
929 if (strv_contains(*units, *c)) {
930 r = list_dependencies_print("...", level + 1, (branches << 1) | (to_print ? 1 : 0),
931 true, NULL, boot);
932 if (r < 0)
933 return r;
934 continue;
935 }
936
937 r = list_dependencies_one(bus, *c, level + 1, units,
938 (branches << 1) | (to_print ? 1 : 0));
939 if (r < 0)
940 return r;
941
942 if (to_print == 0)
943 break;
944 }
945 return 0;
946 }
947
948 static int list_dependencies(sd_bus *bus, const char *name) {
949 _cleanup_strv_free_ char **units = NULL;
950 char ts[FORMAT_TIMESPAN_MAX];
951 struct unit_times *times;
952 int r;
953 const char *id;
954 _cleanup_free_ char *path = NULL;
955 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
956 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
957 struct boot_times *boot;
958
959 assert(bus);
960
961 path = unit_dbus_path_from_name(name);
962 if (!path)
963 return -ENOMEM;
964
965 r = sd_bus_get_property(
966 bus,
967 "org.freedesktop.systemd1",
968 path,
969 "org.freedesktop.systemd1.Unit",
970 "Id",
971 &error,
972 &reply,
973 "s");
974 if (r < 0)
975 return log_error_errno(r, "Failed to get ID: %s", bus_error_message(&error, -r));
976
977 r = sd_bus_message_read(reply, "s", &id);
978 if (r < 0)
979 return bus_log_parse_error(r);
980
981 times = hashmap_get(unit_times_hashmap, id);
982
983 r = acquire_boot_times(bus, &boot);
984 if (r < 0)
985 return r;
986
987 if (times) {
988 if (times->time)
989 printf("%s%s +%s%s\n", ansi_highlight_red(), id,
990 format_timespan(ts, sizeof(ts), times->time, USEC_PER_MSEC), ansi_normal());
991 else if (times->activated > boot->userspace_time)
992 printf("%s @%s\n", id, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
993 else
994 printf("%s\n", id);
995 }
996
997 return list_dependencies_one(bus, name, 0, &units, 0);
998 }
999
1000 static int analyze_critical_chain(int argc, char *argv[], void *userdata) {
1001 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1002 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
1003 struct unit_times *u;
1004 Hashmap *h;
1005 int n, r;
1006
1007 r = acquire_bus(&bus, NULL);
1008 if (r < 0)
1009 return log_error_errno(r, "Failed to create bus connection: %m");
1010
1011 n = acquire_time_data(bus, &times);
1012 if (n <= 0)
1013 return n;
1014
1015 h = hashmap_new(&string_hash_ops);
1016 if (!h)
1017 return log_oom();
1018
1019 for (u = times; u->has_data; u++) {
1020 r = hashmap_put(h, u->name, u);
1021 if (r < 0)
1022 return log_error_errno(r, "Failed to add entry to hashmap: %m");
1023 }
1024 unit_times_hashmap = h;
1025
1026 (void) pager_open(arg_no_pager, false);
1027
1028 puts("The time after the unit is active or started is printed after the \"@\" character.\n"
1029 "The time the unit takes to start is printed after the \"+\" character.\n");
1030
1031 if (argc > 1) {
1032 char **name;
1033 STRV_FOREACH(name, strv_skip(argv, 1))
1034 list_dependencies(bus, *name);
1035 } else
1036 list_dependencies(bus, SPECIAL_DEFAULT_TARGET);
1037
1038 h = hashmap_free(h);
1039 return 0;
1040 }
1041
1042 static int analyze_blame(int argc, char *argv[], void *userdata) {
1043 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1044 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
1045 struct unit_times *u;
1046 int n, r;
1047
1048 r = acquire_bus(&bus, NULL);
1049 if (r < 0)
1050 return log_error_errno(r, "Failed to create bus connection: %m");
1051
1052 n = acquire_time_data(bus, &times);
1053 if (n <= 0)
1054 return n;
1055
1056 typesafe_qsort(times, n, compare_unit_time);
1057
1058 (void) pager_open(arg_no_pager, false);
1059
1060 for (u = times; u->has_data; u++) {
1061 char ts[FORMAT_TIMESPAN_MAX];
1062
1063 if (u->time > 0)
1064 printf("%16s %s\n", format_timespan(ts, sizeof(ts), u->time, USEC_PER_MSEC), u->name);
1065 }
1066
1067 return 0;
1068 }
1069
1070 static int analyze_time(int argc, char *argv[], void *userdata) {
1071 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1072 _cleanup_free_ char *buf = NULL;
1073 int r;
1074
1075 r = acquire_bus(&bus, NULL);
1076 if (r < 0)
1077 return log_error_errno(r, "Failed to create bus connection: %m");
1078
1079 r = pretty_boot_time(bus, &buf);
1080 if (r < 0)
1081 return r;
1082
1083 puts(buf);
1084 return 0;
1085 }
1086
1087 static int graph_one_property(sd_bus *bus, const UnitInfo *u, const char* prop, const char *color, char* patterns[], char* from_patterns[], char* to_patterns[]) {
1088 _cleanup_strv_free_ char **units = NULL;
1089 char **unit;
1090 int r;
1091 bool match_patterns;
1092
1093 assert(u);
1094 assert(prop);
1095 assert(color);
1096
1097 match_patterns = strv_fnmatch(patterns, u->id, 0);
1098
1099 if (!strv_isempty(from_patterns) &&
1100 !match_patterns &&
1101 !strv_fnmatch(from_patterns, u->id, 0))
1102 return 0;
1103
1104 r = bus_get_unit_property_strv(bus, u->unit_path, prop, &units);
1105 if (r < 0)
1106 return r;
1107
1108 STRV_FOREACH(unit, units) {
1109 bool match_patterns2;
1110
1111 match_patterns2 = strv_fnmatch(patterns, *unit, 0);
1112
1113 if (!strv_isempty(to_patterns) &&
1114 !match_patterns2 &&
1115 !strv_fnmatch(to_patterns, *unit, 0))
1116 continue;
1117
1118 if (!strv_isempty(patterns) && !match_patterns && !match_patterns2)
1119 continue;
1120
1121 printf("\t\"%s\"->\"%s\" [color=\"%s\"];\n", u->id, *unit, color);
1122 }
1123
1124 return 0;
1125 }
1126
1127 static int graph_one(sd_bus *bus, const UnitInfo *u, char *patterns[], char *from_patterns[], char *to_patterns[]) {
1128 int r;
1129
1130 assert(bus);
1131 assert(u);
1132
1133 if (IN_SET(arg_dot, DEP_ORDER, DEP_ALL)) {
1134 r = graph_one_property(bus, u, "After", "green", patterns, from_patterns, to_patterns);
1135 if (r < 0)
1136 return r;
1137 }
1138
1139 if (IN_SET(arg_dot, DEP_REQUIRE, DEP_ALL)) {
1140 r = graph_one_property(bus, u, "Requires", "black", patterns, from_patterns, to_patterns);
1141 if (r < 0)
1142 return r;
1143 r = graph_one_property(bus, u, "Requisite", "darkblue", patterns, from_patterns, to_patterns);
1144 if (r < 0)
1145 return r;
1146 r = graph_one_property(bus, u, "Wants", "grey66", patterns, from_patterns, to_patterns);
1147 if (r < 0)
1148 return r;
1149 r = graph_one_property(bus, u, "Conflicts", "red", patterns, from_patterns, to_patterns);
1150 if (r < 0)
1151 return r;
1152 }
1153
1154 return 0;
1155 }
1156
1157 static int expand_patterns(sd_bus *bus, char **patterns, char ***ret) {
1158 _cleanup_strv_free_ char **expanded_patterns = NULL;
1159 char **pattern;
1160 int r;
1161
1162 STRV_FOREACH(pattern, patterns) {
1163 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1164 _cleanup_free_ char *unit = NULL, *unit_id = NULL;
1165
1166 if (strv_extend(&expanded_patterns, *pattern) < 0)
1167 return log_oom();
1168
1169 if (string_is_glob(*pattern))
1170 continue;
1171
1172 unit = unit_dbus_path_from_name(*pattern);
1173 if (!unit)
1174 return log_oom();
1175
1176 r = sd_bus_get_property_string(
1177 bus,
1178 "org.freedesktop.systemd1",
1179 unit,
1180 "org.freedesktop.systemd1.Unit",
1181 "Id",
1182 &error,
1183 &unit_id);
1184 if (r < 0)
1185 return log_error_errno(r, "Failed to get ID: %s", bus_error_message(&error, r));
1186
1187 if (!streq(*pattern, unit_id)) {
1188 if (strv_extend(&expanded_patterns, unit_id) < 0)
1189 return log_oom();
1190 }
1191 }
1192
1193 *ret = expanded_patterns;
1194 expanded_patterns = NULL; /* do not free */
1195
1196 return 0;
1197 }
1198
1199 static int dot(int argc, char *argv[], void *userdata) {
1200 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1201 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1202 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1203 _cleanup_strv_free_ char **expanded_patterns = NULL;
1204 _cleanup_strv_free_ char **expanded_from_patterns = NULL;
1205 _cleanup_strv_free_ char **expanded_to_patterns = NULL;
1206 int r;
1207 UnitInfo u;
1208
1209 r = acquire_bus(&bus, NULL);
1210 if (r < 0)
1211 return log_error_errno(r, "Failed to create bus connection: %m");
1212
1213 r = expand_patterns(bus, strv_skip(argv, 1), &expanded_patterns);
1214 if (r < 0)
1215 return r;
1216
1217 r = expand_patterns(bus, arg_dot_from_patterns, &expanded_from_patterns);
1218 if (r < 0)
1219 return r;
1220
1221 r = expand_patterns(bus, arg_dot_to_patterns, &expanded_to_patterns);
1222 if (r < 0)
1223 return r;
1224
1225 r = sd_bus_call_method(
1226 bus,
1227 "org.freedesktop.systemd1",
1228 "/org/freedesktop/systemd1",
1229 "org.freedesktop.systemd1.Manager",
1230 "ListUnits",
1231 &error,
1232 &reply,
1233 "");
1234 if (r < 0)
1235 log_error_errno(r, "Failed to list units: %s", bus_error_message(&error, -r));
1236
1237 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
1238 if (r < 0)
1239 return bus_log_parse_error(r);
1240
1241 printf("digraph systemd {\n");
1242
1243 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
1244
1245 r = graph_one(bus, &u, expanded_patterns, expanded_from_patterns, expanded_to_patterns);
1246 if (r < 0)
1247 return r;
1248 }
1249 if (r < 0)
1250 return bus_log_parse_error(r);
1251
1252 printf("}\n");
1253
1254 log_info(" Color legend: black = Requires\n"
1255 " dark blue = Requisite\n"
1256 " dark grey = Wants\n"
1257 " red = Conflicts\n"
1258 " green = After\n");
1259
1260 if (on_tty())
1261 log_notice("-- You probably want to process this output with graphviz' dot tool.\n"
1262 "-- Try a shell pipeline like 'systemd-analyze dot | dot -Tsvg > systemd.svg'!\n");
1263
1264 return 0;
1265 }
1266
1267 static int dump_fallback(sd_bus *bus) {
1268 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1269 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1270 const char *text = NULL;
1271 int r;
1272
1273 assert(bus);
1274
1275 r = sd_bus_call_method(
1276 bus,
1277 "org.freedesktop.systemd1",
1278 "/org/freedesktop/systemd1",
1279 "org.freedesktop.systemd1.Manager",
1280 "Dump",
1281 &error,
1282 &reply,
1283 NULL);
1284 if (r < 0)
1285 return log_error_errno(r, "Failed to issue method call Dump: %s", bus_error_message(&error, r));
1286
1287 r = sd_bus_message_read(reply, "s", &text);
1288 if (r < 0)
1289 return bus_log_parse_error(r);
1290
1291 fputs(text, stdout);
1292 return 0;
1293 }
1294
1295 static int dump(int argc, char *argv[], void *userdata) {
1296 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1297 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1298 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1299 int fd = -1;
1300 int r;
1301
1302 r = acquire_bus(&bus, NULL);
1303 if (r < 0)
1304 return log_error_errno(r, "Failed to create bus connection: %m");
1305
1306 (void) pager_open(arg_no_pager, false);
1307
1308 if (!sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD))
1309 return dump_fallback(bus);
1310
1311 r = sd_bus_call_method(
1312 bus,
1313 "org.freedesktop.systemd1",
1314 "/org/freedesktop/systemd1",
1315 "org.freedesktop.systemd1.Manager",
1316 "DumpByFileDescriptor",
1317 &error,
1318 &reply,
1319 NULL);
1320 if (r < 0) {
1321 /* fall back to Dump if DumpByFileDescriptor is not supported */
1322 if (!IN_SET(r, -EACCES, -EBADR))
1323 return log_error_errno(r, "Failed to issue method call DumpByFileDescriptor: %s", bus_error_message(&error, r));
1324
1325 return dump_fallback(bus);
1326 }
1327
1328 r = sd_bus_message_read(reply, "h", &fd);
1329 if (r < 0)
1330 return bus_log_parse_error(r);
1331
1332 fflush(stdout);
1333 return copy_bytes(fd, STDOUT_FILENO, (uint64_t) -1, 0);
1334 }
1335
1336 static int cat_config(int argc, char *argv[], void *userdata) {
1337 char **arg;
1338 int r;
1339
1340 (void) pager_open(arg_no_pager, false);
1341
1342 STRV_FOREACH(arg, argv + 1) {
1343 const char *t = NULL;
1344
1345 if (arg != argv + 1)
1346 print_separator();
1347
1348 if (path_is_absolute(*arg)) {
1349 const char *dir;
1350
1351 NULSTR_FOREACH(dir, CONF_PATHS_NULSTR("")) {
1352 t = path_startswith(*arg, dir);
1353 if (t)
1354 break;
1355 }
1356
1357 if (!t) {
1358 log_error("Path %s does not start with any known prefix.", *arg);
1359 return -EINVAL;
1360 }
1361 } else
1362 t = *arg;
1363
1364 r = conf_files_cat(arg_root, t);
1365 if (r < 0)
1366 return r;
1367 }
1368
1369 return 0;
1370 }
1371
1372 static int set_log_level(int argc, char *argv[], void *userdata) {
1373 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1374 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1375 int r;
1376
1377 assert(argc == 2);
1378 assert(argv);
1379
1380 r = acquire_bus(&bus, NULL);
1381 if (r < 0)
1382 return log_error_errno(r, "Failed to create bus connection: %m");
1383
1384 r = sd_bus_set_property(
1385 bus,
1386 "org.freedesktop.systemd1",
1387 "/org/freedesktop/systemd1",
1388 "org.freedesktop.systemd1.Manager",
1389 "LogLevel",
1390 &error,
1391 "s",
1392 argv[1]);
1393 if (r < 0)
1394 return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
1395
1396 return 0;
1397 }
1398
1399 static int get_log_level(int argc, char *argv[], void *userdata) {
1400 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1401 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1402 _cleanup_free_ char *level = NULL;
1403 int r;
1404
1405 r = acquire_bus(&bus, NULL);
1406 if (r < 0)
1407 return log_error_errno(r, "Failed to create bus connection: %m");
1408
1409 r = sd_bus_get_property_string(
1410 bus,
1411 "org.freedesktop.systemd1",
1412 "/org/freedesktop/systemd1",
1413 "org.freedesktop.systemd1.Manager",
1414 "LogLevel",
1415 &error,
1416 &level);
1417 if (r < 0)
1418 return log_error_errno(r, "Failed to get log level: %s", bus_error_message(&error, r));
1419
1420 puts(level);
1421 return 0;
1422 }
1423
1424 static int get_or_set_log_level(int argc, char *argv[], void *userdata) {
1425 return (argc == 1) ? get_log_level(argc, argv, userdata) : set_log_level(argc, argv, userdata);
1426 }
1427
1428 static int set_log_target(int argc, char *argv[], void *userdata) {
1429 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1430 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1431 int r;
1432
1433 assert(argc == 2);
1434 assert(argv);
1435
1436 r = acquire_bus(&bus, NULL);
1437 if (r < 0)
1438 return log_error_errno(r, "Failed to create bus connection: %m");
1439
1440 r = sd_bus_set_property(
1441 bus,
1442 "org.freedesktop.systemd1",
1443 "/org/freedesktop/systemd1",
1444 "org.freedesktop.systemd1.Manager",
1445 "LogTarget",
1446 &error,
1447 "s",
1448 argv[1]);
1449 if (r < 0)
1450 return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
1451
1452 return 0;
1453 }
1454
1455 static int get_log_target(int argc, char *argv[], void *userdata) {
1456 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1457 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1458 _cleanup_free_ char *target = NULL;
1459 int r;
1460
1461 r = acquire_bus(&bus, NULL);
1462 if (r < 0)
1463 return log_error_errno(r, "Failed to create bus connection: %m");
1464
1465 r = sd_bus_get_property_string(
1466 bus,
1467 "org.freedesktop.systemd1",
1468 "/org/freedesktop/systemd1",
1469 "org.freedesktop.systemd1.Manager",
1470 "LogTarget",
1471 &error,
1472 &target);
1473 if (r < 0)
1474 return log_error_errno(r, "Failed to get log target: %s", bus_error_message(&error, r));
1475
1476 puts(target);
1477 return 0;
1478 }
1479
1480 static int get_or_set_log_target(int argc, char *argv[], void *userdata) {
1481 return (argc == 1) ? get_log_target(argc, argv, userdata) : set_log_target(argc, argv, userdata);
1482 }
1483
1484 static int dump_unit_paths(int argc, char *argv[], void *userdata) {
1485 _cleanup_(lookup_paths_free) LookupPaths paths = {};
1486 int r;
1487 char **p;
1488
1489 r = lookup_paths_init(&paths, arg_scope, 0, NULL);
1490 if (r < 0)
1491 return log_error_errno(r, "lookup_paths_init() failed: %m");
1492
1493 STRV_FOREACH(p, paths.search_path)
1494 puts(*p);
1495
1496 return 0;
1497 }
1498
1499 #if HAVE_SECCOMP
1500 static void dump_syscall_filter(const SyscallFilterSet *set) {
1501 const char *syscall;
1502
1503 printf("%s\n", set->name);
1504 printf(" # %s\n", set->help);
1505 NULSTR_FOREACH(syscall, set->value)
1506 printf(" %s\n", syscall);
1507 }
1508
1509 static int dump_syscall_filters(int argc, char *argv[], void *userdata) {
1510 bool first = true;
1511
1512 (void) pager_open(arg_no_pager, false);
1513
1514 if (strv_isempty(strv_skip(argv, 1))) {
1515 int i;
1516
1517 for (i = 0; i < _SYSCALL_FILTER_SET_MAX; i++) {
1518 if (!first)
1519 puts("");
1520 dump_syscall_filter(syscall_filter_sets + i);
1521 first = false;
1522 }
1523 } else {
1524 char **name;
1525
1526 STRV_FOREACH(name, strv_skip(argv, 1)) {
1527 const SyscallFilterSet *set;
1528
1529 if (!first)
1530 puts("");
1531
1532 set = syscall_filter_set_find(*name);
1533 if (!set) {
1534 /* make sure the error appears below normal output */
1535 fflush(stdout);
1536
1537 log_error("Filter set \"%s\" not found.", *name);
1538 return -ENOENT;
1539 }
1540
1541 dump_syscall_filter(set);
1542 first = false;
1543 }
1544 }
1545
1546 return 0;
1547 }
1548
1549 #else
1550 static int dump_syscall_filters(int argc, char *argv[], void *userdata) {
1551 log_error("Not compiled with syscall filters, sorry.");
1552 return -EOPNOTSUPP;
1553 }
1554 #endif
1555
1556 static int dump_timespan(int argc, char *argv[], void *userdata) {
1557 char **input_timespan;
1558
1559 STRV_FOREACH(input_timespan, strv_skip(argv, 1)) {
1560 int r;
1561 usec_t usec_magnitude = 1, output_usecs;
1562 char ft_buf[FORMAT_TIMESPAN_MAX];
1563
1564 r = parse_time(*input_timespan, &output_usecs, USEC_PER_SEC);
1565 if (r < 0)
1566 return log_error_errno(r, "Failed to parse time span '%s': %m", *input_timespan);
1567
1568 printf("Original: %s\n", *input_timespan);
1569 printf(" %ss: %" PRIu64 "\n", special_glyph(MU), output_usecs);
1570 printf(" Human: %s\n", format_timespan(ft_buf, sizeof(ft_buf), output_usecs, usec_magnitude));
1571
1572 if (input_timespan[1])
1573 putchar('\n');
1574 }
1575
1576 return EXIT_SUCCESS;
1577 }
1578
1579 static int test_calendar(int argc, char *argv[], void *userdata) {
1580 int ret = 0, r;
1581 char **p;
1582 usec_t n;
1583
1584 n = now(CLOCK_REALTIME);
1585
1586 STRV_FOREACH(p, strv_skip(argv, 1)) {
1587 _cleanup_(calendar_spec_freep) CalendarSpec *spec = NULL;
1588 _cleanup_free_ char *t = NULL;
1589 usec_t next;
1590
1591 r = calendar_spec_from_string(*p, &spec);
1592 if (r < 0) {
1593 ret = log_error_errno(r, "Failed to parse calendar specification '%s': %m", *p);
1594 continue;
1595 }
1596
1597 r = calendar_spec_normalize(spec);
1598 if (r < 0) {
1599 ret = log_error_errno(r, "Failed to normalize calendar specification '%s': %m", *p);
1600 continue;
1601 }
1602
1603 r = calendar_spec_to_string(spec, &t);
1604 if (r < 0) {
1605 ret = log_error_errno(r, "Failed to format calendar specification '%s': %m", *p);
1606 continue;
1607 }
1608
1609 if (!streq(t, *p))
1610 printf(" Original form: %s\n", *p);
1611
1612 printf("Normalized form: %s\n", t);
1613
1614 r = calendar_spec_next_usec(spec, n, &next);
1615 if (r == -ENOENT)
1616 printf(" Next elapse: never\n");
1617 else if (r < 0) {
1618 ret = log_error_errno(r, "Failed to determine next elapse for '%s': %m", *p);
1619 continue;
1620 } else {
1621 char buffer[CONST_MAX(FORMAT_TIMESTAMP_MAX, FORMAT_TIMESTAMP_RELATIVE_MAX)];
1622
1623 printf(" Next elapse: %s\n", format_timestamp(buffer, sizeof(buffer), next));
1624
1625 if (!in_utc_timezone())
1626 printf(" (in UTC): %s\n", format_timestamp_utc(buffer, sizeof(buffer), next));
1627
1628 printf(" From now: %s\n", format_timestamp_relative(buffer, sizeof(buffer), next));
1629 }
1630
1631 if (*(p+1))
1632 putchar('\n');
1633 }
1634
1635 return ret;
1636 }
1637
1638 static int service_watchdogs(int argc, char *argv[], void *userdata) {
1639 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1640 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1641 int b, r;
1642
1643 assert(IN_SET(argc, 1, 2));
1644 assert(argv);
1645
1646 r = acquire_bus(&bus, NULL);
1647 if (r < 0)
1648 return log_error_errno(r, "Failed to create bus connection: %m");
1649
1650 /* get ServiceWatchdogs */
1651 if (argc == 1) {
1652 r = sd_bus_get_property_trivial(
1653 bus,
1654 "org.freedesktop.systemd1",
1655 "/org/freedesktop/systemd1",
1656 "org.freedesktop.systemd1.Manager",
1657 "ServiceWatchdogs",
1658 &error,
1659 'b',
1660 &b);
1661 if (r < 0)
1662 return log_error_errno(r, "Failed to get service-watchdog state: %s", bus_error_message(&error, r));
1663
1664 printf("%s\n", yes_no(!!b));
1665
1666 return 0;
1667 }
1668
1669 /* set ServiceWatchdogs */
1670 b = parse_boolean(argv[1]);
1671 if (b < 0) {
1672 log_error("Failed to parse service-watchdogs argument.");
1673 return -EINVAL;
1674 }
1675
1676 r = sd_bus_set_property(
1677 bus,
1678 "org.freedesktop.systemd1",
1679 "/org/freedesktop/systemd1",
1680 "org.freedesktop.systemd1.Manager",
1681 "ServiceWatchdogs",
1682 &error,
1683 "b",
1684 b);
1685 if (r < 0)
1686 return log_error_errno(r, "Failed to set service-watchdog state: %s", bus_error_message(&error, r));
1687
1688 return 0;
1689 }
1690
1691 static int do_verify(int argc, char *argv[], void *userdata) {
1692 return verify_units(strv_skip(argv, 1), arg_scope, arg_man, arg_generators);
1693 }
1694
1695 static int help(int argc, char *argv[], void *userdata) {
1696 _cleanup_free_ char *link = NULL;
1697 int r;
1698
1699 (void) pager_open(arg_no_pager, false);
1700
1701 r = terminal_urlify_man("systemd-analyze", "1", &link);
1702 if (r < 0)
1703 return log_oom();
1704
1705 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1706 "Profile systemd, show unit dependencies, check unit files.\n\n"
1707 " -h --help Show this help\n"
1708 " --version Show package version\n"
1709 " --no-pager Do not pipe output into a pager\n"
1710 " --system Operate on system systemd instance\n"
1711 " --user Operate on user systemd instance\n"
1712 " --global Operate on global user configuration\n"
1713 " -H --host=[USER@]HOST Operate on remote host\n"
1714 " -M --machine=CONTAINER Operate on local container\n"
1715 " --order Show only order in the graph\n"
1716 " --require Show only requirement in the graph\n"
1717 " --from-pattern=GLOB Show only origins in the graph\n"
1718 " --to-pattern=GLOB Show only destinations in the graph\n"
1719 " --fuzz=SECONDS Also print also services which finished SECONDS\n"
1720 " earlier than the latest in the branch\n"
1721 " --man[=BOOL] Do [not] check for existence of man pages\n"
1722 " --generators[=BOOL] Do [not] run unit generators (requires privileges)\n"
1723 "\nCommands:\n"
1724 " time Print time spent in the kernel\n"
1725 " blame Print list of running units ordered by time to init\n"
1726 " critical-chain [UNIT...] Print a tree of the time critical chain of units\n"
1727 " plot Output SVG graphic showing service initialization\n"
1728 " dot [UNIT...] Output dependency graph in man:dot(1) format\n"
1729 " log-level [LEVEL] Get/set logging threshold for manager\n"
1730 " log-target [TARGET] Get/set logging target for manager\n"
1731 " dump Output state serialization of service manager\n"
1732 " cat-config Show configuration file and drop-ins\n"
1733 " unit-paths List load directories for units\n"
1734 " syscall-filter [NAME...] Print list of syscalls in seccomp filter\n"
1735 " verify FILE... Check unit files for correctness\n"
1736 " calendar SPEC... Validate repetitive calendar time events\n"
1737 " service-watchdogs [BOOL] Get/set service watchdog state\n"
1738 " timespan SPAN... Validate a time span\n"
1739 "\nSee the %s for details.\n"
1740 , program_invocation_short_name
1741 , link
1742 );
1743
1744 /* When updating this list, including descriptions, apply changes to shell-completion/bash/systemd-analyze and
1745 * shell-completion/zsh/_systemd-analyze too. */
1746
1747 return 0;
1748 }
1749
1750 static int parse_argv(int argc, char *argv[]) {
1751 enum {
1752 ARG_VERSION = 0x100,
1753 ARG_ORDER,
1754 ARG_REQUIRE,
1755 ARG_ROOT,
1756 ARG_SYSTEM,
1757 ARG_USER,
1758 ARG_GLOBAL,
1759 ARG_DOT_FROM_PATTERN,
1760 ARG_DOT_TO_PATTERN,
1761 ARG_FUZZ,
1762 ARG_NO_PAGER,
1763 ARG_MAN,
1764 ARG_GENERATORS,
1765 };
1766
1767 static const struct option options[] = {
1768 { "help", no_argument, NULL, 'h' },
1769 { "version", no_argument, NULL, ARG_VERSION },
1770 { "order", no_argument, NULL, ARG_ORDER },
1771 { "require", no_argument, NULL, ARG_REQUIRE },
1772 { "root", required_argument, NULL, ARG_ROOT },
1773 { "system", no_argument, NULL, ARG_SYSTEM },
1774 { "user", no_argument, NULL, ARG_USER },
1775 { "global", no_argument, NULL, ARG_GLOBAL },
1776 { "from-pattern", required_argument, NULL, ARG_DOT_FROM_PATTERN },
1777 { "to-pattern", required_argument, NULL, ARG_DOT_TO_PATTERN },
1778 { "fuzz", required_argument, NULL, ARG_FUZZ },
1779 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1780 { "man", optional_argument, NULL, ARG_MAN },
1781 { "generators", optional_argument, NULL, ARG_GENERATORS },
1782 { "host", required_argument, NULL, 'H' },
1783 { "machine", required_argument, NULL, 'M' },
1784 {}
1785 };
1786
1787 int r, c;
1788
1789 assert(argc >= 0);
1790 assert(argv);
1791
1792 while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)
1793 switch (c) {
1794
1795 case 'h':
1796 return help(0, NULL, NULL);
1797
1798 case ARG_VERSION:
1799 return version();
1800
1801 case ARG_ROOT:
1802 arg_root = optarg;
1803 break;
1804
1805 case ARG_SYSTEM:
1806 arg_scope = UNIT_FILE_SYSTEM;
1807 break;
1808
1809 case ARG_USER:
1810 arg_scope = UNIT_FILE_USER;
1811 break;
1812
1813 case ARG_GLOBAL:
1814 arg_scope = UNIT_FILE_GLOBAL;
1815 break;
1816
1817 case ARG_ORDER:
1818 arg_dot = DEP_ORDER;
1819 break;
1820
1821 case ARG_REQUIRE:
1822 arg_dot = DEP_REQUIRE;
1823 break;
1824
1825 case ARG_DOT_FROM_PATTERN:
1826 if (strv_extend(&arg_dot_from_patterns, optarg) < 0)
1827 return log_oom();
1828
1829 break;
1830
1831 case ARG_DOT_TO_PATTERN:
1832 if (strv_extend(&arg_dot_to_patterns, optarg) < 0)
1833 return log_oom();
1834
1835 break;
1836
1837 case ARG_FUZZ:
1838 r = parse_sec(optarg, &arg_fuzz);
1839 if (r < 0)
1840 return r;
1841 break;
1842
1843 case ARG_NO_PAGER:
1844 arg_no_pager = true;
1845 break;
1846
1847 case 'H':
1848 arg_transport = BUS_TRANSPORT_REMOTE;
1849 arg_host = optarg;
1850 break;
1851
1852 case 'M':
1853 arg_transport = BUS_TRANSPORT_MACHINE;
1854 arg_host = optarg;
1855 break;
1856
1857 case ARG_MAN:
1858 if (optarg) {
1859 r = parse_boolean(optarg);
1860 if (r < 0) {
1861 log_error("Failed to parse --man= argument.");
1862 return -EINVAL;
1863 }
1864
1865 arg_man = r;
1866 } else
1867 arg_man = true;
1868
1869 break;
1870
1871 case ARG_GENERATORS:
1872 if (optarg) {
1873 r = parse_boolean(optarg);
1874 if (r < 0) {
1875 log_error("Failed to parse --generators= argument.");
1876 return -EINVAL;
1877 }
1878
1879 arg_generators = r;
1880 } else
1881 arg_generators = true;
1882
1883 break;
1884
1885 case '?':
1886 return -EINVAL;
1887
1888 default:
1889 assert_not_reached("Unhandled option code.");
1890 }
1891
1892 if (arg_scope == UNIT_FILE_GLOBAL &&
1893 !STR_IN_SET(argv[optind] ?: "time", "dot", "unit-paths", "verify")) {
1894 log_error("Option --global only makes sense with verbs dot, unit-paths, verify.");
1895 return -EINVAL;
1896 }
1897
1898 if (arg_root && !streq_ptr(argv[optind], "cat-config")) {
1899 log_error("Option --root is only supported for cat-config right now.");
1900 return -EINVAL;
1901 }
1902
1903 return 1; /* work to do */
1904 }
1905
1906 int main(int argc, char *argv[]) {
1907
1908 static const Verb verbs[] = {
1909 { "help", VERB_ANY, VERB_ANY, 0, help },
1910 { "time", VERB_ANY, 1, VERB_DEFAULT, analyze_time },
1911 { "blame", VERB_ANY, 1, 0, analyze_blame },
1912 { "critical-chain", VERB_ANY, VERB_ANY, 0, analyze_critical_chain },
1913 { "plot", VERB_ANY, 1, 0, analyze_plot },
1914 { "dot", VERB_ANY, VERB_ANY, 0, dot },
1915 { "log-level", VERB_ANY, 2, 0, get_or_set_log_level },
1916 { "log-target", VERB_ANY, 2, 0, get_or_set_log_target },
1917 /* The following four verbs are deprecated aliases */
1918 { "set-log-level", 2, 2, 0, set_log_level },
1919 { "get-log-level", VERB_ANY, 1, 0, get_log_level },
1920 { "set-log-target", 2, 2, 0, set_log_target },
1921 { "get-log-target", VERB_ANY, 1, 0, get_log_target },
1922 { "dump", VERB_ANY, 1, 0, dump },
1923 { "cat-config", 2, VERB_ANY, 0, cat_config },
1924 { "unit-paths", 1, 1, 0, dump_unit_paths },
1925 { "syscall-filter", VERB_ANY, VERB_ANY, 0, dump_syscall_filters },
1926 { "verify", 2, VERB_ANY, 0, do_verify },
1927 { "calendar", 2, VERB_ANY, 0, test_calendar },
1928 { "service-watchdogs", VERB_ANY, 2, 0, service_watchdogs },
1929 { "timespan", 2, VERB_ANY, 0, dump_timespan },
1930 {}
1931 };
1932
1933 int r;
1934
1935 setlocale(LC_ALL, "");
1936 setlocale(LC_NUMERIC, "C"); /* we want to format/parse floats in C style */
1937
1938 log_parse_environment();
1939 log_open();
1940
1941 r = parse_argv(argc, argv);
1942 if (r <= 0)
1943 goto finish;
1944
1945 r = dispatch_verb(argc, argv, verbs, NULL);
1946
1947 finish:
1948 pager_close();
1949
1950 strv_free(arg_dot_from_patterns);
1951 strv_free(arg_dot_to_patterns);
1952
1953 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1954 }
Unnamed repository; edit this file 'description' to name the repository.