?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dntpd: Fix typo.
[dragonfly.git] / usr.bin / evtranalyze / evtranalyze.c
blobdd8b030e72354641b51163e0ce9338512bb7ca85
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
1035 if (!last_ts)
1036 last_ts = ev.ts;
1037 if (freq < 0.0) {
1038 printf("%s\t%ju cycles\t[%.3d]\t%s:%d",
1039 ev.td ? ev.td->comm : "unknown",
1040 (uintmax_t)(ev.ts - last_ts), ev.cpu,
1041 basename(ev.file), ev.line);
1042 } else {
1043 printf("%s\t%.3lf usecs\t[%.3d]\t%s:%d",
1044 ev.td ? ev.td->comm : "unknown",
1045 (ev.ts - last_ts) / freq, ev.cpu,
1046 basename(ev.file), ev.line);
1047 }
1048 if (ev.fmt) {
1049 evtr_event_data(&ev, buf, sizeof(buf));
1050 printf(" !\t%s\n", buf);
1051 } else {
1052 printf("\n");
1053 }
1054 last_ts = ev.ts;
1055 }
1056 if (evtr_query_error(q)) {
1057 err(1, "%s", evtr_query_errmsg(q));
1058 }
1059 evtr_query_destroy(q);
1060 return 0;
1061 }
1062
1063 struct stats_ops {
1064 const char *statscmd;
1065 void *(*prepare)(int, char **, struct evtr_filter *);
1066 void (*each_event)(void *, evtr_event_t);
1067 void (*report)(void *);
1068 };
1069
1070 struct stats_integer_ctx {
1071 const char *varname;
1072 struct {
1073 int plot;
1074 const char *path;
1075 } opts;
1076 void *plotter_ctx;
1077 struct plotter *plotter;
1078 plotid_t time_plot;
1079 uintmax_t sum;
1080 uintmax_t occurrences;
1081 };
1082
1083 static
1084 void *
1085 stats_integer_prepare(int argc, char **argv, struct evtr_filter *filt)
1086 {
1087 struct stats_integer_ctx *ctx;
1088 int ch;
1089
1090 if (!(ctx = calloc(1, sizeof(*ctx))))
1091 return ctx;
1092
1093 optind = 0;
1094 optreset = 1;
1095 while ((ch = getopt(argc, argv, "p:")) != -1) {
1096 switch (ch) {
1097 case 'p':
1098 ctx->opts.plot = !0;
1099 ctx->opts.path = optarg;
1100 break;
1101 default:
1102 usage();
1103 }
1104 }
1105 argc -= optind;
1106 argv += optind;
1107
1108 if (argc != 1)
1109 err(2, "Need exactly one variable");
1110 ctx->varname = argv[0];
1111 ctx->sum = ctx->occurrences = 0;
1112 filt->flags = 0;
1113 filt->cpu = -1;
1114 filt->ev_type = EVTR_TYPE_STMT;
1115 filt->var = ctx->varname;
1116 if (!ctx->opts.plot)
1117 return ctx;
1118
1119 if (!(ctx->plotter = plotter_factory()))
1120 err(1, "can't allocate plotter");
1121 if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1122 err(1, "can't allocate plotter context");
1123
1124 if ((ctx->time_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1125 PLOT_TYPE_LINE,
1126 ctx->varname)) < 0)
1127 err(1, "can't create histogram");
1128 return ctx;
1129 }
1130
1131 static
1132 void
1133 stats_integer_each(void *_ctx, evtr_event_t ev)
1134 {
1135 struct stats_integer_ctx *ctx = _ctx;
1136 if (EVTR_VAL_INT != ev->stmt.val->type) {
1137 fprintf(stderr, "event at %jd (cpu %d) does not treat %s as an"
1138 "integer variable; ignored\n", ev->ts, ev->cpu,
1139 ctx->varname);
1140 return;
1141 }
1142 if (ctx->plotter)
1143 ctx->plotter->plot_line(ctx->plotter_ctx, ctx->time_plot,
1144 (double)ev->ts, (double)ev->stmt.val->num);
1145 ctx->sum += ev->stmt.val->num;
1146 ++ctx->occurrences;
1147 }
1148
1149 static
1150 void
1151 stats_integer_report(void *_ctx)
1152 {
1153 struct stats_integer_ctx *ctx = _ctx;
1154 printf("median for variable %s is %lf\n", ctx->varname,
1155 (double)ctx->sum / ctx->occurrences);
1156 if (ctx->plotter)
1157 ctx->plotter->plot_finish(ctx->plotter_ctx);
1158
1159 free(ctx);
1160 }
1161
1162 struct stats_completion_ctx {
1163 struct stats_completion_options {
1164 int plot;
1165 const char *path;
1166 } opts;
1167 struct plotter *plotter;
1168 void *plotter_ctx;
1169 plotid_t durations_plot;
1170 const char *varname;
1171 const char *ctor;
1172 const char *dtor;
1173 struct hashtab *ctors;
1174 uintmax_t historical_dtors;
1175 uintmax_t uncompleted_events;
1176 uintmax_t begun_events;
1177 uintmax_t completed_events;
1178 uintmax_t completed_duration_sum;
1179 vector_t durations;
1180 };
1181
1182 struct ctor_data {
1183 evtr_variable_value_t val;
1184 uintmax_t ts;
1185 };
1186
1187 static
1188 struct ctor_data *
1189 ctor_data_new(evtr_event_t ev)
1190 {
1191 struct ctor_data *cd;
1192
1193 if (!(cd = malloc(sizeof(*cd))))
1194 return cd;
1195 cd->val = ev->stmt.val;
1196 cd->ts = ev->ts;
1197 return cd;
1198 }
1199
1200 static
1201 void *
1202 stats_completion_prepare(int argc, char **argv, struct evtr_filter *filt)
1203 {
1204 struct stats_completion_ctx *ctx;
1205 int ch;
1206
1207 if (!(ctx = calloc(1, sizeof(*ctx))))
1208 return ctx;
1209
1210 optind = 0;
1211 optreset = 1;
1212 while ((ch = getopt(argc, argv, "p:")) != -1) {
1213 switch (ch) {
1214 case 'p':
1215 ctx->opts.plot = !0;
1216 ctx->opts.path = optarg;
1217 break;
1218 default:
1219 usage();
1220 }
1221 }
1222 argc -= optind;
1223 argv += optind;
1224 if (argc != 3)
1225 err(2, "need a variable, a constructor and a destructor");
1226 if (!(ctx->ctors = ehash_new()))
1227 goto free_ctx;
1228 ctx->ctors->hashfunc = &hashfunc_ctor;
1229 ctx->ctors->cmpfunc = &cmpfunc_ctor;
1230 if (!(ctx->durations = vector_new()))
1231 goto free_ctors;
1232 ctx->varname = argv[0];
1233 ctx->ctor = argv[1];
1234 ctx->dtor = argv[2];
1235
1236 filt->flags = 0;
1237 filt->cpu = -1;
1238 filt->ev_type = EVTR_TYPE_STMT;
1239 filt->var = ctx->varname;
1240
1241 if (!ctx->opts.plot)
1242 return ctx;
1243
1244 if (!(ctx->plotter = plotter_factory()))
1245 err(1, "can't allocate plotter");
1246 if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1247 err(1, "can't allocate plotter context");
1248
1249 if ((ctx->durations_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1250 PLOT_TYPE_HIST,
1251 ctx->varname)) < 0)
1252 err(1, "can't create histogram");
1253 return ctx;
1254 free_ctors:
1255 ; /* XXX */
1256 free_ctx:
1257 free(ctx);
1258 return NULL;
1259 }
1260
1261 static
1262 void
1263 stats_completion_each(void *_ctx, evtr_event_t ev)
1264 {
1265 struct stats_completion_ctx *ctx = _ctx;
1266 struct ctor_data *cd;
1267
1268 if (ev->stmt.val->type != EVTR_VAL_CTOR) {
1269 fprintf(stderr, "event at %jd (cpu %d) does not assign to %s "
1270 "with a data constructor; ignored\n", ev->ts, ev->cpu,
1271 ctx->varname);
1272 return;
1273 }
1274 if (!strcmp(ev->stmt.val->ctor.name, ctx->ctor)) {
1275 uintptr_t v;
1276 if (!ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1277 /* XXX:better diagnostic */
1278 fprintf(stderr, "duplicate ctor\n");
1279 err(3, "giving up");
1280 }
1281 if (!(cd = ctor_data_new(ev)))
1282 err(1, "out of memory");
1283 v = (uintptr_t)cd;
1284 if (!ehash_insert(ctx->ctors, (uintptr_t)ev->stmt.val, v))
1285 err(1, "out of memory");
1286 ++ctx->begun_events;
1287 } else if (!strcmp(ev->stmt.val->ctor.name, ctx->dtor)) {
1288 uintptr_t v;
1289 const char *tmp = ev->stmt.val->ctor.name;
1290 ev->stmt.val->ctor.name = ctx->ctor;
1291 if (ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1292 ++ctx->historical_dtors;
1293 ev->stmt.val->ctor.name = tmp;
1294 return;
1295 }
1296 cd = (struct ctor_data *)v;
1297 if (cd->ts >= ev->ts) {
1298 /* XXX:better diagnostic */
1299 fprintf(stderr, "destructor preceds constructor;"
1300 " ignored\n");
1301 ev->stmt.val->ctor.name = tmp;
1302 return;
1303 }
1304 if (ctx->plotter)
1305 ctx->plotter->plot_histogram(ctx->plotter_ctx,
1306 ctx->durations_plot,
1307 (double)(ev->ts - cd->ts));
1308 vector_push(ctx->durations, ev->ts - cd->ts);
1309 ++ctx->completed_events;
1310 ctx->completed_duration_sum += ev->ts - cd->ts;
1311 if (ehash_delete(ctx->ctors, (uintptr_t)ev->stmt.val))
1312 err(3, "ctor disappeared from hash!");
1313 ev->stmt.val->ctor.name = tmp;
1314 } else {
1315 fprintf(stderr, "event at %jd (cpu %d) assigns to %s "
1316 "with an unexpected data constructor; ignored\n",
1317 ev->ts, ev->cpu, ctx->varname);
1318 return;
1319 }
1320 }
1321
1322 static
1323 void
1324 stats_completion_report(void *_ctx)
1325 {
1326 struct stats_completion_ctx *ctx = _ctx;
1327 double avg;
1328
1329 printf("Events completed without having started:\t%jd\n",
1330 ctx->historical_dtors);
1331 printf("Events started but didn't complete:\t%jd\n",
1332 ctx->begun_events - ctx->completed_events);
1333 avg = (double)ctx->completed_duration_sum / ctx->completed_events;
1334 printf("Average event duration:\t%lf (stddev %lf)\n", avg,
1335 stddev(ctx->durations, avg));
1336
1337 if (ctx->plotter)
1338 ctx->plotter->plot_finish(ctx->plotter_ctx);
1339 vector_destroy(ctx->durations);
1340 /* XXX: hash */
1341 free(ctx);
1342 }
1343
1344 static struct stats_ops cmd_stat_ops[] = {
1345 {
1346 .statscmd = "integer",
1347 .prepare = &stats_integer_prepare,
1348 .each_event = &stats_integer_each,
1349 .report = &stats_integer_report,
1350 },
1351 {
1352 .statscmd = "completion",
1353 .prepare = &stats_completion_prepare,
1354 .each_event = &stats_completion_each,
1355 .report = &stats_completion_report,
1356 },
1357 {
1358 .statscmd = NULL,
1359 },
1360 };
1361
1362 static
1363 int
1364 cmd_stats(int argc, char **argv)
1365 {
1366 struct evtr_event ev;
1367 struct evtr_query *q;
1368 struct evtr_filter filt;
1369 struct cpu_table cputab;
1370 double freq;
1371 uint64_t last_ts = 0;
1372 struct stats_ops *statsops = &cmd_stat_ops[0];
1373 void *statctx;
1374
1375 for (; statsops->statscmd; ++statsops) {
1376 if (!strcmp(statsops->statscmd, argv[1]))
1377 break;
1378 }
1379 if (!statsops->statscmd)
1380 err(2, "No such stats type: %s", argv[1]);
1381
1382 --argc;
1383 ++argv;
1384 cputab_init(&cputab);
1385 /*
1386 * Assume all cores run on the same frequency
1387 * for now. There's no reason to complicate
1388 * things unless we can detect frequency change
1389 * events as well.
1390 *
1391 * Note that the code is very simplistic and will
1392 * produce garbage if the kernel doesn't fixup
1393 * the timestamps for cores running with different
1394 * frequencies.
1395 */
1396 freq = cputab.cpus[0].freq;
1397 freq /= 1000000; /* we want to print out usecs */
1398 printd(MISC, "using freq = %lf\n", freq);
1399
1400 if (!(statctx = statsops->prepare(argc, argv, &filt)))
1401 err(1, "Can't allocate stats context");
1402 q = evtr_query_init(evtr, &filt, 1);
1403 if (!q)
1404 err(1, "Can't initialize query");
1405 while(!evtr_query_next(q, &ev)) {
1406
1407 if (!last_ts)
1408 last_ts = ev.ts;
1409
1410 assert(ev.type == EVTR_TYPE_STMT);
1411 statsops->each_event(statctx, &ev);
1412 last_ts = ev.ts;
1413 }
1414 if (evtr_query_error(q)) {
1415 err(1, "%s", evtr_query_errmsg(q));
1416 }
1417 evtr_query_destroy(q);
1418 statsops->report(statctx);
1419 return 0;
1420 }
1421
1422
1423 static
1424 int
1425 cmd_summary(int argc, char **argv)
1426 {
1427 struct evtr_filter filt;
1428 struct evtr_event ev;
1429 struct evtr_query *q;
1430 double freq;
1431 struct cpu_table cputab;
1432 struct ts_interval global;
1433 uintmax_t global_evcnt;
1434 int i;
1435
1436 (void)argc;
1437 (void)argv;
1438
1439 cputab_init(&cputab);
1440 filt.ev_type = EVTR_TYPE_PROBE;
1441 filt.fmt = NULL;
1442 filt.flags = 0;
1443 filt.cpu = -1;
1444
1445 q = evtr_query_init(evtr, &filt, 1);
1446 if (!q)
1447 err(1, "Can't initialize query\n");
1448 while(!evtr_query_next(q, &ev)) {
1449 struct cpu *c = &cputab.cpus[ev.cpu];
1450 if (!c->firstlast.start)
1451 c->firstlast.start = ev.ts;
1452 ++c->evcnt;
1453 c->firstlast.end = ev.ts;
1454 }
1455 if (evtr_query_error(q)) {
1456 err(1, "%s", evtr_query_errmsg(q));
1457 }
1458 evtr_query_destroy(q);
1459
1460 find_first_last_ts(&cputab, &global);
1461
1462 freq = cputab.cpus[0].freq;
1463 global_evcnt = 0;
1464 for (i = 0; i < cputab.ncpus; ++i) {
1465 struct cpu *c = &cputab.cpus[i];
1466 printf("CPU %d: %jd events in %.3lf secs\n", i,
1467 c->evcnt, (c->firstlast.end - c->firstlast.start)
1468 / freq);
1469 global_evcnt += c->evcnt;
1470 }
1471 printf("Total: %jd events on %d cpus in %.3lf secs\n", global_evcnt,
1472 cputab.ncpus, (global.end - global.start) / freq);
1473 return 0;
1474 }
1475
1476
1477 int
1478 main(int argc, char **argv)
1479 {
1480 int ch;
1481 FILE *inf;
1482 struct command *cmd;
1483 char *tmp;
1484
1485 while ((ch = getopt(argc, argv, "f:D:")) != -1) {
1486 switch (ch) {
1487 case 'f':
1488 opt_infile = optarg;
1489 break;
1490 case 'D':
1491 if ((tmp = strchr(optarg, ':'))) {
1492 *tmp++ = '\0';
1493 evtr_set_debug(tmp);
1494 }
1495 printd_set_flags(optarg, &evtranalyze_debug);
1496 break;
1497 default:
1498 usage();
1499 }
1500 }
1501 argc -= optind;
1502 argv += optind;
1503
1504 if (argc == 0) {
1505 err(2, "need to specify a command\n");
1506 }
1507 if (!opt_infile) {
1508 err(2, "you need to specify an input file\n");
1509 } else if (!strcmp(opt_infile, "-")) {
1510 inf = stdin;
1511 } else {
1512 inf = fopen(opt_infile, "r");
1513 if (!inf) {
1514 err(2, "Can't open input file\n");
1515 }
1516 }
1517
1518 if (!(evtr = evtr_open_read(inf))) {
1519 err(1, "Can't open evtr stream\n");
1520 }
1521
1522
1523 for (cmd = commands; cmd->name != NULL; ++cmd) {
1524 if (strcmp(argv[0], cmd->name))
1525 continue;
1526 cmd->func(argc, argv);
1527 break;
1528 }
1529 if (!cmd->name) {
1530 err(2, "no such command: %s\n", argv[0]);
1531 }
1532
1533 evtr_close(evtr);
1534 return 0;
1535 }
DragonFly BSD