From 1f2ecb0393bf071fcd476300e0b3f94726b01b15 Mon Sep 17 00:00:00 2001 From: Daniel Mack Date: Thu, 2 Apr 2015 15:15:43 +0200 Subject: bootchart: kill a bunch of global variables This code is in a confusingly bad shape. Kill a bunch of global variables and pass needed variables around in function calls. --- src/bootchart/bootchart.c | 55 ++-- src/bootchart/bootchart.h | 18 +- src/bootchart/store.c | 34 +-- src/bootchart/store.h | 7 +- src/bootchart/svg.c | 652 +++++++++++++++++++++++----------------------- src/bootchart/svg.h | 12 +- 6 files changed, 397 insertions(+), 381 deletions(-) (limited to 'src') diff --git a/src/bootchart/bootchart.c b/src/bootchart/bootchart.c index 8cb1ee692..95939007b 100644 --- a/src/bootchart/bootchart.c +++ b/src/bootchart/bootchart.c @@ -58,14 +58,6 @@ #include "bootchart.h" #include "list.h" -double graph_start; -double log_start; -struct ps_struct *ps_first; -int pscount; -int cpus; -double interval; -FILE *of = NULL; -int overrun = 0; static int exiting = 0; #define DEFAULT_SAMPLES_LEN 500 @@ -77,20 +69,17 @@ static int exiting = 0; /* graph defaults */ bool arg_entropy = false; -bool initcall = true; +bool arg_initcall = true; bool arg_relative = false; bool arg_filter = true; bool arg_show_cmdline = false; bool arg_show_cgroup = false; bool arg_pss = false; bool arg_percpu = false; -int samples; int arg_samples_len = DEFAULT_SAMPLES_LEN; /* we record len+1 (1 start sample) */ double arg_hz = DEFAULT_HZ; double arg_scale_x = DEFAULT_SCALE_X; double arg_scale_y = DEFAULT_SCALE_Y; -static struct list_sample_data *sampledata; -struct list_sample_data *head; char arg_init_path[PATH_MAX] = DEFAULT_INIT; char arg_output_path[PATH_MAX] = DEFAULT_OUTPUT; @@ -315,6 +304,11 @@ int main(int argc, char *argv[]) { _cleanup_free_ char *build = NULL; _cleanup_close_ int sysfd = -1; _cleanup_closedir_ DIR *proc = NULL; + _cleanup_fclose_ FILE *of = NULL; + double graph_start; + double log_start; + double interval; + struct ps_struct *ps_first; struct sigaction sig = { .sa_handler = signal_handler, }; @@ -323,7 +317,13 @@ int main(int argc, char *argv[]) { char datestr[200]; time_t t = 0; int r; + int pscount = 0; + int n_cpus = 0; + int overrun = 0; + int samples; struct rlimit rlim; + struct list_sample_data *head; + static struct list_sample_data *sampledata; parse_conf(); @@ -364,7 +364,18 @@ int main(int argc, char *argv[]) { interval = (1.0 / arg_hz) * 1000000000.0; - log_uptime(); + if (arg_relative) + graph_start = log_start = gettime_ns(); + else { + struct timespec n; + double uptime; + + clock_gettime(CLOCK_BOOTTIME, &n); + uptime = (n.tv_sec + (n.tv_nsec / (double) NSEC_PER_SEC)); + + log_start = gettime_ns(); + graph_start = log_start - uptime; + } if (graph_start < 0.0) { log_error("Failed to setup graph start time.\n\n" @@ -409,7 +420,7 @@ int main(int argc, char *argv[]) { /* wait for /proc to become available, discarding samples */ if (proc) { - r = log_sample(proc, samples, &sampledata); + r = log_sample(proc, samples, ps_first, &sampledata, &pscount, &n_cpus); if (r < 0) return EXIT_FAILURE; } @@ -475,7 +486,18 @@ int main(int argc, char *argv[]) { return EXIT_FAILURE; } - r = svg_do(strna(build)); + r = svg_do(of, + strna(build), + head, + ps_first, + samples, + pscount, + n_cpus, + graph_start, + log_start, + interval, + overrun); + if (r < 0) { log_error_errno(r, "Error generating svg file: %m\n"); return EXIT_FAILURE; @@ -485,9 +507,6 @@ int main(int argc, char *argv[]) { do_journal_append(output_file); - if (of) - fclose(of); - /* nitpic cleanups */ ps = ps_first->next_ps; while (ps->next_ps) { diff --git a/src/bootchart/bootchart.h b/src/bootchart/bootchart.h index 6e83a99a2..bdb4b0019 100644 --- a/src/bootchart/bootchart.h +++ b/src/bootchart/bootchart.h @@ -103,14 +103,6 @@ struct ps_struct { struct ps_sched_struct *sample; }; -extern int entropy_avail[]; - -extern double graph_start; -extern double log_start; -extern double sampletime[]; -extern struct ps_struct *ps_first; -extern struct block_stat_struct blockstat[]; -extern int pscount; extern bool arg_relative; extern bool arg_filter; extern bool arg_show_cmdline; @@ -118,17 +110,11 @@ extern bool arg_show_cgroup; extern bool arg_pss; extern bool arg_entropy; extern bool arg_percpu; -extern bool initcall; -extern int samples; -extern int cpus; -extern int arg_samples_len; +extern bool arg_initcall; +extern int arg_samples_len; extern double arg_hz; extern double arg_scale_x; extern double arg_scale_y; -extern int overrun; -extern double interval; extern char arg_output_path[PATH_MAX]; extern char arg_init_path[PATH_MAX]; - -extern FILE *of; diff --git a/src/bootchart/store.c b/src/bootchart/store.c index 612510408..b0aab4f25 100644 --- a/src/bootchart/store.c +++ b/src/bootchart/store.c @@ -54,24 +54,6 @@ double gettime_ns(void) { return (n.tv_sec + (n.tv_nsec / (double) NSEC_PER_SEC)); } -static double gettime_up(void) { - struct timespec n; - - clock_gettime(CLOCK_BOOTTIME, &n); - return (n.tv_sec + (n.tv_nsec / (double) NSEC_PER_SEC)); -} - -void log_uptime(void) { - if (arg_relative) - graph_start = log_start = gettime_ns(); - else { - double uptime = gettime_up(); - - log_start = gettime_ns(); - graph_start = log_start - uptime; - } -} - static char *bufgetline(char *buf) { char *c; @@ -105,7 +87,13 @@ static int pid_cmdline_strscpy(int procfd, char *buffer, size_t buf_len, int pid return 0; } -int log_sample(DIR *proc, int sample, struct list_sample_data **ptr) { +int log_sample(DIR *proc, + int sample, + struct ps_struct *ps_first, + struct list_sample_data **ptr, + int *pscount, + int *cpus) { + static int vmstat = -1; static int schedstat = -1; char buf[4096]; @@ -195,8 +183,8 @@ vmstat_next: sampledata->runtime[c] = atoll(rt); sampledata->waittime[c] = atoll(wt); - if (c == cpus) - cpus = c + 1; + if (c == *cpus) + *cpus = c + 1; } schedstat_next: m = bufgetline(m); @@ -263,7 +251,7 @@ schedstat_next: ps->sample->sampledata = sampledata; - pscount++; + (*pscount)++; /* mark our first sample */ ps->first = ps->last = ps->sample; @@ -480,7 +468,7 @@ schedstat_next: catch_rename: /* catch process rename, try to randomize time */ mod = (arg_hz < 4.0) ? 4.0 : (arg_hz / 4.0); - if (((samples - ps->pid) + pid) % (int)(mod) == 0) { + if (((sample - ps->pid) + pid) % (int)(mod) == 0) { /* re-fetch name */ /* get name, start time */ diff --git a/src/bootchart/store.h b/src/bootchart/store.h index bc54f4f63..bbb4796ef 100644 --- a/src/bootchart/store.h +++ b/src/bootchart/store.h @@ -29,4 +29,9 @@ double gettime_ns(void); void log_uptime(void); -int log_sample(DIR *proc, int sample, struct list_sample_data **ptr); +int log_sample(DIR *proc, + int sample, + struct ps_struct *ps_first, + struct list_sample_data **ptr, + int *pscount, + int *cpus); diff --git a/src/bootchart/svg.c b/src/bootchart/svg.c index b031090d2..c89ef8ed5 100644 --- a/src/bootchart/svg.c +++ b/src/bootchart/svg.c @@ -44,10 +44,6 @@ #define kb_to_graph(m) ((m) * arg_scale_y * 0.0001) #define to_color(n) (192.0 - ((n) * 192.0)) -static char str[8092]; - -#define svg(a...) do { snprintf(str, 8092, ## a); fputs(str, of); fflush(of); } while (0) - static const char * const colorwheel[12] = { "rgb(255,32,32)", // red "rgb(32,192,192)", // cyan @@ -72,9 +68,8 @@ static double ksize = 0; static double esize = 0; static struct list_sample_data *sampledata; static struct list_sample_data *prev_sampledata; -extern struct list_sample_data *head; -static void svg_header(void) { +static void svg_header(FILE *of, struct list_sample_data *head, double graph_start) { double w; double h; struct list_sample_data *sampledata_last; @@ -97,60 +92,59 @@ static void svg_header(void) { + (arg_pss ? (100.0 * arg_scale_y) + (arg_scale_y * 7.0) : 0.0) /* pss estimate */ + psize + ksize + esize; - svg("\n"); - svg("\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); - //svg("\n", 1000 + 150 + (pcount * 20)); - svg("\n\n"); + //fprintf(of, "\n", 1000 + 150 + (pcount * 20)); + fprintf(of, "\n\n"); /* write some basic info as a comment, including some help */ - svg("\n"); - svg("\n"); - svg("\n"); - svg("\n"); - svg("\n\n"); - - svg("\n", VERSION); - svg("\n", arg_hz, arg_samples_len); - svg("\n", arg_scale_x, arg_scale_y); - svg("\n", arg_relative, arg_filter); - svg("\n", arg_pss, arg_entropy); - svg("\n\n", arg_output_path, arg_init_path); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n"); + fprintf(of, "\n\n"); + + fprintf(of, "\n", VERSION); + fprintf(of, "\n", arg_hz, arg_samples_len); + fprintf(of, "\n", arg_scale_x, arg_scale_y); + fprintf(of, "\n", arg_relative, arg_filter); + fprintf(of, "\n", arg_pss, arg_entropy); + fprintf(of, "\n\n", arg_output_path, arg_init_path); /* style sheet */ - svg("\n \n\n\n"); + fprintf(of, "\n \n\n\n"); } -static int svg_title(const char *build) { +static int svg_title(FILE *of, const char *build, int pscount, double log_start, int overrun) { _cleanup_free_ char *cmdline = NULL; _cleanup_free_ char *model = NULL; _cleanup_free_ char *buf = NULL; @@ -179,10 +173,8 @@ static int svg_title(const char *build) { snprintf(filename, sizeof(filename), "/sys/block/%s/device/model", rootbdev); r = read_one_line_file(filename, &model); - if (r < 0) { - log_error("Error reading disk model for %s: %m\n", rootbdev); - return r; - } + if (r < 0) + log_warning("Error reading disk model for %s: %m\n", rootbdev); } /* various utsname parameters */ @@ -215,33 +207,30 @@ static int svg_title(const char *build) { if (c) *c = '\0'; - svg("Bootchart for %s - %s\n", - uts.nodename, date); - svg("System: %s %s %s %s\n", - uts.sysname, uts.release, uts.version, uts.machine); - svg("CPU: %s\n", - cpu); - svg("Disk: %s\n", - model); - svg("Boot options: %s\n", - cmdline); - svg("Build: %s\n", - build); - svg("Log start time: %.03fs\n", log_start); - svg("Idle time: "); + fprintf(of, "Bootchart for %s - %s\n", + uts.nodename, date); + fprintf(of, "System: %s %s %s %s\n", + uts.sysname, uts.release, uts.version, uts.machine); + fprintf(of, "CPU: %s\n", cpu); + fprintf(of, "Disk: %s\n", model); + fprintf(of, "Boot options: %s\n", cmdline); + fprintf(of, "Build: %s\n", build); + fprintf(of, "Log start time: %.03fs\n", log_start); + fprintf(of, "Idle time: "); if (idletime >= 0.0) - svg("%.03fs", idletime); + fprintf(of, "%.03fs", idletime); else - svg("Not detected"); - svg("\n"); - svg("Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered\n", - arg_hz, arg_samples_len, overrun, pscount, pfiltered); + fprintf(of, "Not detected"); + + fprintf(of, "\n"); + fprintf(of, "Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered\n", + arg_hz, arg_samples_len, overrun, pscount, pfiltered); return 0; } -static void svg_graph_box(int height) { +static void svg_graph_box(FILE *of, struct list_sample_data *head, int height, double graph_start) { double d = 0.0; int i = 0; double finalsample = 0.0; @@ -255,36 +244,35 @@ static void svg_graph_box(int height) { finalsample = sampledata_last->sampletime; /* outside box, fill */ - svg("\n", - time_to_graph(0.0), - time_to_graph(finalsample - graph_start), - ps_to_graph(height)); + fprintf(of, "\n", + time_to_graph(0.0), + time_to_graph(finalsample - graph_start), + ps_to_graph(height)); for (d = graph_start; d <= finalsample; d += (arg_scale_x < 2.0 ? 60.0 : arg_scale_x < 10.0 ? 1.0 : 0.1)) { /* lines for each second */ if (i % 50 == 0) - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); else if (i % 10 == 0) - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); else - svg(" \n", - time_to_graph(d - graph_start), - time_to_graph(d - graph_start), - ps_to_graph(height)); + fprintf(of, " \n", + time_to_graph(d - graph_start), + time_to_graph(d - graph_start), + ps_to_graph(height)); /* time label */ if (i % 10 == 0) - svg(" %.01fs\n", - time_to_graph(d - graph_start), - -5.0, - d - graph_start); + fprintf(of, " %.01fs\n", + time_to_graph(d - graph_start), + -5.0, d - graph_start); i++; } @@ -305,7 +293,10 @@ static char* xml_comment_encode(const char* name) { return enc_name; } -static void svg_pss_graph(void) { +static void svg_pss_graph(FILE *of, + struct list_sample_data *head, + struct ps_struct *ps_first, + double graph_start) { struct ps_struct *ps; int i; struct list_sample_data *sampledata_last; @@ -316,24 +307,24 @@ static void svg_pss_graph(void) { } - svg("\n\n\n"); + fprintf(of, "\n\n\n"); - svg("\n Memory allocation - Pss\n"); + fprintf(of, "\n Memory allocation - Pss\n"); /* vsize 1000 == 1000mb */ - svg_graph_box(100); + svg_graph_box(of, head, 100, graph_start); /* draw some hlines for usable memory sizes */ for (i = 100000; i < 1000000; i += 100000) { - svg(" \n", + fprintf(of, " \n", time_to_graph(.0), kb_to_graph(i), time_to_graph(sampledata_last->sampletime - graph_start), kb_to_graph(i)); - svg(" %dM\n", - time_to_graph(sampledata_last->sampletime - graph_start) + 5, - kb_to_graph(i), (1000000 - i) / 1000); + fprintf(of, " %dM\n", + time_to_graph(sampledata_last->sampletime - graph_start) + 5, + kb_to_graph(i), (1000000 - i) / 1000); } - svg("\n"); + fprintf(of, "\n"); /* now plot the graph itself */ i = 1; @@ -372,7 +363,7 @@ static void svg_pss_graph(void) { top += ps->sample->pss; } - svg(" \n", + fprintf(of, " \n", "rgb(64,64,64)", time_to_graph(prev_sampledata->sampletime - graph_start), kb_to_graph(1000000.0 - top), @@ -396,7 +387,7 @@ static void svg_pss_graph(void) { if (ps->sample->sampledata == sampledata) { if (ps->sample->pss > (100 * arg_scale_y)) { top = bottom + ps->sample->pss; - svg(" \n", + fprintf(of, " \n", colorwheel[ps->pid % 12], time_to_graph(prev_sampledata->sampletime - graph_start), kb_to_graph(1000000.0 - top), @@ -412,7 +403,7 @@ static void svg_pss_graph(void) { ps->sample = cross_place; if (ps->sample->pss > (100 * arg_scale_y)) { top = bottom + ps->sample->pss; - svg(" \n", + fprintf(of, " \n", colorwheel[ps->pid % 12], time_to_graph(prev_sampledata->sampletime - graph_start), kb_to_graph(1000000.0 - top), @@ -479,7 +470,7 @@ static void svg_pss_graph(void) { top = bottom + ps->sample->pss; /* draw a label with the process / PID */ if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y))) - svg(" %s [%i]\n", + fprintf(of, " %s [%i]\n", time_to_graph(sampledata->sampletime - graph_start), kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), ps->name, @@ -497,11 +488,10 @@ static void svg_pss_graph(void) { top = bottom + ps->sample->pss; /* draw a label with the process / PID */ if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y))) - svg(" %s [%i]\n", - time_to_graph(sampledata->sampletime - graph_start), - kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), - ps->name, - ps->pid); + fprintf(of, " %s [%i]\n", + time_to_graph(sampledata->sampletime - graph_start), + kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)), + ps->name, ps->pid); bottom = top; } } @@ -509,7 +499,7 @@ static void svg_pss_graph(void) { } /* debug output - full data dump */ - svg("\n\n\n"); + fprintf(of, "\n\n\n"); ps = ps_first; while (ps->next_ps) { _cleanup_free_ char *enc_name = NULL; @@ -521,19 +511,24 @@ static void svg_pss_graph(void) { if (!enc_name) continue; - svg("\n"); + fprintf(of, " -->\n"); } } -static void svg_io_bi_bar(void) { +static void svg_io_bi_bar(FILE *of, + struct list_sample_data *head, + int n_samples, + double graph_start, + double interval) { + double max = 0.0; double range; int max_here = 0; @@ -542,9 +537,8 @@ static void svg_io_bi_bar(void) { struct list_sample_data *start_sampledata; struct list_sample_data *stop_sampledata; - svg("\n"); - - svg("IO utilization - read\n"); + fprintf(of, "\n"); + fprintf(of, "IO utilization - read\n"); /* * calculate rounding range @@ -558,7 +552,7 @@ static void svg_io_bi_bar(void) { range = 2.0; /* no smoothing */ /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* find the max IO first */ i = 1; @@ -569,7 +563,7 @@ static void svg_io_bi_bar(void) { double tot; start = MAX(i - ((range / 2) - 1), 0); - stop = MIN(i + (range / 2), samples - 1); + stop = MIN(i + (range / 2), n_samples - 1); diff = (stop - start); start_sampledata = sampledata; @@ -608,7 +602,7 @@ static void svg_io_bi_bar(void) { double pbi = 0; start = MAX(i - ((range / 2) - 1), 0); - stop = MIN(i + (range / 2), samples); + stop = MIN(i + (range / 2), n_samples); diff = (stop - start); start_sampledata = sampledata; @@ -626,25 +620,29 @@ static void svg_io_bi_bar(void) { pbi = tot / max; if (pbi > 0.001) - svg("\n", - time_to_graph(prev_sampledata->sampletime - graph_start), - (arg_scale_y * 5) - (pbi * (arg_scale_y * 5)), - time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), - pbi * (arg_scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (pbi * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + pbi * (arg_scale_y * 5)); /* labels around highest value */ if (i == max_here) { - svg(" %0.2fmb/sec\n", - time_to_graph(sampledata->sampletime - graph_start) + 5, - ((arg_scale_y * 5) - (pbi * (arg_scale_y * 5))) + 15, - max / 1024.0 / (interval / 1000000000.0)); + fprintf(of, " %0.2fmb/sec\n", + time_to_graph(sampledata->sampletime - graph_start) + 5, + ((arg_scale_y * 5) - (pbi * (arg_scale_y * 5))) + 15, + max / 1024.0 / (interval / 1000000000.0)); } i++; prev_sampledata = sampledata; } } -static void svg_io_bo_bar(void) { +static void svg_io_bo_bar(FILE *of, + struct list_sample_data *head, + int n_samples, + double graph_start, + double interval) { double max = 0.0; double range; int max_here = 0; @@ -653,9 +651,8 @@ static void svg_io_bo_bar(void) { struct list_sample_data *start_sampledata; struct list_sample_data *stop_sampledata; - svg("\n"); - - svg("IO utilization - write\n"); + fprintf(of, "\n"); + fprintf(of, "IO utilization - write\n"); /* * calculate rounding range @@ -669,7 +666,7 @@ static void svg_io_bo_bar(void) { range = 2.0; /* no smoothing */ /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* find the max IO first */ i = 0; @@ -680,7 +677,7 @@ static void svg_io_bo_bar(void) { double tot; start = MAX(i - ((range / 2) - 1), 0); - stop = MIN(i + (range / 2), samples - 1); + stop = MIN(i + (range / 2), n_samples - 1); diff = (stop - start); start_sampledata = sampledata; @@ -717,7 +714,7 @@ static void svg_io_bo_bar(void) { pbo = 0; start = MAX(i - ((range / 2) - 1), 0); - stop = MIN(i + (range / 2), samples); + stop = MIN(i + (range / 2), n_samples); diff = (stop - start); start_sampledata = sampledata; @@ -735,34 +732,34 @@ static void svg_io_bo_bar(void) { pbo = tot / max; if (pbo > 0.001) - svg("\n", - time_to_graph(prev_sampledata->sampletime - graph_start), - (arg_scale_y * 5) - (pbo * (arg_scale_y * 5)), - time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), - pbo * (arg_scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (pbo * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + pbo * (arg_scale_y * 5)); /* labels around highest bo value */ if (i == max_here) { - svg(" %0.2fmb/sec\n", - time_to_graph(sampledata->sampletime - graph_start) + 5, - ((arg_scale_y * 5) - (pbo * (arg_scale_y * 5))), - max / 1024.0 / (interval / 1000000000.0)); + fprintf(of, " %0.2fmb/sec\n", + time_to_graph(sampledata->sampletime - graph_start) + 5, + ((arg_scale_y * 5) - (pbo * (arg_scale_y * 5))), + max / 1024.0 / (interval / 1000000000.0)); } i++; prev_sampledata = sampledata; } } -static void svg_cpu_bar(int cpu_num) { +static void svg_cpu_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) { - svg("\n"); + fprintf(of, "\n"); if (cpu_num < 0) - svg("CPU[overall] utilization\n"); + fprintf(of, "CPU[overall] utilization\n"); else - svg("CPU[%d] utilization\n", cpu_num); + fprintf(of, "CPU[%d] utilization\n", cpu_num); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, proportional to the CPU util. */ prev_sampledata = head; @@ -774,7 +771,7 @@ static void svg_cpu_bar(int cpu_num) { ptrt = trt = 0.0; if (cpu_num < 0) - for (c = 0; c < cpus; c++) + for (c = 0; c < n_cpus; c++) trt += sampledata->runtime[c] - prev_sampledata->runtime[c]; else trt = sampledata->runtime[cpu_num] - prev_sampledata->runtime[cpu_num]; @@ -782,7 +779,7 @@ static void svg_cpu_bar(int cpu_num) { trt = trt / 1000000000.0; if (cpu_num < 0) - trt = trt / (double)cpus; + trt = trt / (double)n_cpus; if (trt > 0.0) ptrt = trt / (sampledata->sampletime - prev_sampledata->sampletime); @@ -791,27 +788,27 @@ static void svg_cpu_bar(int cpu_num) { ptrt = 1.0; if (ptrt > 0.001) { - svg("\n", - time_to_graph(prev_sampledata->sampletime - graph_start), - (arg_scale_y * 5) - (ptrt * (arg_scale_y * 5)), - time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), - ptrt * (arg_scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + (arg_scale_y * 5) - (ptrt * (arg_scale_y * 5)), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + ptrt * (arg_scale_y * 5)); } prev_sampledata = sampledata; } } -static void svg_wait_bar(int cpu_num) { +static void svg_wait_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) { - svg("\n"); + fprintf(of, "\n"); if (cpu_num < 0) - svg("CPU[overall] wait\n"); + fprintf(of, "CPU[overall] wait\n"); else - svg("CPU[%d] wait\n", cpu_num); + fprintf(of, "CPU[%d] wait\n", cpu_num); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, proportional to the CPU util. */ prev_sampledata = head; @@ -823,7 +820,7 @@ static void svg_wait_bar(int cpu_num) { ptwt = twt = 0.0; if (cpu_num < 0) - for (c = 0; c < cpus; c++) + for (c = 0; c < n_cpus; c++) twt += sampledata->waittime[c] - prev_sampledata->waittime[c]; else twt = sampledata->waittime[cpu_num] - prev_sampledata->waittime[cpu_num]; @@ -831,7 +828,7 @@ static void svg_wait_bar(int cpu_num) { twt = twt / 1000000000.0; if (cpu_num < 0) - twt = twt / (double)cpus; + twt = twt / (double)n_cpus; if (twt > 0.0) ptwt = twt / (sampledata->sampletime - prev_sampledata->sampletime); @@ -840,38 +837,37 @@ static void svg_wait_bar(int cpu_num) { ptwt = 1.0; if (ptwt > 0.001) { - svg("\n", - time_to_graph(prev_sampledata->sampletime - graph_start), - ((arg_scale_y * 5) - (ptwt * (arg_scale_y * 5))), - time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), - ptwt * (arg_scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + ((arg_scale_y * 5) - (ptwt * (arg_scale_y * 5))), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + ptwt * (arg_scale_y * 5)); } prev_sampledata = sampledata; } } -static void svg_entropy_bar(void) { +static void svg_entropy_bar(FILE *of, struct list_sample_data *head, double graph_start) { - svg("\n"); + fprintf(of, "\n"); - svg("Entropy pool size\n"); + fprintf(of, "Entropy pool size\n"); /* surrounding box */ - svg_graph_box(5); + svg_graph_box(of, head, 5, graph_start); /* bars for each sample, scale 0-4096 */ prev_sampledata = head; LIST_FOREACH_BEFORE(link, sampledata, head) { - /* svg("\n", sampletime[i], entropy_avail[i]); */ - svg("\n", - time_to_graph(prev_sampledata->sampletime - graph_start), - ((arg_scale_y * 5) - ((sampledata->entropy_avail / 4096.) * (arg_scale_y * 5))), - time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), - (sampledata->entropy_avail / 4096.) * (arg_scale_y * 5)); + fprintf(of, "\n", + time_to_graph(prev_sampledata->sampletime - graph_start), + ((arg_scale_y * 5) - ((sampledata->entropy_avail / 4096.) * (arg_scale_y * 5))), + time_to_graph(sampledata->sampletime - prev_sampledata->sampletime), + (sampledata->entropy_avail / 4096.) * (arg_scale_y * 5)); prev_sampledata = sampledata; } } -static struct ps_struct *get_next_ps(struct ps_struct *ps) { +static struct ps_struct *get_next_ps(struct ps_struct *ps, struct ps_struct *ps_first) { /* * walk the list of processes and return the next one to be * painted @@ -919,7 +915,7 @@ static bool ps_filter(struct ps_struct *ps) { return 0; } -static void svg_do_initcall(int count_only) { +static void svg_do_initcall(FILE *of, struct list_sample_data *head, int count_only, double graph_start) { _cleanup_pclose_ FILE *f = NULL; double t; char func[256]; @@ -927,17 +923,16 @@ static void svg_do_initcall(int count_only) { int usecs; /* can't plot initcall when disabled or in relative mode */ - if (!initcall || arg_relative) { + if (!arg_initcall || arg_relative) { kcount = 0; return; } if (!count_only) { - svg("\n"); - - svg("Kernel init threads\n"); + fprintf(of, "\n"); + fprintf(of, "Kernel init threads\n"); /* surrounding box */ - svg_graph_box(kcount); + svg_graph_box(of, head, kcount, graph_start); } kcount = 0; @@ -983,47 +978,52 @@ static void svg_do_initcall(int count_only) { continue; } - svg("\n", - func, t, usecs, ret); + fprintf(of, "\n", + func, t, usecs, ret); if (usecs < 1000) continue; /* rect */ - svg(" \n", - time_to_graph(t - (usecs / 1000000.0)), - ps_to_graph(kcount), - time_to_graph(usecs / 1000000.0), - ps_to_graph(1)); + fprintf(of, " \n", + time_to_graph(t - (usecs / 1000000.0)), + ps_to_graph(kcount), + time_to_graph(usecs / 1000000.0), + ps_to_graph(1)); /* label */ - svg(" %s %.03fs\n", - time_to_graph(t - (usecs / 1000000.0)) + 5, - ps_to_graph(kcount) + 15, - func, - usecs / 1000000.0); + fprintf(of, " %s %.03fs\n", + time_to_graph(t - (usecs / 1000000.0)) + 5, + ps_to_graph(kcount) + 15, + func, usecs / 1000000.0); kcount++; } } -static void svg_ps_bars(void) { +static void svg_ps_bars(FILE *of, + struct list_sample_data *head, + int n_samples, + int n_cpus, + struct ps_struct *ps_first, + double graph_start, + double interval) { + struct ps_struct *ps; int i = 0; int j = 0; int pid; double w = 0.0; - svg("\n"); - - svg("Processes\n"); + fprintf(of, "\n"); + fprintf(of, "Processes\n"); /* surrounding box */ - svg_graph_box(pcount); + svg_graph_box(of, head, pcount, graph_start); /* pass 2 - ps boxes */ ps = ps_first; - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { _cleanup_free_ char *enc_name = NULL, *escaped = NULL; double endtime; double starttime; @@ -1037,8 +1037,8 @@ static void svg_ps_bars(void) { continue; /* leave some trace of what we actually filtered etc. */ - svg("\n", enc_name, ps->pid, - ps->ppid, ps->total); + fprintf(of, "\n", enc_name, ps->pid, + ps->ppid, ps->total); starttime = ps->first->sampledata->sampletime; @@ -1053,20 +1053,20 @@ static void svg_ps_bars(void) { /* if this is the last child, we might still need to draw a connecting line */ if ((!ps->next) && (ps->parent)) - svg(" \n", - ps->parent->pos_x, - ps_to_graph(j-1) + 10.0, /* whee, use the last value here */ - ps->parent->pos_x, - ps->parent->pos_y); + fprintf(of, " \n", + ps->parent->pos_x, + ps_to_graph(j-1) + 10.0, /* whee, use the last value here */ + ps->parent->pos_x, + ps->parent->pos_y); continue; } endtime = ps->last->sampledata->sampletime; - svg(" \n", - time_to_graph(starttime - graph_start), - ps_to_graph(j), - time_to_graph(ps->last->sampledata->sampletime - starttime), - ps_to_graph(1)); + fprintf(of, " \n", + time_to_graph(starttime - graph_start), + ps_to_graph(j), + time_to_graph(ps->last->sampledata->sampletime - starttime), + ps_to_graph(1)); /* paint cpu load over these */ ps->sample = ps->first; @@ -1095,18 +1095,18 @@ static void svg_ps_bars(void) { if ((prt < 0.1) && (wrt < 0.1)) /* =~ 26 (color threshold) */ continue; - svg(" \n", - time_to_graph(prev->sampledata->sampletime - graph_start), - ps_to_graph(j), - time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), - ps_to_graph(wrt)); + fprintf(of, " \n", + time_to_graph(prev->sampledata->sampletime - graph_start), + ps_to_graph(j), + time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), + ps_to_graph(wrt)); /* draw cpu over wait - TODO figure out how/why run + wait > interval */ - svg(" \n", - time_to_graph(prev->sampledata->sampletime - graph_start), - ps_to_graph(j + (1.0 - prt)), - time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), - ps_to_graph(prt)); + fprintf(of, " \n", + time_to_graph(prev->sampledata->sampletime - graph_start), + ps_to_graph(j + (1.0 - prt)), + time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime), + ps_to_graph(prt)); t++; } @@ -1118,34 +1118,34 @@ static void svg_ps_bars(void) { w = starttime; /* text label of process name */ - svg(" %s [%i]%.03fs %s\n", - time_to_graph(w - graph_start) + 5.0, - ps_to_graph(j) + 14.0, - escaped ? escaped : ps->name, - ps->pid, - (ps->last->runtime - ps->first->runtime) / 1000000000.0, - arg_show_cgroup ? ps->cgroup : ""); + fprintf(of, " %s [%i]%.03fs %s\n", + time_to_graph(w - graph_start) + 5.0, + ps_to_graph(j) + 14.0, + escaped ? escaped : ps->name, + ps->pid, + (ps->last->runtime - ps->first->runtime) / 1000000000.0, + arg_show_cgroup ? ps->cgroup : ""); /* paint lines to the parent process */ if (ps->parent) { /* horizontal part */ - svg(" \n", - time_to_graph(starttime - graph_start), - ps_to_graph(j) + 10.0, - ps->parent->pos_x, - ps_to_graph(j) + 10.0); + fprintf(of, " \n", + time_to_graph(starttime - graph_start), + ps_to_graph(j) + 10.0, + ps->parent->pos_x, + ps_to_graph(j) + 10.0); /* one vertical line connecting all the horizontal ones up */ if (!ps->next) - svg(" \n", - ps->parent->pos_x, - ps_to_graph(j) + 10.0, - ps->parent->pos_x, - ps->parent->pos_y); + fprintf(of, " \n", + ps->parent->pos_x, + ps_to_graph(j) + 10.0, + ps->parent->pos_x, + ps->parent->pos_y); } j++; /* count boxes */ - svg("\n"); + fprintf(of, "\n"); } /* last pass - determine when idle */ @@ -1165,7 +1165,7 @@ static void svg_ps_bars(void) { ps->sample = ps->first; i = ps->sample->next->sampledata->counter; - while (ps->sample->next && i<(samples-(arg_hz/2))) { + while (ps->sample->next && i<(n_samples-(arg_hz/2))) { double crt; double brt; int c; @@ -1179,7 +1179,7 @@ static void svg_ps_bars(void) { /* subtract bootchart cpu utilization from total */ crt = 0.0; - for (c = 0; c < cpus; c++) + for (c = 0; c < n_cpus; c++) crt += sample_hz->sampledata->runtime[c] - ps->sample->sampledata->runtime[c]; brt = sample_hz->runtime - ps->sample->runtime; /* @@ -1190,24 +1190,23 @@ static void svg_ps_bars(void) { */ if ((crt - brt) < (interval / 2.0)) { idletime = ps->sample->sampledata->sampletime - graph_start; - svg("\n\n", - idletime); - svg("\n", - time_to_graph(idletime), - -arg_scale_y, - time_to_graph(idletime), - ps_to_graph(pcount) + arg_scale_y); - svg("%.01fs\n", - time_to_graph(idletime) + 5.0, - ps_to_graph(pcount) + arg_scale_y, - idletime); + fprintf(of, "\n\n", idletime); + fprintf(of, "\n", + time_to_graph(idletime), + -arg_scale_y, + time_to_graph(idletime), + ps_to_graph(pcount) + arg_scale_y); + fprintf(of, "%.01fs\n", + time_to_graph(idletime) + 5.0, + ps_to_graph(pcount) + arg_scale_y, + idletime); break; } i++; } } -static void svg_top_ten_cpu(void) { +static void svg_top_ten_cpu(FILE *of, struct ps_struct *ps_first) { struct ps_struct *top[10]; struct ps_struct emptyps = {}; struct ps_struct *ps; @@ -1218,7 +1217,7 @@ static void svg_top_ten_cpu(void) { /* walk all ps's and setup ptrs */ ps = ps_first; - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { for (n = 0; n < 10; n++) { if (ps->total <= top[n]->total) continue; @@ -1230,16 +1229,16 @@ static void svg_top_ten_cpu(void) { } } - svg("Top CPU consumers:\n"); + fprintf(of, "Top CPU consumers:\n"); for (n = 0; n < 10; n++) - svg("%3.03fs - %s [%d]\n", - 20 + (n * 13), - top[n]->total, - top[n]->name, - top[n]->pid); + fprintf(of, "%3.03fs - %s [%d]\n", + 20 + (n * 13), + top[n]->total, + top[n]->name, + top[n]->pid); } -static void svg_top_ten_pss(void) { +static void svg_top_ten_pss(FILE *of, struct ps_struct *ps_first) { struct ps_struct *top[10]; struct ps_struct emptyps = {}; struct ps_struct *ps; @@ -1250,7 +1249,7 @@ static void svg_top_ten_pss(void) { /* walk all ps's and setup ptrs */ ps = ps_first; - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { for (n = 0; n < 10; n++) { if (ps->pss_max <= top[n]->pss_max) continue; @@ -1262,30 +1261,39 @@ static void svg_top_ten_pss(void) { } } - svg("Top PSS consumers:\n"); + fprintf(of, "Top PSS consumers:\n"); for (n = 0; n < 10; n++) - svg("%dK - %s [%d]\n", - 20 + (n * 13), - top[n]->pss_max, - top[n]->name, - top[n]->pid); + fprintf(of, "%dK - %s [%d]\n", + 20 + (n * 13), + top[n]->pss_max, + top[n]->name, + top[n]->pid); } -int svg_do(const char *build) { +int svg_do(FILE *of, + const char *build, + struct list_sample_data *head, + struct ps_struct *ps_first, + int n_samples, + int pscount, + int n_cpus, + double graph_start, + double log_start, + double interval, + int overrun) { + struct ps_struct *ps; double offset = 7; int r, c; - memzero(&str, sizeof(str)); - ps = ps_first; /* count initcall thread count first */ - svg_do_initcall(1); + svg_do_initcall(of, head, 1, graph_start); ksize = (kcount ? ps_to_graph(kcount) + (arg_scale_y * 2) : 0); /* then count processes */ - while ((ps = get_next_ps(ps))) { + while ((ps = get_next_ps(ps, ps_first))) { if (!ps_filter(ps)) pcount++; else @@ -1296,70 +1304,70 @@ int svg_do(const char *build) { esize = (arg_entropy ? arg_scale_y * 7 : 0); /* after this, we can draw the header with proper sizing */ - svg_header(); - svg("\n\n"); + svg_header(of, head, graph_start); + fprintf(of, "\n\n"); - svg("\n"); - svg_io_bi_bar(); - svg("\n\n"); + fprintf(of, "\n"); + svg_io_bi_bar(of, head, n_samples, graph_start, interval); + fprintf(of, "\n\n"); - svg("\n", 400.0 + (arg_scale_y * offset)); - svg_io_bo_bar(); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_io_bo_bar(of, head, n_samples, graph_start, interval); + fprintf(of, "\n\n"); - for (c = -1; c < (arg_percpu ? cpus : 0); c++) { + for (c = -1; c < (arg_percpu ? n_cpus : 0); c++) { offset += 7; - svg("\n", 400.0 + (arg_scale_y * offset)); - svg_cpu_bar(c); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_cpu_bar(of, head, n_cpus, c, graph_start); + fprintf(of, "\n\n"); offset += 7; - svg("\n", 400.0 + (arg_scale_y * offset)); - svg_wait_bar(c); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_wait_bar(of, head, n_cpus, c, graph_start); + fprintf(of, "\n\n"); } if (kcount) { offset += 7; - svg("\n", 400.0 + (arg_scale_y * offset)); - svg_do_initcall(0); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset)); + svg_do_initcall(of, head, 0, graph_start); + fprintf(of, "\n\n"); } offset += 7; - svg("\n", 400.0 + (arg_scale_y * offset) + ksize); - svg_ps_bars(); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize); + svg_ps_bars(of, head, n_samples, n_cpus, ps_first, graph_start, interval); + fprintf(of, "\n\n"); - svg("\n"); - r = svg_title(build); - svg("\n\n"); + fprintf(of, "\n"); + r = svg_title(of, build, pscount, log_start, overrun); + fprintf(of, "\n\n"); if (r < 0) return r; - svg("\n"); - svg_top_ten_cpu(); - svg("\n\n"); + fprintf(of, "\n"); + svg_top_ten_cpu(of, ps_first); + fprintf(of, "\n\n"); if (arg_entropy) { - svg("\n", 400.0 + (arg_scale_y * offset) + ksize + psize); - svg_entropy_bar(); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize + psize); + svg_entropy_bar(of, head, graph_start); + fprintf(of, "\n\n"); } if (arg_pss) { - svg("\n", 400.0 + (arg_scale_y * offset) + ksize + psize + esize); - svg_pss_graph(); - svg("\n\n"); + fprintf(of, "\n", 400.0 + (arg_scale_y * offset) + ksize + psize + esize); + svg_pss_graph(of, head, ps_first, graph_start); + fprintf(of, "\n\n"); - svg("\n"); - svg_top_ten_pss(); - svg("\n\n"); + fprintf(of, "\n"); + svg_top_ten_pss(of, ps_first); + fprintf(of, "\n\n"); } - /* svg footer */ - svg("\n\n"); + /* fprintf footer */ + fprintf(of, "\n\n"); return 0; } diff --git a/src/bootchart/svg.h b/src/bootchart/svg.h index f0fb1a7ce..75efa2261 100644 --- a/src/bootchart/svg.h +++ b/src/bootchart/svg.h @@ -24,4 +24,14 @@ along with systemd; If not, see . ***/ -int svg_do(const char *build); +int svg_do(FILE *of, + const char *build, + struct list_sample_data *head, + struct ps_struct *ps_first, + int n_samples, + int pscount, + int n_cpus, + double graph_start, + double log_start, + double interval, + int overrun); -- cgit v1.2.3