From 2265fbf7e5614e9a9e5272937219181290f86e07 Mon Sep 17 00:00:00 2001 From: Simon Peeters Date: Wed, 6 Feb 2013 15:21:03 +0100 Subject: [PATCH] systemd-analyze: rewrite in C. Written by Peeters Simon . Makefile stuff and cleaned up a bit by Auke Kok . Some code inspired by Marc-Antoine Perennou . --- Makefile.am | 21 +- src/analyze/systemd-analyze.c | 624 +++++++++++++++++++++++++++++++++ src/analyze/systemd-analyze.in | 328 ----------------- 3 files changed, 634 insertions(+), 339 deletions(-) create mode 100644 src/analyze/systemd-analyze.c delete mode 100755 src/analyze/systemd-analyze.in diff --git a/Makefile.am b/Makefile.am index 65294a56a..403439b6e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -267,7 +267,8 @@ rootbin_PROGRAMS = \ systemd-ask-password \ systemd-tty-ask-password-agent \ systemd-tmpfiles \ - systemd-machine-id-setup + systemd-machine-id-setup \ + systemd-analyze bin_PROGRAMS = \ systemd-cgls \ @@ -297,14 +298,16 @@ systemgenerator_PROGRAMS = \ systemd-fstab-generator \ systemd-system-update-generator -dist_bin_SCRIPTS = \ - src/analyze/systemd-analyze +systemd_analyze_SOURCES = \ + src/analyze/systemd-analyze.c -EXTRA_DIST += \ - src/analyze/systemd-analyze.in +systemd_analyze_CFLAGS = \ + $(AM_CFLAGS) \ + $(DBUS_CFLAGS) -CLEANFILES += \ - src/analyze/systemd-analyze +systemd_analyze_LDADD = \ + libsystemd-shared.la \ + libsystemd-dbus.la dist_bashcompletion_DATA = \ shell-completion/systemd-bash-completion.sh @@ -3465,10 +3468,6 @@ src/%.policy.in: src/%.policy.in.in Makefile $(SED_PROCESS) $(AM_V_GEN)chmod +x $@ -src/analyze/systemd-analyze: %: %.in Makefile - $(SED_PROCESS) - $(AM_V_GEN)chmod +x $@ - src/%.c: src/%.gperf $(AM_V_at)$(MKDIR_P) $(dir $@) $(AM_V_GPERF)$(GPERF) < $< > $@ diff --git a/src/analyze/systemd-analyze.c b/src/analyze/systemd-analyze.c new file mode 100644 index 000000000..1ea56c689 --- /dev/null +++ b/src/analyze/systemd-analyze.c @@ -0,0 +1,624 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2010 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include + +#include "install.h" +#include "log.h" +#include "dbus-common.h" +#include "build.h" +#include "util.h" +#include "strxcpyx.h" + +#define compare(a, b) (((a) > (b))? 1 : (((b) > (a))? -1 : 0)) +#define svg(...) printf(__VA_ARGS__) +#define svg_bar(class, x1, x2, y) \ + svg(" \n", \ + (class), \ + scale_x * (x1), scale_y * (y), \ + scale_x * ((x2) - (x1)), scale_y - 1.0) +#define svg_text(x, y, format, ...) do {\ + svg(" ", scale_x * (x) + 5.0, scale_y * (y) + 14.0); \ + svg(format, ## __VA_ARGS__); \ + svg("\n"); \ + } while(false) + +static UnitFileScope arg_scope = UNIT_FILE_SYSTEM; + +double scale_x = 0.1; // pixels per ms +double scale_y = 20.0; + +struct boot_times { + uint64_t firmware_time; + uint64_t loader_time; + uint64_t kernel_time; + uint64_t kernel_done_time; + uint64_t initrd_time; + uint64_t userspace_time; + uint64_t finish_time; +}; +struct unit_times { + char *name; + uint64_t ixt; + uint64_t iet; + uint64_t axt; + uint64_t aet; + uint64_t time; +}; + +static int bus_get_uint64_property (DBusConnection *bus, const char *path, const char *interface, const char *property, uint64_t *val) +{ + _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; + int r; + DBusMessageIter iter, sub; + + r = bus_method_call_with_reply ( + bus, + "org.freedesktop.systemd1", + path, + "org.freedesktop.DBus.Properties", + "Get", + &reply, + NULL, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_STRING, &property, + DBUS_TYPE_INVALID); + if (r < 0) + return r; + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + return -EIO; + } + + dbus_message_iter_recurse(&iter, &sub); + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT64) { + log_error("Failed to parse reply."); + return -EIO; + } + + dbus_message_iter_get_basic(&sub, val); + + return 0; +} + +static int compare_unit_time(const void *a, const void *b) +{ + return compare(((struct unit_times *)b)->time, + ((struct unit_times *)a)->time); +} + +static int compare_unit_start(const void *a, const void *b) +{ + return compare(((struct unit_times *)a)->ixt, + ((struct unit_times *)b)->ixt); +} + +static char *get_os_name(void) +{ + char *n = NULL; + + parse_env_file("/etc/os-release", NEWLINE, "PRETTY_NAME", &n, NULL); + return n; +} + +static int acquire_time_data(DBusConnection *bus, struct unit_times **out) +{ + _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; + DBusMessageIter iter, sub; + int r, c = 0, n_units = 0; + struct unit_times *unit_times = NULL; + + r = bus_method_call_with_reply ( + bus, + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "ListUnits", + &reply, + NULL, + DBUS_TYPE_INVALID); + if (r) + goto fail; + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || + dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto fail; + } + + for (dbus_message_iter_recurse(&iter, &sub); + dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID; + dbus_message_iter_next(&sub)) { + struct unit_info u; + struct unit_times *t; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto fail; + } + + if (c >= n_units) { + struct unit_times *w; + + n_units = MAX(2*c, 16); + w = realloc(unit_times, sizeof(struct unit_times) * n_units); + + if (!w) { + r = log_oom(); + goto fail; + } + + unit_times = w; + } + t = unit_times+c; + t->name = NULL; + + r = bus_parse_unit_info(&sub, &u); + if (r < 0) + goto fail; + + if (bus_get_uint64_property(bus, u.unit_path, + "org.freedesktop.systemd1.Unit", + "InactiveExitTimestampMonotonic", + &t->ixt) < 0 || + bus_get_uint64_property(bus, u.unit_path, + "org.freedesktop.systemd1.Unit", + "ActiveEnterTimestampMonotonic", + &t->aet) < 0 || + bus_get_uint64_property(bus, u.unit_path, + "org.freedesktop.systemd1.Unit", + "ActiveExitTimestampMonotonic", + &t->axt) < 0 || + bus_get_uint64_property(bus, u.unit_path, + "org.freedesktop.systemd1.Unit", + "InactiveEnterTimestampMonotonic", + &t->iet) < 0) { + r = -EIO; + goto fail; + } + + t->iet /= 1000; + t->ixt /= 1000; + t->aet /= 1000; + t->axt /= 1000; + + if (t->aet >= t->ixt) + t->time = t->aet - t->ixt; + else if (t->iet >= t->ixt) + t->time = t->iet - t->ixt; + else + t->time = 0; + + if (t->ixt == 0) + continue; + + t->name = strdup(u.id); + if (t->name == NULL) { + r = log_oom(); + goto fail; + } + c++; + } + + *out = unit_times; + return c; +fail: + for (; c >= 0; c--) + free(unit_times[c].name); + free(unit_times); + return r; +} + +static struct boot_times *acquire_boot_times(DBusConnection *bus) +{ + static struct boot_times times; + static bool cached = false; + if (cached) + return × + + if (bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "FirmwareTimestampMonotonic", + ×.firmware_time) < 0 || + bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "LoaderTimestampMonotonic", + ×.loader_time) < 0 || + bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "KernelTimestamp", + ×.kernel_time) < 0 || + bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "InitRDTimestampMonotonic", + ×.initrd_time) < 0 || + bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "UserspaceTimestampMonotonic", + ×.userspace_time) < 0 || + bus_get_uint64_property(bus, + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "FinishTimestampMonotonic", + ×.finish_time) < 0) + return NULL; + + if (!times.finish_time) { + log_error("Bootup is not yet finished. Please try again later."); + return NULL; + } + + times.firmware_time /= 1000; + times.loader_time /= 1000; + times.initrd_time /= 1000; + times.userspace_time /= 1000; + times.finish_time /= 1000; + + if (times.initrd_time) + times.kernel_done_time = times.initrd_time; + else + times.kernel_done_time = times.userspace_time; + + cached = true; + return × +} + +static char *pretty_boot_time(DBusConnection *bus) +{ + struct boot_times *t; + size_t size = 4096; + static char buf[4096]; + char *ptr = buf; + + t = acquire_boot_times(bus); + if (!t) + return NULL; + + size = strpcpyf(&ptr, size, "Startup finished in "); + if (t->firmware_time) + size = strpcpyf(&ptr, size, "%llums (firmware) + ", (unsigned long long)(t->firmware_time - t->loader_time)); + if (t->loader_time) + size = strpcpyf(&ptr, size, "%llums (loader) + ", (unsigned long long)t->loader_time); + if (t->kernel_time) + size = strpcpyf(&ptr, size, "%llums (kernel) + ", (unsigned long long)t->kernel_done_time); + if (t->initrd_time > 0) + size = strpcpyf(&ptr, size, "%llums (initrd) + ", (unsigned long long)(t->userspace_time - t->initrd_time)); + + size = strpcpyf(&ptr, size, "%llums (userspace) ", (unsigned long long)(t->finish_time - t->userspace_time)); + if (t->kernel_time > 0) + size = strpcpyf(&ptr, size, "= %llums", (unsigned long long)(t->firmware_time + t->finish_time)); + else + size = strpcpyf(&ptr, size, "= %llums", (unsigned long long)(t->finish_time - t->userspace_time)); + + return buf; +} + +static void svg_graph_box(int height, int64_t begin, int64_t end) +{ + /* outside box, fill */ + svg("\n", + scale_x * (end - begin), scale_y * height); + + for (int i = (begin / 100) * 100; i <= end; i+=100) { + /* lines for each second */ + if (i % 5000 == 0) + svg(" \n" + " %.01fs\n", + scale_x * i, scale_x * i, scale_y * height, scale_x * i, -5.0, 0.001 * i); + else if (i % 1000 == 0) + svg(" \n" + " %.01fs\n", + scale_x * i, scale_x * i, scale_y * height, scale_x * i, -5.0, 0.001 * i); + else + svg(" \n", + scale_x * i, scale_x * i, scale_y * height); + } +} + +static int analyze_plot(DBusConnection *bus) +{ + struct unit_times *times; + struct boot_times *boot; + struct utsname name; + int n, m = 1, y=0; + double width; + char *osname; + char *pretty_times; + + boot = acquire_boot_times(bus); + if (!boot) + return -EIO; + pretty_times = pretty_boot_time(bus); + if (!pretty_times) + return -EIO; + + osname = get_os_name(); + + n = uname(&name); + if (n < 0) { + log_error("Cannot get system name: %m"); + return -errno; + } + + n = acquire_time_data(bus, ×); + if (n<=0) + return n; + + qsort(times, n, sizeof(struct unit_times), compare_unit_start); + + width = scale_x * (boot->firmware_time + boot->finish_time); + if (width < 800.0) + width = 800.0; + + if (boot->firmware_time > boot->loader_time) + m++; + if (boot->loader_time) { + m++; + if (width < 1000.0) + width = 1000.0; + } + if (boot->initrd_time) + m++; + if (boot->kernel_time) + m++; + + for (struct unit_times *u = times; u < times + n; u++) { + double len; + if (u->ixt < boot->userspace_time || + u->ixt > boot->finish_time) { + free(u->name); + u->name = NULL; + continue; + } + len = ((boot->firmware_time + u->ixt) * scale_x) + + (10.0 * strlen(u->name)); + if (len > width) + width = len; + + if (u->iet > u->ixt && u->iet <= boot->finish_time + && u->aet == 0 && u->axt == 0) + u->aet = u->axt = u->iet; + if (u->aet < u->ixt || u->aet > boot->finish_time) + u->aet = boot->finish_time; + if (u->axt < u->aet || u->aet > boot->finish_time) + u->axt = boot->finish_time; + if (u->iet < u->axt || u->iet > boot->finish_time) + u->iet = boot->finish_time; + m++; + } + + svg("\n" + "\n"); + + svg("\n\n", + 80.0 + width, 150.0 + (m * scale_y)); + + /* write some basic info as a comment, including some help */ + svg("\n" + "\n" + "\n" + "\n" + "\n\n" + "\n\n", VERSION); + + /* style sheet */ + svg("\n \n\n\n"); + + svg("%s", pretty_times); + svg("%s %s (%s %s) %s", + isempty(osname)? "Linux" : osname, + name.nodename, name.release, name.version, name.machine); + svg("Legend: Red = Activating; Pink = Active; Dark Pink = Deactivating", + 120.0 + (m *scale_y)); + + svg("\n", 20.0 + (scale_x * boot->firmware_time)); + svg_graph_box(m, -boot->firmware_time, boot->finish_time); + + if (boot->firmware_time) { + svg_bar("firmware", -(int64_t) boot->firmware_time, -(int64_t) boot->loader_time, y); + svg_text(-(int64_t) boot->firmware_time, y, "firmware"); + y++; + } + if (boot->loader_time) { + svg_bar("loader", -(int64_t) boot->loader_time, 0, y); + svg_text(-(int64_t) boot->loader_time, y, "loader"); + y++; + } + if (boot->kernel_time) { + svg_bar("kernel", 0, boot->kernel_done_time, y); + svg_text(0, y, "kernel"); + y++; + } + if (boot->initrd_time) { + svg_bar("initrd", boot->initrd_time, boot->userspace_time, y); + svg_text(boot->initrd_time, y, "initrd"); + y++; + } + svg_bar("userspace", boot->userspace_time, boot->finish_time, y); + svg_text(boot->userspace_time, y, "userspace"); + y++; + + for (struct unit_times *u = times; u < times + n; u++) { + if (!u->name) + continue; + svg_bar("activating", u->ixt, u->aet, y); + svg_bar("active", u->aet, u->axt, y); + svg_bar("deactivating", u->axt, u->iet, y); + svg_text(u->ixt, y, u->time? "%s (%llums)" : "%s", u->name, (unsigned long long)u->time); + y++; + } + svg("\n\n"); + + svg(""); + return 0; +} + +static int analyze_blame(DBusConnection *bus) +{ + struct unit_times *times; + int n = acquire_time_data(bus, ×); + if (n<=0) + return n; + + qsort(times, n, sizeof(struct unit_times), compare_unit_time); + + for (int i = 0; i < n; i++) { + if (times[i].time) + printf("%6llums %s\n", (unsigned long long)times[i].time, times[i].name); + } + return 0; +} + +static int analyze_time(DBusConnection *bus) +{ + char *buf; + buf = pretty_boot_time(bus); + if (!buf) + return -EIO; + if (puts(buf) == EOF) + return -errno; + return 0; +} + +static void analyze_help(void) +{ + printf("%s [OPTIONS...] {COMMAND} ...\n\n" + "Process systemd profiling information\n\n" + " -h --help Show this help\n" + " --version Show package version\n" + " --system Connect to system manager\n" + " --user Connect to user service manager\n\n" + "Commands:\n" + " time print time spent in the kernel before reaching userspace\n" + " blame print list of running units ordered by time to init\n" + " plot output SVG graphic showing service initialization\n\n", + program_invocation_short_name); +} + +static int parse_argv(int argc, char *argv[]) +{ + enum { + ARG_VERSION = 0x100, + ARG_USER, + ARG_SYSTEM + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "user", no_argument, NULL, ARG_USER }, + { "system", no_argument, NULL, ARG_SYSTEM }, + { NULL, 0, NULL, 0 } + }; + + assert(argc >= 0); + assert(argv); + + while (true) { + switch (getopt_long(argc, argv, "h", options, NULL)) { + case 'h': + analyze_help(); + return 0; + case ARG_VERSION: + puts(PACKAGE_STRING "\n" SYSTEMD_FEATURES); + return 0; + case ARG_USER: + arg_scope = UNIT_FILE_USER; + break; + case ARG_SYSTEM: + arg_scope = UNIT_FILE_SYSTEM; + break; + case -1: + return 1; + case '?': + return -EINVAL; + default: + assert_not_reached("Unhandled option"); + } + } +} + +int main(int argc, char *argv[]) { + int r; + DBusConnection *bus = NULL; + + setlocale(LC_ALL, ""); + log_parse_environment(); + log_open(); + + r = parse_argv(argc, argv); + if (r == 0) + return 0; + if (r < 0) + return 1; + + bus = dbus_bus_get(arg_scope == UNIT_FILE_SYSTEM ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, NULL); + if (!bus) + return 1; + + if (!argv[optind] || streq(argv[optind], "time")) + r = analyze_time(bus); + else if (streq(argv[optind], "blame")) + r = analyze_blame(bus); + else if (streq(argv[optind], "plot")) + r = analyze_plot(bus); + else + log_error("Unknown operation '%s'.", argv[optind]); + + dbus_connection_unref(bus); + if (r) + return 1; + return 0; +} diff --git a/src/analyze/systemd-analyze.in b/src/analyze/systemd-analyze.in deleted file mode 100755 index e964bb336..000000000 --- a/src/analyze/systemd-analyze.in +++ /dev/null @@ -1,328 +0,0 @@ -#!@PYTHON_BINARY@ -# -*-python-*- - -# This file is part of systemd. -# -# Copyright 2010-2013 Lennart Poettering -# -# systemd is free software; you can redistribute it and/or modify it -# under the terms of the GNU Lesser General Public License as published by -# the Free Software Foundation; either version 2.1 of the License, or -# (at your option) any later version. -# -# systemd is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public License -# along with systemd; If not, see . - -import sys, os -import argparse -from gi.repository import Gio -try: - import cairo -except ImportError: - cairo = None - -def acquire_time_data(): - manager = Gio.DBusProxy.new_for_bus_sync(bus, Gio.DBusProxyFlags.NONE, - None, 'org.freedesktop.systemd1', '/org/freedesktop/systemd1', 'org.freedesktop.systemd1.Manager', None) - units = manager.ListUnits() - - l = [] - - for i in units: - if i[5] != "": - continue - - properties = Gio.DBusProxy.new_for_bus_sync(bus, Gio.DBusProxyFlags.NONE, - None, 'org.freedesktop.systemd1', i[6], 'org.freedesktop.DBus.Properties', None) - - ixt = properties.Get('(ss)', 'org.freedesktop.systemd1.Unit', 'InactiveExitTimestampMonotonic') - aet = properties.Get('(ss)', 'org.freedesktop.systemd1.Unit', 'ActiveEnterTimestampMonotonic') - axt = properties.Get('(ss)', 'org.freedesktop.systemd1.Unit', 'ActiveExitTimestampMonotonic') - iet = properties.Get('(ss)', 'org.freedesktop.systemd1.Unit', 'InactiveEnterTimestampMonotonic') - - l.append((str(i[0]), ixt, aet, axt, iet)) - - return l - -def acquire_start_time(): - properties = Gio.DBusProxy.new_for_bus_sync(bus, Gio.DBusProxyFlags.NONE, - None, 'org.freedesktop.systemd1', '/org/freedesktop/systemd1', 'org.freedesktop.DBus.Properties', None) - - # Note that the firmware/loader times are returned as positive - # values but are actually considered negative from the point - # in time of kernel initialization. Also, the monotonic kernel - # time will always be 0 since that's the epoch of the - # monotonic clock. Since we want to know whether the kernel - # timestamp is set at all we will instead ask for the realtime - # clock for this timestamp. - - firmware_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'FirmwareTimestampMonotonic') - loader_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'LoaderTimestampMonotonic') - kernel_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'KernelTimestamp') - initrd_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'InitRDTimestampMonotonic') - userspace_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'UserspaceTimestampMonotonic') - finish_time = properties.Get('(ss)', 'org.freedesktop.systemd1.Manager', 'FinishTimestampMonotonic') - - if finish_time == 0: - sys.exit("Bootup is not yet finished. Please try again later.") - - assert firmware_time >= loader_time - assert initrd_time <= userspace_time - assert userspace_time <= finish_time - - return firmware_time, loader_time, kernel_time, initrd_time, userspace_time, finish_time - -def draw_box(context, j, k, l, m, r = 0, g = 0, b = 0): - context.save() - context.set_source_rgb(r, g, b) - context.rectangle(j, k, l, m) - context.fill() - context.restore() - -def draw_text(context, x, y, text, size = 12, r = 0, g = 0, b = 0, vcenter = 0.5, hcenter = 0.5): - context.save() - - context.set_source_rgb(r, g, b) - context.select_font_face("Sans", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL) - context.set_font_size(size) - - if vcenter or hcenter: - x_bearing, y_bearing, width, height = context.text_extents(text)[:4] - - if hcenter: - x = x - width*hcenter - x_bearing - - if vcenter: - y = y - height*vcenter - y_bearing - - context.move_to(x, y) - context.show_text(text) - - context.restore() - -def time(): - - firmware_time, loader_time, kernel_time, initrd_time, userspace_time, finish_time = acquire_start_time() - - sys.stdout.write("Startup finished in ") - - if firmware_time > 0: - sys.stdout.write("%lums (firmware) + " % ((firmware_time - loader_time) / 1000)) - if loader_time > 0: - sys.stdout.write("%lums (loader) + " % (loader_time / 1000)) - if initrd_time > 0: - sys.stdout.write("%lums (kernel) + %lums (initrd) + " % (initrd_time / 1000, (userspace_time - initrd_time) / 1000)) - elif kernel_time > 0: - sys.stdout.write("%lums (kernel) + " % (userspace_time / 1000)) - - sys.stdout.write("%lums (userspace) " % ((finish_time - userspace_time) / 1000)) - - if kernel_time > 0: - sys.stdout.write("= %lums\n" % ((firmware_time + finish_time) / 1000)) - else: - sys.stdout.write("= %lums\n" % ((finish_time - userspace_time) / 1000)) - -def blame(): - - data = acquire_time_data() - s = sorted(data, key = lambda i: i[2] - i[1], reverse = True) - - for name, ixt, aet, axt, iet in s: - - if ixt <= 0 or aet <= 0: - continue - - if aet <= ixt: - continue - - sys.stdout.write("%6lums %s\n" % ((aet - ixt) / 1000, name)) - -def plot(): - if cairo is None: - sys.exit("Failed to initilize python-cairo required for 'plot' verb.") - firmware_time, loader_time, kernel_time, initrd_time, userspace_time, finish_time = acquire_start_time() - data = acquire_time_data() - s = sorted(data, key = lambda i: i[1]) - - # Account for kernel and initramfs bars if they exist - if initrd_time > 0: - count = 3 - else: - count = 2 - - for name, ixt, aet, axt, iet in s: - - if (ixt >= userspace_time and ixt <= finish_time) or \ - (aet >= userspace_time and aet <= finish_time) or \ - (axt >= userspace_time and axt <= finish_time): - count += 1 - - border = 100 - bar_height = 20 - bar_space = bar_height * 0.1 - - # 1000px = 10s, 1px = 10ms - width = finish_time/10000 + border*2 - height = count * (bar_height + bar_space) + border * 2 - - if width < 1000: - width = 1000 - - surface = cairo.SVGSurface(sys.stdout, width, height) - context = cairo.Context(surface) - - draw_box(context, 0, 0, width, height, 1, 1, 1) - - context.translate(border + 0.5, border + 0.5) - - context.save() - context.set_line_width(1) - context.set_source_rgb(0.7, 0.7, 0.7) - - for x in range(0, int(finish_time/10000) + 100, 100): - context.move_to(x, 0) - context.line_to(x, height-border*2) - - context.move_to(0, 0) - context.line_to(width-border*2, 0) - - context.move_to(0, height-border*2) - context.line_to(width-border*2, height-border*2) - - context.stroke() - context.restore() - - osrel = "Linux" - if os.path.exists("/etc/os-release"): - for line in open("/etc/os-release"): - if line.startswith('PRETTY_NAME='): - osrel = line[12:] - osrel = osrel.strip('\"\n') - break - - banner = "{} {} ({} {}) {}".format(osrel, *(os.uname()[1:5])) - draw_text(context, 0, -15, banner, hcenter = 0, vcenter = 1) - - for x in range(0, int(finish_time/10000) + 100, 100): - draw_text(context, x, -5, "%lus" % (x/100), vcenter = 0, hcenter = 0) - - y = 0 - - # draw boxes for kernel and initramfs boot time - if initrd_time > 0: - draw_box(context, 0, y, initrd_time/10000, bar_height, 0.7, 0.7, 0.7) - draw_text(context, 10, y + bar_height/2, "kernel", hcenter = 0) - y += bar_height + bar_space - - draw_box(context, initrd_time/10000, y, userspace_time/10000-initrd_time/10000, bar_height, 0.7, 0.7, 0.7) - draw_text(context, initrd_time/10000 + 10, y + bar_height/2, "initramfs", hcenter = 0) - y += bar_height + bar_space - - else: - draw_box(context, 0, y, userspace_time/10000, bar_height, 0.6, 0.6, 0.6) - draw_text(context, 10, y + bar_height/2, "kernel", hcenter = 0) - y += bar_height + bar_space - - draw_box(context, userspace_time/10000, y, finish_time/10000-userspace_time/10000, bar_height, 0.7, 0.7, 0.7) - draw_text(context, userspace_time/10000 + 10, y + bar_height/2, "userspace", hcenter = 0) - y += bar_height + bar_space - - for name, ixt, aet, axt, iet in s: - - drawn = False - left = -1 - - if ixt >= userspace_time and ixt <= finish_time: - - # Activating - a = ixt - b = min(filter(lambda x: x >= ixt, (aet, axt, iet, finish_time))) - ixt - - draw_box(context, a/10000, y, b/10000, bar_height, 1, 0, 0) - drawn = True - - if left < 0: - left = a - - if aet >= userspace_time and aet <= finish_time: - - # Active - a = aet - b = min(filter(lambda x: x >= aet, (axt, iet, finish_time))) - aet - - draw_box(context, a/10000, y, b/10000, bar_height, .8, .6, .6) - drawn = True - - if left < 0: - left = a - - if axt >= userspace_time and axt <= finish_time: - - # Deactivating - a = axt - b = min(filter(lambda x: x >= axt, (iet, finish_time))) - axt - - draw_box(context, a/10000, y, b/10000, bar_height, .6, .4, .4) - drawn = True - - if left < 0: - left = a - - if drawn: - x = left/10000 - - if x < width/2-border: - draw_text(context, x + 10, y + bar_height/2, name, hcenter = 0) - else: - draw_text(context, x - 10, y + bar_height/2, name, hcenter = 1) - - y += bar_height + bar_space - - draw_text(context, 0, height-border*2, "Legend: Red = Activating; Pink = Active; Dark Pink = Deactivating", hcenter = 0, vcenter = -1) - - if initrd_time > 0: - draw_text(context, 0, height-border*2 + bar_height, "Startup finished in %lums (kernel) + %lums (initramfs) + %lums (userspace) = %lums" % ( \ - initrd_time/1000, \ - (userspace_time - initrd_time)/1000, \ - (finish_time - userspace_time)/1000, \ - finish_time/1000), hcenter = 0, vcenter = -1) - else: - draw_text(context, 0, height-border*2 + bar_height, "Startup finished in %lums (kernel) + %lums (userspace) = %lums" % ( \ - userspace_time/1000, \ - (finish_time - userspace_time)/1000, \ - finish_time/1000), hcenter = 0, vcenter = -1) - - surface.finish() - -parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter, - version='systemd-analyze @PACKAGE_VERSION@', - description='Process systemd profiling information', - epilog='''\ -time - print time spent in the kernel before reaching userspace -blame - print list of running units ordered by time to init -plot - output SVG graphic showing service initialization -''') - -parser.add_argument('action', choices=('time', 'blame', 'plot'), - default='time', nargs='?', - help='action to perform (default: time)') -parser.add_argument('--user', action='store_true', - help='use the session bus') - -args = parser.parse_args() - -if args.user: - bus = Gio.BusType.SESSION -else: - bus = Gio.BusType.SYSTEM - -verb = {'time' : time, - 'blame': blame, - 'plot' : plot, - } -verb.get(args.action)() -- 2.30.2