?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nrelease: Clean up a bit the 'clean' target
[dragonfly.git] / usr.bin / evtranalyze / evtranalyze.c
blob36d1411f4a848d1289d4300e8395d1a1796e07dc
1 /*
2 * Copyright (c) 2009, 2010 Aggelos Economopoulos. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 * 3. Neither the name of The DragonFly Project nor the names of its
15 * contributors may be used to endorse or promote products derived
16 * from this software without specific, prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <assert.h>
33 #include <ctype.h>
34 #include <err.h>
35 #include <inttypes.h>
36 #include <libgen.h>
37 #include <math.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <unistd.h>
42
43 #include <evtr.h>
44 #include "xml.h"
45 #include "svg.h"
46 #include "plotter.h"
47 #include "trivial.h"
48
49 enum {
50 NR_TOP_THREADS = 5,
51 NR_BUCKETS = 1021,
52 };
53
54 struct rows {
55 double row_increment;
56 double row_off;
57 };
58
59 #define CMD_PROTO(name) \
60 static int cmd_ ## name(int, char **)
61
62 CMD_PROTO(show);
63 CMD_PROTO(svg);
64 CMD_PROTO(stats);
65 CMD_PROTO(summary);
66
67 struct command {
68 const char *name;
69 int (*func)(int argc, char **argv);
70 } commands[] = {
71 {
72 .name = "show",
73 .func = &cmd_show,
74 },
75 {
76 .name = "svg",
77 .func = &cmd_svg,
78 },
79 {
80 .name = "stats",
81 .func = &cmd_stats,
82 },
83 {
84 .name = "summary",
85 .func = &cmd_summary,
86 },
87 {
88 .name = NULL,
89 },
90 };
91
92 evtr_t evtr;
93 static char *opt_infile;
94 unsigned evtranalyze_debug;
95
96 static
97 void
98 printd_set_flags(const char *str, unsigned int *flags)
99 {
100 /*
101 * This is suboptimal as we don't detect
102 * invalid flags.
103 */
104 for (; *str; ++str) {
105 if ('A' == *str) {
106 *flags = -1;
107 return;
108 }
109 if (!islower(*str))
110 err(2, "invalid debug flag %c\n", *str);
111 *flags |= 1 << (*str - 'a');
112 }
113 }
114
115 struct hashentry {
116 uintptr_t key;
117 uintptr_t val;
118 struct hashentry *next;
119 };
120
121 struct hashtab {
122 struct hashentry *buckets[NR_BUCKETS];
123 uintptr_t (*hashfunc)(uintptr_t);
124 uintptr_t (*cmpfunc)(uintptr_t, uintptr_t);
125 };
126
127 static int
128 ehash_find(const struct hashtab *tab, uintptr_t key, uintptr_t *val)
129 {
130 struct hashentry *ent;
131
132 for(ent = tab->buckets[tab->hashfunc(key)];
133 ent && tab->cmpfunc(ent->key, key);
134 ent = ent->next);
135
136 if (!ent)
137 return !0;
138 *val = ent->val;
139 return 0;
140 }
141
142 static struct hashentry *
143 ehash_insert(struct hashtab *tab, uintptr_t key, uintptr_t val)
144 {
145 struct hashentry *ent;
146 int hsh;
147
148 if (!(ent = malloc(sizeof(*ent)))) {
149 fprintf(stderr, "out of memory\n");
150 return NULL;
151 }
152 hsh = tab->hashfunc(key);
153 ent->next = tab->buckets[hsh];
154 ent->key = key;
155 ent->val = val;
156 tab->buckets[hsh] = ent;
157 return ent;
158 }
159 static
160 int
161 ehash_delete(struct hashtab *tab, uintptr_t key)
162 {
163 struct hashentry *ent, *prev;
164
165 prev = NULL;
166 for(ent = tab->buckets[tab->hashfunc(key)];
167 ent && tab->cmpfunc(ent->key, key);
168 prev = ent, ent = ent->next);
169 if (!ent)
170 return !0;
171 if (prev)
172 prev->next = ent->next;
173 else
174 tab->buckets[tab->hashfunc(key)] = ent->next;
175 free(ent);
176 return 0;
177 }
178
179 static
180 uintptr_t
181 cmpfunc_pointer(uintptr_t a, uintptr_t b)
182 {
183 return b - a;
184 }
185
186 static
187 uintptr_t
188 hashfunc_pointer(uintptr_t p)
189 {
190 return p % NR_BUCKETS;
191 }
192
193 static
194 uintptr_t
195 hashfunc_string(uintptr_t p)
196 {
197 const char *str = (char *)p;
198 unsigned long hash = 5381;
199 int c;
200
201 while ((c = *str++))
202 hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
203 return hash % NR_BUCKETS;
204 }
205
206 static struct hashtab *
207 ehash_new(void)
208 {
209 struct hashtab *tab;
210 if (!(tab = calloc(sizeof(struct hashtab), 1)))
211 return tab;
212 tab->hashfunc = &hashfunc_pointer;
213 tab->cmpfunc = &cmpfunc_pointer;
214 return tab;
215 }
216
217 /* returns 0 if equal */
218 static
219 int
220 cmp_vals(evtr_variable_value_t a, evtr_variable_value_t b)
221 {
222 if (a->type != b->type)
223 return !0;
224 switch (a->type) {
225 case EVTR_VAL_NIL:
226 return 0;
227 case EVTR_VAL_INT:
228 return !(a->num == b->num);
229 case EVTR_VAL_STR:
230 return strcmp(a->str, b->str);
231 case EVTR_VAL_HASH:
232 return !0; /* come on! */
233 case EVTR_VAL_CTOR:
234 err(3, "not implemented");
235 }
236 err(3, "can't get here");
237 }
238
239 static
240 uintptr_t
241 cmpfunc_ctor(uintptr_t _a, uintptr_t _b)
242 {
243 evtr_variable_value_t vala, valb;
244 vala = (evtr_variable_value_t)_a;
245 valb = (evtr_variable_value_t)_b;
246 if (strcmp(vala->ctor.name, valb->ctor.name))
247 return !0;
248 vala = TAILQ_FIRST(&vala->ctor.args);
249 valb = TAILQ_FIRST(&valb->ctor.args);
250 for (;;) {
251 if (!vala && !valb)
252 return 0;
253 if ((vala && !valb) || (valb && !vala))
254 return !0;
255 if (cmp_vals(vala, valb))
256 return !0;
257 vala = TAILQ_NEXT(vala, link);
258 valb = TAILQ_NEXT(valb, link);
259 }
260 }
261
262 static
263 uintptr_t
264 hashfunc_ctor(uintptr_t _p)
265 {
266 evtr_variable_value_t val, ctor_val = (evtr_variable_value_t)_p;
267 char buf[1024], *p = &buf[0];
268 size_t len;
269
270 p = buf;
271 assert(ctor_val->type == EVTR_VAL_CTOR);
272 len = strlcpy(buf, ctor_val->ctor.name, sizeof(buf));
273 if (len >= sizeof(buf))
274 goto done;
275
276 TAILQ_FOREACH(val, &ctor_val->ctor.args, link) {
277 switch (val->type) {
278 case EVTR_VAL_NIL:
279 assert(!"can't happen");
280 break;
281 case EVTR_VAL_INT:
282 len += snprintf(p + len, sizeof(buf) - len - 1,
283 "%jd", val->num);
284 break;
285 case EVTR_VAL_STR:
286 len = strlcat(p, val->str, sizeof(buf));
287 break;
288 case EVTR_VAL_HASH:
289 break; /* come on! */
290 case EVTR_VAL_CTOR:
291 err(3, "not implemented");
292 }
293 if (len >= (sizeof(buf) - 1))
294 break;
295 }
296 done:
297 buf[sizeof(buf) - 1] = '\0';
298 return hashfunc_string((uintptr_t)buf);
299 }
300
301 typedef struct vector {
302 uintmax_t *vals;
303 int used;
304 int allocated;
305 } *vector_t;
306
307 static vector_t
308 vector_new(void)
309 {
310 vector_t v;
311 if (!(v = malloc(sizeof(*v))))
312 return v;
313 v->allocated = 2;
314 if (!(v->vals = malloc(v->allocated * sizeof(v->vals[0])))) {
315 free(v);
316 return NULL;
317 }
318 v->allocated =
319 v->used = 0;
320 return v;
321 }
322
323 static
324 void
325 vector_push(vector_t v, uintmax_t val)
326 {
327 uintmax_t *tmp;
328 if (v->used == v->allocated) {
329 tmp = realloc(v->vals, 2 * v->allocated * sizeof(v->vals[0]));
330 if (!tmp)
331 err(1, "out of memory");
332 v->vals = tmp;
333 v->allocated *= 2;
334 }
335 v->vals[v->used++] = val;
336 }
337
338 static
339 void
340 vector_destroy(vector_t v)
341 {
342 free(v->vals);
343 free(v);
344 }
345
346 static
347 int
348 vector_nelems(vector_t v)
349 {
350 return v->used;
351 }
352
353 #define vector_foreach(v, val, i) \
354 for (i = 0, val = v->vals[0]; i < v->used; val = v->vals[++i])
355
356 static
357 double
358 stddev(vector_t v, double avg)
359 {
360 uintmax_t val;
361 int i;
362 double diff, sqr_sum = 0.0;
363
364 if (vector_nelems(v) < 2)
365 return 1 / 0.0;
366 vector_foreach(v, val, i) {
367 diff = val - avg;
368 sqr_sum += diff * diff;
369 }
370 return sqrt(sqr_sum / (vector_nelems(v) - 1));
371 }
372
373 static
374 void
375 usage(void)
376 {
377 fprintf(stderr, "bad usage :P\n");
378 exit(2);
379 }
380
381 static
382 void
383 rows_init(struct rows *rows, int n, double height, double perc)
384 {
385 double row_h;
386 rows->row_increment = height / n;
387 /* actual row height */
388 row_h = perc * rows->row_increment;
389 rows->row_off = (rows->row_increment - row_h) / 2.0;
390 assert(!isnan(rows->row_increment));
391 assert(!isnan(rows->row_off));
392 }
393
394 static
395 void
396 rows_n(struct rows *rows, int n, double *y, double *height)
397 {
398 *y = n * rows->row_increment + rows->row_off;
399 *height = rows->row_increment - 2 * rows->row_off;
400 }
401
402 /*
403 * Which fontsize to use so that the string fits in the
404 * given rect.
405 */
406 static
407 double
408 fontsize_for_rect(double width, double height, int textlen)
409 {
410 double wpc, maxh;
411 /*
412 * We start with a font size equal to the height
413 * of the rectangle and round down so that we only
414 * use a limited number of sizes.
415 *
416 * For a rectangle width comparable to the height,
417 * the text might extend outside of the rectangle.
418 * In that case we need to limit it.
419 */
420 /* available width per character */
421 wpc = width / textlen;
422 /*
423 * Assuming a rough hight/width ratio for characters,
424 * calculate the available height and round it down
425 * just to be on the safe side.
426 */
427 #define GLYPH_HIGHT_TO_WIDTH 1.5
428 maxh = GLYPH_HIGHT_TO_WIDTH * wpc * 0.9;
429 if (height > maxh) {
430 height = maxh;
431 } else if (height < 0.01) {
432 height = 0.01;
433 } else {
434 /* rounding (XXX: make cheaper)*/
435 height = log(height);
436 height = round(height);
437 height = exp(height);
438 }
439 return height;
440 }
441
442 struct pass_hook {
443 void (*pre)(void *);
444 void (*event)(void *, evtr_event_t);
445 void (*post)(void *);
446 void *data;
447 struct evtr_filter *filts;
448 int nfilts;
449 };
450
451 struct thread_info {
452 uint64_t runtime;
453 };
454
455 struct ts_interval {
456 uint64_t start;
457 uint64_t end;
458 };
459
460 struct td_switch_ctx {
461 svg_document_t svg;
462 struct rows *cpu_rows;
463 struct rows *thread_rows;
464 /* which events the user cares about */
465 struct ts_interval interval;
466 /* first/last event timestamps on any cpu */
467 struct ts_interval firstlast;
468 double width;
469 double xscale; /* scale factor applied to x */
470 svg_rect_t cpu_sw_rect;
471 svg_rect_t thread_rect;
472 svg_rect_t inactive_rect;
473 svg_text_t thread_label;
474 struct cpu_table {
475 struct cpu *cpus;
476 int ncpus;
477 } cputab;
478 struct evtr_thread **top_threads;
479 int nr_top_threads;
480 double thread_rows_yoff;
481 };
482
483 struct cpu {
484 struct evtr_thread *td;
485 int i; /* cpu index */
486 uint64_t ts; /* time cpu switched to td */
487 /* timestamp for first/last event on this cpu */
488 struct ts_interval firstlast;
489 double freq;
490 uintmax_t evcnt;
491 };
492
493 static
494 void
495 do_pass(struct pass_hook *hooks, int nhooks)
496 {
497 struct evtr_filter *filts = NULL;
498 int nfilts = 0, i;
499 struct evtr_query *q;
500 struct evtr_event ev;
501
502 for (i = 0; i < nhooks; ++i) {
503 struct pass_hook *h = &hooks[i];
504 if (h->pre)
505 h->pre(h->data);
506 if (h->nfilts > 0) {
507 filts = realloc(filts, (nfilts + h->nfilts) *
508 sizeof(struct evtr_filter));
509 if (!filts)
510 err(1, "Out of memory");
511 memcpy(filts + nfilts, h->filts,
512 h->nfilts * sizeof(struct evtr_filter));
513 nfilts += h->nfilts;
514 }
515 }
516 q = evtr_query_init(evtr, filts, nfilts);
517 if (!q)
518 err(1, "Can't initialize query\n");
519 while(!evtr_query_next(q, &ev)) {
520 for (i = 0; i < nhooks; ++i) {
521 if (hooks[i].event)
522 hooks[i].event(hooks[i].data, &ev);
523 }
524 }
525 if (evtr_query_error(q)) {
526 err(1, "%s", evtr_query_errmsg(q));
527 }
528 evtr_query_destroy(q);
529
530 for (i = 0; i < nhooks; ++i) {
531 if (hooks[i].post)
532 hooks[i].post(hooks[i].data);
533 }
534 if (evtr_rewind(evtr))
535 err(1, "Can't rewind event stream\n");
536 }
537
538 static
539 void
540 draw_thread_run(struct td_switch_ctx *ctx, struct cpu *c, evtr_event_t ev, int row)
541 {
542 double x, w, y, height;
543 w = (ev->ts - c->ts) * ctx->xscale;
544 x = (ev->ts - ctx->firstlast.start) * ctx->xscale;
545 rows_n(ctx->thread_rows, row, &y, &height);
546 svg_rect_draw(ctx->svg, ctx->thread_rect, x - w,
547 y + ctx->thread_rows_yoff, w, height);
548 }
549
550 static
551 void
552 draw_ctx_switch(struct td_switch_ctx *ctx, struct cpu *c, evtr_event_t ev)
553 {
554 struct svg_transform textrot;
555 char comm[100];
556 double x, w, fs, y, height;
557 int textlen;
558
559 assert(ctx->xscale > 0.0);
560 if (!c->ts)
561 return;
562 /* distance to previous context switch */
563 w = (ev->ts - c->ts) * ctx->xscale;
564 x = (ev->ts - ctx->firstlast.start) * ctx->xscale;
565 if ((x - w) < 0) {
566 fprintf(stderr, "(%ju - %ju) * %.20lf\n",
567 (uintmax_t)ev->ts,
568 (uintmax_t)ctx->firstlast.start, ctx->xscale);
569 abort();
570 }
571
572 rows_n(ctx->cpu_rows, c->i, &y, &height);
573 assert(!isnan(y));
574 assert(!isnan(height));
575
576 svg_rect_draw(ctx->svg, ctx->cpu_sw_rect, x - w, y, w, height);
577
578 /*
579 * Draw the text label describing the thread we
580 * switched out of.
581 */
582 textrot.tx = x - w;
583 textrot.ty = y;
584 textrot.sx = 1.0;
585 textrot.sy = 1.0;
586 textrot.rot = 90.0;
587 textlen = snprintf(comm, sizeof(comm) - 1, "%s (%p)",
588 c->td ? c->td->comm : "unknown",
589 c->td ? c->td->id: NULL);
590 if (textlen > (int)sizeof(comm))
591 textlen = sizeof(comm) - 1;
592 comm[sizeof(comm) - 1] = '\0';
593 /*
594 * Note the width and hight are exchanged because
595 * the bounding rectangle is rotated by 90 degrees.
596 */
597 fs = fontsize_for_rect(height, w, textlen);
598 svg_text_draw(ctx->svg, ctx->thread_label, &textrot, comm,
599 fs);
600 }
601
602
603 /*
604 * The stats for ntd have changed, update ->top_threads
605 */
606 static
607 void
608 top_threads_update(struct td_switch_ctx *ctx, struct evtr_thread *ntd)
609 {
610 struct thread_info *tdi = ntd->userdata;
611 int i, j;
612 for (i = 0; i < ctx->nr_top_threads; ++i) {
613 struct evtr_thread *td = ctx->top_threads[i];
614 if (td == ntd) {
615 /*
616 * ntd is already in top_threads and it is at
617 * the correct ranking
618 */
619 break;
620 }
621 if (!td) {
622 /* empty slot -- just insert our thread */
623 ctx->top_threads[i] = ntd;
624 break;
625 }
626 if (((struct thread_info *)td->userdata)->runtime >=
627 tdi->runtime) {
628 /* this thread ranks higher than we do. Move on */
629 continue;
630 }
631 /*
632 * OK, we've found the first thread that we outrank, so we
633 * need to replace it w/ our thread.
634 */
635 td = ntd; /* td holds the thread we will insert next */
636 for (j = i + 1; j < ctx->nr_top_threads; ++j, ++i) {
637 struct evtr_thread *tmp;
638
639 /* tmp holds the thread we replace */
640 tmp = ctx->top_threads[j];
641 ctx->top_threads[j] = td;
642 if (tmp == ntd) {
643 /*
644 * Our thread was already in the top list,
645 * and we just removed the second instance.
646 * Nothing more to do.
647 */
648 break;
649 }
650 td = tmp;
651 }
652 break;
653 }
654 }
655
656 static
657 void
658 ctxsw_prepare_event(void *_ctx, evtr_event_t ev)
659 {
660 struct td_switch_ctx *ctx = _ctx;
661 struct cpu *c, *cpus = ctx->cputab.cpus;
662 struct thread_info *tdi;
663
664 (void)evtr;
665 printd(INTV, "test1 (%ju:%ju) : %ju\n",
666 (uintmax_t)ctx->interval.start,
667 (uintmax_t)ctx->interval.end,
668 (uintmax_t)ev->ts);
669 if ((ev->ts > ctx->interval.end) ||
670 (ev->ts < ctx->interval.start))
671 return;
672 printd(INTV, "PREPEV on %d\n", ev->cpu);
673
674 /* update first/last timestamps */
675 c = &cpus[ev->cpu];
676 if (!c->firstlast.start) {
677 c->firstlast.start = ev->ts;
678 }
679 c->firstlast.end = ev->ts;
680 /*
681 * c->td can be null when this is the first ctxsw event we
682 * observe for a cpu
683 */
684 if (c->td) {
685 /* update thread stats */
686 if (!c->td->userdata) {
687 if (!(tdi = malloc(sizeof(struct thread_info))))
688 err(1, "Out of memory");
689 c->td->userdata = tdi;
690 tdi->runtime = 0;
691 }
692 tdi = c->td->userdata;
693 tdi->runtime += ev->ts - c->ts;
694 top_threads_update(ctx, c->td);
695 }
696
697 /* Notice that ev->td is the new thread for ctxsw events */
698 c->td = ev->td;
699 c->ts = ev->ts;
700 }
701
702 static
703 void
704 find_first_last_ts(struct cpu_table *cputab, struct ts_interval *fl)
705 {
706 struct cpu *cpus = &cputab->cpus[0];
707 int i;
708
709 fl->start = -1;
710 fl->end = 0;
711 for (i = 0; i < cputab->ncpus; ++i) {
712 printd(INTV, "cpu%d: (%ju, %ju)\n", i,
713 (uintmax_t)cpus[i].firstlast.start,
714 (uintmax_t)cpus[i].firstlast.end);
715 if (cpus[i].firstlast.start &&
716 (cpus[i].firstlast.start < fl->start))
717 fl->start = cpus[i].firstlast.start;
718 if (cpus[i].firstlast.end &&
719 (cpus[i].firstlast.end > fl->end))
720 fl->end = cpus[i].firstlast.end;
721 cpus[i].td = NULL;
722 cpus[i].ts = 0;
723 }
724 printd(INTV, "global (%jd, %jd)\n", (uintmax_t)fl->start, (uintmax_t)fl->end);
725 }
726
727 static
728 void
729 ctxsw_prepare_post(void *_ctx)
730 {
731 struct td_switch_ctx *ctx = _ctx;
732
733 find_first_last_ts(&ctx->cputab, &ctx->firstlast);
734 }
735
736 static
737 void
738 ctxsw_draw_pre(void *_ctx)
739 {
740 struct td_switch_ctx *ctx = _ctx;
741 struct svg_transform textrot;
742 char comm[100];
743 double y, height, fs;
744 int i, textlen;
745 struct evtr_thread *td;
746
747 textrot.tx = 0.0 - 0.2; /* XXX */
748 textrot.sx = 1.0;
749 textrot.sy = 1.0;
750 textrot.rot = 270.0;
751
752 for (i = 0; i < ctx->nr_top_threads; ++i) {
753 td = ctx->top_threads[i];
754 if (!td)
755 break;
756 rows_n(ctx->thread_rows, i, &y, &height);
757 svg_rect_draw(ctx->svg, ctx->inactive_rect, 0.0,
758 y + ctx->thread_rows_yoff, ctx->width, height);
759 textlen = snprintf(comm, sizeof(comm) - 1, "%s (%p)",
760 td->comm, td->id);
761 if (textlen > (int)sizeof(comm))
762 textlen = sizeof(comm) - 1;
763 comm[sizeof(comm) - 1] = '\0';
764 fs = fontsize_for_rect(height, 100.0, textlen);
765
766 textrot.ty = y + ctx->thread_rows_yoff + height;
767 svg_text_draw(ctx->svg, ctx->thread_label, &textrot,
768 comm, fs);
769 }
770 }
771
772 static
773 void
774 ctxsw_draw_event(void *_ctx, evtr_event_t ev)
775 {
776 struct td_switch_ctx *ctx = _ctx;
777 struct cpu *c = &ctx->cputab.cpus[ev->cpu];
778 int i;
779
780 /*
781 * ctx->firstlast.end can be 0 if there were no events
782 * in the specified interval, in which case
783 * ctx->firstlast.start is invalid too.
784 */
785 assert(!ctx->firstlast.end || (ev->ts >= ctx->firstlast.start));
786 printd(INTV, "test2 (%ju:%ju) : %ju\n", (uintmax_t)ctx->interval.start,
787 (uintmax_t)ctx->interval.end, (uintmax_t)ev->ts);
788 if ((ev->ts > ctx->interval.end) ||
789 (ev->ts < ctx->interval.start))
790 return;
791 printd(INTV, "DRAWEV %d\n", ev->cpu);
792 if (c->td != ev->td) { /* thread switch (or preemption) */
793 draw_ctx_switch(ctx, c, ev);
794 /* XXX: this is silly */
795 for (i = 0; i < ctx->nr_top_threads; ++i) {
796 if (!ctx->top_threads[i])
797 break;
798 if (ctx->top_threads[i] == c->td) {
799 draw_thread_run(ctx, c, ev, i);
800 break;
801 }
802 }
803 c->td = ev->td;
804 c->ts = ev->ts;
805 }
806 }
807
808 static
809 void
810 cputab_init(struct cpu_table *ct)
811 {
812 struct cpu *cpus;
813 double *freqs;
814 int i;
815
816 if ((ct->ncpus = evtr_ncpus(evtr)) <= 0)
817 err(1, "No cpu information!\n");
818 printd(MISC, "evtranalyze: ncpus %d\n", ct->ncpus);
819 if (!(ct->cpus = malloc(sizeof(struct cpu) * ct->ncpus))) {
820 err(1, "Can't allocate memory\n");
821 }
822 cpus = ct->cpus;
823 if (!(freqs = malloc(sizeof(double) * ct->ncpus))) {
824 err(1, "Can't allocate memory\n");
825 }
826 if ((i = evtr_cpufreqs(evtr, freqs))) {
827 warnc(i, "Can't get cpu frequencies\n");
828 for (i = 0; i < ct->ncpus; ++i) {
829 freqs[i] = -1.0;
830 }
831 }
832
833 /* initialize cpu array */
834 for (i = 0; i < ct->ncpus; ++i) {
835 cpus[i].td = NULL;
836 cpus[i].ts = 0;
837 cpus[i].i = i;
838 cpus[i].firstlast.start = 0;
839 cpus[i].firstlast.end = 0;
840 cpus[i].evcnt = 0;
841 cpus[i].freq = freqs[i];
842 }
843 free(freqs);
844 }
845
846 static
847 void
848 parse_interval(const char *_str, struct ts_interval *ts,
849 struct cpu_table *cputab)
850 {
851 double s, e, freq;
852 const char *str = _str + 1;
853
854 if ('c' == *_str) { /* cycles */
855 if (sscanf(str, "%" SCNu64 ":%" SCNu64,
856 &ts->start,
857 &ts->end) == 2)
858 return;
859 } else if ('m' == *_str) { /* miliseconds */
860 if (sscanf(str, "%lf:%lf", &s, &e) == 2) {
861 freq = cputab->cpus[0].freq;
862 freq *= 1000.0; /* msecs */
863 if (freq < 0.0) {
864 fprintf(stderr, "No frequency information"
865 " available\n");
866 err(2, "Can't convert time to cycles\n");
867 }
868 ts->start = s * freq;
869 ts->end = e * freq;
870 return;
871 }
872 }
873 fprintf(stderr, "invalid interval format: %s\n", _str);
874 usage();
875 }
876
877
878 static
879 int
880 cmd_svg(int argc, char **argv)
881 {
882 svg_document_t svg;
883 int ch;
884 double height, width;
885 struct rows cpu_rows, thread_rows;
886 struct td_switch_ctx td_ctx;
887 const char *outpath = "output.svg";
888 struct evtr_filter ctxsw_filts[2] = {
889 {
890 .flags = 0,
891 .cpu = -1,
892 .ev_type = EVTR_TYPE_PROBE,
893 },
894 {
895 .flags = 0,
896 .cpu = -1,
897 .ev_type = EVTR_TYPE_PROBE,
898 },
899 };
900 struct pass_hook ctxsw_prepare = {
901 .pre = NULL,
902 .event = ctxsw_prepare_event,
903 .post = ctxsw_prepare_post,
904 .data = &td_ctx,
905 .filts = ctxsw_filts,
906 .nfilts = sizeof(ctxsw_filts)/sizeof(ctxsw_filts[0]),
907 }, ctxsw_draw = {
908 .pre = ctxsw_draw_pre,
909 .event = ctxsw_draw_event,
910 .post = NULL,
911 .data = &td_ctx,
912 .filts = ctxsw_filts,
913 .nfilts = sizeof(ctxsw_filts)/sizeof(ctxsw_filts[0]),
914 };
915
916 /*
917 * We are interested in thread switch and preemption
918 * events, but we don't use the data directly. Instead
919 * we rely on ev->td.
920 */
921 ctxsw_filts[0].fmt = "sw %p > %p";
922 ctxsw_filts[1].fmt = "pre %p > %p";
923 td_ctx.interval.start = 0;
924 td_ctx.interval.end = -1; /* i.e. no interval given */
925 td_ctx.nr_top_threads = NR_TOP_THREADS;
926 cputab_init(&td_ctx.cputab); /* needed for parse_interval() */
927
928 optind = 0;
929 optreset = 1;
930 while ((ch = getopt(argc, argv, "i:o:")) != -1) {
931 switch (ch) {
932 case 'i':
933 parse_interval(optarg, &td_ctx.interval,
934 &td_ctx.cputab);
935 break;
936 case 'o':
937 outpath = optarg;
938 break;
939 default:
940 usage();
941 }
942
943 }
944 argc -= optind;
945 argv += optind;
946
947 height = 200.0;
948 width = 700.0;
949 td_ctx.width = width;
950
951 if (!(td_ctx.top_threads = calloc(td_ctx.nr_top_threads,
952 sizeof(struct evtr_thread *))))
953 err(1, "Can't allocate memory\n");
954 if (!(svg = svg_document_create(outpath)))
955 err(1, "Can't open svg document\n");
956
957 /*
958 * Create rectangles to use for output.
959 */
960 if (!(td_ctx.cpu_sw_rect = svg_rect_new("generic")))
961 err(1, "Can't create rectangle\n");
962 if (!(td_ctx.thread_rect = svg_rect_new("thread")))
963 err(1, "Can't create rectangle\n");
964 if (!(td_ctx.inactive_rect = svg_rect_new("inactive")))
965 err(1, "Can't create rectangle\n");
966 /* text for thread names */
967 if (!(td_ctx.thread_label = svg_text_new("generic")))
968 err(1, "Can't create text\n");
969 rows_init(&cpu_rows, td_ctx.cputab.ncpus, height, 0.9);
970 td_ctx.svg = svg;
971 td_ctx.xscale = -1.0;
972 td_ctx.cpu_rows = &cpu_rows;
973
974 do_pass(&ctxsw_prepare, 1);
975 td_ctx.thread_rows_yoff = height;
976 td_ctx.thread_rows = &thread_rows;
977 rows_init(td_ctx.thread_rows, td_ctx.nr_top_threads, 300, 0.9);
978 td_ctx.xscale = width / (td_ctx.firstlast.end - td_ctx.firstlast.start);
979 printd(SVG, "first %ju, last %ju, xscale %lf\n",
980 (uintmax_t)td_ctx.firstlast.start, (uintmax_t)td_ctx.firstlast.end,
981 td_ctx.xscale);
982
983 do_pass(&ctxsw_draw, 1);
984
985 svg_document_close(svg);
986 return 0;
987 }
988
989 static
990 int
991 cmd_show(int argc, char **argv)
992 {
993 struct evtr_event ev;
994 struct evtr_query *q;
995 struct evtr_filter filt;
996 struct cpu_table cputab;
997 double freq;
998 int ch;
999 uint64_t last_ts = 0;
1000
1001 cputab_init(&cputab);
1002 /*
1003 * Assume all cores run on the same frequency
1004 * for now. There's no reason to complicate
1005 * things unless we can detect frequency change
1006 * events as well.
1007 *
1008 * Note that the code is very simplistic and will
1009 * produce garbage if the kernel doesn't fixup
1010 * the timestamps for cores running with different
1011 * frequencies.
1012 */
1013 freq = cputab.cpus[0].freq;
1014 freq /= 1000000; /* we want to print out usecs */
1015 printd(MISC, "using freq = %lf\n", freq);
1016 filt.flags = 0;
1017 filt.cpu = -1;
1018 filt.ev_type = EVTR_TYPE_PROBE;
1019 filt.fmt = NULL;
1020 optind = 0;
1021 optreset = 1;
1022 while ((ch = getopt(argc, argv, "f:")) != -1) {
1023 switch (ch) {
1024 case 'f':
1025 filt.fmt = optarg;
1026 break;
1027 }
1028 }
1029 q = evtr_query_init(evtr, &filt, 1);
1030 if (!q)
1031 err(1, "Can't initialize query\n");
1032 while(!evtr_query_next(q, &ev)) {
1033 char buf[1024];
1034 char *tmpbuf;
1035
1036 if (!last_ts)
1037 last_ts = ev.ts;
1038
1039 tmpbuf = strdup(ev.file);
1040
1041 if (freq < 0.0) {
1042 printf("%s\t%ju cycles\t[%.3d]\t%s:%d",
1043 ev.td ? ev.td->comm : "unknown",
1044 (uintmax_t)(ev.ts - last_ts), ev.cpu,
1045 basename(tmpbuf), ev.line);
1046 } else {
1047 printf("%s\t%.3lf usecs\t[%.3d]\t%s:%d",
1048 ev.td ? ev.td->comm : "unknown",
1049 (ev.ts - last_ts) / freq, ev.cpu,
1050 basename(tmpbuf), ev.line);
1051 }
1052 free(tmpbuf);
1053 if (ev.fmt) {
1054 evtr_event_data(&ev, buf, sizeof(buf));
1055 printf(" !\t%s\n", buf);
1056 } else {
1057 printf("\n");
1058 }
1059 last_ts = ev.ts;
1060 }
1061 if (evtr_query_error(q)) {
1062 err(1, "%s", evtr_query_errmsg(q));
1063 }
1064 evtr_query_destroy(q);
1065 return 0;
1066 }
1067
1068 struct stats_ops {
1069 const char *statscmd;
1070 void *(*prepare)(int, char **, struct evtr_filter *);
1071 void (*each_event)(void *, evtr_event_t);
1072 void (*report)(void *);
1073 };
1074
1075 struct stats_integer_ctx {
1076 const char *varname;
1077 struct {
1078 int plot;
1079 const char *path;
1080 } opts;
1081 void *plotter_ctx;
1082 struct plotter *plotter;
1083 plotid_t time_plot;
1084 uintmax_t sum;
1085 uintmax_t occurrences;
1086 };
1087
1088 static
1089 void *
1090 stats_integer_prepare(int argc, char **argv, struct evtr_filter *filt)
1091 {
1092 struct stats_integer_ctx *ctx;
1093 int ch;
1094
1095 if (!(ctx = calloc(1, sizeof(*ctx))))
1096 return ctx;
1097
1098 optind = 0;
1099 optreset = 1;
1100 while ((ch = getopt(argc, argv, "p:")) != -1) {
1101 switch (ch) {
1102 case 'p':
1103 ctx->opts.plot = !0;
1104 ctx->opts.path = optarg;
1105 break;
1106 default:
1107 usage();
1108 }
1109 }
1110 argc -= optind;
1111 argv += optind;
1112
1113 if (argc != 1)
1114 err(2, "Need exactly one variable");
1115 ctx->varname = argv[0];
1116 ctx->sum = ctx->occurrences = 0;
1117 filt->flags = 0;
1118 filt->cpu = -1;
1119 filt->ev_type = EVTR_TYPE_STMT;
1120 filt->var = ctx->varname;
1121 if (!ctx->opts.plot)
1122 return ctx;
1123
1124 if (!(ctx->plotter = plotter_factory()))
1125 err(1, "can't allocate plotter");
1126 if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1127 err(1, "can't allocate plotter context");
1128
1129 if ((ctx->time_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1130 PLOT_TYPE_LINE,
1131 ctx->varname)) < 0)
1132 err(1, "can't create histogram");
1133 return ctx;
1134 }
1135
1136 static
1137 void
1138 stats_integer_each(void *_ctx, evtr_event_t ev)
1139 {
1140 struct stats_integer_ctx *ctx = _ctx;
1141 if (EVTR_VAL_INT != ev->stmt.val->type) {
1142 fprintf(stderr, "event at %jd (cpu %d) does not treat %s as an"
1143 "integer variable; ignored\n", ev->ts, ev->cpu,
1144 ctx->varname);
1145 return;
1146 }
1147 if (ctx->plotter)
1148 ctx->plotter->plot_line(ctx->plotter_ctx, ctx->time_plot,
1149 (double)ev->ts, (double)ev->stmt.val->num);
1150 ctx->sum += ev->stmt.val->num;
1151 ++ctx->occurrences;
1152 }
1153
1154 static
1155 void
1156 stats_integer_report(void *_ctx)
1157 {
1158 struct stats_integer_ctx *ctx = _ctx;
1159 printf("median for variable %s is %lf\n", ctx->varname,
1160 (double)ctx->sum / ctx->occurrences);
1161 if (ctx->plotter)
1162 ctx->plotter->plot_finish(ctx->plotter_ctx);
1163
1164 free(ctx);
1165 }
1166
1167 struct stats_completion_ctx {
1168 struct stats_completion_options {
1169 int plot;
1170 const char *path;
1171 } opts;
1172 struct plotter *plotter;
1173 void *plotter_ctx;
1174 plotid_t durations_plot;
1175 const char *varname;
1176 const char *ctor;
1177 const char *dtor;
1178 struct hashtab *ctors;
1179 uintmax_t historical_dtors;
1180 uintmax_t uncompleted_events;
1181 uintmax_t begun_events;
1182 uintmax_t completed_events;
1183 uintmax_t completed_duration_sum;
1184 vector_t durations;
1185 };
1186
1187 struct ctor_data {
1188 evtr_variable_value_t val;
1189 uintmax_t ts;
1190 };
1191
1192 static
1193 struct ctor_data *
1194 ctor_data_new(evtr_event_t ev)
1195 {
1196 struct ctor_data *cd;
1197
1198 if (!(cd = malloc(sizeof(*cd))))
1199 return cd;
1200 cd->val = ev->stmt.val;
1201 cd->ts = ev->ts;
1202 return cd;
1203 }
1204
1205 static
1206 void *
1207 stats_completion_prepare(int argc, char **argv, struct evtr_filter *filt)
1208 {
1209 struct stats_completion_ctx *ctx;
1210 int ch;
1211
1212 if (!(ctx = calloc(1, sizeof(*ctx))))
1213 return ctx;
1214
1215 optind = 0;
1216 optreset = 1;
1217 while ((ch = getopt(argc, argv, "p:")) != -1) {
1218 switch (ch) {
1219 case 'p':
1220 ctx->opts.plot = !0;
1221 ctx->opts.path = optarg;
1222 break;
1223 default:
1224 usage();
1225 }
1226 }
1227 argc -= optind;
1228 argv += optind;
1229 if (argc != 3)
1230 err(2, "need a variable, a constructor and a destructor");
1231 if (!(ctx->ctors = ehash_new()))
1232 goto free_ctx;
1233 ctx->ctors->hashfunc = &hashfunc_ctor;
1234 ctx->ctors->cmpfunc = &cmpfunc_ctor;
1235 if (!(ctx->durations = vector_new()))
1236 goto free_ctors;
1237 ctx->varname = argv[0];
1238 ctx->ctor = argv[1];
1239 ctx->dtor = argv[2];
1240
1241 filt->flags = 0;
1242 filt->cpu = -1;
1243 filt->ev_type = EVTR_TYPE_STMT;
1244 filt->var = ctx->varname;
1245
1246 if (!ctx->opts.plot)
1247 return ctx;
1248
1249 if (!(ctx->plotter = plotter_factory()))
1250 err(1, "can't allocate plotter");
1251 if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1252 err(1, "can't allocate plotter context");
1253
1254 if ((ctx->durations_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1255 PLOT_TYPE_HIST,
1256 ctx->varname)) < 0)
1257 err(1, "can't create histogram");
1258 return ctx;
1259 free_ctors:
1260 ; /* XXX */
1261 free_ctx:
1262 free(ctx);
1263 return NULL;
1264 }
1265
1266 static
1267 void
1268 stats_completion_each(void *_ctx, evtr_event_t ev)
1269 {
1270 struct stats_completion_ctx *ctx = _ctx;
1271 struct ctor_data *cd;
1272
1273 if (ev->stmt.val->type != EVTR_VAL_CTOR) {
1274 fprintf(stderr, "event at %jd (cpu %d) does not assign to %s "
1275 "with a data constructor; ignored\n", ev->ts, ev->cpu,
1276 ctx->varname);
1277 return;
1278 }
1279 if (!strcmp(ev->stmt.val->ctor.name, ctx->ctor)) {
1280 uintptr_t v;
1281 if (!ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1282 /* XXX:better diagnostic */
1283 fprintf(stderr, "duplicate ctor\n");
1284 err(3, "giving up");
1285 }
1286 if (!(cd = ctor_data_new(ev)))
1287 err(1, "out of memory");
1288 v = (uintptr_t)cd;
1289 if (!ehash_insert(ctx->ctors, (uintptr_t)ev->stmt.val, v))
1290 err(1, "out of memory");
1291 ++ctx->begun_events;
1292 } else if (!strcmp(ev->stmt.val->ctor.name, ctx->dtor)) {
1293 uintptr_t v;
1294 const char *tmp = ev->stmt.val->ctor.name;
1295 ev->stmt.val->ctor.name = ctx->ctor;
1296 if (ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1297 ++ctx->historical_dtors;
1298 ev->stmt.val->ctor.name = tmp;
1299 return;
1300 }
1301 cd = (struct ctor_data *)v;
1302 if (cd->ts >= ev->ts) {
1303 /* XXX:better diagnostic */
1304 fprintf(stderr, "destructor preceds constructor;"
1305 " ignored\n");
1306 ev->stmt.val->ctor.name = tmp;
1307 return;
1308 }
1309 if (ctx->plotter)
1310 ctx->plotter->plot_histogram(ctx->plotter_ctx,
1311 ctx->durations_plot,
1312 (double)(ev->ts - cd->ts));
1313 vector_push(ctx->durations, ev->ts - cd->ts);
1314 ++ctx->completed_events;
1315 ctx->completed_duration_sum += ev->ts - cd->ts;
1316 if (ehash_delete(ctx->ctors, (uintptr_t)ev->stmt.val))
1317 err(3, "ctor disappeared from hash!");
1318 ev->stmt.val->ctor.name = tmp;
1319 } else {
1320 fprintf(stderr, "event at %jd (cpu %d) assigns to %s "
1321 "with an unexpected data constructor; ignored\n",
1322 ev->ts, ev->cpu, ctx->varname);
1323 return;
1324 }
1325 }
1326
1327 static
1328 void
1329 stats_completion_report(void *_ctx)
1330 {
1331 struct stats_completion_ctx *ctx = _ctx;
1332 double avg;
1333
1334 printf("Events completed without having started:\t%jd\n",
1335 ctx->historical_dtors);
1336 printf("Events started but didn't complete:\t%jd\n",
1337 ctx->begun_events - ctx->completed_events);
1338 avg = (double)ctx->completed_duration_sum / ctx->completed_events;
1339 printf("Average event duration:\t%lf (stddev %lf)\n", avg,
1340 stddev(ctx->durations, avg));
1341
1342 if (ctx->plotter)
1343 ctx->plotter->plot_finish(ctx->plotter_ctx);
1344 vector_destroy(ctx->durations);
1345 /* XXX: hash */
1346 free(ctx);
1347 }
1348
1349 static struct stats_ops cmd_stat_ops[] = {
1350 {
1351 .statscmd = "integer",
1352 .prepare = &stats_integer_prepare,
1353 .each_event = &stats_integer_each,
1354 .report = &stats_integer_report,
1355 },
1356 {
1357 .statscmd = "completion",
1358 .prepare = &stats_completion_prepare,
1359 .each_event = &stats_completion_each,
1360 .report = &stats_completion_report,
1361 },
1362 {
1363 .statscmd = NULL,
1364 },
1365 };
1366
1367 static
1368 int
1369 cmd_stats(int argc, char **argv)
1370 {
1371 struct evtr_event ev;
1372 struct evtr_query *q;
1373 struct evtr_filter filt;
1374 struct cpu_table cputab;
1375 double freq;
1376 uint64_t last_ts = 0;
1377 struct stats_ops *statsops = &cmd_stat_ops[0];
1378 void *statctx;
1379
1380 for (; statsops->statscmd; ++statsops) {
1381 if (!strcmp(statsops->statscmd, argv[1]))
1382 break;
1383 }
1384 if (!statsops->statscmd)
1385 err(2, "No such stats type: %s", argv[1]);
1386
1387 --argc;
1388 ++argv;
1389 cputab_init(&cputab);
1390 /*
1391 * Assume all cores run on the same frequency
1392 * for now. There's no reason to complicate
1393 * things unless we can detect frequency change
1394 * events as well.
1395 *
1396 * Note that the code is very simplistic and will
1397 * produce garbage if the kernel doesn't fixup
1398 * the timestamps for cores running with different
1399 * frequencies.
1400 */
1401 freq = cputab.cpus[0].freq;
1402 freq /= 1000000; /* we want to print out usecs */
1403 printd(MISC, "using freq = %lf\n", freq);
1404
1405 if (!(statctx = statsops->prepare(argc, argv, &filt)))
1406 err(1, "Can't allocate stats context");
1407 q = evtr_query_init(evtr, &filt, 1);
1408 if (!q)
1409 err(1, "Can't initialize query");
1410 while(!evtr_query_next(q, &ev)) {
1411
1412 if (!last_ts)
1413 last_ts = ev.ts;
1414
1415 assert(ev.type == EVTR_TYPE_STMT);
1416 statsops->each_event(statctx, &ev);
1417 last_ts = ev.ts;
1418 }
1419 if (evtr_query_error(q)) {
1420 err(1, "%s", evtr_query_errmsg(q));
1421 }
1422 evtr_query_destroy(q);
1423 statsops->report(statctx);
1424 return 0;
1425 }
1426
1427
1428 static
1429 int
1430 cmd_summary(int argc, char **argv)
1431 {
1432 struct evtr_filter filt;
1433 struct evtr_event ev;
1434 struct evtr_query *q;
1435 double freq;
1436 struct cpu_table cputab;
1437 struct ts_interval global;
1438 uintmax_t global_evcnt;
1439 int i;
1440
1441 (void)argc;
1442 (void)argv;
1443
1444 cputab_init(&cputab);
1445 filt.ev_type = EVTR_TYPE_PROBE;
1446 filt.fmt = NULL;
1447 filt.flags = 0;
1448 filt.cpu = -1;
1449
1450 q = evtr_query_init(evtr, &filt, 1);
1451 if (!q)
1452 err(1, "Can't initialize query\n");
1453 while(!evtr_query_next(q, &ev)) {
1454 struct cpu *c = &cputab.cpus[ev.cpu];
1455 if (!c->firstlast.start)
1456 c->firstlast.start = ev.ts;
1457 ++c->evcnt;
1458 c->firstlast.end = ev.ts;
1459 }
1460 if (evtr_query_error(q)) {
1461 err(1, "%s", evtr_query_errmsg(q));
1462 }
1463 evtr_query_destroy(q);
1464
1465 find_first_last_ts(&cputab, &global);
1466
1467 freq = cputab.cpus[0].freq;
1468 global_evcnt = 0;
1469 for (i = 0; i < cputab.ncpus; ++i) {
1470 struct cpu *c = &cputab.cpus[i];
1471 printf("CPU %d: %jd events in %.3lf secs\n", i,
1472 c->evcnt, (c->firstlast.end - c->firstlast.start)
1473 / freq);
1474 global_evcnt += c->evcnt;
1475 }
1476 printf("Total: %jd events on %d cpus in %.3lf secs\n", global_evcnt,
1477 cputab.ncpus, (global.end - global.start) / freq);
1478 return 0;
1479 }
1480
1481
1482 int
1483 main(int argc, char **argv)
1484 {
1485 int ch;
1486 FILE *inf;
1487 struct command *cmd;
1488 char *tmp;
1489
1490 while ((ch = getopt(argc, argv, "f:D:")) != -1) {
1491 switch (ch) {
1492 case 'f':
1493 opt_infile = optarg;
1494 break;
1495 case 'D':
1496 if ((tmp = strchr(optarg, ':'))) {
1497 *tmp++ = '\0';
1498 evtr_set_debug(tmp);
1499 }
1500 printd_set_flags(optarg, &evtranalyze_debug);
1501 break;
1502 default:
1503 usage();
1504 }
1505 }
1506 argc -= optind;
1507 argv += optind;
1508
1509 if (argc == 0) {
1510 err(2, "need to specify a command\n");
1511 }
1512 if (!opt_infile) {
1513 err(2, "you need to specify an input file\n");
1514 } else if (!strcmp(opt_infile, "-")) {
1515 inf = stdin;
1516 } else {
1517 inf = fopen(opt_infile, "r");
1518 if (!inf) {
1519 err(2, "Can't open input file\n");
1520 }
1521 }
1522
1523 if (!(evtr = evtr_open_read(inf))) {
1524 err(1, "Can't open evtr stream\n");
1525 }
1526
1527
1528 for (cmd = commands; cmd->name != NULL; ++cmd) {
1529 if (strcmp(argv[0], cmd->name))
1530 continue;
1531 cmd->func(argc, argv);
1532 break;
1533 }
1534 if (!cmd->name) {
1535 err(2, "no such command: %s\n", argv[0]);
1536 }
1537
1538 evtr_close(evtr);
1539 return 0;
1540 }
DragonFly BSD