src/analyze/analyze.c

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