]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/analyze/analyze.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #11827 from keszybz/pkgconfig-variables
[thirdparty/systemd.git] / src / analyze / analyze.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
2265fbf7 2/***
96b2fb93 3 Copyright © 2013 Simon Peeters
2265fbf7
SP		 4***/
5
2265fbf7 6#include <getopt.h>
3f1c1287 7#include <inttypes.h>
2265fbf7 8#include <locale.h>
3f6fd1ba
LP		 9#include <stdio.h>
10#include <stdlib.h>
2265fbf7 11
048ecf5b 12#include "sd-bus.h"
3f6fd1ba 13
b5efdb8a 14#include "alloc-util.h"
ec16f3b6 15#include "analyze-security.h"
3f6fd1ba 16#include "analyze-verify.h"
681bd2c5 17#include "build.h"
048ecf5b 18#include "bus-error.h"
20b16441 19#include "bus-unit-util.h"
3f6fd1ba 20#include "bus-util.h"
6d86f4bd 21#include "calendarspec.h"
854a42fb 22#include "conf-files.h"
c0a1bfac 23#include "copy.h"
90bea744 24#include "def.h"
c0a1bfac 25#include "fd-util.h"
cdf6258c 26#include "fileio.h"
7d50b32a 27#include "glob-util.h"
bb150966 28#include "hashmap.h"
8752c575 29#include "locale-util.h"
3f6fd1ba 30#include "log.h"
d665c7b2 31#include "main-func.h"
9ea9d4cf 32#include "pager.h"
6bedfcbb 33#include "parse-util.h"
854a42fb 34#include "path-util.h"
294bf0c3 35#include "pretty-print.h"
349cc4a5 36#if HAVE_SECCOMP
294bf0c3 37# include "seccomp-util.h"
0f734bdc 38#endif
3f6fd1ba
LP		 39#include "special.h"
40#include "strv.h"
41#include "strxcpyx.h"
3f1c1287 42#include "time-util.h"
288a74cc 43#include "terminal-util.h"
3f6fd1ba
LP		 44#include "unit-name.h"
45#include "util.h"
a6bcef29 46#include "verbs.h"
2265fbf7 47
2f6eb835 48#define SCALE_X (0.1 / 1000.0) /* pixels per us */
a213b7e9 49#define SCALE_Y (20.0)
2f6eb835 50
2265fbf7 51#define svg(...) printf(__VA_ARGS__)
c170f3a4
LP		 52
53#define svg_bar(class, x1, x2, y) \
2265fbf7 54 svg(" <rect class=\"%s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n", \
c170f3a4 55 (class), \
2f6eb835
LP		 56 SCALE_X * (x1), SCALE_Y * (y), \
57 SCALE_X * ((x2) - (x1)), SCALE_Y - 1.0)
c170f3a4
LP		 58
59#define svg_text(b, x, y, format, ...) \
60 do { \
2f6eb835 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); \
c170f3a4
LP		 62 svg(format, ## __VA_ARGS__); \
63 svg("</text>\n"); \
9ed794a3 64 } while (false)
2265fbf7 65
1700761b
SP		 66static enum dot {
67 DEP_ALL,
68 DEP_ORDER,
69 DEP_REQUIRE
70} arg_dot = DEP_ALL;
e55933db
ŁS		 71static char** arg_dot_from_patterns = NULL;
72static char** arg_dot_to_patterns = NULL;
9ea9d4cf 73static usec_t arg_fuzz = 0;
0221d68a 74static PagerFlags arg_pager_flags = 0;
3cd26e7c 75static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
f72b7018 76static const char *arg_host = NULL;
28b35ef2 77static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
1d3bc017 78static bool arg_man = true;
641c0fd1 79static bool arg_generators = false;
46d8646a 80static const char *arg_root = NULL;
f2ccf832 81static unsigned arg_iterations = 1;
bb150966 82
d665c7b2
YW		 83STATIC_DESTRUCTOR_REGISTER(arg_dot_from_patterns, strv_freep);
84STATIC_DESTRUCTOR_REGISTER(arg_dot_to_patterns, strv_freep);
85
2265fbf7 86struct boot_times {
c170f3a4
LP		 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;
c2e0d600
TA		 94 usec_t security_start_time;
95 usec_t security_finish_time;
518d10e9
UTL		 96 usec_t generators_start_time;
97 usec_t generators_finish_time;
d9acfb71
TA		 98 usec_t unitsload_start_time;
99 usec_t unitsload_finish_time;
8c006565
YW		 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;
06bef033
IS		 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;
2265fbf7 118};
9ea9d4cf 119
2265fbf7 120struct unit_times {
df560cf6 121 bool has_data;
2265fbf7 122 char *name;
cc27380c
TA		 123 usec_t activating;
124 usec_t activated;
125 usec_t deactivated;
126 usec_t deactivating;
c170f3a4 127 usec_t time;
2265fbf7
SP		 128};
129
7e690cef
DH		 130struct 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
f7e29336 140static int acquire_bus(sd_bus **bus, bool *use_full_bus) {
5c69b31c 141 bool user = arg_scope != UNIT_FILE_SYSTEM;
fb507898 142 int r;
5c69b31c 143
f7e29336 144 if (use_full_bus && *use_full_bus) {
fb507898
YW		 145 r = bus_connect_transport(arg_transport, arg_host, user, bus);
146 if (IN_SET(r, 0, -EHOSTDOWN))
147 return r;
5c69b31c
GJ		 148
149 *use_full_bus = false;
150 }
151
f7e29336 152 return bus_connect_transport_systemd(arg_transport, arg_host, user, bus);
bf0e0a4d
ZJS		 153}
154
048ecf5b 155static int bus_get_uint64_property(sd_bus *bus, const char *path, const char *interface, const char *property, uint64_t *val) {
4afd3348 156 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
c170f3a4 157 int r;
2265fbf7 158
988b9df2
LP		 159 assert(bus);
160 assert(path);
161 assert(interface);
162 assert(property);
163 assert(val);
164
a936124f
TA		 165 r = sd_bus_get_property_trivial(
166 bus,
167 "org.freedesktop.systemd1",
168 path,
169 interface,
170 property,
171 &error,
172 't', val);
048ecf5b 173
4ae25393 174 if (r < 0)
0ed3da7c 175 return log_error_errno(r, "Failed to parse reply: %s", bus_error_message(&error, r));
2265fbf7 176
2265fbf7
SP		 177 return 0;
178}
179
988b9df2 180static int bus_get_unit_property_strv(sd_bus *bus, const char *path, const char *property, char ***strv) {
4afd3348 181 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
988b9df2
LP		 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);
4ae25393 197 if (r < 0)
0ed3da7c 198 return log_error_errno(r, "Failed to get unit property %s: %s", property, bus_error_message(&error, r));
988b9df2
LP		 199
200 return 0;
201}
202
93bab288
YW		 203static int compare_unit_time(const struct unit_times *a, const struct unit_times *b) {
204 return CMP(b->time, a->time);
2265fbf7
SP		 205}
206
93bab288
YW		 207static int compare_unit_start(const struct unit_times *a, const struct unit_times *b) {
208 return CMP(a->activating, b->activating);
2265fbf7
SP		 209}
210
df560cf6 211static void unit_times_free(struct unit_times *t) {
c170f3a4
LP		 212 struct unit_times *p;
213
df560cf6 214 for (p = t; p->has_data; p++)
c170f3a4 215 free(p->name);
c170f3a4
LP		 216 free(t);
217}
218
df560cf6
FB		 219DEFINE_TRIVIAL_CLEANUP_FUNC(struct unit_times *, unit_times_free);
220
06bef033
IS		 221static 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
048ecf5b 230static int acquire_boot_times(sd_bus *bus, struct boot_times **bt) {
cc0eb780
YW		 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;
2265fbf7
SP		 253 static struct boot_times times;
254 static bool cached = false;
cc0eb780 255 int r;
c170f3a4 256
2265fbf7 257 if (cached)
c170f3a4
LP		 258 goto finish;
259
260 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
2265fbf7 261
cc0eb780
YW		 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));
8c006565 273
c2953e08
ZJS		 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");
2265fbf7 281
eddb5037
YW		 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. */
baa4880b 284 if (times.initrd_time > 0)
28b35ef2
ZJS		 285 times.kernel_done_time = times.initrd_time;
286 else
287 times.kernel_done_time = times.userspace_time;
288 } else {
06bef033 289 /*
eddb5037 290 * User-instance-specific or container-system-specific timestamps processing
06bef033
IS		 291 * (see comment to reverse_offset in struct boot_times).
292 */
293 times.reverse_offset = times.userspace_time;
294
79ecaae4
YW		 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;
06bef033 297
79ecaae4 298 subtract_timestamp(&times.finish_time, times.reverse_offset);
06bef033
IS		 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);
06bef033 305 }
2265fbf7
SP		 306
307 cached = true;
c170f3a4
LP		 308
309finish:
310 *bt = &times;
311 return 0;
2265fbf7
SP		 312}
313
7e690cef 314static void free_host_info(struct host_info *hi) {
b1b533a0 315 if (!hi)
19f462f2 316 return;
b1b533a0 317
7e690cef
DH		 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}
b1b533a0 327
19f462f2 328DEFINE_TRIVIAL_CLEANUP_FUNC(struct host_info*, free_host_info);
7e690cef 329
29b8b5ce 330static int acquire_time_data(sd_bus *bus, struct unit_times **out) {
cc0eb780
YW		 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 };
4afd3348
LP		 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;
df560cf6 340 _cleanup_(unit_times_freep) struct unit_times *unit_times = NULL;
97cec9ba
YW		 341 struct boot_times *boot_times = NULL;
342 size_t allocated = 0, c = 0;
29b8b5ce 343 UnitInfo u;
97cec9ba 344 int r;
29b8b5ce 345
06bef033
IS		 346 r = acquire_boot_times(bus, &boot_times);
347 if (r < 0)
df560cf6 348 return r;
06bef033 349
29b8b5ce
IS		 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);
4ae25393 358 if (r < 0)
0ed3da7c 359 return log_error_errno(r, "Failed to list units: %s", bus_error_message(&error, r));
29b8b5ce
IS		 360
361 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
df560cf6
FB		 362 if (r < 0)
363 return bus_log_parse_error(r);
29b8b5ce
IS		 364
365 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
366 struct unit_times *t;
367
97cec9ba 368 if (!GREEDY_REALLOC(unit_times, allocated, c+2))
df560cf6 369 return log_oom();
29b8b5ce 370
df560cf6
FB		 371 unit_times[c+1].has_data = false;
372 t = &unit_times[c];
29b8b5ce
IS		 373 t->name = NULL;
374
375 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
376
cc0eb780
YW		 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)
c2953e08
ZJS		 387 return log_error_errno(r, "Failed to get timestamp properties of unit %s: %s",
388 u.id, bus_error_message(&error, r));
29b8b5ce 389
06bef033
IS		 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
29b8b5ce
IS		 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);
df560cf6
FB		 406 if (!t->name)
407 return log_oom();
408
409 t->has_data = true;
29b8b5ce
IS		 410 c++;
411 }
df560cf6
FB		 412 if (r < 0)
413 return bus_log_parse_error(r);
29b8b5ce 414
df560cf6 415 *out = TAKE_PTR(unit_times);
29b8b5ce 416 return c;
29b8b5ce
IS		 417}
418
7e690cef 419static int acquire_host_info(sd_bus *bus, struct host_info **hi) {
7e690cef 420 static const struct bus_properties_map hostname_map[] = {
b1b533a0
LP		 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) },
7e690cef
DH		 425 { "OperatingSystemPrettyName", "s", NULL, offsetof(struct host_info, os_pretty_name) },
426 {}
427 };
428
429 static const struct bus_properties_map manager_map[] = {
b1b533a0
LP		 430 { "Virtualization", "s", NULL, offsetof(struct host_info, virtualization) },
431 { "Architecture", "s", NULL, offsetof(struct host_info, architecture) },
7e690cef
DH		 432 {}
433 };
434
4afd3348 435 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
4f481d76 436 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *system_bus = NULL;
b1b533a0
LP		 437 _cleanup_(free_host_infop) struct host_info *host;
438 int r;
439
7e690cef
DH		 440 host = new0(struct host_info, 1);
441 if (!host)
442 return log_oom();
443
4f481d76
YW		 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,
7e690cef
DH		 453 "org.freedesktop.hostname1",
454 "/org/freedesktop/hostname1",
455 hostname_map,
a7e4861c 456 BUS_MAP_STRDUP,
f9e0eefc 457 &error,
f37f8a61 458 NULL,
7e690cef 459 host);
4f481d76 460 if (r < 0) {
c2953e08
ZJS		 461 log_debug_errno(r, "Failed to get host information from systemd-hostnamed, ignoring: %s",
462 bus_error_message(&error, r));
4f481d76
YW		 463 sd_bus_error_free(&error);
464 }
7e690cef 465
4f481d76 466manager:
7e690cef
DH		 467 r = bus_map_all_properties(bus,
468 "org.freedesktop.systemd1",
469 "/org/freedesktop/systemd1",
470 manager_map,
a7e4861c 471 BUS_MAP_STRDUP,
f9e0eefc 472 &error,
f37f8a61 473 NULL,
7e690cef 474 host);
febda62a 475 if (r < 0)
c2953e08
ZJS		 476 return log_error_errno(r, "Failed to get host information from systemd: %s",
477 bus_error_message(&error, r));
7e690cef 478
1cc6c93a 479 *hi = TAKE_PTR(host);
7e690cef 480 return 0;
7e690cef
DH		 481}
482
048ecf5b 483static int pretty_boot_time(sd_bus *bus, char **_buf) {
c170f3a4 484 char ts[FORMAT_TIMESPAN_MAX];
2265fbf7 485 struct boot_times *t;
2265fbf7 486 static char buf[4096];
c170f3a4
LP		 487 size_t size;
488 char *ptr;
489 int r;
bd07d3d0
JR		 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;
c170f3a4
LP		 493
494 r = acquire_boot_times(bus, &t);
495 if (r < 0)
496 return r;
2265fbf7 497
bd07d3d0
JR		 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) {
0c753963 520 log_info_errno(r, "Could not get time to reach default.target, ignoring: %m");
bd07d3d0
JR		 521 activated_time = USEC_INFINITY;
522 }
523
c170f3a4
LP		 524 ptr = buf;
525 size = sizeof(buf);
2265fbf7
SP		 526
527 size = strpcpyf(&ptr, size, "Startup finished in ");
baa4880b 528 if (t->firmware_time > 0)
2fa4092c 529 size = strpcpyf(&ptr, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), t->firmware_time - t->loader_time, USEC_PER_MSEC));
baa4880b 530 if (t->loader_time > 0)
2fa4092c 531 size = strpcpyf(&ptr, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), t->loader_time, USEC_PER_MSEC));
02be0cca 532 if (t->kernel_done_time > 0)
2fa4092c 533 size = strpcpyf(&ptr, size, "%s (kernel) + ", format_timespan(ts, sizeof(ts), t->kernel_done_time, USEC_PER_MSEC));
2265fbf7 534 if (t->initrd_time > 0)
2fa4092c 535 size = strpcpyf(&ptr, size, "%s (initrd) + ", format_timespan(ts, sizeof(ts), t->userspace_time - t->initrd_time, USEC_PER_MSEC));
2265fbf7 536
2fa4092c 537 size = strpcpyf(&ptr, size, "%s (userspace) ", format_timespan(ts, sizeof(ts), t->finish_time - t->userspace_time, USEC_PER_MSEC));
02be0cca 538 if (t->kernel_done_time > 0)
feb92776 539 strpcpyf(&ptr, size, "= %s ", format_timespan(ts, sizeof(ts), t->firmware_time + t->finish_time, USEC_PER_MSEC));
2265fbf7 540
eddb5037 541 if (unit_id && activated_time > 0 && activated_time != USEC_INFINITY) {
b5d6f7ea
ZJS		 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));
eddb5037 546 } else if (unit_id && activated_time == 0)
da933f7d
JR		 547 size = strpcpyf(&ptr, size, "\n%s was never reached", unit_id);
548 else if (unit_id && activated_time == USEC_INFINITY)
feb92776 549 size = strpcpyf(&ptr, size, "\nCould not get time to reach %s.", unit_id);
da933f7d
JR		 550 else if (!unit_id)
551 size = strpcpyf(&ptr, size, "\ncould not find default.target");
552
c170f3a4
LP		 553 ptr = strdup(buf);
554 if (!ptr)
555 return log_oom();
556
557 *_buf = ptr;
558 return 0;
2265fbf7
SP		 559}
560
c170f3a4
LP		 561static void svg_graph_box(double height, double begin, double end) {
562 long long i;
563
2265fbf7
SP		 564 /* outside box, fill */
565 svg("<rect class=\"box\" x=\"0\" y=\"0\" width=\"%.03f\" height=\"%.03f\" />\n",
2f6eb835 566 SCALE_X * (end - begin), SCALE_Y * height);
2265fbf7 567
c170f3a4 568 for (i = ((long long) (begin / 100000)) * 100000; i <= end; i+=100000) {
2265fbf7 569 /* lines for each second */
c170f3a4 570 if (i % 5000000 == 0)
2265fbf7
SP		 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",
2f6eb835 573 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
c170f3a4 574 else if (i % 1000000 == 0)
2265fbf7
SP		 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",
2f6eb835 577 SCALE_X * i, SCALE_X * i, SCALE_Y * height, SCALE_X * i, -5.0, 0.000001 * i);
2265fbf7
SP		 578 else
579 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
2f6eb835 580 SCALE_X * i, SCALE_X * i, SCALE_Y * height);
2265fbf7
SP		 581 }
582}
583
7725fc11
YW		 584static 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
a6bcef29 606static int analyze_plot(int argc, char *argv[], void *userdata) {
b1b533a0 607 _cleanup_(free_host_infop) struct host_info *host = NULL;
a6bcef29 608 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
df560cf6 609 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
4f481d76
YW		 610 _cleanup_free_ char *pretty_times = NULL;
611 bool use_full_bus = arg_scope == UNIT_FILE_SYSTEM;
2265fbf7 612 struct boot_times *boot;
4f481d76 613 struct unit_times *u;
a6bcef29 614 int n, m = 1, y = 0, r;
2265fbf7 615 double width;
2265fbf7 616
f7e29336 617 r = acquire_bus(&bus, &use_full_bus);
a6bcef29
LP		 618 if (r < 0)
619 return log_error_errno(r, "Failed to create bus connection: %m");
620
c170f3a4
LP		 621 n = acquire_boot_times(bus, &boot);
622 if (n < 0)
623 return n;
2265fbf7 624
c170f3a4
LP		 625 n = pretty_boot_time(bus, &pretty_times);
626 if (n < 0)
627 return n;
2265fbf7 628
4f481d76 629 if (use_full_bus || arg_scope != UNIT_FILE_SYSTEM) {
5c69b31c
GJ		 630 n = acquire_host_info(bus, &host);
631 if (n < 0)
632 return n;
633 }
2265fbf7
SP		 634
635 n = acquire_time_data(bus, &times);
c170f3a4 636 if (n <= 0)
19f462f2 637 return n;
2265fbf7 638
93bab288 639 typesafe_qsort(times, n, compare_unit_start);
2265fbf7 640
2f6eb835 641 width = SCALE_X * (boot->firmware_time + boot->finish_time);
2265fbf7
SP		 642 if (width < 800.0)
643 width = 800.0;
644
645 if (boot->firmware_time > boot->loader_time)
646 m++;
baa4880b 647 if (boot->loader_time > 0) {
2265fbf7
SP		 648 m++;
649 if (width < 1000.0)
650 width = 1000.0;
651 }
baa4880b 652 if (boot->initrd_time > 0)
2265fbf7 653 m++;
02be0cca 654 if (boot->kernel_done_time > 0)
2265fbf7
SP		 655 m++;
656
df560cf6 657 for (u = times; u->has_data; u++) {
95168f7d 658 double text_start, text_width;
c170f3a4 659
7725fc11 660 if (u->activating > boot->finish_time) {
a1e58e8e 661 u->name = mfree(u->name);
2265fbf7
SP		 662 continue;
663 }
95168f7d
TA		 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);
cc27380c 669 text_start = (boot->firmware_time + u->activating) * SCALE_X;
95168f7d
TA		 670 if (text_width > text_start && text_width + text_start > width)
671 width = text_width + text_start;
2265fbf7 672
efe6112d
YW		 673 if (u->deactivated > u->activating &&
674 u->deactivated <= boot->finish_time &&
675 u->activated == 0 && u->deactivating == 0)
cc27380c
TA		 676 u->activated = u->deactivating = u->deactivated;
677 if (u->activated < u->activating || u->activated > boot->finish_time)
678 u->activated = boot->finish_time;
efe6112d 679 if (u->deactivating < u->activated || u->deactivating > boot->finish_time)
cc27380c
TA		 680 u->deactivating = boot->finish_time;
681 if (u->deactivated < u->deactivating || u->deactivated > boot->finish_time)
682 u->deactivated = boot->finish_time;
2265fbf7
SP		 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",
518d10e9 692 80.0 + width, 150.0 + (m * SCALE_Y) +
d9acfb71 693 5 * SCALE_Y /* legend */);
2265fbf7
SP		 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"
681bd2c5 701 "<!-- This plot was generated by systemd-analyze version %-16.16s -->\n\n", GIT_VERSION);
2265fbf7
SP		 702
703 /* style sheet */
704 svg("<defs>\n <style type=\"text/css\">\n <![CDATA[\n"
705 " rect { stroke-width: 1; stroke-opacity: 0; }\n"
418e3750 706 " rect.background { fill: rgb(255,255,255); }\n"
2265fbf7
SP		 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"
c2e0d600 715 " rect.security { fill: rgb(144,238,144); fill-opacity: 0.7; }\n"
518d10e9 716 " rect.generators { fill: rgb(102,204,255); fill-opacity: 0.7; }\n"
d9acfb71 717 " rect.unitsload { fill: rgb( 82,184,255); fill-opacity: 0.7; }\n"
2265fbf7
SP		 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"
2b7d6965
TA		 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"
2265fbf7
SP		 727 " ]]>\n </style>\n</defs>\n\n");
728
418e3750 729 svg("<rect class=\"background\" width=\"100%%\" height=\"100%%\" />\n");
2265fbf7 730 svg("<text x=\"20\" y=\"50\">%s</text>", pretty_times);
4f481d76 731 if (host)
5c69b31c
GJ		 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));
2265fbf7 740
2f6eb835 741 svg("<g transform=\"translate(%.3f,100)\">\n", 20.0 + (SCALE_X * boot->firmware_time));
b5cfa740 742 svg_graph_box(m, -(double) boot->firmware_time, boot->finish_time);
2265fbf7 743
baa4880b 744 if (boot->firmware_time > 0) {
c170f3a4
LP		 745 svg_bar("firmware", -(double) boot->firmware_time, -(double) boot->loader_time, y);
746 svg_text(true, -(double) boot->firmware_time, y, "firmware");
2265fbf7
SP		 747 y++;
748 }
baa4880b 749 if (boot->loader_time > 0) {
c170f3a4
LP		 750 svg_bar("loader", -(double) boot->loader_time, 0, y);
751 svg_text(true, -(double) boot->loader_time, y, "loader");
2265fbf7
SP		 752 y++;
753 }
02be0cca 754 if (boot->kernel_done_time > 0) {
2265fbf7 755 svg_bar("kernel", 0, boot->kernel_done_time, y);
c170f3a4 756 svg_text(true, 0, y, "kernel");
2265fbf7
SP		 757 y++;
758 }
baa4880b 759 if (boot->initrd_time > 0) {
2265fbf7 760 svg_bar("initrd", boot->initrd_time, boot->userspace_time, y);
8c006565
YW		 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);
c170f3a4 767 svg_text(true, boot->initrd_time, y, "initrd");
2265fbf7
SP		 768 y++;
769 }
7725fc11
YW		 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
518d10e9 778 svg_bar("active", boot->userspace_time, boot->finish_time, y);
79ecaae4
YW		 779 if (boot->security_start_time > 0)
780 svg_bar("security", boot->security_start_time, boot->security_finish_time, y);
518d10e9 781 svg_bar("generators", boot->generators_start_time, boot->generators_finish_time, y);
d9acfb71 782 svg_bar("unitsload", boot->unitsload_start_time, boot->unitsload_finish_time, y);
95168f7d 783 svg_text(true, boot->userspace_time, y, "systemd");
2265fbf7
SP		 784 y++;
785
7725fc11
YW		 786 for (; u->has_data; u++)
787 y += plot_unit_times(u, width, y);
518d10e9 788
b5cfa740
TA		 789 svg("</g>\n");
790
518d10e9 791 /* Legend */
b5cfa740 792 svg("<g transform=\"translate(20,100)\">\n");
518d10e9
UTL		 793 y++;
794 svg_bar("activating", 0, 300000, y);
95168f7d 795 svg_text(true, 400000, y, "Activating");
518d10e9
UTL		 796 y++;
797 svg_bar("active", 0, 300000, y);
95168f7d 798 svg_text(true, 400000, y, "Active");
518d10e9
UTL		 799 y++;
800 svg_bar("deactivating", 0, 300000, y);
95168f7d 801 svg_text(true, 400000, y, "Deactivating");
518d10e9 802 y++;
79ecaae4
YW		 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 }
518d10e9 808 svg_bar("generators", 0, 300000, y);
95168f7d 809 svg_text(true, 400000, y, "Generators");
518d10e9 810 y++;
d9acfb71 811 svg_bar("unitsload", 0, 300000, y);
95168f7d 812 svg_text(true, 400000, y, "Loading unit files");
d9acfb71 813 y++;
518d10e9 814
2265fbf7
SP		 815 svg("</g>\n\n");
816
988b9df2 817 svg("</svg>\n");
c170f3a4 818
df560cf6 819 return 0;
2265fbf7
SP		 820}
821
14cb109d 822static int list_dependencies_print(const char *name, unsigned level, unsigned branches,
bb150966 823 bool last, struct unit_times *times, struct boot_times *boot) {
14cb109d 824 unsigned i;
bb150966
HH		 825 char ts[FORMAT_TIMESPAN_MAX], ts2[FORMAT_TIMESPAN_MAX];
826
827 for (i = level; i != 0; i--)
9a6f746f 828 printf("%s", special_glyph(branches & (1 << (i-1)) ? SPECIAL_GLYPH_TREE_VERTICAL : SPECIAL_GLYPH_TREE_SPACE));
bb150966 829
9a6f746f 830 printf("%s", special_glyph(last ? SPECIAL_GLYPH_TREE_RIGHT : SPECIAL_GLYPH_TREE_BRANCH));
bb150966
HH		 831
832 if (times) {
baa4880b 833 if (times->time > 0)
54f8c958 834 printf("%s%s @%s +%s%s", ansi_highlight_red(), name,
cc27380c 835 format_timespan(ts, sizeof(ts), times->activating - boot->userspace_time, USEC_PER_MSEC),
54f8c958 836 format_timespan(ts2, sizeof(ts2), times->time, USEC_PER_MSEC), ansi_normal());
cc27380c
TA		 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));
bb150966
HH		 839 else
840 printf("%s", name);
988b9df2
LP		 841 } else
842 printf("%s", name);
bb150966
HH		 843 printf("\n");
844
845 return 0;
846}
847
048ecf5b 848static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
988b9df2 849 _cleanup_free_ char *path = NULL;
bb150966
HH		 850
851 assert(bus);
852 assert(name);
853 assert(deps);
854
855 path = unit_dbus_path_from_name(name);
234519ae 856 if (!path)
988b9df2 857 return -ENOMEM;
bb150966 858
988b9df2 859 return bus_get_unit_property_strv(bus, path, "After", deps);
bb150966
HH		 860}
861
862static Hashmap *unit_times_hashmap;
863
93bab288 864static int list_dependencies_compare(char * const *a, char * const *b) {
bb150966
HH		 865 usec_t usa = 0, usb = 0;
866 struct unit_times *times;
867
868 times = hashmap_get(unit_times_hashmap, *a);
869 if (times)
cc27380c 870 usa = times->activated;
bb150966
HH		 871 times = hashmap_get(unit_times_hashmap, *b);
872 if (times)
cc27380c 873 usb = times->activated;
bb150966 874
93bab288 875 return CMP(usb, usa);
bb150966
HH		 876}
877
230cc99a
ZJS		 878static 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
14cb109d
YW		 883static int list_dependencies_one(sd_bus *bus, const char *name, unsigned level, char ***units,
884 unsigned branches) {
bb150966
HH		 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
988b9df2 893 if (strv_extend(units, name))
bb150966
HH		 894 return log_oom();
895
896 r = list_dependencies_get_dependencies(bus, name, &deps);
897 if (r < 0)
898 return r;
899
93bab288 900 typesafe_qsort(deps, strv_length(deps), list_dependencies_compare);
bb150966
HH		 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);
230cc99a 908 if (times_in_range(times, boot) &&
e6813152 909 times->activated >= service_longest)
cc27380c 910 service_longest = times->activated;
bb150966
HH		 911 }
912
234519ae 913 if (service_longest == 0)
bb150966
HH		 914 return r;
915
916 STRV_FOREACH(c, deps) {
917 times = hashmap_get(unit_times_hashmap, *c);
230cc99a
ZJS		 918 if (times_in_range(times, boot) &&
919 service_longest - times->activated <= arg_fuzz)
bb150966 920 to_print++;
bb150966
HH		 921 }
922
f168c273 923 if (!to_print)
bb150966
HH		 924 return r;
925
926 STRV_FOREACH(c, deps) {
927 times = hashmap_get(unit_times_hashmap, *c);
230cc99a
ZJS		 928 if (!times_in_range(times, boot) ||
929 service_longest - times->activated > arg_fuzz)
bb150966
HH		 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);
872c8faa
ZJS		 941 if (r < 0)
942 return r;
bb150966
HH		 943 continue;
944 }
945
946 r = list_dependencies_one(bus, *c, level + 1, units,
947 (branches << 1) | (to_print ? 1 : 0));
872c8faa 948 if (r < 0)
bb150966
HH		 949 return r;
950
baa4880b 951 if (to_print == 0)
bb150966 952 break;
bb150966
HH		 953 }
954 return 0;
955}
956
048ecf5b 957static int list_dependencies(sd_bus *bus, const char *name) {
bb150966
HH		 958 _cleanup_strv_free_ char **units = NULL;
959 char ts[FORMAT_TIMESPAN_MAX];
960 struct unit_times *times;
961 int r;
0ee9613d
TA		 962 const char *id;
963 _cleanup_free_ char *path = NULL;
4afd3348
LP		 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;
bb150966
HH		 966 struct boot_times *boot;
967
968 assert(bus);
969
805bf39c 970 path = unit_dbus_path_from_name(name);
234519ae 971 if (!path)
988b9df2 972 return -ENOMEM;
bb150966 973
a936124f
TA		 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");
4ae25393 983 if (r < 0)
0ed3da7c 984 return log_error_errno(r, "Failed to get ID: %s", bus_error_message(&error, r));
bb150966 985
048ecf5b 986 r = sd_bus_message_read(reply, "s", &id);
5b30bef8
LP		 987 if (r < 0)
988 return bus_log_parse_error(r);
bb150966 989
bb150966
HH		 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)
54f8c958
LP		 998 printf("%s%s +%s%s\n", ansi_highlight_red(), id,
999 format_timespan(ts, sizeof(ts), times->time, USEC_PER_MSEC), ansi_normal());
cc27380c
TA		 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));
bb150966
HH		 1002 else
1003 printf("%s\n", id);
1004 }
1005
805bf39c 1006 return list_dependencies_one(bus, name, 0, &units, 0);
bb150966
HH		 1007}
1008
a6bcef29
LP		 1009static int analyze_critical_chain(int argc, char *argv[], void *userdata) {
1010 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
df560cf6
FB		 1011 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
1012 struct unit_times *u;
bb150966 1013 Hashmap *h;
988b9df2 1014 int n, r;
bb150966 1015
f7e29336 1016 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1017 if (r < 0)
1018 return log_error_errno(r, "Failed to create bus connection: %m");
1019
bb150966
HH		 1020 n = acquire_time_data(bus, &times);
1021 if (n <= 0)
1022 return n;
1023
d5099efc 1024 h = hashmap_new(&string_hash_ops);
bb150966 1025 if (!h)
8efbce13 1026 return log_oom();
bb150966 1027
df560cf6
FB		 1028 for (u = times; u->has_data; u++) {
1029 r = hashmap_put(h, u->name, u);
bb150966 1030 if (r < 0)
8efbce13 1031 return log_error_errno(r, "Failed to add entry to hashmap: %m");
bb150966
HH		 1032 }
1033 unit_times_hashmap = h;
1034
0221d68a 1035 (void) pager_open(arg_pager_flags);
9ea9d4cf 1036
bb150966
HH		 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
a6bcef29 1040 if (argc > 1) {
805bf39c 1041 char **name;
a6bcef29 1042 STRV_FOREACH(name, strv_skip(argv, 1))
805bf39c 1043 list_dependencies(bus, *name);
9ea9d4cf 1044 } else
805bf39c 1045 list_dependencies(bus, SPECIAL_DEFAULT_TARGET);
bb150966 1046
a6bcef29 1047 h = hashmap_free(h);
bb150966
HH		 1048 return 0;
1049}
1050
a6bcef29
LP		 1051static int analyze_blame(int argc, char *argv[], void *userdata) {
1052 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
df560cf6
FB		 1053 _cleanup_(unit_times_freep) struct unit_times *times = NULL;
1054 struct unit_times *u;
a6bcef29
LP		 1055 int n, r;
1056
f7e29336 1057 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1058 if (r < 0)
1059 return log_error_errno(r, "Failed to create bus connection: %m");
c170f3a4
LP		 1060
1061 n = acquire_time_data(bus, &times);
1062 if (n <= 0)
2265fbf7
SP		 1063 return n;
1064
93bab288 1065 typesafe_qsort(times, n, compare_unit_time);
2265fbf7 1066
0221d68a 1067 (void) pager_open(arg_pager_flags);
9ea9d4cf 1068
df560cf6 1069 for (u = times; u->has_data; u++) {
c170f3a4
LP		 1070 char ts[FORMAT_TIMESPAN_MAX];
1071
df560cf6
FB		 1072 if (u->time > 0)
1073 printf("%16s %s\n", format_timespan(ts, sizeof(ts), u->time, USEC_PER_MSEC), u->name);
2265fbf7 1074 }
c170f3a4 1075
2265fbf7
SP		 1076 return 0;
1077}
1078
a6bcef29
LP		 1079static int analyze_time(int argc, char *argv[], void *userdata) {
1080 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
c170f3a4
LP		 1081 _cleanup_free_ char *buf = NULL;
1082 int r;
1083
f7e29336 1084 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1085 if (r < 0)
1086 return log_error_errno(r, "Failed to create bus connection: %m");
1087
c170f3a4
LP		 1088 r = pretty_boot_time(bus, &buf);
1089 if (r < 0)
1090 return r;
1091
1092 puts(buf);
2265fbf7
SP		 1093 return 0;
1094}
1095
4387795e 1096static int graph_one_property(sd_bus *bus, const UnitInfo *u, const char* prop, const char *color, char* patterns[], char* from_patterns[], char* to_patterns[]) {
048ecf5b 1097 _cleanup_strv_free_ char **units = NULL;
048ecf5b
TA		 1098 char **unit;
1099 int r;
6ecb6cec 1100 bool match_patterns;
1700761b 1101
048ecf5b 1102 assert(u);
1700761b 1103 assert(prop);
048ecf5b
TA		 1104 assert(color);
1105
2404701e 1106 match_patterns = strv_fnmatch(patterns, u->id, 0);
6ecb6cec 1107
4387795e 1108 if (!strv_isempty(from_patterns) &&
6ecb6cec 1109 !match_patterns &&
4387795e 1110 !strv_fnmatch(from_patterns, u->id, 0))
6ecb6cec
ZJS		 1111 return 0;
1112
6e6ca4a5 1113 r = bus_get_unit_property_strv(bus, u->unit_path, prop, &units);
07d0eaa0 1114 if (r < 0)
988b9df2 1115 return r;
1700761b 1116
048ecf5b 1117 STRV_FOREACH(unit, units) {
6ecb6cec
ZJS		 1118 bool match_patterns2;
1119
2404701e 1120 match_patterns2 = strv_fnmatch(patterns, *unit, 0);
816f25e8 1121
4387795e 1122 if (!strv_isempty(to_patterns) &&
6ecb6cec 1123 !match_patterns2 &&
4387795e 1124 !strv_fnmatch(to_patterns, *unit, 0))
bceccd5e 1125 continue;
e55933db 1126
6ecb6cec 1127 if (!strv_isempty(patterns) && !match_patterns && !match_patterns2)
bceccd5e 1128 continue;
048ecf5b
TA		 1129
1130 printf("\t\"%s\"->\"%s\" [color=\"%s\"];\n", u->id, *unit, color);
1700761b
SP		 1131 }
1132
1133 return 0;
1134}
1135
4387795e 1136static int graph_one(sd_bus *bus, const UnitInfo *u, char *patterns[], char *from_patterns[], char *to_patterns[]) {
1700761b 1137 int r;
1700761b
SP		 1138
1139 assert(bus);
1140 assert(u);
1141
8901b405 1142 if (IN_SET(arg_dot, DEP_ORDER, DEP_ALL)) {
4387795e 1143 r = graph_one_property(bus, u, "After", "green", patterns, from_patterns, to_patterns);
048ecf5b
TA		 1144 if (r < 0)
1145 return r;
1700761b
SP		 1146 }
1147
8901b405 1148 if (IN_SET(arg_dot, DEP_REQUIRE, DEP_ALL)) {
4387795e 1149 r = graph_one_property(bus, u, "Requires", "black", patterns, from_patterns, to_patterns);
8901b405
MS		 1150 if (r < 0)
1151 return r;
1152 r = graph_one_property(bus, u, "Requisite", "darkblue", patterns, from_patterns, to_patterns);
048ecf5b
TA		 1153 if (r < 0)
1154 return r;
4387795e 1155 r = graph_one_property(bus, u, "Wants", "grey66", patterns, from_patterns, to_patterns);
048ecf5b
TA		 1156 if (r < 0)
1157 return r;
4387795e 1158 r = graph_one_property(bus, u, "Conflicts", "red", patterns, from_patterns, to_patterns);
048ecf5b
TA		 1159 if (r < 0)
1160 return r;
1700761b
SP		 1161 }
1162
1163 return 0;
1164}
1165
83efb7c2
EV		 1166static 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) {
4afd3348 1172 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
83efb7c2
EV		 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
a6bcef29 1208static int dot(int argc, char *argv[], void *userdata) {
4afd3348
LP		 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;
a6bcef29 1211 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
83efb7c2 1212 _cleanup_strv_free_ char **expanded_patterns = NULL;
4387795e
EV		 1213 _cleanup_strv_free_ char **expanded_from_patterns = NULL;
1214 _cleanup_strv_free_ char **expanded_to_patterns = NULL;
1700761b 1215 int r;
f459b602 1216 UnitInfo u;
048ecf5b 1217
f7e29336 1218 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 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);
83efb7c2
EV		 1223 if (r < 0)
1224 return r;
1225
4387795e
EV		 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
a936124f
TA		 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 "");
4ae25393 1243 if (r < 0)
0ed3da7c 1244 log_error_errno(r, "Failed to list units: %s", bus_error_message(&error, r));
1700761b 1245
048ecf5b 1246 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
1700761b 1247 if (r < 0)
988b9df2 1248 return bus_log_parse_error(r);
1700761b
SP		 1249
1250 printf("digraph systemd {\n");
1251
048ecf5b 1252 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
f459b602 1253
4387795e 1254 r = graph_one(bus, &u, expanded_patterns, expanded_from_patterns, expanded_to_patterns);
1700761b
SP		 1255 if (r < 0)
1256 return r;
1257 }
f459b602
MAP		 1258 if (r < 0)
1259 return bus_log_parse_error(r);
1700761b
SP		 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}
c8a8806e 1275
c0a1bfac
DT		 1276static 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
a6bcef29 1304static int dump(int argc, char *argv[], void *userdata) {
4afd3348 1305 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a6bcef29
LP		 1306 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1307 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
c0a1bfac 1308 int fd = -1;
9ea9d4cf 1309 int r;
9ea9d4cf 1310
f7e29336 1311 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1312 if (r < 0)
1313 return log_error_errno(r, "Failed to create bus connection: %m");
a65615ca 1314
0221d68a 1315 (void) pager_open(arg_pager_flags);
9ea9d4cf 1316
c0a1bfac
DT		 1317 if (!sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD))
1318 return dump_fallback(bus);
1319
a936124f
TA		 1320 r = sd_bus_call_method(
1321 bus,
8486c923
LP		 1322 "org.freedesktop.systemd1",
1323 "/org/freedesktop/systemd1",
1324 "org.freedesktop.systemd1.Manager",
c0a1bfac 1325 "DumpByFileDescriptor",
8486c923
LP		 1326 &error,
1327 &reply,
1328 NULL);
c0a1bfac
DT		 1329 if (r < 0) {
1330 /* fall back to Dump if DumpByFileDescriptor is not supported */
1331 if (!IN_SET(r, -EACCES, -EBADR))
c2953e08
ZJS		 1332 return log_error_errno(r, "Failed to issue method call DumpByFileDescriptor: %s",
1333 bus_error_message(&error, r));
9ea9d4cf 1334
c0a1bfac
DT		 1335 return dump_fallback(bus);
1336 }
1337
1338 r = sd_bus_message_read(reply, "h", &fd);
5b30bef8
LP		 1339 if (r < 0)
1340 return bus_log_parse_error(r);
9ea9d4cf 1341
c0a1bfac
DT		 1342 fflush(stdout);
1343 return copy_bytes(fd, STDOUT_FILENO, (uint64_t) -1, 0);
9ea9d4cf
LP		 1344}
1345
854a42fb 1346static int cat_config(int argc, char *argv[], void *userdata) {
2987225c 1347 char **arg, **list;
854a42fb
ZJS		 1348 int r;
1349
0221d68a 1350 (void) pager_open(arg_pager_flags);
854a42fb 1351
2987225c
LP		 1352 list = strv_skip(argv, 1);
1353 STRV_FOREACH(arg, list) {
971f6ea5
ZJS		 1354 const char *t = NULL;
1355
2987225c 1356 if (arg != list)
cb91deaf 1357 print_separator();
854a42fb
ZJS		 1358
1359 if (path_is_absolute(*arg)) {
971f6ea5
ZJS		 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
baaa35ad
ZJS		 1368 if (!t)
1369 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
c2953e08 1370 "Path %s does not start with any known prefix.", *arg);
971f6ea5
ZJS		 1371 } else
1372 t = *arg;
1373
1374 r = conf_files_cat(arg_root, t);
854a42fb
ZJS		 1375 if (r < 0)
1376 return r;
1377 }
1378
1379 return 0;
1380}
1381
a6bcef29 1382static int set_log_level(int argc, char *argv[], void *userdata) {
4afd3348 1383 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a6bcef29 1384 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
048ecf5b 1385 int r;
a65615ca 1386
a6bcef29
LP		 1387 assert(argc == 2);
1388 assert(argv);
a65615ca 1389
f7e29336 1390 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1391 if (r < 0)
1392 return log_error_errno(r, "Failed to create bus connection: %m");
a65615ca 1393
a936124f
TA		 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",
a6bcef29 1402 argv[1]);
2ca2a91c
LP		 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
a6bcef29 1409static int get_log_level(int argc, char *argv[], void *userdata) {
ef5a8cb1 1410 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a6bcef29 1411 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
ef5a8cb1 1412 _cleanup_free_ char *level = NULL;
a6bcef29 1413 int r;
ef5a8cb1 1414
f7e29336 1415 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1416 if (r < 0)
1417 return log_error_errno(r, "Failed to create bus connection: %m");
ef5a8cb1
LW		 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
90657286
YW		 1434static 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
a6bcef29 1438static int set_log_target(int argc, char *argv[], void *userdata) {
4afd3348 1439 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a6bcef29 1440 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2ca2a91c
LP		 1441 int r;
1442
a6bcef29
LP		 1443 assert(argc == 2);
1444 assert(argv);
2ca2a91c 1445
f7e29336 1446 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1447 if (r < 0)
1448 return log_error_errno(r, "Failed to create bus connection: %m");
a65615ca 1449
2ca2a91c
LP		 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",
a6bcef29 1458 argv[1]);
2ca2a91c
LP		 1459 if (r < 0)
1460 return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
1461
a65615ca
LP		 1462 return 0;
1463}
1464
a6bcef29 1465static int get_log_target(int argc, char *argv[], void *userdata) {
ef5a8cb1 1466 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a6bcef29 1467 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
ef5a8cb1 1468 _cleanup_free_ char *target = NULL;
a6bcef29 1469 int r;
ef5a8cb1 1470
f7e29336 1471 r = acquire_bus(&bus, NULL);
a6bcef29
LP		 1472 if (r < 0)
1473 return log_error_errno(r, "Failed to create bus connection: %m");
ef5a8cb1
LW		 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
90657286
YW		 1490static 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
31a5924e 1494static int dump_unit_paths(int argc, char *argv[], void *userdata) {
8e766630 1495 _cleanup_(lookup_paths_free) LookupPaths paths = {};
31a5924e
ZJS		 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
349cc4a5 1509#if HAVE_SECCOMP
cdf6258c
LP		 1510
1511static 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
1554static 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
869feb33
ZJS		 1565static void dump_syscall_filter(const SyscallFilterSet *set) {
1566 const char *syscall;
1567
a9bfb3ef
LP		 1568 printf("%s%s%s\n"
1569 " # %s\n",
1570 ansi_highlight(),
1571 set->name,
1572 ansi_normal(),
1573 set->help);
1574
869feb33 1575 NULSTR_FOREACH(syscall, set->value)
a9bfb3ef
LP		 1576 printf(" %s%s%s\n",
1577 syscall[0] == '@' ? ansi_underline() : "",
1578 syscall,
1579 ansi_normal());
869feb33
ZJS		 1580}
1581
a6bcef29 1582static int dump_syscall_filters(int argc, char *argv[], void *userdata) {
869feb33
ZJS		 1583 bool first = true;
1584
0221d68a 1585 (void) pager_open(arg_pager_flags);
869feb33 1586
a6bcef29 1587 if (strv_isempty(strv_skip(argv, 1))) {
cdf6258c
LP		 1588 _cleanup_(set_free_freep) Set *kernel = NULL;
1589 int i, k;
1590
1591 k = load_kernel_syscalls(&kernel);
869feb33
ZJS		 1592
1593 for (i = 0; i < _SYSCALL_FILTER_SET_MAX; i++) {
cdf6258c 1594 const SyscallFilterSet *set = syscall_filter_sets + i;
869feb33
ZJS		 1595 if (!first)
1596 puts("");
cdf6258c
LP		 1597
1598 dump_syscall_filter(set);
1599 kernel_syscalls_remove(kernel, set);
869feb33
ZJS		 1600 first = false;
1601 }
cdf6258c
LP		 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"
a9bfb3ef
LP		 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());
cdf6258c
LP		 1614
1615 SET_FOREACH(syscall, kernel, j)
1616 printf("# %s\n", syscall);
1617 }
869feb33
ZJS		 1618 } else {
1619 char **name;
1620
a6bcef29 1621 STRV_FOREACH(name, strv_skip(argv, 1)) {
869feb33
ZJS		 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
c2953e08
ZJS		 1632 return log_error_errno(SYNTHETIC_ERRNO(ENOENT),
1633 "Filter set \"%s\" not found.", *name);
869feb33
ZJS		 1634 }
1635
1636 dump_syscall_filter(set);
1637 first = false;
1638 }
1639 }
1640
1641 return 0;
1642}
1643
1720590b 1644#else
d3340e6f 1645static int dump_syscall_filters(int argc, char *argv[], void *userdata) {
baaa35ad
ZJS		 1646 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1647 "Not compiled with syscall filters, sorry.");
d3340e6f 1648}
1720590b
ZJS		 1649#endif
1650
3f1c1287
CD		 1651static 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);
9a6f746f 1664 printf(" %ss: %" PRIu64 "\n", special_glyph(SPECIAL_GLYPH_MU), output_usecs);
3f1c1287
CD		 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
84653d99
ZJS		 1674static 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;
6d86f4bd 1678
84653d99
ZJS		 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);
6d86f4bd 1682
84653d99
ZJS		 1683 r = calendar_spec_normalize(spec);
1684 if (r < 0)
1685 return log_error_errno(r, "Failed to normalize calendar specification '%s': %m", p);
6d86f4bd 1686
84653d99
ZJS		 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);
6d86f4bd 1690
84653d99
ZJS		 1691 if (!streq(t, p))
1692 printf(" Original form: %s\n", p);
6d86f4bd 1693
84653d99 1694 printf("Normalized form: %s\n", t);
6d86f4bd 1695
84653d99
ZJS		 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)
deed4d50
ZJS		 1703 printf(" Next elapse: %snever%s\n",
1704 ansi_highlight_yellow(), ansi_normal());
84653d99
ZJS		 1705 return 0;
1706 }
1707 if (r < 0)
1708 return log_error_errno(r, "Failed to determine next elapse for '%s': %m", p);
6d86f4bd 1709
84653d99 1710 if (i == 0)
deed4d50
ZJS		 1711 printf(" Next elapse: %s%s%s\n",
1712 ansi_highlight_blue(), format_timestamp(buffer, sizeof(buffer), next), ansi_normal());
84653d99
ZJS		 1713 else {
1714 int k = DECIMAL_STR_WIDTH(i+1);
6d86f4bd 1715
84653d99
ZJS		 1716 if (k < 8)
1717 k = 8 - k;
1718 else
1719 k = 0;
f2ccf832 1720
deed4d50
ZJS		 1721 printf("%*sIter. #%u: %s%s%s\n",
1722 k, "", i+1,
1723 ansi_highlight_blue(), format_timestamp(buffer, sizeof(buffer), next), ansi_normal());
84653d99 1724 }
f2ccf832 1725
84653d99
ZJS		 1726 if (!in_utc_timezone())
1727 printf(" (in UTC): %s\n", format_timestamp_utc(buffer, sizeof(buffer), next));
f2ccf832 1728
84653d99 1729 printf(" From now: %s\n", format_timestamp_relative(buffer, sizeof(buffer), next));
6d86f4bd 1730
84653d99
ZJS		 1731 n = next;
1732 }
f2ccf832 1733
84653d99
ZJS		 1734 return 0;
1735}
6d86f4bd 1736
84653d99
ZJS		 1737static int test_calendar(int argc, char *argv[], void *userdata) {
1738 int ret = 0, r;
1739 char **p;
1740 usec_t n;
6d86f4bd 1741
84653d99 1742 n = now(CLOCK_REALTIME); /* We want to use the same "base" for all expressions */
f2ccf832 1743
84653d99
ZJS		 1744 STRV_FOREACH(p, strv_skip(argv, 1)) {
1745 r = test_calendar_one(n, *p);
1746 if (ret == 0 && r < 0)
1747 ret = r;
6d86f4bd
LP		 1748
1749 if (*(p+1))
1750 putchar('\n');
1751 }
1752
1753 return ret;
1754}
1755
889d695d
JK		 1756static 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
90657286 1761 assert(IN_SET(argc, 1, 2));
889d695d
JK		 1762 assert(argv);
1763
f7e29336 1764 r = acquire_bus(&bus, NULL);
90657286
YW		 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 */
889d695d
JK		 1788 b = parse_boolean(argv[1]);
1789 if (b < 0) {
1790 log_error("Failed to parse service-watchdogs argument.");
1791 return -EINVAL;
1792 }
1793
889d695d
JK		 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)
90657286 1804 return log_error_errno(r, "Failed to set service-watchdog state: %s", bus_error_message(&error, r));
889d695d
JK		 1805
1806 return 0;
1807}
1808
a6bcef29 1809static int do_verify(int argc, char *argv[], void *userdata) {
28b35ef2 1810 return verify_units(strv_skip(argv, 1), arg_scope, arg_man, arg_generators);
a6bcef29
LP		 1811}
1812
ec16f3b6
LP		 1813static 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
a6bcef29 1826static int help(int argc, char *argv[], void *userdata) {
37ec0fdd
LP		 1827 _cleanup_free_ char *link = NULL;
1828 int r;
9ea9d4cf 1829
0221d68a 1830 (void) pager_open(arg_pager_flags);
9ea9d4cf 1831
37ec0fdd
LP		 1832 r = terminal_urlify_man("systemd-analyze", "1", &link);
1833 if (r < 0)
1834 return log_oom();
1835
2265fbf7 1836 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1d3bc017 1837 "Profile systemd, show unit dependencies, check unit files.\n\n"
869feb33
ZJS		 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"
28b35ef2 1843 " --global Operate on global user configuration\n"
869feb33
ZJS		 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"
20a51f6a
YW		 1852 " --man[=BOOL] Do [not] check for existence of man pages\n"
1853 " --generators[=BOOL] Do [not] run unit generators (requires privileges)\n"
f2ccf832 1854 " --iterations=N Show the specified number of iterations\n"
20a51f6a 1855 "\nCommands:\n"
869feb33
ZJS		 1856 " time Print time spent in the kernel\n"
1857 " blame Print list of running units ordered by time to init\n"
bc6695ec 1858 " critical-chain [UNIT...] Print a tree of the time critical chain of units\n"
869feb33 1859 " plot Output SVG graphic showing service initialization\n"
bc6695ec 1860 " dot [UNIT...] Output dependency graph in man:dot(1) format\n"
90657286
YW		 1861 " log-level [LEVEL] Get/set logging threshold for manager\n"
1862 " log-target [TARGET] Get/set logging target for manager\n"
869feb33 1863 " dump Output state serialization of service manager\n"
854a42fb 1864 " cat-config Show configuration file and drop-ins\n"
31a5924e 1865 " unit-paths List load directories for units\n"
869feb33
ZJS		 1866 " syscall-filter [NAME...] Print list of syscalls in seccomp filter\n"
1867 " verify FILE... Check unit files for correctness\n"
6d86f4bd 1868 " calendar SPEC... Validate repetitive calendar time events\n"
90657286 1869 " service-watchdogs [BOOL] Get/set service watchdog state\n"
3f1c1287 1870 " timespan SPAN... Validate a time span\n"
ec16f3b6 1871 " security [UNIT...] Analyze security of unit\n"
37ec0fdd
LP		 1872 "\nSee the %s for details.\n"
1873 , program_invocation_short_name
1874 , link
1875 );
96de7c04 1876
37ec0fdd 1877 /* When updating this list, including descriptions, apply changes to shell-completion/bash/systemd-analyze and
1d3bc017 1878 * shell-completion/zsh/_systemd-analyze too. */
a6bcef29
LP		 1879
1880 return 0;
2265fbf7
SP		 1881}
1882
9ea9d4cf 1883static int parse_argv(int argc, char *argv[]) {
2265fbf7
SP		 1884 enum {
1885 ARG_VERSION = 0x100,
1700761b
SP		 1886 ARG_ORDER,
1887 ARG_REQUIRE,
46d8646a 1888 ARG_ROOT,
e55933db 1889 ARG_SYSTEM,
28b35ef2
ZJS		 1890 ARG_USER,
1891 ARG_GLOBAL,
e55933db 1892 ARG_DOT_FROM_PATTERN,
bb150966 1893 ARG_DOT_TO_PATTERN,
9ea9d4cf 1894 ARG_FUZZ,
1d3bc017 1895 ARG_NO_PAGER,
dad29dff 1896 ARG_MAN,
641c0fd1 1897 ARG_GENERATORS,
f2ccf832 1898 ARG_ITERATIONS,
2265fbf7
SP		 1899 };
1900
1901 static const struct option options[] = {
9ea9d4cf
LP		 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 },
46d8646a 1906 { "root", required_argument, NULL, ARG_ROOT },
9ea9d4cf 1907 { "system", no_argument, NULL, ARG_SYSTEM },
28b35ef2
ZJS		 1908 { "user", no_argument, NULL, ARG_USER },
1909 { "global", no_argument, NULL, ARG_GLOBAL },
9ea9d4cf
LP		 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 },
dad29dff 1914 { "man", optional_argument, NULL, ARG_MAN },
641c0fd1 1915 { "generators", optional_argument, NULL, ARG_GENERATORS },
8fe12d88
LP		 1916 { "host", required_argument, NULL, 'H' },
1917 { "machine", required_argument, NULL, 'M' },
f2ccf832 1918 { "iterations", required_argument, NULL, ARG_ITERATIONS },
eb9da376 1919 {}
2265fbf7
SP		 1920 };
1921
eb9da376
LP		 1922 int r, c;
1923
2265fbf7
SP		 1924 assert(argc >= 0);
1925 assert(argv);
1926
601185b4 1927 while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)
eb9da376 1928 switch (c) {
c170f3a4
LP		 1929
1930 case 'h':
a6bcef29 1931 return help(0, NULL, NULL);
c170f3a4
LP		 1932
1933 case ARG_VERSION:
3f6fd1ba 1934 return version();
c170f3a4 1935
46d8646a
ZJS		 1936 case ARG_ROOT:
1937 arg_root = optarg;
1938 break;
1939
28b35ef2
ZJS		 1940 case ARG_SYSTEM:
1941 arg_scope = UNIT_FILE_SYSTEM;
1942 break;
1943
c170f3a4 1944 case ARG_USER:
28b35ef2 1945 arg_scope = UNIT_FILE_USER;
c170f3a4
LP		 1946 break;
1947
28b35ef2
ZJS		 1948 case ARG_GLOBAL:
1949 arg_scope = UNIT_FILE_GLOBAL;
c170f3a4
LP		 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
e55933db 1960 case ARG_DOT_FROM_PATTERN:
903a0b07
LP		 1961 if (strv_extend(&arg_dot_from_patterns, optarg) < 0)
1962 return log_oom();
1963
e55933db
ŁS		 1964 break;
1965
1966 case ARG_DOT_TO_PATTERN:
903a0b07
LP		 1967 if (strv_extend(&arg_dot_to_patterns, optarg) < 0)
1968 return log_oom();
1969
e55933db
ŁS		 1970 break;
1971
bb150966
HH		 1972 case ARG_FUZZ:
1973 r = parse_sec(optarg, &arg_fuzz);
1974 if (r < 0)
1975 return r;
1976 break;
1977
9ea9d4cf 1978 case ARG_NO_PAGER:
0221d68a 1979 arg_pager_flags |= PAGER_DISABLE;
9ea9d4cf
LP		 1980 break;
1981
3cd26e7c
LP		 1982 case 'H':
1983 arg_transport = BUS_TRANSPORT_REMOTE;
1984 arg_host = optarg;
1985 break;
1986
1987 case 'M':
de33fc62 1988 arg_transport = BUS_TRANSPORT_MACHINE;
3cd26e7c
LP		 1989 arg_host = optarg;
1990 break;
1991
dad29dff
LP		 1992 case ARG_MAN:
1993 if (optarg) {
1994 r = parse_boolean(optarg);
baaa35ad
ZJS		 1995 if (r < 0)
1996 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1997 "Failed to parse --man= argument.");
dad29dff 1998
5d904a6a 1999 arg_man = r;
dad29dff
LP		 2000 } else
2001 arg_man = true;
2002
1d3bc017
ZJS		 2003 break;
2004
641c0fd1
ZJS		 2005 case ARG_GENERATORS:
2006 if (optarg) {
2007 r = parse_boolean(optarg);
baaa35ad
ZJS		 2008 if (r < 0)
2009 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
2010 "Failed to parse --generators= argument.");
641c0fd1 2011
5d904a6a 2012 arg_generators = r;
641c0fd1
ZJS		 2013 } else
2014 arg_generators = true;
2015
2016 break;
2017
f2ccf832
LP		 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
c170f3a4
LP		 2025 case '?':
2026 return -EINVAL;
2027
2028 default:
1d3bc017 2029 assert_not_reached("Unhandled option code.");
2265fbf7 2030 }
eb9da376 2031
31a5924e 2032 if (arg_scope == UNIT_FILE_GLOBAL &&
baaa35ad
ZJS		 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.");
31a5924e 2036
f1d9d36a
ZJS		 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
baaa35ad
ZJS		 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.");
46d8646a 2044
1d3bc017 2045 return 1; /* work to do */
2265fbf7
SP		 2046}
2047
d665c7b2 2048static int run(int argc, char *argv[]) {
a6bcef29
LP		 2049
2050 static const Verb verbs[] = {
889d695d
JK		 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 },
90657286
YW		 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 */
889d695d
JK		 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 },
854a42fb 2065 { "cat-config", 2, VERB_ANY, 0, cat_config },
31a5924e 2066 { "unit-paths", 1, 1, 0, dump_unit_paths },
889d695d
JK		 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 },
90657286 2070 { "service-watchdogs", VERB_ANY, 2, 0, service_watchdogs },
3f1c1287 2071 { "timespan", 2, VERB_ANY, 0, dump_timespan },
ec16f3b6 2072 { "security", VERB_ANY, VERB_ANY, 0, do_security },
a6bcef29
LP		 2073 {}
2074 };
2075
5220a6f3 2076 int r;
2265fbf7
SP		 2077
2078 setlocale(LC_ALL, "");
c170f3a4 2079 setlocale(LC_NUMERIC, "C"); /* we want to format/parse floats in C style */
a6bcef29 2080
2265fbf7
SP		 2081 log_parse_environment();
2082 log_open();
2083
2084 r = parse_argv(argc, argv);
9ea9d4cf 2085 if (r <= 0)
d665c7b2 2086 return r;
c170f3a4 2087
d665c7b2 2088 return dispatch_verb(argc, argv, verbs, NULL);
2265fbf7 2089}
d665c7b2
YW		 2090
2091DEFINE_MAIN_FUNCTION(run);
Unnamed repository; edit this file 'description' to name the repository.