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