src/analyze/analyze.c

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