svg.c revision 3ffd4af22052963e7a29431721ee204e634bea75
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright (C) 2009-2013 Intel Corporation
Authors:
Auke Kok <auke-jan.h.kok@intel.com>
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 <http://www.gnu.org/licenses/>.
***/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include "architecture.h"
#include "util.h"
#include "fileio.h"
#include "macro.h"
#include "store.h"
#include "svg.h"
#include "bootchart.h"
#include "list.h"
#include "utf8.h"
#include "fd-util.h"
#define time_to_graph(t) ((t) * arg_scale_x)
#define ps_to_graph(n) ((n) * arg_scale_y)
static const char * const colorwheel[12] = {
"rgb(255,32,32)", // red
"rgb(32,192,192)", // cyan
"rgb(255,128,32)", // orange
"rgb(128,32,192)", // blue-violet
"rgb(255,255,32)", // yellow
"rgb(192,32,128)", // red-violet
"rgb(32,255,32)", // green
"rgb(255,64,32)", // red-orange
"rgb(32,32,255)", // blue
"rgb(255,192,32)", // yellow-orange
"rgb(192,32,192)", // violet
"rgb(32,192,32)" // yellow-green
};
static double idletime = -1.0;
static int pfiltered = 0;
static int pcount = 0;
static int kcount = 0;
static double psize = 0;
static double ksize = 0;
static double esize = 0;
static struct list_sample_data *sampledata;
static struct list_sample_data *prev_sampledata;
double w;
double h;
struct list_sample_data *sampledata_last;
}
/* min width is about 1600px due to the label */
w = ((w < 1600.0) ? 1600.0 : w);
/* height is variable based on pss, psize, ksize */
//fprintf(of, "<g transform=\"translate(10,%d)\">\n", 1000 + 150 + (pcount * 20));
/* write some basic info as a comment, including some help */
/* style sheet */
fprintf(of, " line.idle { stroke: rgb(64,64,64); stroke-dasharray: 10 6; stroke-opacity: 0.7; }\n");
}
const char *cpu;
char *c;
time_t t;
int r;
if (r < 0) {
log_error_errno(r, "Unable to read cmdline: %m");
return r;
}
/* extract root fs so we can find disk model name in sysfs */
/* FIXME: this works only in the simple case */
if (c) {
char rootbdev[4];
char filename[32];
if (r < 0)
}
/* various utsname parameters */
if (r < 0) {
log_error("Error getting uname info\n");
return -errno;
}
/* date */
assert_se(r > 0);
/* CPU type */
if (r < 0)
cpu = "Unknown";
else
if (model)
if (idletime >= 0.0)
else
fprintf(of, "<text class=\"sec\" x=\"20\" y=\"155\">Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered</text>\n",
return 0;
}
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;
struct list_sample_data *sampledata_last;
}
/* outside box, fill */
time_to_graph(0.0),
for (d = graph_start; d <= finalsample;
/* lines for each second */
if (i % 50 == 0)
time_to_graph(d - graph_start),
time_to_graph(d - graph_start),
else if (i % 10 == 0)
time_to_graph(d - graph_start),
time_to_graph(d - graph_start),
else
time_to_graph(d - graph_start),
time_to_graph(d - graph_start),
/* time label */
if (i % 10 == 0)
time_to_graph(d - graph_start),
-5.0, d - graph_start);
i++;
}
}
/* xml comments must not contain "--" */
static char* xml_comment_encode(const char* name) {
char *enc_name, *p;
if (!enc_name)
return NULL;
for (p = enc_name; *p; p++)
if (p[0] == '-' && p[1] == '-')
p[1] = '_';
return enc_name;
}
struct list_sample_data *head,
double graph_start) {
int i;
struct list_sample_data *sampledata_last;
}
/* vsize 1000 == 1000mb */
/* draw some hlines for usable memory sizes */
for (i = 100000; i < 1000000; i += 100000) {
time_to_graph(.0),
kb_to_graph(i),
kb_to_graph(i));
}
/* now plot the graph itself */
i = 1;
int bottom;
int top;
struct ps_sched_struct *cross_place;
bottom = 0;
top = 0;
/* put all the small pss blocks into the bottom */
if (!ps)
continue;
break;
}
break;
}
}
}
fprintf(of, " <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
"rgb(64,64,64)",
/* now plot the ones that are of significant size */
if (!ps)
continue;
break;
}
/* don't draw anything smaller than 2mb */
continue;
fprintf(of, " <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
}
break;
}
fprintf(of, " <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
}
}
i++;
}
/* overlay all the text labels */
i = 1;
int bottom;
int top = 0;
struct ps_sched_struct *prev_sample;
struct ps_sched_struct *cross_place;
/* put all the small pss blocks into the bottom */
if (!ps)
continue;
break;
}
break;
}
}
}
/* now plot the ones that are of significant size */
if (!ps)
continue;
break;
}
/* don't draw anything smaller than 2mb */
/* draw a label with the process / PID */
}
break;
}
}
/* draw a label with the process / PID */
}
}
i++;
}
/* debug output - full data dump */
if (!ps)
continue;
if (!enc_name)
continue;
}
}
}
struct list_sample_data *head,
int n_samples,
double graph_start,
double interval) {
double max = 0.0;
double range;
int max_here = 0;
int i;
int k;
struct list_sample_data *start_sampledata;
struct list_sample_data *stop_sampledata;
/*
* calculate rounding range
*
* We need to round IO data since IO block data is not updated on
* each poll. Applying a smoothing function loses some burst data,
* so keep the smoothing range short.
*/
if (range < 2.0)
/* surrounding box */
/* find the max IO first */
i = 1;
int start;
int stop;
int diff;
double tot;
max_here = i;
}
i++;
}
/* plot bi */
i = 1;
int start;
int stop;
int diff;
double tot;
double pbi = 0;
if (max > 0)
if (pbi > 0.001)
/* labels around highest value */
if (i == max_here)
i++;
}
}
struct list_sample_data *head,
int n_samples,
double graph_start,
double interval) {
double max = 0.0;
double range;
int max_here = 0;
int i;
int k;
struct list_sample_data *start_sampledata;
struct list_sample_data *stop_sampledata;
/*
* calculate rounding range
*
* We need to round IO data since IO block data is not updated on
* each poll. Applying a smoothing function loses some burst data,
* so keep the smoothing range short.
*/
if (range < 2.0)
/* surrounding box */
/* find the max IO first */
i = 0;
int start;
int stop;
int diff;
double tot;
max_here = i;
}
i++;
}
/* plot bo */
i = 1;
pbo = 0;
/ diff;
if (max > 0)
if (pbo > 0.001)
/* labels around highest bo value */
if (i == max_here)
i++;
}
}
static void svg_cpu_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) {
if (cpu_num < 0)
else
/* surrounding box */
/* bars for each sample, proportional to the CPU util. */
int c;
double trt;
double ptrt;
if (cpu_num < 0)
for (c = 0; c < n_cpus; c++)
else
if (cpu_num < 0)
if (trt > 0.0)
if (ptrt > 1.0)
ptrt = 1.0;
if (ptrt > 0.001)
}
}
static void svg_wait_bar(FILE *of, struct list_sample_data *head, int n_cpus, int cpu_num, double graph_start) {
if (cpu_num < 0)
else
/* surrounding box */
/* bars for each sample, proportional to the CPU util. */
int c;
double twt;
double ptwt;
if (cpu_num < 0)
for (c = 0; c < n_cpus; c++)
else
if (cpu_num < 0)
if (twt > 0.0)
if (ptwt > 1.0)
ptwt = 1.0;
if (ptwt > 0.001)
}
}
/* surrounding box */
/* bars for each sample, scale 0-4096 */
}
}
/*
* walk the list of processes and return the next one to be
* painted
*/
/* go deep */
/* find siblings */
/* go back for parent siblings */
for (;;) {
if (!ps)
return ps;
}
return NULL;
}
if (!arg_filter)
return false;
/* can't draw data when there is only 1 sample (need start + stop) */
return true;
/* don't filter kthreadd */
return false;
/* drop stuff that doesn't use any real CPU time */
return true;
return 0;
}
static void svg_do_initcall(FILE *of, struct list_sample_data *head, int count_only, double graph_start) {
double t;
char func[256];
int ret;
int usecs;
/* can't plot initcall when disabled or in relative mode */
if (!arg_initcall || arg_relative) {
kcount = 0;
return;
}
if (!count_only) {
/* surrounding box */
}
kcount = 0;
/*
* Initcall graphing - parses dmesg buffer and displays kernel threads
* This somewhat uses the same methods and scaling to show processes
* but looks a lot simpler. It's overlaid entirely onto the PS graph
* when appropriate.
*/
if (!f)
return;
while (!feof(f)) {
int c;
int z = 0;
char l[256];
continue;
c = sscanf(l, "[%lf] initcall %s %*s %d %*s %d %*s",
if (c != 4) {
/* also parse initcalls done by module loading */
c = sscanf(l, "[%lf] initcall %s %*s %*s %d %*s %d %*s",
if (c != 4)
continue;
}
/* chop the +0xXX/0xXX stuff */
while(func[z] != '+')
z++;
func[z] = 0;
if (count_only) {
/* filter out irrelevant stuff */
if (usecs >= 1000)
kcount++;
continue;
}
if (usecs < 1000)
continue;
/* rect */
ps_to_graph(1));
/* label */
kcount++;
}
}
struct list_sample_data *head,
int n_samples,
int n_cpus,
double graph_start,
double interval) {
int i = 0;
int j = 0;
int pid;
double w = 0.0;
/* surrounding box */
/* pass 2 - ps boxes */
double endtime;
double starttime;
int t;
if (!enc_name)
continue;
/* leave some trace of what we actually filtered etc. */
/* remember where _to_ our children need to draw a line */
/* hook children to our parent coords instead */
/* if this is the last child, we might still need to draw a connecting line */
continue;
}
ps_to_graph(j),
ps_to_graph(1));
/* paint cpu load over these */
t = 1;
struct ps_sched_struct *prev;
/* calculate over interval */
/* this can happen if timekeeping isn't accurate enough */
if (prt > 1.0)
prt = 1.0;
if (wrt > 1.0)
wrt = 1.0;
continue;
ps_to_graph(j),
ps_to_graph(wrt));
ps_to_graph(prt));
t++;
}
/* determine where to display the process name */
/* too small to fit label inside the box */
w = endtime;
else
w = starttime;
/* text label of process name */
fprintf(of, " <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]<tspan class=\"run\">%.03fs</tspan> %s</text>\n",
ps_to_graph(j) + 14.0,
/* paint lines to the parent process */
/* horizontal part */
ps_to_graph(j) + 10.0,
ps_to_graph(j) + 10.0);
/* one vertical line connecting all the horizontal ones up */
ps_to_graph(j) + 10.0,
}
j++; /* count boxes */
}
/* last pass - determine when idle */
/* make sure we start counting from the point where we actually have
* data: assume that bootchart's first sample is when data started
*/
break;
}
/* need to know last node first */
double crt;
double brt;
int c;
int ii;
struct ps_sched_struct *sample_hz;
/* subtract bootchart cpu utilization from total */
crt = 0.0;
for (c = 0; c < n_cpus; c++)
/*
* our definition of "idle":
*
* if for (hz / 2) we've used less CPU than (interval / 2) ...
* defaults to 4.0%, which experimentally, is where atom idles
*/
idletime);
break;
}
i++;
}
}
int n, m;
for (n = 0; n < (int) ELEMENTSOF(top); n++)
/* walk all ps's and setup ptrs */
for (n = 0; n < 10; n++) {
continue;
/* cascade insert */
for (m = 9; m > n; m--)
break;
}
}
for (n = 0; n < 10; n++)
20 + (n * 13),
}
int n, m;
for (n = 0; n < (int) ELEMENTSOF(top); n++)
/* walk all ps's and setup ptrs */
for (n = 0; n < 10; n++) {
continue;
/* cascade insert */
for (m = 9; m > n; m--)
break;
}
}
for (n = 0; n < 10; n++)
20 + (n * 13),
}
const char *build,
struct list_sample_data *head,
int n_samples,
int pscount,
int n_cpus,
double graph_start,
double log_start,
double interval,
int overrun) {
double offset = 7;
int r, c;
sampledata = head;
/* count initcall thread count first */
/* then count processes */
pcount++;
else
pfiltered++;
}
/* after this, we can draw the header with proper sizing */
offset += 7;
offset += 7;
}
if (kcount) {
offset += 7;
}
offset += 7;
if (r < 0)
return r;
if (arg_entropy) {
fprintf(of, "<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset) + ksize + psize);
}
if (arg_pss) {
fprintf(of, "<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset) + ksize + psize + esize);
}
/* fprintf footer */
return 0;
}