]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/bootchart/svg.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
remove unused includes
[thirdparty/systemd.git] / src / bootchart / svg.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright (C) 2009-2013 Intel Corporation
7
8 Authors:
9 Auke Kok <auke-jan.h.kok@intel.com>
10
11 systemd is free software; you can redistribute it and/or modify it
12 under the terms of the GNU Lesser General Public License as published by
13 the Free Software Foundation; either version 2.1 of the License, or
14 (at your option) any later version.
15
16 systemd is distributed in the hope that it will be useful, but
17 WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
20
21 You should have received a copy of the GNU Lesser General Public License
22 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 ***/
24
25 #include <stdio.h>
26 #include <string.h>
27 #include <time.h>
28 #include <limits.h>
29 #include <unistd.h>
30 #include <sys/utsname.h>
31 #include <fcntl.h>
32
33 #include "util.h"
34 #include "macro.h"
35 #include "store.h"
36 #include "svg.h"
37 #include "bootchart.h"
38 #include "list.h"
39 #include "utf8.h"
40
41 #define time_to_graph(t) ((t) * arg_scale_x)
42 #define ps_to_graph(n) ((n) * arg_scale_y)
43 #define kb_to_graph(m) ((m) * arg_scale_y * 0.0001)
44 #define to_color(n) (192.0 - ((n) * 192.0))
45
46 static char str[8092];
47
48 #define svg(a...) do { snprintf(str, 8092, ## a); fputs(str, of); fflush(of); } while (0)
49
50 static const char * const colorwheel[12] = {
51 "rgb(255,32,32)", // red
52 "rgb(32,192,192)", // cyan
53 "rgb(255,128,32)", // orange
54 "rgb(128,32,192)", // blue-violet
55 "rgb(255,255,32)", // yellow
56 "rgb(192,32,128)", // red-violet
57 "rgb(32,255,32)", // green
58 "rgb(255,64,32)", // red-orange
59 "rgb(32,32,255)", // blue
60 "rgb(255,192,32)", // yellow-orange
61 "rgb(192,32,192)", // violet
62 "rgb(32,192,32)" // yellow-green
63 };
64
65 static double idletime = -1.0;
66 static int pfiltered = 0;
67 static int pcount = 0;
68 static int kcount = 0;
69 static double psize = 0;
70 static double ksize = 0;
71 static double esize = 0;
72 static struct list_sample_data *sampledata;
73 static struct list_sample_data *prev_sampledata;
74 extern struct list_sample_data *head;
75
76 static void svg_header(void) {
77 double w;
78 double h;
79 struct list_sample_data *sampledata_last;
80
81 assert(head);
82
83 sampledata = head;
84 LIST_FIND_TAIL(link, sampledata, head);
85 sampledata_last = head;
86 LIST_FOREACH_BEFORE(link, sampledata, head) {
87 sampledata_last = sampledata;
88 }
89
90 /* min width is about 1600px due to the label */
91 w = 150.0 + 10.0 + time_to_graph(sampledata_last->sampletime - graph_start);
92 w = ((w < 1600.0) ? 1600.0 : w);
93
94 /* height is variable based on pss, psize, ksize */
95 h = 400.0 + (arg_scale_y * 30.0) /* base graphs and title */
96 + (arg_pss ? (100.0 * arg_scale_y) + (arg_scale_y * 7.0) : 0.0) /* pss estimate */
97 + psize + ksize + esize;
98
99 svg("<?xml version=\"1.0\" standalone=\"no\"?>\n");
100 svg("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" ");
101 svg("\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
102
103 //svg("<g transform=\"translate(10,%d)\">\n", 1000 + 150 + (pcount * 20));
104 svg("<svg width=\"%.0fpx\" height=\"%.0fpx\" version=\"1.1\" ",
105 w, h);
106 svg("xmlns=\"http://www.w3.org/2000/svg\">\n\n");
107
108 /* write some basic info as a comment, including some help */
109 svg("<!-- This file is a bootchart SVG file. It is best rendered in a browser -->\n");
110 svg("<!-- such as Chrome, Chromium, or Firefox. Other applications that -->\n");
111 svg("<!-- render these files properly but more slowly are ImageMagick, gimp, -->\n");
112 svg("<!-- inkscape, etc. To display the files on your system, just point -->\n");
113 svg("<!-- your browser to file:///run/log/ and click. This bootchart was -->\n\n");
114
115 svg("<!-- generated by bootchart version %s, running with options: -->\n", VERSION);
116 svg("<!-- hz=\"%f\" n=\"%d\" -->\n", arg_hz, arg_samples_len);
117 svg("<!-- x=\"%f\" y=\"%f\" -->\n", arg_scale_x, arg_scale_y);
118 svg("<!-- rel=\"%d\" f=\"%d\" -->\n", arg_relative, arg_filter);
119 svg("<!-- p=\"%d\" e=\"%d\" -->\n", arg_pss, arg_entropy);
120 svg("<!-- o=\"%s\" i=\"%s\" -->\n\n", arg_output_path, arg_init_path);
121
122 /* style sheet */
123 svg("<defs>\n <style type=\"text/css\">\n <![CDATA[\n");
124
125 svg(" rect { stroke-width: 1; }\n");
126 svg(" rect.bg { fill: rgb(255,255,255); }\n");
127 svg(" rect.cpu { fill: rgb(64,64,240); stroke-width: 0; fill-opacity: 0.7; }\n");
128 svg(" rect.wait { fill: rgb(240,240,0); stroke-width: 0; fill-opacity: 0.7; }\n");
129 svg(" rect.bi { fill: rgb(240,128,128); stroke-width: 0; fill-opacity: 0.7; }\n");
130 svg(" rect.bo { fill: rgb(192,64,64); stroke-width: 0; fill-opacity: 0.7; }\n");
131 svg(" rect.ps { fill: rgb(192,192,192); stroke: rgb(128,128,128); fill-opacity: 0.7; }\n");
132 svg(" rect.krnl { fill: rgb(240,240,0); stroke: rgb(128,128,128); fill-opacity: 0.7; }\n");
133 svg(" rect.box { fill: rgb(240,240,240); stroke: rgb(192,192,192); }\n");
134 svg(" rect.clrw { stroke-width: 0; fill-opacity: 0.7;}\n");
135 svg(" line { stroke: rgb(64,64,64); stroke-width: 1; }\n");
136 svg("// line.sec1 { }\n");
137 svg(" line.sec5 { stroke-width: 2; }\n");
138 svg(" line.sec01 { stroke: rgb(224,224,224); stroke-width: 1; }\n");
139 svg(" line.dot { stroke-dasharray: 2 4; }\n");
140 svg(" line.idle { stroke: rgb(64,64,64); stroke-dasharray: 10 6; stroke-opacity: 0.7; }\n");
141
142 svg(" .run { font-size: 8; font-style: italic; }\n");
143 svg(" text { font-family: Verdana, Helvetica; font-size: 10; }\n");
144 svg(" text.sec { font-size: 8; }\n");
145 svg(" text.t1 { font-size: 24; }\n");
146 svg(" text.t2 { font-size: 12; }\n");
147 svg(" text.idle { font-size: 18; }\n");
148
149 svg(" ]]>\n </style>\n</defs>\n\n");
150 }
151
152 static void svg_title(const char *build) {
153 char cmdline[256] = "";
154 char filename[PATH_MAX];
155 char buf[256];
156 char rootbdev[16] = "Unknown";
157 char model[256] = "Unknown";
158 char date[256] = "Unknown";
159 char cpu[256] = "Unknown";
160 char *c;
161 FILE *f;
162 time_t t;
163 int fd, r;
164 struct utsname uts;
165
166 /* grab /proc/cmdline */
167 fd = openat(procfd, "cmdline", O_RDONLY);
168 f = fdopen(fd, "r");
169 if (f) {
170 if (!fgets(cmdline, 255, f))
171 sprintf(cmdline, "Unknown");
172 fclose(f);
173 }
174
175 /* extract root fs so we can find disk model name in sysfs */
176 /* FIXME: this works only in the simple case */
177 c = strstr(cmdline, "root=/dev/");
178 if (c) {
179 strncpy(rootbdev, &c[10], 3);
180 rootbdev[3] = '\0';
181 sprintf(filename, "block/%s/device/model", rootbdev);
182 fd = openat(sysfd, filename, O_RDONLY);
183 f = fdopen(fd, "r");
184 if (f) {
185 if (!fgets(model, 255, f))
186 fprintf(stderr, "Error reading disk model for %s\n", rootbdev);
187 fclose(f);
188 }
189 }
190
191 /* various utsname parameters */
192 if (uname(&uts))
193 fprintf(stderr, "Error getting uname info\n");
194
195 /* date */
196 t = time(NULL);
197 r = strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", localtime(&t));
198 assert_se(r > 0);
199
200 /* CPU type */
201 fd = openat(procfd, "cpuinfo", O_RDONLY);
202 f = fdopen(fd, "r");
203 if (f) {
204 while (fgets(buf, 255, f)) {
205 if (strstr(buf, "model name")) {
206 strncpy(cpu, &buf[13], 255);
207 break;
208 }
209 }
210 fclose(f);
211 }
212
213 svg("<text class=\"t1\" x=\"0\" y=\"30\">Bootchart for %s - %s</text>\n",
214 uts.nodename, date);
215 svg("<text class=\"t2\" x=\"20\" y=\"50\">System: %s %s %s %s</text>\n",
216 uts.sysname, uts.release, uts.version, uts.machine);
217 svg("<text class=\"t2\" x=\"20\" y=\"65\">CPU: %s</text>\n",
218 cpu);
219 svg("<text class=\"t2\" x=\"20\" y=\"80\">Disk: %s</text>\n",
220 model);
221 svg("<text class=\"t2\" x=\"20\" y=\"95\">Boot options: %s</text>\n",
222 cmdline);
223 svg("<text class=\"t2\" x=\"20\" y=\"110\">Build: %s</text>\n",
224 build);
225 svg("<text class=\"t2\" x=\"20\" y=\"125\">Log start time: %.03fs</text>\n", log_start);
226 svg("<text class=\"t2\" x=\"20\" y=\"140\">Idle time: ");
227
228 if (idletime >= 0.0)
229 svg("%.03fs", idletime);
230 else
231 svg("Not detected");
232 svg("</text>\n");
233 svg("<text class=\"sec\" x=\"20\" y=\"155\">Graph data: %.03f samples/sec, recorded %i total, dropped %i samples, %i processes, %i filtered</text>\n",
234 arg_hz, arg_samples_len, overrun, pscount, pfiltered);
235 }
236
237 static void svg_graph_box(int height) {
238 double d = 0.0;
239 int i = 0;
240 double finalsample = 0.0;
241 struct list_sample_data *sampledata_last;
242
243 sampledata_last = head;
244 LIST_FOREACH_BEFORE(link, sampledata, head) {
245 sampledata_last = sampledata;
246 }
247
248 finalsample = sampledata_last->sampletime;
249
250 /* outside box, fill */
251 svg("<rect class=\"box\" x=\"%.03f\" y=\"0\" width=\"%.03f\" height=\"%.03f\" />\n",
252 time_to_graph(0.0),
253 time_to_graph(finalsample - graph_start),
254 ps_to_graph(height));
255
256 for (d = graph_start; d <= finalsample;
257 d += (arg_scale_x < 2.0 ? 60.0 : arg_scale_x < 10.0 ? 1.0 : 0.1)) {
258 /* lines for each second */
259 if (i % 50 == 0)
260 svg(" <line class=\"sec5\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
261 time_to_graph(d - graph_start),
262 time_to_graph(d - graph_start),
263 ps_to_graph(height));
264 else if (i % 10 == 0)
265 svg(" <line class=\"sec1\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
266 time_to_graph(d - graph_start),
267 time_to_graph(d - graph_start),
268 ps_to_graph(height));
269 else
270 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"0\" x2=\"%.03f\" y2=\"%.03f\" />\n",
271 time_to_graph(d - graph_start),
272 time_to_graph(d - graph_start),
273 ps_to_graph(height));
274
275 /* time label */
276 if (i % 10 == 0)
277 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\" >%.01fs</text>\n",
278 time_to_graph(d - graph_start),
279 -5.0,
280 d - graph_start);
281
282 i++;
283 }
284 }
285
286 /* xml comments must not contain "--" */
287 static char* xml_comment_encode(const char* name) {
288 char *enc_name, *p;
289
290 enc_name = strdup(name);
291 if (!enc_name)
292 return NULL;
293
294 for (p = enc_name; *p; p++)
295 if (p[0] == '-' && p[1] == '-')
296 p[1] = '_';
297
298 return enc_name;
299 }
300
301 static void svg_pss_graph(void) {
302 struct ps_struct *ps;
303 int i;
304 struct list_sample_data *sampledata_last;
305
306 sampledata_last = head;
307 LIST_FOREACH_BEFORE(link, sampledata, head) {
308 sampledata_last = sampledata;
309 }
310
311
312 svg("\n\n<!-- Pss memory size graph -->\n");
313
314 svg("\n <text class=\"t2\" x=\"5\" y=\"-15\">Memory allocation - Pss</text>\n");
315
316 /* vsize 1000 == 1000mb */
317 svg_graph_box(100);
318 /* draw some hlines for usable memory sizes */
319 for (i = 100000; i < 1000000; i += 100000) {
320 svg(" <line class=\"sec01\" x1=\"%.03f\" y1=\"%.0f\" x2=\"%.03f\" y2=\"%.0f\"/>\n",
321 time_to_graph(.0),
322 kb_to_graph(i),
323 time_to_graph(sampledata_last->sampletime - graph_start),
324 kb_to_graph(i));
325 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.0f\">%dM</text>\n",
326 time_to_graph(sampledata_last->sampletime - graph_start) + 5,
327 kb_to_graph(i), (1000000 - i) / 1000);
328 }
329 svg("\n");
330
331 /* now plot the graph itself */
332 i = 1;
333 prev_sampledata = head;
334 LIST_FOREACH_BEFORE(link, sampledata, head) {
335 int bottom;
336 int top;
337 struct ps_sched_struct *cross_place;
338
339 bottom = 0;
340 top = 0;
341
342 /* put all the small pss blocks into the bottom */
343 ps = ps_first;
344 while (ps->next_ps) {
345 ps = ps->next_ps;
346 if (!ps)
347 continue;
348 ps->sample = ps->first;
349 while (ps->sample->next) {
350 ps->sample = ps->sample->next;
351 if (ps->sample->sampledata == sampledata)
352 break;
353 }
354 if (ps->sample->sampledata == sampledata) {
355 if (ps->sample->pss <= (100 * arg_scale_y))
356 top += ps->sample->pss;
357 break;
358 }
359 }
360 while (ps->sample->cross) {
361 cross_place = ps->sample->cross;
362 ps = ps->sample->cross->ps_new;
363 ps->sample = cross_place;
364 if (ps->sample->pss <= (100 * arg_scale_y))
365 top += ps->sample->pss;
366 }
367
368 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
369 "rgb(64,64,64)",
370 time_to_graph(prev_sampledata->sampletime - graph_start),
371 kb_to_graph(1000000.0 - top),
372 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
373 kb_to_graph(top - bottom));
374 bottom = top;
375
376 /* now plot the ones that are of significant size */
377 ps = ps_first;
378 while (ps->next_ps) {
379 ps = ps->next_ps;
380 if (!ps)
381 continue;
382 ps->sample = ps->first;
383 while (ps->sample->next) {
384 ps->sample = ps->sample->next;
385 if (ps->sample->sampledata == sampledata)
386 break;
387 }
388 /* don't draw anything smaller than 2mb */
389 if (ps->sample->sampledata == sampledata) {
390 if (ps->sample->pss > (100 * arg_scale_y)) {
391 top = bottom + ps->sample->pss;
392 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
393 colorwheel[ps->pid % 12],
394 time_to_graph(prev_sampledata->sampletime - graph_start),
395 kb_to_graph(1000000.0 - top),
396 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
397 kb_to_graph(top - bottom));
398 bottom = top;
399 }
400 break;
401 }
402 }
403 while ((cross_place = ps->sample->cross)) {
404 ps = ps->sample->cross->ps_new;
405 ps->sample = cross_place;
406 if (ps->sample->pss > (100 * arg_scale_y)) {
407 top = bottom + ps->sample->pss;
408 svg(" <rect class=\"clrw\" style=\"fill: %s\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
409 colorwheel[ps->pid % 12],
410 time_to_graph(prev_sampledata->sampletime - graph_start),
411 kb_to_graph(1000000.0 - top),
412 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
413 kb_to_graph(top - bottom));
414 bottom = top;
415 }
416 }
417 prev_sampledata = sampledata;
418 i++;
419 }
420
421 /* overlay all the text labels */
422 i = 1;
423 LIST_FOREACH_BEFORE(link, sampledata, head) {
424 int bottom;
425 int top = 0;
426 struct ps_sched_struct *prev_sample;
427 struct ps_sched_struct *cross_place;
428
429 /* put all the small pss blocks into the bottom */
430 ps = ps_first->next_ps;
431 while (ps->next_ps) {
432 ps = ps->next_ps;
433 if (!ps)
434 continue;
435 ps->sample = ps->first;
436 while (ps->sample->next) {
437 ps->sample = ps->sample->next;
438 if (ps->sample->sampledata == sampledata)
439 break;
440 }
441 if (ps->sample->sampledata == sampledata) {
442 if (ps->sample->pss <= (100 * arg_scale_y))
443 top += ps->sample->pss;
444 break;
445 }
446 }
447 while ((cross_place = ps->sample->cross)) {
448 ps = ps->sample->cross->ps_new;
449 ps->sample = cross_place;
450 if (ps->sample->pss <= (100 * arg_scale_y))
451 top += ps->sample->pss;
452 }
453 bottom = top;
454
455 /* now plot the ones that are of significant size */
456 ps = ps_first;
457 while (ps->next_ps) {
458 prev_sample = ps->sample;
459 ps = ps->next_ps;
460 if (!ps)
461 continue;
462 ps->sample = ps->first;
463 while (ps->sample->next) {
464 prev_sample = ps->sample;
465 ps->sample = ps->sample->next;
466 if (ps->sample->sampledata == sampledata)
467 break;
468 }
469 /* don't draw anything smaller than 2mb */
470 if (ps->sample->sampledata == sampledata) {
471 if (ps->sample->pss > (100 * arg_scale_y)) {
472 top = bottom + ps->sample->pss;
473 /* draw a label with the process / PID */
474 if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y)))
475 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]</text>\n",
476 time_to_graph(sampledata->sampletime - graph_start),
477 kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)),
478 ps->name,
479 ps->pid);
480 bottom = top;
481 }
482 break;
483 }
484 }
485 while ((cross_place = ps->sample->cross)) {
486 ps = ps->sample->cross->ps_new;
487 ps->sample = cross_place;
488 prev_sample = ps->sample->prev;
489 if (ps->sample->pss > (100 * arg_scale_y)) {
490 top = bottom + ps->sample->pss;
491 /* draw a label with the process / PID */
492 if ((i == 1) || (prev_sample->pss <= (100 * arg_scale_y)))
493 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]</text>\n",
494 time_to_graph(sampledata->sampletime - graph_start),
495 kb_to_graph(1000000.0 - bottom - ((top - bottom) / 2)),
496 ps->name,
497 ps->pid);
498 bottom = top;
499 }
500 }
501 i++;
502 }
503
504 /* debug output - full data dump */
505 svg("\n\n<!-- PSS map - csv format -->\n");
506 ps = ps_first;
507 while (ps->next_ps) {
508 _cleanup_free_ char *enc_name = NULL;
509 ps = ps->next_ps;
510 if (!ps)
511 continue;
512
513 enc_name = xml_comment_encode(ps->name);
514 if (!enc_name)
515 continue;
516
517 svg("<!-- %s [%d] pss=", enc_name, ps->pid);
518
519 ps->sample = ps->first;
520 while (ps->sample->next) {
521 ps->sample = ps->sample->next;
522 svg("%d," , ps->sample->pss);
523 }
524 svg(" -->\n");
525 }
526
527 }
528
529 static void svg_io_bi_bar(void) {
530 double max = 0.0;
531 double range;
532 int max_here = 0;
533 int i;
534 int k;
535 struct list_sample_data *start_sampledata;
536 struct list_sample_data *stop_sampledata;
537
538 svg("<!-- IO utilization graph - In -->\n");
539
540 svg("<text class=\"t2\" x=\"5\" y=\"-15\">IO utilization - read</text>\n");
541
542 /*
543 * calculate rounding range
544 *
545 * We need to round IO data since IO block data is not updated on
546 * each poll. Applying a smoothing function loses some burst data,
547 * so keep the smoothing range short.
548 */
549 range = 0.25 / (1.0 / arg_hz);
550 if (range < 2.0)
551 range = 2.0; /* no smoothing */
552
553 /* surrounding box */
554 svg_graph_box(5);
555
556 /* find the max IO first */
557 i = 1;
558 LIST_FOREACH_BEFORE(link, sampledata, head) {
559 int start;
560 int stop;
561 int diff;
562 double tot;
563
564 start = MAX(i - ((range / 2) - 1), 0);
565 stop = MIN(i + (range / 2), samples - 1);
566 diff = (stop - start);
567
568 start_sampledata = sampledata;
569 stop_sampledata = sampledata;
570
571 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
572 start_sampledata = start_sampledata->link_next;
573 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
574 stop_sampledata = stop_sampledata->link_prev;
575
576 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
577 / diff;
578
579 if (tot > max) {
580 max = tot;
581 max_here = i;
582 }
583
584 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
585 / diff;
586
587 if (tot > max)
588 max = tot;
589
590 i++;
591 }
592
593 /* plot bi */
594 i = 1;
595 prev_sampledata = head;
596 LIST_FOREACH_BEFORE(link, sampledata, head) {
597 int start;
598 int stop;
599 int diff;
600 double tot;
601 double pbi = 0;
602
603 start = MAX(i - ((range / 2) - 1), 0);
604 stop = MIN(i + (range / 2), samples);
605 diff = (stop - start);
606
607 start_sampledata = sampledata;
608 stop_sampledata = sampledata;
609
610 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
611 start_sampledata = start_sampledata->link_next;
612 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
613 stop_sampledata = stop_sampledata->link_prev;
614
615 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
616 / diff;
617
618 if (max > 0)
619 pbi = tot / max;
620
621 if (pbi > 0.001)
622 svg("<rect class=\"bi\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
623 time_to_graph(prev_sampledata->sampletime - graph_start),
624 (arg_scale_y * 5) - (pbi * (arg_scale_y * 5)),
625 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
626 pbi * (arg_scale_y * 5));
627
628 /* labels around highest value */
629 if (i == max_here) {
630 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\">%0.2fmb/sec</text>\n",
631 time_to_graph(sampledata->sampletime - graph_start) + 5,
632 ((arg_scale_y * 5) - (pbi * (arg_scale_y * 5))) + 15,
633 max / 1024.0 / (interval / 1000000000.0));
634 }
635 i++;
636 prev_sampledata = sampledata;
637 }
638 }
639
640 static void svg_io_bo_bar(void) {
641 double max = 0.0;
642 double range;
643 int max_here = 0;
644 int i;
645 int k;
646 struct list_sample_data *start_sampledata;
647 struct list_sample_data *stop_sampledata;
648
649 svg("<!-- IO utilization graph - out -->\n");
650
651 svg("<text class=\"t2\" x=\"5\" y=\"-15\">IO utilization - write</text>\n");
652
653 /*
654 * calculate rounding range
655 *
656 * We need to round IO data since IO block data is not updated on
657 * each poll. Applying a smoothing function loses some burst data,
658 * so keep the smoothing range short.
659 */
660 range = 0.25 / (1.0 / arg_hz);
661 if (range < 2.0)
662 range = 2.0; /* no smoothing */
663
664 /* surrounding box */
665 svg_graph_box(5);
666
667 /* find the max IO first */
668 i = 0;
669 LIST_FOREACH_BEFORE(link, sampledata, head) {
670 int start;
671 int stop;
672 int diff;
673 double tot;
674
675 start = MAX(i - ((range / 2) - 1), 0);
676 stop = MIN(i + (range / 2), samples - 1);
677 diff = (stop - start);
678
679 start_sampledata = sampledata;
680 stop_sampledata = sampledata;
681
682 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
683 start_sampledata = start_sampledata->link_next;
684 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
685 stop_sampledata = stop_sampledata->link_prev;
686
687 tot = (double)(stop_sampledata->blockstat.bi - start_sampledata->blockstat.bi)
688 / diff;
689 if (tot > max)
690 max = tot;
691 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
692 / diff;
693 if (tot > max) {
694 max = tot;
695 max_here = i;
696 }
697 i++;
698 }
699
700 /* plot bo */
701 prev_sampledata = head;
702 i=1;
703 LIST_FOREACH_BEFORE(link, sampledata, head) {
704 int start;
705 int stop;
706 int diff;
707 double tot;
708 double pbo;
709
710 pbo = 0;
711
712 start = MAX(i - ((range / 2) - 1), 0);
713 stop = MIN(i + (range / 2), samples);
714 diff = (stop - start);
715
716 start_sampledata = sampledata;
717 stop_sampledata = sampledata;
718
719 for (k=0;(k<((range/2)-1))&&(start_sampledata->link_next);k++)
720 start_sampledata = start_sampledata->link_next;
721 for (k=0;(k<(range/2))&&(stop_sampledata->link_prev);k++)
722 stop_sampledata = stop_sampledata->link_prev;
723
724 tot = (double)(stop_sampledata->blockstat.bo - start_sampledata->blockstat.bo)
725 / diff;
726
727 if (max > 0)
728 pbo = tot / max;
729
730 if (pbo > 0.001)
731 svg("<rect class=\"bo\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
732 time_to_graph(prev_sampledata->sampletime - graph_start),
733 (arg_scale_y * 5) - (pbo * (arg_scale_y * 5)),
734 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
735 pbo * (arg_scale_y * 5));
736
737 /* labels around highest bo value */
738 if (i == max_here) {
739 svg(" <text class=\"sec\" x=\"%.03f\" y=\"%.03f\">%0.2fmb/sec</text>\n",
740 time_to_graph(sampledata->sampletime - graph_start) + 5,
741 ((arg_scale_y * 5) - (pbo * (arg_scale_y * 5))),
742 max / 1024.0 / (interval / 1000000000.0));
743 }
744 i++;
745 prev_sampledata = sampledata;
746 }
747 }
748
749 static void svg_cpu_bar(int cpu_num) {
750
751 svg("<!-- CPU utilization graph -->\n");
752
753 if (cpu_num < 0)
754 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU[overall] utilization</text>\n");
755 else
756 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU[%d] utilization</text>\n", cpu_num);
757 /* surrounding box */
758 svg_graph_box(5);
759
760 /* bars for each sample, proportional to the CPU util. */
761 prev_sampledata = head;
762 LIST_FOREACH_BEFORE(link, sampledata, head) {
763 int c;
764 double trt;
765 double ptrt;
766
767 ptrt = trt = 0.0;
768
769 if (cpu_num < 0)
770 for (c = 0; c < cpus; c++)
771 trt += sampledata->runtime[c] - prev_sampledata->runtime[c];
772 else
773 trt = sampledata->runtime[cpu_num] - prev_sampledata->runtime[cpu_num];
774
775 trt = trt / 1000000000.0;
776
777 if (cpu_num < 0)
778 trt = trt / (double)cpus;
779
780 if (trt > 0.0)
781 ptrt = trt / (sampledata->sampletime - prev_sampledata->sampletime);
782
783 if (ptrt > 1.0)
784 ptrt = 1.0;
785
786 if (ptrt > 0.001) {
787 svg("<rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
788 time_to_graph(prev_sampledata->sampletime - graph_start),
789 (arg_scale_y * 5) - (ptrt * (arg_scale_y * 5)),
790 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
791 ptrt * (arg_scale_y * 5));
792 }
793 prev_sampledata = sampledata;
794 }
795 }
796
797 static void svg_wait_bar(int cpu_num) {
798
799 svg("<!-- Wait time aggregation box -->\n");
800
801 if (cpu_num < 0)
802 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU[overall] wait</text>\n");
803 else
804 svg("<text class=\"t2\" x=\"5\" y=\"-15\">CPU[%d] wait</text>\n", cpu_num);
805
806 /* surrounding box */
807 svg_graph_box(5);
808
809 /* bars for each sample, proportional to the CPU util. */
810 prev_sampledata = head;
811 LIST_FOREACH_BEFORE(link, sampledata, head) {
812 int c;
813 double twt;
814 double ptwt;
815
816 ptwt = twt = 0.0;
817
818 if (cpu_num < 0)
819 for (c = 0; c < cpus; c++)
820 twt += sampledata->waittime[c] - prev_sampledata->waittime[c];
821 else
822 twt = sampledata->waittime[cpu_num] - prev_sampledata->waittime[cpu_num];
823
824 twt = twt / 1000000000.0;
825
826 if (cpu_num < 0)
827 twt = twt / (double)cpus;
828
829 if (twt > 0.0)
830 ptwt = twt / (sampledata->sampletime - prev_sampledata->sampletime);
831
832 if (ptwt > 1.0)
833 ptwt = 1.0;
834
835 if (ptwt > 0.001) {
836 svg("<rect class=\"wait\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
837 time_to_graph(prev_sampledata->sampletime - graph_start),
838 ((arg_scale_y * 5) - (ptwt * (arg_scale_y * 5))),
839 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
840 ptwt * (arg_scale_y * 5));
841 }
842 prev_sampledata = sampledata;
843 }
844 }
845
846 static void svg_entropy_bar(void) {
847
848 svg("<!-- entropy pool graph -->\n");
849
850 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Entropy pool size</text>\n");
851 /* surrounding box */
852 svg_graph_box(5);
853
854 /* bars for each sample, scale 0-4096 */
855 prev_sampledata = head;
856 LIST_FOREACH_BEFORE(link, sampledata, head) {
857 /* svg("<!-- entropy %.03f %i -->\n", sampletime[i], entropy_avail[i]); */
858 svg("<rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
859 time_to_graph(prev_sampledata->sampletime - graph_start),
860 ((arg_scale_y * 5) - ((sampledata->entropy_avail / 4096.) * (arg_scale_y * 5))),
861 time_to_graph(sampledata->sampletime - prev_sampledata->sampletime),
862 (sampledata->entropy_avail / 4096.) * (arg_scale_y * 5));
863 prev_sampledata = sampledata;
864 }
865 }
866
867 static struct ps_struct *get_next_ps(struct ps_struct *ps) {
868 /*
869 * walk the list of processes and return the next one to be
870 * painted
871 */
872 if (ps == ps_first)
873 return ps->next_ps;
874
875 /* go deep */
876 if (ps->children)
877 return ps->children;
878
879 /* find siblings */
880 if (ps->next)
881 return ps->next;
882
883 /* go back for parent siblings */
884 while (1) {
885 if (ps->parent)
886 if (ps->parent->next)
887 return ps->parent->next;
888 ps = ps->parent;
889 if (!ps)
890 return ps;
891 }
892
893 return NULL;
894 }
895
896 static bool ps_filter(struct ps_struct *ps) {
897 if (!arg_filter)
898 return false;
899
900 /* can't draw data when there is only 1 sample (need start + stop) */
901 if (ps->first == ps->last)
902 return true;
903
904 /* don't filter kthreadd */
905 if (ps->pid == 2)
906 return false;
907
908 /* drop stuff that doesn't use any real CPU time */
909 if (ps->total <= 0.001)
910 return true;
911
912 return 0;
913 }
914
915 static void svg_do_initcall(int count_only) {
916 _cleanup_pclose_ FILE *f = NULL;
917 double t;
918 char func[256];
919 int ret;
920 int usecs;
921
922 /* can't plot initcall when disabled or in relative mode */
923 if (!initcall || arg_relative) {
924 kcount = 0;
925 return;
926 }
927
928 if (!count_only) {
929 svg("<!-- initcall -->\n");
930
931 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Kernel init threads</text>\n");
932 /* surrounding box */
933 svg_graph_box(kcount);
934 }
935
936 kcount = 0;
937
938 /*
939 * Initcall graphing - parses dmesg buffer and displays kernel threads
940 * This somewhat uses the same methods and scaling to show processes
941 * but looks a lot simpler. It's overlaid entirely onto the PS graph
942 * when appropriate.
943 */
944
945 f = popen("dmesg", "r");
946 if (!f)
947 return;
948
949 while (!feof(f)) {
950 int c;
951 int z = 0;
952 char l[256];
953
954 if (fgets(l, sizeof(l) - 1, f) == NULL)
955 continue;
956
957 c = sscanf(l, "[%lf] initcall %s %*s %d %*s %d %*s",
958 &t, func, &ret, &usecs);
959 if (c != 4) {
960 /* also parse initcalls done by module loading */
961 c = sscanf(l, "[%lf] initcall %s %*s %*s %d %*s %d %*s",
962 &t, func, &ret, &usecs);
963 if (c != 4)
964 continue;
965 }
966
967 /* chop the +0xXX/0xXX stuff */
968 while(func[z] != '+')
969 z++;
970 func[z] = 0;
971
972 if (count_only) {
973 /* filter out irrelevant stuff */
974 if (usecs >= 1000)
975 kcount++;
976 continue;
977 }
978
979 svg("<!-- thread=\"%s\" time=\"%.3f\" elapsed=\"%d\" result=\"%d\" -->\n",
980 func, t, usecs, ret);
981
982 if (usecs < 1000)
983 continue;
984
985 /* rect */
986 svg(" <rect class=\"krnl\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
987 time_to_graph(t - (usecs / 1000000.0)),
988 ps_to_graph(kcount),
989 time_to_graph(usecs / 1000000.0),
990 ps_to_graph(1));
991
992 /* label */
993 svg(" <text x=\"%.03f\" y=\"%.03f\">%s <tspan class=\"run\">%.03fs</tspan></text>\n",
994 time_to_graph(t - (usecs / 1000000.0)) + 5,
995 ps_to_graph(kcount) + 15,
996 func,
997 usecs / 1000000.0);
998
999 kcount++;
1000 }
1001 }
1002
1003 static void svg_ps_bars(void) {
1004 struct ps_struct *ps;
1005 int i = 0;
1006 int j = 0;
1007 int pid;
1008 double w = 0.0;
1009
1010 svg("<!-- Process graph -->\n");
1011
1012 svg("<text class=\"t2\" x=\"5\" y=\"-15\">Processes</text>\n");
1013
1014 /* surrounding box */
1015 svg_graph_box(pcount);
1016
1017 /* pass 2 - ps boxes */
1018 ps = ps_first;
1019 while ((ps = get_next_ps(ps))) {
1020 _cleanup_free_ char *enc_name = NULL, *escaped = NULL;
1021 double endtime;
1022 double starttime;
1023 int t;
1024
1025 if (!utf8_is_printable(ps->name, strlen(ps->name)))
1026 escaped = utf8_escape_non_printable(ps->name);
1027
1028 enc_name = xml_comment_encode(escaped ? escaped : ps->name);
1029 if (!enc_name)
1030 continue;
1031
1032 /* leave some trace of what we actually filtered etc. */
1033 svg("<!-- %s [%i] ppid=%i runtime=%.03fs -->\n", enc_name, ps->pid,
1034 ps->ppid, ps->total);
1035
1036 starttime = ps->first->sampledata->sampletime;
1037
1038 if (!ps_filter(ps)) {
1039 /* remember where _to_ our children need to draw a line */
1040 ps->pos_x = time_to_graph(starttime - graph_start);
1041 ps->pos_y = ps_to_graph(j+1); /* bottom left corner */
1042 } else if (ps->parent){
1043 /* hook children to our parent coords instead */
1044 ps->pos_x = ps->parent->pos_x;
1045 ps->pos_y = ps->parent->pos_y;
1046
1047 /* if this is the last child, we might still need to draw a connecting line */
1048 if ((!ps->next) && (ps->parent))
1049 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1050 ps->parent->pos_x,
1051 ps_to_graph(j-1) + 10.0, /* whee, use the last value here */
1052 ps->parent->pos_x,
1053 ps->parent->pos_y);
1054 continue;
1055 }
1056
1057 endtime = ps->last->sampledata->sampletime;
1058 svg(" <rect class=\"ps\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1059 time_to_graph(starttime - graph_start),
1060 ps_to_graph(j),
1061 time_to_graph(ps->last->sampledata->sampletime - starttime),
1062 ps_to_graph(1));
1063
1064 /* paint cpu load over these */
1065 ps->sample = ps->first;
1066 t = 1;
1067 while (ps->sample->next) {
1068 double rt, prt;
1069 double wt, wrt;
1070 struct ps_sched_struct *prev;
1071
1072 prev = ps->sample;
1073 ps->sample = ps->sample->next;
1074
1075 /* calculate over interval */
1076 rt = ps->sample->runtime - prev->runtime;
1077 wt = ps->sample->waittime - prev->waittime;
1078
1079 prt = (rt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime);
1080 wrt = (wt / 1000000000) / (ps->sample->sampledata->sampletime - prev->sampledata->sampletime);
1081
1082 /* this can happen if timekeeping isn't accurate enough */
1083 if (prt > 1.0)
1084 prt = 1.0;
1085 if (wrt > 1.0)
1086 wrt = 1.0;
1087
1088 if ((prt < 0.1) && (wrt < 0.1)) /* =~ 26 (color threshold) */
1089 continue;
1090
1091 svg(" <rect class=\"wait\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1092 time_to_graph(prev->sampledata->sampletime - graph_start),
1093 ps_to_graph(j),
1094 time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime),
1095 ps_to_graph(wrt));
1096
1097 /* draw cpu over wait - TODO figure out how/why run + wait > interval */
1098 svg(" <rect class=\"cpu\" x=\"%.03f\" y=\"%.03f\" width=\"%.03f\" height=\"%.03f\" />\n",
1099 time_to_graph(prev->sampledata->sampletime - graph_start),
1100 ps_to_graph(j + (1.0 - prt)),
1101 time_to_graph(ps->sample->sampledata->sampletime - prev->sampledata->sampletime),
1102 ps_to_graph(prt));
1103 t++;
1104 }
1105
1106 /* determine where to display the process name */
1107 if ((endtime - starttime) < 1.5)
1108 /* too small to fit label inside the box */
1109 w = endtime;
1110 else
1111 w = starttime;
1112
1113 /* text label of process name */
1114 svg(" <text x=\"%.03f\" y=\"%.03f\"><![CDATA[%s]]> [%i]<tspan class=\"run\">%.03fs</tspan> %s</text>\n",
1115 time_to_graph(w - graph_start) + 5.0,
1116 ps_to_graph(j) + 14.0,
1117 escaped ? escaped : ps->name,
1118 ps->pid,
1119 (ps->last->runtime - ps->first->runtime) / 1000000000.0,
1120 arg_show_cgroup ? ps->cgroup : "");
1121 /* paint lines to the parent process */
1122 if (ps->parent) {
1123 /* horizontal part */
1124 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1125 time_to_graph(starttime - graph_start),
1126 ps_to_graph(j) + 10.0,
1127 ps->parent->pos_x,
1128 ps_to_graph(j) + 10.0);
1129
1130 /* one vertical line connecting all the horizontal ones up */
1131 if (!ps->next)
1132 svg(" <line class=\"dot\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1133 ps->parent->pos_x,
1134 ps_to_graph(j) + 10.0,
1135 ps->parent->pos_x,
1136 ps->parent->pos_y);
1137 }
1138
1139 j++; /* count boxes */
1140
1141 svg("\n");
1142 }
1143
1144 /* last pass - determine when idle */
1145 pid = getpid();
1146 /* make sure we start counting from the point where we actually have
1147 * data: assume that bootchart's first sample is when data started
1148 */
1149
1150 ps = ps_first;
1151 while (ps->next_ps) {
1152 ps = ps->next_ps;
1153 if (ps->pid == pid)
1154 break;
1155 }
1156
1157 /* need to know last node first */
1158 ps->sample = ps->first;
1159 i = ps->sample->next->sampledata->counter;
1160
1161 while (ps->sample->next && i<(samples-(arg_hz/2))) {
1162 double crt;
1163 double brt;
1164 int c;
1165 int ii;
1166 struct ps_sched_struct *sample_hz;
1167
1168 ps->sample = ps->sample->next;
1169 sample_hz = ps->sample;
1170 for (ii=0;((ii<(int)arg_hz/2)&&(ps->sample->next));ii++)
1171 sample_hz = sample_hz->next;
1172
1173 /* subtract bootchart cpu utilization from total */
1174 crt = 0.0;
1175 for (c = 0; c < cpus; c++)
1176 crt += sample_hz->sampledata->runtime[c] - ps->sample->sampledata->runtime[c];
1177 brt = sample_hz->runtime - ps->sample->runtime;
1178 /*
1179 * our definition of "idle":
1180 *
1181 * if for (hz / 2) we've used less CPU than (interval / 2) ...
1182 * defaults to 4.0%, which experimentally, is where atom idles
1183 */
1184 if ((crt - brt) < (interval / 2.0)) {
1185 idletime = ps->sample->sampledata->sampletime - graph_start;
1186 svg("\n<!-- idle detected at %.03f seconds -->\n",
1187 idletime);
1188 svg("<line class=\"idle\" x1=\"%.03f\" y1=\"%.03f\" x2=\"%.03f\" y2=\"%.03f\" />\n",
1189 time_to_graph(idletime),
1190 -arg_scale_y,
1191 time_to_graph(idletime),
1192 ps_to_graph(pcount) + arg_scale_y);
1193 svg("<text class=\"idle\" x=\"%.03f\" y=\"%.03f\">%.01fs</text>\n",
1194 time_to_graph(idletime) + 5.0,
1195 ps_to_graph(pcount) + arg_scale_y,
1196 idletime);
1197 break;
1198 }
1199 i++;
1200 }
1201 }
1202
1203 static void svg_top_ten_cpu(void) {
1204 struct ps_struct *top[10];
1205 struct ps_struct emptyps = {};
1206 struct ps_struct *ps;
1207 int n, m;
1208
1209 for (n = 0; n < (int) ELEMENTSOF(top); n++)
1210 top[n] = &emptyps;
1211
1212 /* walk all ps's and setup ptrs */
1213 ps = ps_first;
1214 while ((ps = get_next_ps(ps))) {
1215 for (n = 0; n < 10; n++) {
1216 if (ps->total <= top[n]->total)
1217 continue;
1218 /* cascade insert */
1219 for (m = 9; m > n; m--)
1220 top[m] = top[m-1];
1221 top[n] = ps;
1222 break;
1223 }
1224 }
1225
1226 svg("<text class=\"t2\" x=\"20\" y=\"0\">Top CPU consumers:</text>\n");
1227 for (n = 0; n < 10; n++)
1228 svg("<text class=\"t3\" x=\"20\" y=\"%d\">%3.03fs - <![CDATA[%s]]> [%d]</text>\n",
1229 20 + (n * 13),
1230 top[n]->total,
1231 top[n]->name,
1232 top[n]->pid);
1233 }
1234
1235 static void svg_top_ten_pss(void) {
1236 struct ps_struct *top[10];
1237 struct ps_struct emptyps = {};
1238 struct ps_struct *ps;
1239 int n, m;
1240
1241 for (n = 0; n < (int) ELEMENTSOF(top); n++)
1242 top[n] = &emptyps;
1243
1244 /* walk all ps's and setup ptrs */
1245 ps = ps_first;
1246 while ((ps = get_next_ps(ps))) {
1247 for (n = 0; n < 10; n++) {
1248 if (ps->pss_max <= top[n]->pss_max)
1249 continue;
1250 /* cascade insert */
1251 for (m = 9; m > n; m--)
1252 top[m] = top[m-1];
1253 top[n] = ps;
1254 break;
1255 }
1256 }
1257
1258 svg("<text class=\"t2\" x=\"20\" y=\"0\">Top PSS consumers:</text>\n");
1259 for (n = 0; n < 10; n++)
1260 svg("<text class=\"t3\" x=\"20\" y=\"%d\">%dK - <![CDATA[%s]]> [%d]</text>\n",
1261 20 + (n * 13),
1262 top[n]->pss_max,
1263 top[n]->name,
1264 top[n]->pid);
1265 }
1266
1267 void svg_do(const char *build) {
1268 struct ps_struct *ps;
1269 double offset = 7;
1270 int c;
1271
1272 memzero(&str, sizeof(str));
1273
1274 ps = ps_first;
1275
1276 /* count initcall thread count first */
1277 svg_do_initcall(1);
1278 ksize = (kcount ? ps_to_graph(kcount) + (arg_scale_y * 2) : 0);
1279
1280 /* then count processes */
1281 while ((ps = get_next_ps(ps))) {
1282 if (!ps_filter(ps))
1283 pcount++;
1284 else
1285 pfiltered++;
1286 }
1287 psize = ps_to_graph(pcount) + (arg_scale_y * 2);
1288
1289 esize = (arg_entropy ? arg_scale_y * 7 : 0);
1290
1291 /* after this, we can draw the header with proper sizing */
1292 svg_header();
1293 svg("<rect class=\"bg\" width=\"100%%\" height=\"100%%\" />\n\n");
1294
1295 svg("<g transform=\"translate(10,400)\">\n");
1296 svg_io_bi_bar();
1297 svg("</g>\n\n");
1298
1299 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset));
1300 svg_io_bo_bar();
1301 svg("</g>\n\n");
1302
1303 for (c = -1; c < (arg_percpu ? cpus : 0); c++) {
1304 offset += 7;
1305 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset));
1306 svg_cpu_bar(c);
1307 svg("</g>\n\n");
1308
1309 offset += 7;
1310 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset));
1311 svg_wait_bar(c);
1312 svg("</g>\n\n");
1313 }
1314
1315 if (kcount) {
1316 offset += 7;
1317 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset));
1318 svg_do_initcall(0);
1319 svg("</g>\n\n");
1320 }
1321
1322 offset += 7;
1323 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset) + ksize);
1324 svg_ps_bars();
1325 svg("</g>\n\n");
1326
1327 svg("<g transform=\"translate(10, 0)\">\n");
1328 svg_title(build);
1329 svg("</g>\n\n");
1330
1331 svg("<g transform=\"translate(10,200)\">\n");
1332 svg_top_ten_cpu();
1333 svg("</g>\n\n");
1334
1335 if (arg_entropy) {
1336 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset) + ksize + psize);
1337 svg_entropy_bar();
1338 svg("</g>\n\n");
1339 }
1340
1341 if (arg_pss) {
1342 svg("<g transform=\"translate(10,%.03f)\">\n", 400.0 + (arg_scale_y * offset) + ksize + psize + esize);
1343 svg_pss_graph();
1344 svg("</g>\n\n");
1345
1346 svg("<g transform=\"translate(410,200)\">\n");
1347 svg_top_ten_pss();
1348 svg("</g>\n\n");
1349 }
1350
1351 /* svg footer */
1352 svg("\n</svg>\n");
1353 }
Unnamed repository; edit this file 'description' to name the repository.