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