]> 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: read host and system information from remote
[thirdparty/systemd.git] / src / analyze / analyze.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010-2013 Lennart Poettering
7 Copyright 2013 Simon Peeters
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <getopt.h>
26 #include <locale.h>
27 #include <sys/utsname.h>
28 #include <fnmatch.h>
29
30 #include "sd-bus.h"
31 #include "bus-util.h"
32 #include "bus-error.h"
33 #include "install.h"
34 #include "log.h"
35 #include "build.h"
36 #include "util.h"
37 #include "strxcpyx.h"
38 #include "fileio.h"
39 #include "strv.h"
40 #include "unit-name.h"
41 #include "special.h"
42 #include "hashmap.h"
43 #include "pager.h"
44
45 #define SCALE_X (0.1 / 1000.0) /* pixels per us */
46 #define SCALE_Y (20.0)
47
48 #define compare(a, b) (((a) > (b))? 1 : (((b) > (a))? -1 : 0))
49
50 #define svg(...) printf(__VA_ARGS__)
51
52 #define svg_bar(class, x1, x2, y) \
53 svg(" <rect class=\"%s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n", \
54 (class), \
55 SCALE_X * (x1), SCALE_Y * (y), \
56 SCALE_X * ((x2) - (x1)), SCALE_Y - 1.0)
57
58 #define svg_text(b, x, y, format, ...) \
59 do { \
60 svg(" <text class=\"%s\" x=\"%.03f\" y=\"%.03f\">", (b) ? "left" : "right", SCALE_X * (x) + (b ? 5.0 : -5.0), SCALE_Y * (y) + 14.0); \
61 svg(format, ## __VA_ARGS__); \
62 svg("</text>\n"); \
63 } while(false)
64
65 static enum dot {
66 DEP_ALL,
67 DEP_ORDER,
68 DEP_REQUIRE
69 } arg_dot = DEP_ALL;
70 static char** arg_dot_from_patterns = NULL;
71 static char** arg_dot_to_patterns = NULL;
72 static usec_t arg_fuzz = 0;
73 static bool arg_no_pager = false;
74 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
75 static char *arg_host = NULL;
76 static bool arg_user = false;
77
78 struct boot_times {
79 usec_t firmware_time;
80 usec_t loader_time;
81 usec_t kernel_time;
82 usec_t kernel_done_time;
83 usec_t initrd_time;
84 usec_t userspace_time;
85 usec_t finish_time;
86 usec_t security_start_time;
87 usec_t security_finish_time;
88 usec_t generators_start_time;
89 usec_t generators_finish_time;
90 usec_t unitsload_start_time;
91 usec_t unitsload_finish_time;
92 };
93
94 struct unit_times {
95 char *name;
96 usec_t activating;
97 usec_t activated;
98 usec_t deactivated;
99 usec_t deactivating;
100 usec_t time;
101 };
102
103 struct host_info {
104 char *hostname;
105 char *kernel_name;
106 char *kernel_release;
107 char *kernel_version;
108 char *os_pretty_name;
109 char *virtualization;
110 char *architecture;
111 };
112
113 static void pager_open_if_enabled(void) {
114
115 if (arg_no_pager)
116 return;
117
118 pager_open(false);
119 }
120
121 static int bus_get_uint64_property(sd_bus *bus, const char *path, const char *interface, const char *property, uint64_t *val) {
122 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
123 int r;
124
125 assert(bus);
126 assert(path);
127 assert(interface);
128 assert(property);
129 assert(val);
130
131 r = sd_bus_get_property_trivial(
132 bus,
133 "org.freedesktop.systemd1",
134 path,
135 interface,
136 property,
137 &error,
138 't', val);
139
140 if (r < 0) {
141 log_error("Failed to parse reply: %s", bus_error_message(&error, -r));
142 return r;
143 }
144
145 return 0;
146 }
147
148 static int bus_get_unit_property_strv(sd_bus *bus, const char *path, const char *property, char ***strv) {
149 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
150 int r;
151
152 assert(bus);
153 assert(path);
154 assert(property);
155 assert(strv);
156
157 r = sd_bus_get_property_strv(
158 bus,
159 "org.freedesktop.systemd1",
160 path,
161 "org.freedesktop.systemd1.Unit",
162 property,
163 &error,
164 strv);
165 if (r < 0) {
166 log_error("Failed to get unit property %s: %s", property, bus_error_message(&error, -r));
167 return r;
168 }
169
170 return 0;
171 }
172
173 static int compare_unit_time(const void *a, const void *b) {
174 return compare(((struct unit_times *)b)->time,
175 ((struct unit_times *)a)->time);
176 }
177
178 static int compare_unit_start(const void *a, const void *b) {
179 return compare(((struct unit_times *)a)->activating,
180 ((struct unit_times *)b)->activating);
181 }
182
183 static void free_unit_times(struct unit_times *t, unsigned n) {
184 struct unit_times *p;
185
186 for (p = t; p < t + n; p++)
187 free(p->name);
188
189 free(t);
190 }
191
192 static int acquire_time_data(sd_bus *bus, struct unit_times **out) {
193 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
194 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
195 int r, c = 0;
196 struct unit_times *unit_times = NULL;
197 size_t size = 0;
198 UnitInfo u;
199
200 r = sd_bus_call_method(
201 bus,
202 "org.freedesktop.systemd1",
203 "/org/freedesktop/systemd1",
204 "org.freedesktop.systemd1.Manager",
205 "ListUnits",
206 &error, &reply,
207 NULL);
208 if (r < 0) {
209 log_error("Failed to list units: %s", bus_error_message(&error, -r));
210 goto fail;
211 }
212
213 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
214 if (r < 0) {
215 bus_log_parse_error(r);
216 goto fail;
217 }
218
219 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
220 struct unit_times *t;
221
222 if (!GREEDY_REALLOC(unit_times, size, c+1)) {
223 r = log_oom();
224 goto fail;
225 }
226
227 t = unit_times+c;
228 t->name = NULL;
229
230 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
231
232 if (bus_get_uint64_property(bus, u.unit_path,
233 "org.freedesktop.systemd1.Unit",
234 "InactiveExitTimestampMonotonic",
235 &t->activating) < 0 ||
236 bus_get_uint64_property(bus, u.unit_path,
237 "org.freedesktop.systemd1.Unit",
238 "ActiveEnterTimestampMonotonic",
239 &t->activated) < 0 ||
240 bus_get_uint64_property(bus, u.unit_path,
241 "org.freedesktop.systemd1.Unit",
242 "ActiveExitTimestampMonotonic",
243 &t->deactivating) < 0 ||
244 bus_get_uint64_property(bus, u.unit_path,
245 "org.freedesktop.systemd1.Unit",
246 "InactiveEnterTimestampMonotonic",
247 &t->deactivated) < 0) {
248 r = -EIO;
249 goto fail;
250 }
251
252 if (t->activated >= t->activating)
253 t->time = t->activated - t->activating;
254 else if (t->deactivated >= t->activating)
255 t->time = t->deactivated - t->activating;
256 else
257 t->time = 0;
258
259 if (t->activating == 0)
260 continue;
261
262 t->name = strdup(u.id);
263 if (t->name == NULL) {
264 r = log_oom();
265 goto fail;
266 }
267 c++;
268 }
269 if (r < 0) {
270 bus_log_parse_error(r);
271 goto fail;
272 }
273
274 *out = unit_times;
275 return c;
276
277 fail:
278 free_unit_times(unit_times, (unsigned) c);
279 return r;
280 }
281
282 static int acquire_boot_times(sd_bus *bus, struct boot_times **bt) {
283 static struct boot_times times;
284 static bool cached = false;
285
286 if (cached)
287 goto finish;
288
289 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
290
291 if (bus_get_uint64_property(bus,
292 "/org/freedesktop/systemd1",
293 "org.freedesktop.systemd1.Manager",
294 "FirmwareTimestampMonotonic",
295 &times.firmware_time) < 0 ||
296 bus_get_uint64_property(bus,
297 "/org/freedesktop/systemd1",
298 "org.freedesktop.systemd1.Manager",
299 "LoaderTimestampMonotonic",
300 &times.loader_time) < 0 ||
301 bus_get_uint64_property(bus,
302 "/org/freedesktop/systemd1",
303 "org.freedesktop.systemd1.Manager",
304 "KernelTimestamp",
305 &times.kernel_time) < 0 ||
306 bus_get_uint64_property(bus,
307 "/org/freedesktop/systemd1",
308 "org.freedesktop.systemd1.Manager",
309 "InitRDTimestampMonotonic",
310 &times.initrd_time) < 0 ||
311 bus_get_uint64_property(bus,
312 "/org/freedesktop/systemd1",
313 "org.freedesktop.systemd1.Manager",
314 "UserspaceTimestampMonotonic",
315 &times.userspace_time) < 0 ||
316 bus_get_uint64_property(bus,
317 "/org/freedesktop/systemd1",
318 "org.freedesktop.systemd1.Manager",
319 "FinishTimestampMonotonic",
320 &times.finish_time) < 0 ||
321 bus_get_uint64_property(bus,
322 "/org/freedesktop/systemd1",
323 "org.freedesktop.systemd1.Manager",
324 "SecurityStartTimestampMonotonic",
325 &times.security_start_time) < 0 ||
326 bus_get_uint64_property(bus,
327 "/org/freedesktop/systemd1",
328 "org.freedesktop.systemd1.Manager",
329 "SecurityFinishTimestampMonotonic",
330 &times.security_finish_time) < 0 ||
331 bus_get_uint64_property(bus,
332 "/org/freedesktop/systemd1",
333 "org.freedesktop.systemd1.Manager",
334 "GeneratorsStartTimestampMonotonic",
335 &times.generators_start_time) < 0 ||
336 bus_get_uint64_property(bus,
337 "/org/freedesktop/systemd1",
338 "org.freedesktop.systemd1.Manager",
339 "GeneratorsFinishTimestampMonotonic",
340 &times.generators_finish_time) < 0 ||
341 bus_get_uint64_property(bus,
342 "/org/freedesktop/systemd1",
343 "org.freedesktop.systemd1.Manager",
344 "UnitsLoadStartTimestampMonotonic",
345 &times.unitsload_start_time) < 0 ||
346 bus_get_uint64_property(bus,
347 "/org/freedesktop/systemd1",
348 "org.freedesktop.systemd1.Manager",
349 "UnitsLoadFinishTimestampMonotonic",
350 &times.unitsload_finish_time) < 0)
351 return -EIO;
352
353 if (times.finish_time <= 0) {
354 log_error("Bootup is not yet finished. Please try again later.");
355 return -EINPROGRESS;
356 }
357
358 if (times.initrd_time)
359 times.kernel_done_time = times.initrd_time;
360 else
361 times.kernel_done_time = times.userspace_time;
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 free(hi->hostname);
372 free(hi->kernel_name);
373 free(hi->kernel_release);
374 free(hi->kernel_version);
375 free(hi->os_pretty_name);
376 free(hi->virtualization);
377 free(hi->architecture);
378 free(hi);
379 }
380
381 static int acquire_host_info(sd_bus *bus, struct host_info **hi) {
382 int r;
383 struct host_info *host;
384
385 static const struct bus_properties_map hostname_map[] = {
386 { "Hostname", "s", NULL, offsetof(struct host_info, hostname) },
387 { "KernelName", "s", NULL, offsetof(struct host_info, kernel_name) },
388 { "KernelRelease", "s", NULL, offsetof(struct host_info, kernel_release) },
389 { "KernelVersion", "s", NULL, offsetof(struct host_info, kernel_version) },
390 { "OperatingSystemPrettyName", "s", NULL, offsetof(struct host_info, os_pretty_name) },
391 {}
392 };
393
394 static const struct bus_properties_map manager_map[] = {
395 { "Virtualization", "s", NULL, offsetof(struct host_info, virtualization) },
396 { "Architecture", "s", NULL, offsetof(struct host_info, architecture) },
397 {}
398 };
399
400 host = new0(struct host_info, 1);
401 if (!host)
402 return log_oom();
403
404 r = bus_map_all_properties(bus,
405 "org.freedesktop.hostname1",
406 "/org/freedesktop/hostname1",
407 hostname_map,
408 host);
409 if (r < 0)
410 goto fail;
411
412 r = bus_map_all_properties(bus,
413 "org.freedesktop.systemd1",
414 "/org/freedesktop/systemd1",
415 manager_map,
416 host);
417 if (r < 0)
418 goto fail;
419
420 *hi = host;
421 return 0;
422 fail:
423 free_host_info(host);
424 return r;
425 }
426
427 static int pretty_boot_time(sd_bus *bus, char **_buf) {
428 char ts[FORMAT_TIMESPAN_MAX];
429 struct boot_times *t;
430 static char buf[4096];
431 size_t size;
432 char *ptr;
433 int r;
434
435 r = acquire_boot_times(bus, &t);
436 if (r < 0)
437 return r;
438
439 ptr = buf;
440 size = sizeof(buf);
441
442 size = strpcpyf(&ptr, size, "Startup finished in ");
443 if (t->firmware_time)
444 size = strpcpyf(&ptr, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), t->firmware_time - t->loader_time, USEC_PER_MSEC));
445 if (t->loader_time)
446 size = strpcpyf(&ptr, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), t->loader_time, USEC_PER_MSEC));
447 if (t->kernel_time)
448 size = strpcpyf(&ptr, size, "%s (kernel) + ", format_timespan(ts, sizeof(ts), t->kernel_done_time, USEC_PER_MSEC));
449 if (t->initrd_time > 0)
450 size = strpcpyf(&ptr, size, "%s (initrd) + ", format_timespan(ts, sizeof(ts), t->userspace_time - t->initrd_time, USEC_PER_MSEC));
451
452 size = strpcpyf(&ptr, size, "%s (userspace) ", format_timespan(ts, sizeof(ts), t->finish_time - t->userspace_time, USEC_PER_MSEC));
453 if (t->kernel_time > 0)
454 strpcpyf(&ptr, size, "= %s", format_timespan(ts, sizeof(ts), t->firmware_time + t->finish_time, USEC_PER_MSEC));
455 else
456 strpcpyf(&ptr, size, "= %s", format_timespan(ts, sizeof(ts), t->finish_time - t->userspace_time, USEC_PER_MSEC));
457
458 ptr = strdup(buf);
459 if (!ptr)
460 return log_oom();
461
462 *_buf = ptr;
463 return 0;
464 }
465
466 static void svg_graph_box(double height, double begin, double end) {
467 long long i;
468
469 /* outside box, fill */
470 svg("<rect class=\"box\" x=\"0\" y=\"0\" width=\"%.03f\" height=\"%.03f\" />\n",
471 SCALE_X * (end - begin), SCALE_Y * height);
472
473 for (i = ((long long) (begin / 100000)) * 100000; i <= end; i+=100000) {
474 /* lines for each second */
475 if (i % 5000000 == 0)
476 svg(" <line class=\"sec5\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n"
477 " <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
478 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
479 else if (i % 1000000 == 0)
480 svg(" <line class=\"sec1\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n"
481 " <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
482 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
483 else
484 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
485 SCALE_X * i, SCALE_X * i, SCALE_Y * height);
486 }
487 }
488
489 static int analyze_plot(sd_bus *bus) {
490 struct unit_times *times;
491 struct boot_times *boot;
492 struct host_info *host = NULL;
493 int n, m = 1, y=0;
494 double width;
495 _cleanup_free_ char *pretty_times = NULL;
496 struct unit_times *u;
497
498 n = acquire_boot_times(bus, &boot);
499 if (n < 0)
500 return n;
501
502 n = pretty_boot_time(bus, &pretty_times);
503 if (n < 0)
504 return n;
505
506 n = acquire_host_info(bus, &host);
507 if (n < 0)
508 return n;
509
510 n = acquire_time_data(bus, &times);
511 if (n <= 0)
512 goto out;
513
514 qsort(times, n, sizeof(struct unit_times), compare_unit_start);
515
516 width = SCALE_X * (boot->firmware_time + boot->finish_time);
517 if (width < 800.0)
518 width = 800.0;
519
520 if (boot->firmware_time > boot->loader_time)
521 m++;
522 if (boot->loader_time) {
523 m++;
524 if (width < 1000.0)
525 width = 1000.0;
526 }
527 if (boot->initrd_time)
528 m++;
529 if (boot->kernel_time)
530 m++;
531
532 for (u = times; u < times + n; u++) {
533 double text_start, text_width;
534
535 if (u->activating < boot->userspace_time ||
536 u->activating > boot->finish_time) {
537 free(u->name);
538 u->name = NULL;
539 continue;
540 }
541
542 /* If the text cannot fit on the left side then
543 * increase the svg width so it fits on the right.
544 * TODO: calculate the text width more accurately */
545 text_width = 8.0 * strlen(u->name);
546 text_start = (boot->firmware_time + u->activating) * SCALE_X;
547 if (text_width > text_start && text_width + text_start > width)
548 width = text_width + text_start;
549
550 if (u->deactivated > u->activating && u->deactivated <= boot->finish_time
551 && u->activated == 0 && u->deactivating == 0)
552 u->activated = u->deactivating = u->deactivated;
553 if (u->activated < u->activating || u->activated > boot->finish_time)
554 u->activated = boot->finish_time;
555 if (u->deactivating < u->activated || u->activated > boot->finish_time)
556 u->deactivating = boot->finish_time;
557 if (u->deactivated < u->deactivating || u->deactivated > boot->finish_time)
558 u->deactivated = boot->finish_time;
559 m++;
560 }
561
562 svg("<?xml version=\"1.0\" standalone=\"no\"?>\n"
563 "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" "
564 "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
565
566 svg("<svg width=\"%.0fpx\" height=\"%.0fpx\" version=\"1.1\" "
567 "xmlns=\"http://www.w3.org/2000/svg\">\n\n",
568 80.0 + width, 150.0 + (m * SCALE_Y) +
569 5 * SCALE_Y /* legend */);
570
571 /* write some basic info as a comment, including some help */
572 svg("<!-- This file is a systemd-analyze SVG file. It is best rendered in a -->\n"
573 "<!-- browser such as Chrome, Chromium or Firefox. Other applications -->\n"
574 "<!-- that render these files properly but much slower are ImageMagick, -->\n"
575 "<!-- gimp, inkscape, etc. To display the files on your system, just -->\n"
576 "<!-- point your browser to this file. -->\n\n"
577 "<!-- This plot was generated by systemd-analyze version %-16.16s -->\n\n", VERSION);
578
579 /* style sheet */
580 svg("<defs>\n <style type=\"text/css\">\n <![CDATA[\n"
581 " rect { stroke-width: 1; stroke-opacity: 0; }\n"
582 " rect.background { fill: rgb(255,255,255); }\n"
583 " rect.activating { fill: rgb(255,0,0); fill-opacity: 0.7; }\n"
584 " rect.active { fill: rgb(200,150,150); fill-opacity: 0.7; }\n"
585 " rect.deactivating { fill: rgb(150,100,100); fill-opacity: 0.7; }\n"
586 " rect.kernel { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
587 " rect.initrd { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
588 " rect.firmware { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
589 " rect.loader { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
590 " rect.userspace { fill: rgb(150,150,150); fill-opacity: 0.7; }\n"
591 " rect.security { fill: rgb(144,238,144); fill-opacity: 0.7; }\n"
592 " rect.generators { fill: rgb(102,204,255); fill-opacity: 0.7; }\n"
593 " rect.unitsload { fill: rgb( 82,184,255); fill-opacity: 0.7; }\n"
594 " rect.box { fill: rgb(240,240,240); stroke: rgb(192,192,192); }\n"
595 " line { stroke: rgb(64,64,64); stroke-width: 1; }\n"
596 "// line.sec1 { }\n"
597 " line.sec5 { stroke-width: 2; }\n"
598 " line.sec01 { stroke: rgb(224,224,224); stroke-width: 1; }\n"
599 " text { font-family: Verdana, Helvetica; font-size: 14px; }\n"
600 " text.left { font-family: Verdana, Helvetica; font-size: 14px; text-anchor: start; }\n"
601 " text.right { font-family: Verdana, Helvetica; font-size: 14px; text-anchor: end; }\n"
602 " text.sec { font-size: 10px; }\n"
603 " ]]>\n </style>\n</defs>\n\n");
604
605 svg("<rect class=\"background\" width=\"100%%\" height=\"100%%\" />\n");
606 svg("<text x=\"20\" y=\"50\">%s</text>", pretty_times);
607 svg("<text x=\"20\" y=\"30\">%s %s (%s %s %s) %s %s</text>",
608 isempty(host->os_pretty_name) ? "Linux" : host->os_pretty_name,
609 isempty(host->hostname) ? "" : host->hostname,
610 isempty(host->kernel_name) ? "" : host->kernel_name,
611 isempty(host->kernel_release) ? "" : host->kernel_release,
612 isempty(host->kernel_version) ? "" : host->kernel_version,
613 isempty(host->architecture) ? "" : host->architecture,
614 isempty(host->virtualization) ? "" : host->virtualization);
615
616 svg("<g transform=\"translate(%.3f,100)\">\n", 20.0 + (SCALE_X * boot->firmware_time));
617 svg_graph_box(m, -(double) boot->firmware_time, boot->finish_time);
618
619 if (boot->firmware_time) {
620 svg_bar("firmware", -(double) boot->firmware_time, -(double) boot->loader_time, y);
621 svg_text(true, -(double) boot->firmware_time, y, "firmware");
622 y++;
623 }
624 if (boot->loader_time) {
625 svg_bar("loader", -(double) boot->loader_time, 0, y);
626 svg_text(true, -(double) boot->loader_time, y, "loader");
627 y++;
628 }
629 if (boot->kernel_time) {
630 svg_bar("kernel", 0, boot->kernel_done_time, y);
631 svg_text(true, 0, y, "kernel");
632 y++;
633 }
634 if (boot->initrd_time) {
635 svg_bar("initrd", boot->initrd_time, boot->userspace_time, y);
636 svg_text(true, boot->initrd_time, y, "initrd");
637 y++;
638 }
639 svg_bar("active", boot->userspace_time, boot->finish_time, y);
640 svg_bar("security", boot->security_start_time, boot->security_finish_time, y);
641 svg_bar("generators", boot->generators_start_time, boot->generators_finish_time, y);
642 svg_bar("unitsload", boot->unitsload_start_time, boot->unitsload_finish_time, y);
643 svg_text(true, boot->userspace_time, y, "systemd");
644 y++;
645
646 for (u = times; u < times + n; u++) {
647 char ts[FORMAT_TIMESPAN_MAX];
648 bool b;
649
650 if (!u->name)
651 continue;
652
653 svg_bar("activating", u->activating, u->activated, y);
654 svg_bar("active", u->activated, u->deactivating, y);
655 svg_bar("deactivating", u->deactivating, u->deactivated, y);
656
657 /* place the text on the left if we have passed the half of the svg width */
658 b = u->activating * SCALE_X < width / 2;
659 if (u->time)
660 svg_text(b, u->activating, y, "%s (%s)",
661 u->name, format_timespan(ts, sizeof(ts), u->time, USEC_PER_MSEC));
662 else
663 svg_text(b, u->activating, y, "%s", u->name);
664 y++;
665 }
666
667 svg("</g>\n");
668
669 /* Legend */
670 svg("<g transform=\"translate(20,100)\">\n");
671 y++;
672 svg_bar("activating", 0, 300000, y);
673 svg_text(true, 400000, y, "Activating");
674 y++;
675 svg_bar("active", 0, 300000, y);
676 svg_text(true, 400000, y, "Active");
677 y++;
678 svg_bar("deactivating", 0, 300000, y);
679 svg_text(true, 400000, y, "Deactivating");
680 y++;
681 svg_bar("security", 0, 300000, y);
682 svg_text(true, 400000, y, "Setting up security module");
683 y++;
684 svg_bar("generators", 0, 300000, y);
685 svg_text(true, 400000, y, "Generators");
686 y++;
687 svg_bar("unitsload", 0, 300000, y);
688 svg_text(true, 400000, y, "Loading unit files");
689 y++;
690
691 svg("</g>\n\n");
692
693 svg("</svg>\n");
694
695 free_unit_times(times, (unsigned) n);
696
697 n = 0;
698 out:
699 free_host_info(host);
700 return n;
701 }
702
703 static int list_dependencies_print(const char *name, unsigned int level, unsigned int branches,
704 bool last, struct unit_times *times, struct boot_times *boot) {
705 unsigned int i;
706 char ts[FORMAT_TIMESPAN_MAX], ts2[FORMAT_TIMESPAN_MAX];
707
708 for (i = level; i != 0; i--)
709 printf("%s", draw_special_char(branches & (1 << (i-1)) ? DRAW_TREE_VERTICAL : DRAW_TREE_SPACE));
710
711 printf("%s", draw_special_char(last ? DRAW_TREE_RIGHT : DRAW_TREE_BRANCH));
712
713 if (times) {
714 if (times->time)
715 printf("%s%s @%s +%s%s", ANSI_HIGHLIGHT_RED_ON, name,
716 format_timespan(ts, sizeof(ts), times->activating - boot->userspace_time, USEC_PER_MSEC),
717 format_timespan(ts2, sizeof(ts2), times->time, USEC_PER_MSEC), ANSI_HIGHLIGHT_OFF);
718 else if (times->activated > boot->userspace_time)
719 printf("%s @%s", name, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
720 else
721 printf("%s", name);
722 } else
723 printf("%s", name);
724 printf("\n");
725
726 return 0;
727 }
728
729 static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
730 _cleanup_free_ char *path = NULL;
731
732 assert(bus);
733 assert(name);
734 assert(deps);
735
736 path = unit_dbus_path_from_name(name);
737 if (path == NULL)
738 return -ENOMEM;
739
740 return bus_get_unit_property_strv(bus, path, "After", deps);
741 }
742
743 static Hashmap *unit_times_hashmap;
744
745 static int list_dependencies_compare(const void *_a, const void *_b) {
746 const char **a = (const char**) _a, **b = (const char**) _b;
747 usec_t usa = 0, usb = 0;
748 struct unit_times *times;
749
750 times = hashmap_get(unit_times_hashmap, *a);
751 if (times)
752 usa = times->activated;
753 times = hashmap_get(unit_times_hashmap, *b);
754 if (times)
755 usb = times->activated;
756
757 return usb - usa;
758 }
759
760 static int list_dependencies_one(sd_bus *bus, const char *name, unsigned int level, char ***units,
761 unsigned int branches) {
762 _cleanup_strv_free_ char **deps = NULL;
763 char **c;
764 int r = 0;
765 usec_t service_longest = 0;
766 int to_print = 0;
767 struct unit_times *times;
768 struct boot_times *boot;
769
770 if (strv_extend(units, name))
771 return log_oom();
772
773 r = list_dependencies_get_dependencies(bus, name, &deps);
774 if (r < 0)
775 return r;
776
777 qsort_safe(deps, strv_length(deps), sizeof (char*), list_dependencies_compare);
778
779 r = acquire_boot_times(bus, &boot);
780 if (r < 0)
781 return r;
782
783 STRV_FOREACH(c, deps) {
784 times = hashmap_get(unit_times_hashmap, *c);
785 if (times
786 && times->activated
787 && times->activated <= boot->finish_time
788 && (times->activated >= service_longest
789 || service_longest == 0)) {
790 service_longest = times->activated;
791 break;
792 }
793 }
794
795 if (service_longest == 0 )
796 return r;
797
798 STRV_FOREACH(c, deps) {
799 times = hashmap_get(unit_times_hashmap, *c);
800 if (times && times->activated
801 && times->activated <= boot->finish_time
802 && (service_longest - times->activated) <= arg_fuzz) {
803 to_print++;
804 }
805 }
806
807 if (!to_print)
808 return r;
809
810 STRV_FOREACH(c, deps) {
811 times = hashmap_get(unit_times_hashmap, *c);
812 if (!times
813 || !times->activated
814 || times->activated > boot->finish_time
815 || service_longest - times->activated > arg_fuzz)
816 continue;
817
818 to_print--;
819
820 r = list_dependencies_print(*c, level, branches, to_print == 0, times, boot);
821 if (r < 0)
822 return r;
823
824 if (strv_contains(*units, *c)) {
825 r = list_dependencies_print("...", level + 1, (branches << 1) | (to_print ? 1 : 0),
826 true, NULL, boot);
827 if (r < 0)
828 return r;
829 continue;
830 }
831
832 r = list_dependencies_one(bus, *c, level + 1, units,
833 (branches << 1) | (to_print ? 1 : 0));
834 if (r < 0)
835 return r;
836
837 if (!to_print)
838 break;
839 }
840 return 0;
841 }
842
843 static int list_dependencies(sd_bus *bus, const char *name) {
844 _cleanup_strv_free_ char **units = NULL;
845 char ts[FORMAT_TIMESPAN_MAX];
846 struct unit_times *times;
847 int r;
848 const char *path, *id;
849 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
850 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
851 struct boot_times *boot;
852
853 assert(bus);
854
855 path = unit_dbus_path_from_name(name);
856 if (path == NULL)
857 return -ENOMEM;
858
859 r = sd_bus_get_property(
860 bus,
861 "org.freedesktop.systemd1",
862 path,
863 "org.freedesktop.systemd1.Unit",
864 "Id",
865 &error,
866 &reply,
867 "s");
868 if (r < 0) {
869 log_error("Failed to get ID: %s", bus_error_message(&error, -r));
870 return r;
871 }
872
873 r = sd_bus_message_read(reply, "s", &id);
874 if (r < 0)
875 return bus_log_parse_error(r);
876
877 times = hashmap_get(unit_times_hashmap, id);
878
879 r = acquire_boot_times(bus, &boot);
880 if (r < 0)
881 return r;
882
883 if (times) {
884 if (times->time)
885 printf("%s%s +%s%s\n", ANSI_HIGHLIGHT_RED_ON, id,
886 format_timespan(ts, sizeof(ts), times->time, USEC_PER_MSEC), ANSI_HIGHLIGHT_OFF);
887 else if (times->activated > boot->userspace_time)
888 printf("%s @%s\n", id, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
889 else
890 printf("%s\n", id);
891 }
892
893 return list_dependencies_one(bus, name, 0, &units, 0);
894 }
895
896 static int analyze_critical_chain(sd_bus *bus, char *names[]) {
897 struct unit_times *times;
898 unsigned int i;
899 Hashmap *h;
900 int n, r;
901
902 n = acquire_time_data(bus, &times);
903 if (n <= 0)
904 return n;
905
906 h = hashmap_new(string_hash_func, string_compare_func);
907 if (!h)
908 return -ENOMEM;
909
910 for (i = 0; i < (unsigned)n; i++) {
911 r = hashmap_put(h, times[i].name, &times[i]);
912 if (r < 0)
913 return r;
914 }
915 unit_times_hashmap = h;
916
917 pager_open_if_enabled();
918
919 puts("The time after the unit is active or started is printed after the \"@\" character.\n"
920 "The time the unit takes to start is printed after the \"+\" character.\n");
921
922 if (!strv_isempty(names)) {
923 char **name;
924 STRV_FOREACH(name, names)
925 list_dependencies(bus, *name);
926 } else
927 list_dependencies(bus, SPECIAL_DEFAULT_TARGET);
928
929 hashmap_free(h);
930 free_unit_times(times, (unsigned) n);
931 return 0;
932 }
933
934 static int analyze_blame(sd_bus *bus) {
935 struct unit_times *times;
936 unsigned i;
937 int n;
938
939 n = acquire_time_data(bus, &times);
940 if (n <= 0)
941 return n;
942
943 qsort(times, n, sizeof(struct unit_times), compare_unit_time);
944
945 pager_open_if_enabled();
946
947 for (i = 0; i < (unsigned) n; i++) {
948 char ts[FORMAT_TIMESPAN_MAX];
949
950 if (times[i].time > 0)
951 printf("%16s %s\n", format_timespan(ts, sizeof(ts), times[i].time, USEC_PER_MSEC), times[i].name);
952 }
953
954 free_unit_times(times, (unsigned) n);
955 return 0;
956 }
957
958 static int analyze_time(sd_bus *bus) {
959 _cleanup_free_ char *buf = NULL;
960 int r;
961
962 r = pretty_boot_time(bus, &buf);
963 if (r < 0)
964 return r;
965
966 puts(buf);
967 return 0;
968 }
969
970 static int graph_one_property(sd_bus *bus, const UnitInfo *u, const char* prop, const char *color, char* patterns[]) {
971 _cleanup_strv_free_ char **units = NULL;
972 char **unit;
973 int r;
974
975 assert(u);
976 assert(prop);
977 assert(color);
978
979 r = bus_get_unit_property_strv(bus, u->unit_path, prop, &units);
980 if (r < 0)
981 return r;
982
983 STRV_FOREACH(unit, units) {
984 char **p;
985 bool match_found;
986
987 if (!strv_isempty(arg_dot_from_patterns)) {
988 match_found = false;
989
990 STRV_FOREACH(p, arg_dot_from_patterns)
991 if (fnmatch(*p, u->id, 0) == 0) {
992 match_found = true;
993 break;
994 }
995
996 if (!match_found)
997 continue;
998 }
999
1000 if (!strv_isempty(arg_dot_to_patterns)) {
1001 match_found = false;
1002
1003 STRV_FOREACH(p, arg_dot_to_patterns)
1004 if (fnmatch(*p, *unit, 0) == 0) {
1005 match_found = true;
1006 break;
1007 }
1008
1009 if (!match_found)
1010 continue;
1011 }
1012
1013 if (!strv_isempty(patterns)) {
1014 match_found = false;
1015
1016 STRV_FOREACH(p, patterns)
1017 if (fnmatch(*p, u->id, 0) == 0 || fnmatch(*p, *unit, 0) == 0) {
1018 match_found = true;
1019 break;
1020 }
1021 if (!match_found)
1022 continue;
1023 }
1024
1025 printf("\t\"%s\"->\"%s\" [color=\"%s\"];\n", u->id, *unit, color);
1026 }
1027
1028 return 0;
1029 }
1030
1031 static int graph_one(sd_bus *bus, const UnitInfo *u, char *patterns[]) {
1032 int r;
1033
1034 assert(bus);
1035 assert(u);
1036
1037 if (arg_dot == DEP_ORDER ||arg_dot == DEP_ALL) {
1038 r = graph_one_property(bus, u, "After", "green", patterns);
1039 if (r < 0)
1040 return r;
1041 }
1042
1043 if (arg_dot == DEP_REQUIRE ||arg_dot == DEP_ALL) {
1044 r = graph_one_property(bus, u, "Requires", "black", patterns);
1045 if (r < 0)
1046 return r;
1047 r = graph_one_property(bus, u, "RequiresOverridable", "black", patterns);
1048 if (r < 0)
1049 return r;
1050 r = graph_one_property(bus, u, "RequisiteOverridable", "darkblue", patterns);
1051 if (r < 0)
1052 return r;
1053 r = graph_one_property(bus, u, "Wants", "grey66", patterns);
1054 if (r < 0)
1055 return r;
1056 r = graph_one_property(bus, u, "Conflicts", "red", patterns);
1057 if (r < 0)
1058 return r;
1059 r = graph_one_property(bus, u, "ConflictedBy", "red", patterns);
1060 if (r < 0)
1061 return r;
1062 }
1063
1064 return 0;
1065 }
1066
1067 static int dot(sd_bus *bus, char* patterns[]) {
1068 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1069 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1070 int r;
1071 UnitInfo u;
1072
1073 r = sd_bus_call_method(
1074 bus,
1075 "org.freedesktop.systemd1",
1076 "/org/freedesktop/systemd1",
1077 "org.freedesktop.systemd1.Manager",
1078 "ListUnits",
1079 &error,
1080 &reply,
1081 "");
1082 if (r < 0) {
1083 log_error("Failed to list units: %s", bus_error_message(&error, -r));
1084 return r;
1085 }
1086
1087 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
1088 if (r < 0)
1089 return bus_log_parse_error(r);
1090
1091 printf("digraph systemd {\n");
1092
1093 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
1094
1095 r = graph_one(bus, &u, patterns);
1096 if (r < 0)
1097 return r;
1098 }
1099 if (r < 0)
1100 return bus_log_parse_error(r);
1101
1102 printf("}\n");
1103
1104 log_info(" Color legend: black = Requires\n"
1105 " dark blue = Requisite\n"
1106 " dark grey = Wants\n"
1107 " red = Conflicts\n"
1108 " green = After\n");
1109
1110 if (on_tty())
1111 log_notice("-- You probably want to process this output with graphviz' dot tool.\n"
1112 "-- Try a shell pipeline like 'systemd-analyze dot | dot -Tsvg > systemd.svg'!\n");
1113
1114 return 0;
1115 }
1116
1117 static int dump(sd_bus *bus, char **args) {
1118 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1119 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1120 const char *text = NULL;
1121 int r;
1122
1123 if (!strv_isempty(args)) {
1124 log_error("Too many arguments.");
1125 return -E2BIG;
1126 }
1127
1128 pager_open_if_enabled();
1129
1130 r = sd_bus_call_method(
1131 bus,
1132 "org.freedesktop.systemd1",
1133 "/org/freedesktop/systemd1",
1134 "org.freedesktop.systemd1.Manager",
1135 "Dump",
1136 &error,
1137 &reply,
1138 "");
1139 if (r < 0) {
1140 log_error("Failed issue method call: %s", bus_error_message(&error, -r));
1141 return r;
1142 }
1143
1144 r = sd_bus_message_read(reply, "s", &text);
1145 if (r < 0)
1146 return bus_log_parse_error(r);
1147
1148 fputs(text, stdout);
1149 return 0;
1150 }
1151
1152 static int set_log_level(sd_bus *bus, char **args) {
1153 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1154 int r;
1155
1156 assert(bus);
1157 assert(args);
1158
1159 if (strv_length(args) != 1) {
1160 log_error("This command expects one argument only.");
1161 return -E2BIG;
1162 }
1163
1164 r = sd_bus_set_property(
1165 bus,
1166 "org.freedesktop.systemd1",
1167 "/org/freedesktop/systemd1",
1168 "org.freedesktop.systemd1.Manager",
1169 "LogLevel",
1170 &error,
1171 "s",
1172 args[0]);
1173 if (r < 0) {
1174 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
1175 return -EIO;
1176 }
1177
1178 return 0;
1179 }
1180
1181 static int help(void) {
1182
1183 pager_open_if_enabled();
1184
1185 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1186 "Process systemd profiling information.\n\n"
1187 " -h --help Show this help\n"
1188 " --version Show package version\n"
1189 " --no-pager Do not pipe output into a pager\n"
1190 " --system Connect to system manager\n"
1191 " --user Connect to user manager\n"
1192 " -H --host=[USER@]HOST Operate on remote host\n"
1193 " -M --machine=CONTAINER Operate on local container\n"
1194 " --order When generating a dependency graph, show only order\n"
1195 " --require When generating a dependency graph, show only requirement\n"
1196 " --from-pattern=GLOB, --to-pattern=GLOB\n"
1197 " When generating a dependency graph, filter only origins\n"
1198 " or destinations, respectively\n"
1199 " --fuzz=TIMESPAN When printing the tree of the critical chain, print also\n"
1200 " services, which finished TIMESPAN earlier, than the\n"
1201 " latest in the branch. The unit of TIMESPAN is seconds\n"
1202 " unless specified with a different unit, i.e. 50ms\n\n"
1203 "Commands:\n"
1204 " time Print time spent in the kernel before reaching userspace\n"
1205 " blame Print list of running units ordered by time to init\n"
1206 " critical-chain Print a tree of the time critical chain of units\n"
1207 " plot Output SVG graphic showing service initialization\n"
1208 " dot Output dependency graph in dot(1) format\n"
1209 " set-log-level LEVEL Set logging threshold for systemd\n"
1210 " dump Output state serialization of service manager\n",
1211 program_invocation_short_name);
1212
1213 /* When updating this list, including descriptions, apply
1214 * changes to shell-completion/bash/systemd and
1215 * shell-completion/systemd-zsh-completion.zsh too. */
1216
1217 return 0;
1218 }
1219
1220 static int parse_argv(int argc, char *argv[]) {
1221 enum {
1222 ARG_VERSION = 0x100,
1223 ARG_ORDER,
1224 ARG_REQUIRE,
1225 ARG_USER,
1226 ARG_SYSTEM,
1227 ARG_DOT_FROM_PATTERN,
1228 ARG_DOT_TO_PATTERN,
1229 ARG_FUZZ,
1230 ARG_NO_PAGER
1231 };
1232
1233 static const struct option options[] = {
1234 { "help", no_argument, NULL, 'h' },
1235 { "version", no_argument, NULL, ARG_VERSION },
1236 { "order", no_argument, NULL, ARG_ORDER },
1237 { "require", no_argument, NULL, ARG_REQUIRE },
1238 { "user", no_argument, NULL, ARG_USER },
1239 { "system", no_argument, NULL, ARG_SYSTEM },
1240 { "from-pattern", required_argument, NULL, ARG_DOT_FROM_PATTERN },
1241 { "to-pattern", required_argument, NULL, ARG_DOT_TO_PATTERN },
1242 { "fuzz", required_argument, NULL, ARG_FUZZ },
1243 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1244 { "host", required_argument, NULL, 'H' },
1245 { "machine", required_argument, NULL, 'M' },
1246 {}
1247 };
1248
1249 int r, c;
1250
1251 assert(argc >= 0);
1252 assert(argv);
1253
1254 while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0) {
1255
1256 switch (c) {
1257
1258 case 'h':
1259 return help();
1260
1261 case ARG_VERSION:
1262 puts(PACKAGE_STRING);
1263 puts(SYSTEMD_FEATURES);
1264 return 0;
1265
1266 case ARG_USER:
1267 arg_user = true;
1268 break;
1269
1270 case ARG_SYSTEM:
1271 arg_user = false;
1272 break;
1273
1274 case ARG_ORDER:
1275 arg_dot = DEP_ORDER;
1276 break;
1277
1278 case ARG_REQUIRE:
1279 arg_dot = DEP_REQUIRE;
1280 break;
1281
1282 case ARG_DOT_FROM_PATTERN:
1283 if (strv_extend(&arg_dot_from_patterns, optarg) < 0)
1284 return log_oom();
1285
1286 break;
1287
1288 case ARG_DOT_TO_PATTERN:
1289 if (strv_extend(&arg_dot_to_patterns, optarg) < 0)
1290 return log_oom();
1291
1292 break;
1293
1294 case ARG_FUZZ:
1295 r = parse_sec(optarg, &arg_fuzz);
1296 if (r < 0)
1297 return r;
1298 break;
1299
1300 case ARG_NO_PAGER:
1301 arg_no_pager = true;
1302 break;
1303
1304 case 'H':
1305 arg_transport = BUS_TRANSPORT_REMOTE;
1306 arg_host = optarg;
1307 break;
1308
1309 case 'M':
1310 arg_transport = BUS_TRANSPORT_CONTAINER;
1311 arg_host = optarg;
1312 break;
1313
1314 case '?':
1315 return -EINVAL;
1316
1317 default:
1318 assert_not_reached("Unhandled option");
1319 }
1320 }
1321
1322 return 1;
1323 }
1324
1325 int main(int argc, char *argv[]) {
1326 _cleanup_bus_unref_ sd_bus *bus = NULL;
1327 int r;
1328
1329 setlocale(LC_ALL, "");
1330 setlocale(LC_NUMERIC, "C"); /* we want to format/parse floats in C style */
1331 log_parse_environment();
1332 log_open();
1333
1334 r = parse_argv(argc, argv);
1335 if (r <= 0)
1336 goto finish;
1337
1338 r = bus_open_transport(arg_transport, arg_host, arg_user, &bus);
1339 if (r < 0) {
1340 log_error("Failed to create bus connection: %s", strerror(-r));
1341 goto finish;
1342 }
1343
1344 if (!argv[optind] || streq(argv[optind], "time"))
1345 r = analyze_time(bus);
1346 else if (streq(argv[optind], "blame"))
1347 r = analyze_blame(bus);
1348 else if (streq(argv[optind], "critical-chain"))
1349 r = analyze_critical_chain(bus, argv+optind+1);
1350 else if (streq(argv[optind], "plot"))
1351 r = analyze_plot(bus);
1352 else if (streq(argv[optind], "dot"))
1353 r = dot(bus, argv+optind+1);
1354 else if (streq(argv[optind], "dump"))
1355 r = dump(bus, argv+optind+1);
1356 else if (streq(argv[optind], "set-log-level"))
1357 r = set_log_level(bus, argv+optind+1);
1358 else
1359 log_error("Unknown operation '%s'.", argv[optind]);
1360
1361 finish:
1362 pager_close();
1363
1364 strv_free(arg_dot_from_patterns);
1365 strv_free(arg_dot_to_patterns);
1366
1367 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1368 }
Unnamed repository; edit this file 'description' to name the repository.