lib/libevtr/evtr.c

   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 <errno.h>
  36 #include <limits.h>
  37 #include <stdarg.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <sys/queue.h>
  42 #include <sys/stat.h>
  43 #include <sys/tree.h>
  44
  45
  46 #include "evtr.h"
  47 #include "internal.h"
  48
  49 unsigned evtr_debug;
  50
  51 static
  52 void
  53 printd_set_flags(const char *str, unsigned int *flags)
  54 {
  55         /*
  56          * This is suboptimal as we don't detect
  57          * invalid flags.
  58          */
  59         for (; *str; ++str) {
  60                 if ('A' == *str) {
  61                         *flags = -1;
  62                         return;
  63                 }
  64                 if (!islower(*str))
  65                         err(2, "invalid debug flag %c\n", *str);
  66                 *flags |= 1 << (*str - 'a');
  67         }
  68 }
  69
  70
  71 enum {
  72         MAX_EVHDR_SIZE = PATH_MAX + 200,
  73         /* string namespaces */
  74         EVTR_NS_PATH = 0x1,
  75         EVTR_NS_FUNC,
  76         EVTR_NS_DSTR,
  77         EVTR_NS_MAX,
  78         NR_BUCKETS = 1021,      /* prime */
  79         REC_ALIGN = 8,
  80         REC_BOUNDARY = 1 << 14,
  81         FILTF_ID = 0x10,
  82         EVTRF_WR = 0x1,         /* open for writing */
  83         EVTRQF_PENDING = 0x1,
  84 };
  85
  86 typedef uint16_t fileid_t;
  87 typedef uint16_t funcid_t;
  88 typedef uint16_t fmtid_t;
  89
  90 struct trace_event_header {
  91         uint8_t type;
  92         uint64_t ts;    /* XXX: this should only be part of probe */
  93 } __attribute__((packed));
  94
  95 struct probe_event_header {
  96         struct trace_event_header eh;
  97         /*
  98          * For these fields, 0 implies "not available"
  99          */
 100         fileid_t file;
 101         funcid_t caller1;
 102         funcid_t caller2;
 103         funcid_t func;
 104         uint16_t line;
 105         fmtid_t fmt;
 106         uint16_t datalen;
 107         uint8_t cpu;    /* -1 if n/a */
 108 } __attribute__((packed));
 109
 110 struct string_event_header {
 111         struct trace_event_header eh;
 112         uint16_t ns;
 113         uint32_t id;
 114         uint16_t len;
 115 } __attribute__((packed));
 116
 117 struct fmt_event_header {
 118         struct trace_event_header eh;
 119         uint16_t id;
 120         uint8_t subsys_len;
 121         uint8_t fmt_len;
 122 } __attribute__((packed));
 123
 124 struct cpuinfo_event_header {
 125         double freq;
 126         uint8_t cpu;
 127 } __attribute__((packed));
 128
 129 struct hashentry {
 130         uintptr_t key;
 131         uintptr_t val;
 132         struct hashentry *next;
 133 };
 134
 135 struct hashtab {
 136         struct hashentry *buckets[NR_BUCKETS];
 137         uintptr_t (*hashfunc)(uintptr_t);
 138         uintptr_t (*cmpfunc)(uintptr_t, uintptr_t);
 139 };
 140
 141 struct symtab {
 142         struct hashtab tab;
 143 };
 144
 145 struct event_fmt {
 146         const char *subsys;
 147         const char *fmt;
 148 };
 149
 150 struct event_filter_unresolved {
 151         TAILQ_ENTRY(event_filter_unresolved) link;
 152         evtr_filter_t filt;
 153 };
 154
 155 struct id_map {
 156         RB_ENTRY(id_map) rb_node;
 157         int id;
 158         const void *data;
 159 };
 160
 161 RB_HEAD(id_tree, id_map);
 162 struct string_map {
 163         struct id_tree root;
 164 };
 165
 166 struct fmt_map {
 167         struct id_tree root;
 168 };
 169
 170 RB_HEAD(thread_tree, evtr_thread);
 171
 172 struct thread_map {
 173         struct thread_tree root;
 174 };
 175
 176 struct event_callback {
 177         void (*cb)(evtr_event_t, void *data);
 178         void *data;     /* this field must be malloc()ed */
 179 };
 180
 181 struct cpu {
 182         struct evtr_thread *td; /* currently executing thread */
 183         double freq;
 184 };
 185
 186 struct evtr {
 187         FILE *f;
 188         int flags;
 189         int err;
 190         const char *errmsg;
 191         off_t bytes;
 192         union {
 193                 /*
 194                  * When writing, we keep track of the strings we've
 195                  * already dumped so we only dump them once.
 196                  * Paths, function names etc belong to different
 197                  * namespaces.
 198                  */
 199                 struct hashtab_str *strings[EVTR_NS_MAX - 1];
 200                 /*
 201                  * When reading, we build a map from id to string.
 202                  * Every id must be defined at the point of use.
 203                  */
 204                 struct string_map maps[EVTR_NS_MAX - 1];
 205         };
 206         union {
 207                 /* same as above, but for subsys+fmt pairs */
 208                 struct fmt_map fmtmap;
 209                 struct hashtab_str *fmts;
 210         };
 211         struct thread_map threads;
 212         struct cpu *cpus;
 213         int ncpus;
 214 };
 215
 216 struct evtr_query {
 217         evtr_t evtr;
 218         off_t off;
 219         evtr_filter_t filt;
 220         int nfilt;
 221         int nmatched;
 222         int ntried;
 223         void *buf;
 224         int bufsize;
 225         struct symtab *symtab;
 226         int ncbs;
 227         struct event_callback **cbs;
 228         /*
 229          * Filters that have a format specified and we
 230          * need to resolve that to an fmtid
 231          */
 232         TAILQ_HEAD(, event_filter_unresolved) unresolved_filtq;
 233         int err;
 234         const char *errmsg;
 235         int flags;
 236         struct evtr_event pending_event;
 237 };
 238
 239 void
 240 evtr_set_debug(const char *str)
 241 {
 242         printd_set_flags(str, &evtr_debug);
 243 }
 244
 245 static int id_map_cmp(struct id_map *, struct id_map *);
 246 RB_PROTOTYPE2(id_tree, id_map, rb_node, id_map_cmp, int);
 247 RB_GENERATE2(id_tree, id_map, rb_node, id_map_cmp, int, id);
 248
 249 static int thread_cmp(struct evtr_thread *, struct evtr_thread *);
 250 RB_PROTOTYPE2(thread_tree, evtr_thread, rb_node, thread_cmp, void *);
 251 RB_GENERATE2(thread_tree, evtr_thread, rb_node, thread_cmp, void *, id);
 252
 253 static inline
 254 void
 255 validate_string(const char *str)
 256 {
 257         if (!(evtr_debug & MISC))
 258                 return;
 259         for (; *str; ++str)
 260                 assert(isprint(*str));
 261 }
 262
 263 static
 264 void
 265 id_tree_free(struct id_tree *root)
 266 {
 267         struct id_map *v, *n;
 268
 269         for (v = RB_MIN(id_tree, root); v; v = n) {
 270                 n = RB_NEXT(id_tree, root, v);
 271                 RB_REMOVE(id_tree, root, v);
 272         }
 273 }
 274
 275 static
 276 int
 277 evtr_register_callback(evtr_query_t q, void (*fn)(evtr_event_t, void *), void *d)
 278 {
 279         struct event_callback *cb;
 280         void *cbs;
 281
 282         if (!(cb = malloc(sizeof(*cb)))) {
 283                 q->err = ENOMEM;
 284                 return !0;
 285         }
 286         cb->cb = fn;
 287         cb->data = d;
 288         if (!(cbs = realloc(q->cbs, (++q->ncbs) * sizeof(cb)))) {
 289                 --q->ncbs;
 290                 free(cb);
 291                 q->err = ENOMEM;
 292                 return !0;
 293         }
 294         q->cbs = cbs;
 295         q->cbs[q->ncbs - 1] = cb;
 296         return 0;
 297 }
 298
 299 static
 300 void
 301 evtr_deregister_callbacks(evtr_query_t q)
 302 {
 303         int i;
 304
 305         for (i = 0; i < q->ncbs; ++i) {
 306                 free(q->cbs[i]);
 307         }
 308         free(q->cbs);
 309         q->cbs = NULL;
 310 }
 311
 312 static
 313 void
 314 evtr_run_callbacks(evtr_event_t ev, evtr_query_t q)
 315 {
 316         struct event_callback *cb;
 317         int i;
 318
 319         for (i = 0; i < q->ncbs; ++i) {
 320                 cb = q->cbs[i];
 321                 cb->cb(ev, cb->data);
 322         }
 323 }
 324
 325 static
 326 struct cpu *
 327 evtr_cpu(evtr_t evtr, int c)
 328 {
 329         if ((c < 0) || (c >= evtr->ncpus))
 330                 return NULL;
 331         return &evtr->cpus[c];
 332 }
 333
 334 static
 335 int
 336 parse_format_data(evtr_event_t ev, const char *fmt, ...) __attribute__((format (scanf, 2, 3)));
 337 static
 338 int
 339 parse_format_data(evtr_event_t ev, const char *fmt, ...)
 340 {
 341         va_list ap;
 342         char buf[2048];
 343
 344         if (strcmp(fmt, ev->fmt))
 345                 return 0;
 346         vsnprintf(buf, sizeof(buf), fmt, __DECONST(void *, ev->fmtdata));
 347         printd(MISC, "string is: %s\n", buf);
 348         va_start(ap, fmt);
 349         return vsscanf(buf, fmt, ap);
 350 }
 351
 352 static
 353 void
 354 evtr_deregister_filters(evtr_query_t q, evtr_filter_t filt, int nfilt)
 355 {
 356         struct event_filter_unresolved *u, *tmp;
 357         int i;
 358         TAILQ_FOREACH_MUTABLE(u, &q->unresolved_filtq, link, tmp) {
 359                 for (i = 0; i < nfilt; ++i) {
 360                         if (u->filt == &filt[i]) {
 361                                 TAILQ_REMOVE(&q->unresolved_filtq, u, link);
 362                         }
 363                 }
 364         }
 365 }
 366
 367 static
 368 int
 369 evtr_filter_register(evtr_query_t q, evtr_filter_t filt)
 370 {
 371         struct event_filter_unresolved *res;
 372
 373         if (!(res = malloc(sizeof(*res)))) {
 374                 q->err = ENOMEM;
 375                 return !0;
 376         }
 377         res->filt = filt;
 378         TAILQ_INSERT_TAIL(&q->unresolved_filtq, res, link);
 379         return 0;
 380 }
 381
 382 static
 383 int
 384 evtr_query_needs_parsing(evtr_query_t q)
 385 {
 386         int i;
 387
 388         for (i = 0; i < q->nfilt; ++i)
 389                 if (q->filt[i].ev_type == EVTR_TYPE_STMT)
 390                         return !0;
 391         return 0;
 392 }
 393
 394 void
 395 evtr_event_data(evtr_event_t ev, char *buf, size_t len)
 396 {
 397         /*
 398          * XXX: we implicitly trust the format string.
 399          * We shouldn't.
 400          */
 401         if (ev->fmtdatalen) {
 402                 vsnprintf(buf, len, ev->fmt, __DECONST(void *, ev->fmtdata));
 403         } else {
 404                 strlcpy(buf, ev->fmt, len);
 405         }
 406 }
 407
 408 int
 409 evtr_error(evtr_t evtr)
 410 {
 411         return evtr->err || (evtr->errmsg != NULL);
 412 }
 413
 414 const char *
 415 evtr_errmsg(evtr_t evtr)
 416 {
 417         return evtr->errmsg ? evtr->errmsg : strerror(evtr->err);
 418 }
 419
 420 int
 421 evtr_query_error(evtr_query_t q)
 422 {
 423         return q->err || (q->errmsg != NULL) || evtr_error(q->evtr);
 424 }
 425
 426 const char *
 427 evtr_query_errmsg(evtr_query_t q)
 428 {
 429         return q->errmsg ? q->errmsg :
 430                 (q->err ? strerror(q->err) :
 431                  (evtr_errmsg(q->evtr)));
 432 }
 433
 434 static
 435 int
 436 id_map_cmp(struct id_map *a, struct id_map *b)
 437 {
 438         return a->id - b->id;
 439 }
 440
 441 static
 442 int
 443 thread_cmp(struct evtr_thread *a, struct evtr_thread *b)
 444 {
 445         ptrdiff_t d;
 446         d =  a->id - b->id;
 447         if (d < 0)
 448                 return -1;
 449         if (!d)
 450                 return 0;
 451         return 1;
 452 }
 453
 454 #define DEFINE_MAP_FIND(prefix, type)           \
 455         static                                  \
 456         type                            \
 457         prefix ## _map_find(struct id_tree *tree, int id)\
 458         {                                                \
 459                 struct id_map *sid;                      \
 460                                                         \
 461                 sid = id_tree_RB_LOOKUP(tree, id);      \
 462                 return sid ? sid->data : NULL;          \
 463         }
 464
 465 DEFINE_MAP_FIND(string, const char *)
 466 DEFINE_MAP_FIND(fmt, const struct event_fmt *)
 467
 468 static
 469 struct evtr_thread *
 470 thread_map_find(struct thread_map *map, void *id)
 471 {
 472         return thread_tree_RB_LOOKUP(&map->root, id);
 473 }
 474
 475 #define DEFINE_MAP_INSERT(prefix, type, _cmp, _dup)     \
 476         static                                  \
 477         int                                                             \
 478         prefix ## _map_insert(struct id_tree *tree, type data, int id) \
 479         {                                                               \
 480         struct id_map *sid, *osid;                                      \
 481                                                                         \
 482         sid = malloc(sizeof(*sid));                                     \
 483         if (!sid) {                                                     \
 484                 return ENOMEM;                                          \
 485         }                                                               \
 486         sid->id = id;                                                   \
 487         sid->data = data;                                               \
 488         if ((osid = id_tree_RB_INSERT(tree, sid))) {                    \
 489                 free(sid);                                              \
 490                 if (_cmp((type)osid->data, data)) {                     \
 491                         return EEXIST;                                  \
 492                 }                                                       \
 493                 printd(DS, "mapping already exists, skipping\n");               \
 494                 /* we're OK with redefinitions of an id to the same string */ \
 495                 return 0;                                               \
 496         }                                                               \
 497         /* only do the strdup if we're inserting a new string */        \
 498         sid->data = _dup(data);         /* XXX: oom */                  \
 499         return 0;                                                       \
 500 }
 501
 502 static
 503 void
 504 thread_map_insert(struct thread_map *map, struct evtr_thread *td)
 505 {
 506         struct evtr_thread *otd;
 507
 508         if ((otd = thread_tree_RB_INSERT(&map->root, td))) {
 509                 /*
 510                  * Thread addresses might be reused, we're
 511                  * ok with that.
 512                  * DANGER, Will Robinson: this means the user
 513                  * of the API needs to copy event->td if they
 514                  * want it to remain stable.
 515                  */
 516                 free((void *)otd->comm);
 517                 otd->comm = td->comm;
 518                 free(td);
 519         }
 520 }
 521
 522 static
 523 int
 524 event_fmt_cmp(const struct event_fmt *a, const struct event_fmt *b)
 525 {
 526         int ret = 0;
 527
 528         if (a->subsys) {
 529                 if (b->subsys) {
 530                         ret = strcmp(a->subsys, b->subsys);
 531                 } else {
 532                         ret = strcmp(a->subsys, "");
 533                 }
 534         } else if (b->subsys) {
 535                         ret = strcmp("", b->subsys);
 536         }
 537         if (ret)
 538                 return ret;
 539         return strcmp(a->fmt, b->fmt);
 540 }
 541
 542 static
 543 struct event_fmt *
 544 event_fmt_dup(const struct event_fmt *o)
 545 {
 546         struct event_fmt *n;
 547
 548         if (!(n = malloc(sizeof(*n)))) {
 549                 return n;
 550         }
 551         memcpy(n, o, sizeof(*n));
 552         return n;
 553 }
 554
 555 DEFINE_MAP_INSERT(string, const char *, strcmp, strdup)
 556 DEFINE_MAP_INSERT(fmt, const struct event_fmt *, event_fmt_cmp, event_fmt_dup)
 557
 558 int
 559 hash_find(const struct hashtab *tab, uintptr_t key, uintptr_t *val)
 560 {
 561         struct hashentry *ent;
 562
 563         for(ent = tab->buckets[tab->hashfunc(key)];
 564             ent && tab->cmpfunc(ent->key, key);
 565             ent = ent->next);
 566
 567         if (!ent)
 568                 return !0;
 569         *val = ent->val;
 570         return 0;
 571 }
 572
 573 struct hashentry *
 574 hash_insert(struct hashtab *tab, uintptr_t key, uintptr_t val)
 575 {
 576         struct hashentry *ent;
 577         int hsh;
 578
 579         if (!(ent = malloc(sizeof(*ent)))) {
 580                 fprintf(stderr, "out of memory\n");
 581                 return NULL;
 582         }
 583         hsh = tab->hashfunc(key);
 584         ent->next = tab->buckets[hsh];
 585         ent->key = key;
 586         ent->val = val;
 587         tab->buckets[hsh] = ent;
 588         return ent;
 589 }
 590
 591 static
 592 uintptr_t
 593 cmpfunc_pointer(uintptr_t a, uintptr_t b)
 594 {
 595         return b - a;
 596 }
 597
 598 static
 599 uintptr_t
 600 hashfunc_pointer(uintptr_t p)
 601 {
 602         return p % NR_BUCKETS;
 603 }
 604
 605 struct hashtab *
 606 hash_new(void)
 607 {
 608         struct hashtab *tab;
 609         if (!(tab = calloc(sizeof(struct hashtab), 1)))
 610                 return tab;
 611         tab->hashfunc = &hashfunc_pointer;
 612         tab->cmpfunc = &cmpfunc_pointer;
 613         return tab;
 614 }
 615
 616 struct hashtab_str {    /* string -> id map */
 617         struct hashtab tab;
 618         uint16_t id;
 619 };
 620
 621 static
 622 uintptr_t
 623 hashfunc_string(uintptr_t p)
 624 {
 625         const char *str = (char *)p;
 626         unsigned long hash = 5381;
 627         int c;
 628
 629         while ((c = *str++))
 630             hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
 631         return hash  % NR_BUCKETS;
 632 }
 633
 634 static
 635 uintptr_t
 636 cmpfunc_string(uintptr_t a, uintptr_t b)
 637 {
 638         return strcmp((char *)a, (char *)b);
 639 }
 640
 641
 642 static
 643 struct hashtab_str *
 644 strhash_new(void)
 645 {
 646         struct hashtab_str *strtab;
 647         if (!(strtab = calloc(sizeof(struct hashtab_str), 1)))
 648                 return strtab;
 649         strtab->tab.hashfunc = &hashfunc_string;
 650         strtab->tab.cmpfunc = &cmpfunc_string;
 651         return strtab;
 652 }
 653
 654 static
 655 void
 656 strhash_destroy(struct hashtab_str *strtab)
 657 {
 658         free(strtab);
 659 }
 660
 661 static
 662 int
 663 strhash_find(struct hashtab_str *strtab, const char *str, uint16_t *id)
 664 {
 665         uintptr_t val;
 666
 667         if (hash_find(&strtab->tab, (uintptr_t)str, &val))
 668                 return !0;
 669         *id = (uint16_t)val;
 670         return 0;
 671 }
 672
 673 static
 674 int
 675 strhash_insert(struct hashtab_str *strtab, const char *str, uint16_t *id)
 676 {
 677         uintptr_t val;
 678
 679         val = ++strtab->id;
 680         if (strtab->id == 0) {
 681                 fprintf(stderr, "too many strings\n");
 682                 return ERANGE;
 683         }
 684         str = strdup(str);
 685         if (!str) {
 686                 fprintf(stderr, "out of memory\n");
 687                 --strtab->id;
 688                 return ENOMEM;
 689         }
 690         hash_insert(&strtab->tab, (uintptr_t)str, (uintptr_t)val);
 691         *id = strtab->id;
 692         return 0;
 693 }
 694
 695 struct symtab *
 696 symtab_new(void)
 697 {
 698         struct symtab *symtab;
 699         if (!(symtab = calloc(sizeof(struct symtab), 1)))
 700                 return symtab;
 701         symtab->tab.hashfunc = &hashfunc_string;
 702         symtab->tab.cmpfunc = &cmpfunc_string;
 703         return symtab;
 704 }
 705
 706 void
 707 symtab_destroy(struct symtab *symtab)
 708 {
 709         free(symtab);
 710 }
 711
 712 struct evtr_variable *
 713 symtab_find(const struct symtab *symtab, const char *str)
 714 {
 715         uintptr_t val;
 716
 717         if (hash_find(&symtab->tab, (uintptr_t)str, &val))
 718                 return NULL;
 719         return (struct evtr_variable *)val;
 720 }
 721
 722 int
 723 symtab_insert(struct symtab *symtab, const char *name,
 724                struct evtr_variable *var)
 725 {
 726         name = strdup(name);
 727         if (!name) {
 728                 fprintf(stderr, "out of memory\n");
 729                 return ENOMEM;
 730         }
 731         hash_insert(&symtab->tab, (uintptr_t)name, (uintptr_t)var);
 732         return 0;
 733 }
 734
 735 static
 736 int
 737 evtr_filter_match(evtr_query_t q, evtr_filter_t f, evtr_event_t ev)
 738 {
 739         if ((f->cpu != -1) && (f->cpu != ev->cpu))
 740                 return 0;
 741
 742         assert(!(f->flags & FILTF_ID));
 743         if (ev->type != f->ev_type)
 744                 return 0;
 745         if (ev->type == EVTR_TYPE_PROBE) {
 746                 if (f->fmt && strcmp(ev->fmt, f->fmt))
 747                         return 0;
 748         } else if (ev->type == EVTR_TYPE_STMT) {
 749                 struct evtr_variable *var;
 750                 /* resolve var */
 751                 /* XXX: no need to do that *every* time */
 752                 parse_var(f->var, q->symtab, &var);
 753                 if (var != ev->stmt.var)
 754                         return 0;
 755         }
 756         return !0;
 757 }
 758
 759 static
 760 int
 761 evtr_match_filters(struct evtr_query *q, evtr_event_t ev)
 762 {
 763         int i;
 764
 765         /* no filters means we're interested in all events */
 766         if (!q->nfilt)
 767                 return !0;
 768         ++q->ntried;
 769         for (i = 0; i < q->nfilt; ++i) {
 770                 if (evtr_filter_match(q, &q->filt[i], ev)) {
 771                         ++q->nmatched;
 772                         return !0;
 773                 }
 774         }
 775         return 0;
 776 }
 777
 778 static
 779 void
 780 parse_callback(evtr_event_t ev, void *d)
 781 {
 782         evtr_query_t q = (evtr_query_t)d;
 783         if (ev->type != EVTR_TYPE_PROBE)
 784                 return;
 785         if (!ev->fmt || (ev->fmt[0] != '#'))
 786                 return;
 787         /*
 788          * Copy the event to ->pending_event, then call
 789          * the parser to convert it into a synthesized
 790          * EVTR_TYPE_STMT event.
 791          */
 792         memcpy(&q->pending_event, ev, sizeof(ev));
 793         parse_string(&q->pending_event, q->symtab, &ev->fmt[1]);
 794         if (!evtr_match_filters(q, &q->pending_event))
 795                 return;
 796         /*
 797          * This will cause us to return ->pending_event next time
 798          * we're called.
 799          */
 800         q->flags |= EVTRQF_PENDING;
 801 }
 802
 803 static
 804 void
 805 thread_creation_callback(evtr_event_t ev, void *d)
 806 {
 807         evtr_query_t q = (evtr_query_t)d;
 808         evtr_t evtr = q->evtr;
 809         struct evtr_thread *td;
 810         void *ktd;
 811         char buf[20];
 812
 813         if (parse_format_data(ev, "new_td %p %s", &ktd, buf) != 2) {
 814                 return;
 815         }
 816         buf[19] = '\0';
 817
 818         if (!(td = malloc(sizeof(*td)))) {
 819                 q->err = ENOMEM;
 820                 return;
 821         }
 822         td->id = ktd;
 823         td->userdata = NULL;
 824         if (!(td->comm = strdup(buf))) {
 825                 free(td);
 826                 q->err = ENOMEM;
 827                 return;
 828         }
 829         printd(DS, "inserting new thread %p: %s\n", td->id, td->comm);
 830         thread_map_insert(&evtr->threads, td);
 831 }
 832
 833 static
 834 void
 835 thread_switch_callback(evtr_event_t ev, void *d)
 836 {
 837         evtr_t evtr = ((evtr_query_t)d)->evtr;
 838         struct evtr_thread *tdp, *tdn;
 839         void *ktdp, *ktdn;
 840         struct cpu *cpu;
 841         static struct evtr_event tdcr;
 842         static char *fmt = "new_td %p %s";
 843         char tidstr[40];
 844         char fmtdata[sizeof(void *) + sizeof(char *)];
 845
 846         cpu = evtr_cpu(evtr, ev->cpu);
 847         if (!cpu) {
 848                 printw("invalid cpu %d\n", ev->cpu);
 849                 return;
 850         }
 851         if (parse_format_data(ev, "sw  %p > %p", &ktdp, &ktdn) != 2) {
 852                 return;
 853         }
 854         tdp = thread_map_find(&evtr->threads, ktdp);
 855         if (!tdp) {
 856                 printd(DS, "switching from unknown thread %p\n", ktdp);
 857         }
 858         tdn = thread_map_find(&evtr->threads, ktdn);
 859         if (!tdn) {
 860                 /*
 861                  * Fake a thread creation event for threads we
 862                  * haven't seen before.
 863                  */
 864                 tdcr.type = EVTR_TYPE_PROBE;
 865                 tdcr.ts = ev->ts;
 866                 tdcr.file = NULL;
 867                 tdcr.func = NULL;
 868                 tdcr.line = 0;
 869                 tdcr.fmt = fmt;
 870                 tdcr.fmtdata = &fmtdata;
 871                 tdcr.fmtdatalen = sizeof(fmtdata);
 872                 tdcr.cpu = ev->cpu;
 873                 tdcr.td = NULL;
 874                 snprintf(tidstr, sizeof(tidstr), "%p", ktdn);
 875                 ((void **)fmtdata)[0] = ktdn;
 876                 ((char **)fmtdata)[1] = &tidstr[0];
 877                 thread_creation_callback(&tdcr, d);
 878
 879                 tdn = thread_map_find(&evtr->threads, ktdn);
 880                 assert(tdn != NULL);
 881                 printd(DS, "switching to unknown thread %p\n", ktdn);
 882                 cpu->td = tdn;
 883                 return;
 884         }
 885         printd(DS, "cpu %d: switching to thread %p\n", ev->cpu, ktdn);
 886         cpu->td = tdn;
 887 }
 888
 889 static
 890 void
 891 assert_foff_in_sync(evtr_t evtr)
 892 {
 893         off_t off;
 894
 895         /*
 896          * We keep our own offset because we
 897          * might want to support mmap()
 898          */
 899         off = ftello(evtr->f);
 900         if (evtr->bytes != off) {
 901                 fprintf(stderr, "bytes %jd, off %jd\n", evtr->bytes, off);
 902                 abort();
 903         }
 904 }
 905
 906 static
 907 int
 908 evtr_write(evtr_t evtr, const void *buf, size_t bytes)
 909 {
 910         assert_foff_in_sync(evtr);
 911         if (fwrite(buf, bytes, 1, evtr->f) != 1) {
 912                 evtr->err = errno;
 913                 evtr->errmsg = strerror(errno);
 914                 return !0;
 915         }
 916         evtr->bytes += bytes;
 917         assert_foff_in_sync(evtr);
 918         return 0;
 919 }
 920
 921 /*
 922  * Called after dumping a record to make sure the next
 923  * record is REC_ALIGN aligned. This does not make much sense,
 924  * as we shouldn't be using packed structs anyway.
 925  */
 926 static
 927 int
 928 evtr_dump_pad(evtr_t evtr)
 929 {
 930         size_t pad;
 931         static char buf[REC_ALIGN];
 932
 933         pad = REC_ALIGN - (evtr->bytes % REC_ALIGN);
 934         if (pad > 0) {
 935                 return evtr_write(evtr, buf, pad);
 936         }
 937         return 0;
 938 }
 939
 940 /*
 941  * We make sure that there is a new record every REC_BOUNDARY
 942  * bytes, this costs next to nothing in space and allows for
 943  * fast seeking.
 944  */
 945 static
 946 int
 947 evtr_dump_avoid_boundary(evtr_t evtr, size_t bytes)
 948 {
 949         unsigned pad, i;
 950         static char buf[256];
 951
 952         pad = REC_BOUNDARY - (evtr->bytes % REC_BOUNDARY);
 953         /* if adding @bytes would cause us to cross a boundary... */
 954         if (bytes > pad) {
 955                 /* then pad to the boundary */
 956                 for (i = 0; i < (pad / sizeof(buf)); ++i) {
 957                         if (evtr_write(evtr, buf, sizeof(buf))) {
 958                                 return !0;
 959                         }
 960                 }
 961                 i = pad % sizeof(buf);
 962                 if (i) {
 963                         if (evtr_write(evtr, buf, i)) {
 964                                 return !0;
 965                         }
 966                 }
 967         }
 968         return 0;
 969 }
 970
 971 static
 972 int
 973 evtr_dump_fmt(evtr_t evtr, uint64_t ts, const evtr_event_t ev)
 974 {
 975         struct fmt_event_header fmt;
 976         uint16_t id;
 977         int err;
 978         char *subsys = "", buf[1024];
 979
 980         if (strlcpy(buf, subsys, sizeof(buf)) >= sizeof(buf)) {
 981                 evtr->errmsg = "name of subsystem is too large";
 982                 evtr->err = ERANGE;
 983                 return 0;
 984         }
 985         if (strlcat(buf, ev->fmt, sizeof(buf)) >= sizeof(buf)) {
 986                 evtr->errmsg = "fmt + name of subsystem is too large";
 987                 evtr->err = ERANGE;
 988                 return 0;
 989         }
 990
 991         if (!strhash_find(evtr->fmts, buf, &id)) {
 992                 return id;
 993         }
 994         if ((err = strhash_insert(evtr->fmts, buf, &id))) {
 995                 evtr->err = err;
 996                 return 0;
 997         }
 998
 999         fmt.eh.type = EVTR_TYPE_FMT;
1000         fmt.eh.ts = ts;
1001         fmt.subsys_len = strlen(subsys);
1002         fmt.fmt_len = strlen(ev->fmt);
1003         fmt.id = id;
1004         if (evtr_dump_avoid_boundary(evtr, sizeof(fmt) + fmt.subsys_len +
1005                                      fmt.fmt_len))
1006                 return 0;
1007         if (evtr_write(evtr, &fmt, sizeof(fmt)))
1008                 return 0;
1009         if (evtr_write(evtr, subsys, fmt.subsys_len))
1010                 return 0;
1011         if (evtr_write(evtr, ev->fmt, fmt.fmt_len))
1012                 return 0;
1013         if (evtr_dump_pad(evtr))
1014                 return 0;
1015         return fmt.id;
1016 }
1017
1018 /*
1019  * Replace string pointers or string ids in fmtdata
1020  */
1021 static
1022 int
1023 mangle_string_ptrs(const char *fmt, uint8_t *fmtdata,
1024                    const char *(*replace)(void *, const char *), void *ctx)
1025 {
1026         const char *f, *p;
1027         size_t skipsize, intsz;
1028         int ret = 0;
1029
1030         for (f = fmt; f[0] != '\0'; ++f) {
1031                 if (f[0] != '%')
1032                         continue;
1033                 ++f;
1034                 skipsize = 0;
1035                 for (p = f; p[0]; ++p) {
1036                         int again = 0;
1037                         /*
1038                          * Eat flags. Notice this will accept duplicate
1039                          * flags.
1040                          */
1041                         switch (p[0]) {
1042                         case '#':
1043                         case '0':
1044                         case '-':
1045                         case ' ':
1046                         case '+':
1047                         case '\'':
1048                                 again = !0;
1049                                 break;
1050                         }
1051                         if (!again)
1052                                 break;
1053                 }
1054                 /* Eat minimum field width, if any */
1055                 for (; isdigit(p[0]); ++p)
1056                         ;
1057                 if (p[0] == '.')
1058                         ++p;
1059                 /* Eat precision, if any */
1060                 for (; isdigit(p[0]); ++p)
1061                         ;
1062                 intsz = 0;
1063                 switch (p[0]) {
1064                 case 'l':
1065                         if (p[1] == 'l') {
1066                                 ++p;
1067                                 intsz = sizeof(long long);
1068                         } else {
1069                                 intsz = sizeof(long);
1070                         }
1071                         break;
1072                 case 'j':
1073                         intsz = sizeof(intmax_t);
1074                         break;
1075                 case 't':
1076                         intsz = sizeof(ptrdiff_t);
1077                         break;
1078                 case 'z':
1079                         intsz = sizeof(size_t);
1080                         break;
1081                 default:
1082                         break;
1083                 }
1084                 if (intsz != 0)
1085                         ++p;
1086                 else
1087                         intsz = sizeof(int);
1088
1089                 switch (p[0]) {
1090                 case 'd':
1091                 case 'i':
1092                 case 'o':
1093                 case 'u':
1094                 case 'x':
1095                 case 'X':
1096                 case 'c':
1097                         skipsize = intsz;
1098                         break;
1099                 case 'p':
1100                         skipsize = sizeof(void *);
1101                         break;
1102                 case 'f':
1103                         if (p[-1] == 'l')
1104                                 skipsize = sizeof(double);
1105                         else
1106                                 skipsize = sizeof(float);
1107                         break;
1108                 case 's':
1109                         ((const char **)fmtdata)[0] =
1110                                 replace(ctx, ((char **)fmtdata)[0]);
1111                         skipsize = sizeof(char *);
1112                         ++ret;
1113                         break;
1114                 default:
1115                         fprintf(stderr, "Unknown conversion specifier %c "
1116                                 "in fmt starting with %s", p[0], f - 1);
1117                         return -1;
1118                 }
1119                 fmtdata += skipsize;
1120         }
1121         return ret;
1122 }
1123
1124 /* XXX: do we really want the timestamp? */
1125 static
1126 int
1127 evtr_dump_string(evtr_t evtr, uint64_t ts, const char *str, int ns)
1128 {
1129         struct string_event_header s;
1130         int err;
1131         uint16_t id;
1132
1133         assert((0 <= ns) && (ns < EVTR_NS_MAX));
1134         if (!strhash_find(evtr->strings[ns], str, &id)) {
1135                 return id;
1136         }
1137         if ((err = strhash_insert(evtr->strings[ns], str, &id))) {
1138                 evtr->err = err;
1139                 return 0;
1140         }
1141
1142         printd(DS, "hash_insert %s ns %d id %d\n", str, ns, id);
1143         s.eh.type = EVTR_TYPE_STR;
1144         s.eh.ts = ts;
1145         s.ns = ns;
1146         s.id = id;
1147         s.len = strnlen(str, PATH_MAX);
1148
1149         if (evtr_dump_avoid_boundary(evtr, sizeof(s) + s.len))
1150                 return 0;
1151         if (evtr_write(evtr, &s, sizeof(s)))
1152                 return 0;
1153         if (evtr_write(evtr, str, s.len))
1154                 return 0;
1155         if (evtr_dump_pad(evtr))
1156                 return 0;
1157         return s.id;
1158 }
1159
1160 struct replace_ctx {
1161         evtr_t evtr;
1162         uint64_t ts;
1163 };
1164
1165 static
1166 const char *
1167 replace_strptr(void *_ctx, const char *s)
1168 {
1169         struct replace_ctx *ctx = _ctx;
1170         return (const char *)(uintptr_t)evtr_dump_string(ctx->evtr, ctx->ts, s,
1171                                                          EVTR_NS_DSTR);
1172 }
1173
1174 static
1175 const char *
1176 replace_strid(void *_ctx, const char *s)
1177 {
1178         struct replace_ctx *ctx = _ctx;
1179         const char *ret;
1180
1181         ret = string_map_find(&ctx->evtr->maps[EVTR_NS_DSTR - 1].root,
1182                               (int)(uintptr_t)s);
1183         if (!ret) {
1184                 fprintf(stderr, "Unknown id for data string\n");
1185                 ctx->evtr->errmsg = "unknown id for data string";
1186                 ctx->evtr->err = !0;
1187         }
1188         validate_string(ret);
1189         printd(DS, "replacing strid %d (ns %d) with string '%s' (or int %#x)\n",
1190                (int)(uintptr_t)s, EVTR_NS_DSTR, ret ? ret : "NULL", (int)(uintptr_t)ret);
1191         return ret;
1192 }
1193
1194 static
1195 int
1196 evtr_dump_probe(evtr_t evtr, evtr_event_t ev)
1197 {
1198         struct probe_event_header kev;
1199         char buf[1024];
1200
1201         memset(&kev, '\0', sizeof(kev));
1202         kev.eh.type = ev->type;
1203         kev.eh.ts = ev->ts;
1204         kev.line = ev->line;
1205         kev.cpu = ev->cpu;
1206         if (ev->file) {
1207                 kev.file = evtr_dump_string(evtr, kev.eh.ts, ev->file,
1208                                             EVTR_NS_PATH);
1209         }
1210         if (ev->func) {
1211                 kev.func = evtr_dump_string(evtr, kev.eh.ts, ev->func,
1212                                             EVTR_NS_FUNC);
1213         }
1214         if (ev->fmt) {
1215                 kev.fmt = evtr_dump_fmt(evtr, kev.eh.ts, ev);
1216         }
1217         if (ev->fmtdata) {
1218                 struct replace_ctx replctx = {
1219                         .evtr = evtr,
1220                         .ts = ev->ts,
1221                 };
1222                 assert(ev->fmtdatalen <= (int)sizeof(buf));
1223                 kev.datalen = ev->fmtdatalen;
1224                 /*
1225                  * Replace all string pointers with string ids before dumping
1226                  * the data.
1227                  */
1228                 memcpy(buf, ev->fmtdata, ev->fmtdatalen);
1229                 if (mangle_string_ptrs(ev->fmt, buf,
1230                                        replace_strptr, &replctx) < 0)
1231                         return !0;
1232                 if (evtr->err)
1233                         return evtr->err;
1234         }
1235         if (evtr_dump_avoid_boundary(evtr, sizeof(kev) + ev->fmtdatalen))
1236                 return !0;
1237         if (evtr_write(evtr, &kev, sizeof(kev)))
1238                 return !0;
1239         if (evtr_write(evtr, buf, ev->fmtdatalen))
1240                 return !0;
1241         if (evtr_dump_pad(evtr))
1242                 return !0;
1243         return 0;
1244 }
1245
1246 static
1247 int
1248 evtr_dump_sysinfo(evtr_t evtr, evtr_event_t ev)
1249 {
1250         uint8_t type = EVTR_TYPE_SYSINFO;
1251         uint16_t ncpus = ev->ncpus;
1252
1253         if (ncpus <= 0) {
1254                 evtr->errmsg = "invalid number of cpus";
1255                 return !0;
1256         }
1257         if (evtr_dump_avoid_boundary(evtr, sizeof(type) + sizeof(ncpus)))
1258                 return !0;
1259         if (evtr_write(evtr, &type, sizeof(type))) {
1260                 return !0;
1261         }
1262         if (evtr_write(evtr, &ncpus, sizeof(ncpus))) {
1263                 return !0;
1264         }
1265         if (evtr_dump_pad(evtr))
1266                 return !0;
1267         return 0;
1268 }
1269 static
1270 int
1271 evtr_dump_cpuinfo(evtr_t evtr, evtr_event_t ev)
1272 {
1273         struct cpuinfo_event_header ci;
1274         uint8_t type;
1275
1276         if (evtr_dump_avoid_boundary(evtr, sizeof(type) + sizeof(ci)))
1277                 return !0;
1278         type = EVTR_TYPE_CPUINFO;
1279         if (evtr_write(evtr, &type, sizeof(type))) {
1280                 return !0;
1281         }
1282         ci.cpu = ev->cpu;
1283         ci.freq = ev->cpuinfo.freq;
1284         if (evtr_dump_avoid_boundary(evtr, sizeof(ci)))
1285                 return !0;
1286         if (evtr_write(evtr, &ci, sizeof(ci))) {
1287                 return !0;
1288         }
1289         if (evtr_dump_pad(evtr))
1290                 return !0;
1291         return 0;
1292 }
1293
1294 int
1295 evtr_rewind(evtr_t evtr)
1296 {
1297         assert((evtr->flags & EVTRF_WR) == 0);
1298         evtr->bytes = 0;
1299         if (fseek(evtr->f, 0, SEEK_SET)) {
1300                 evtr->err = errno;
1301                 return !0;
1302         }
1303         return 0;
1304 }
1305
1306 int
1307 evtr_dump_event(evtr_t evtr, evtr_event_t ev)
1308 {
1309         switch (ev->type) {
1310         case EVTR_TYPE_PROBE:
1311                 return evtr_dump_probe(evtr, ev);
1312         case EVTR_TYPE_SYSINFO:
1313                 return evtr_dump_sysinfo(evtr, ev);
1314         case EVTR_TYPE_CPUINFO:
1315                 return evtr_dump_cpuinfo(evtr, ev);
1316         }
1317         evtr->errmsg = "unknown event type";
1318         return !0;
1319 }
1320
1321 static
1322 evtr_t
1323 evtr_alloc(FILE *f)
1324 {
1325         evtr_t evtr;
1326         if (!(evtr = malloc(sizeof(*evtr)))) {
1327                 return NULL;
1328         }
1329
1330         evtr->f = f;
1331         evtr->err = 0;
1332         evtr->errmsg = NULL;
1333         evtr->bytes = 0;
1334         return evtr;
1335 }
1336
1337 static int evtr_next_event(evtr_t, evtr_event_t);
1338
1339 evtr_t
1340 evtr_open_read(FILE *f)
1341 {
1342         evtr_t evtr;
1343         struct evtr_event ev;
1344         int i;
1345
1346         if (!(evtr = evtr_alloc(f))) {
1347                 return NULL;
1348         }
1349         evtr->flags = 0;
1350         for (i = 0; i < (EVTR_NS_MAX - 1); ++i) {
1351                 RB_INIT(&evtr->maps[i].root);
1352         }
1353         RB_INIT(&evtr->fmtmap.root);
1354         RB_INIT(&evtr->threads.root);
1355         evtr->cpus = NULL;
1356         evtr->ncpus = 0;
1357         /*
1358          * Load the first event so we can pick up any
1359          * sysinfo entries.
1360          */
1361         if (evtr_next_event(evtr, &ev)) {
1362                 goto free_evtr;
1363         }
1364         if (evtr_rewind(evtr))
1365                 goto free_evtr;
1366         return evtr;
1367 free_evtr:
1368         free(evtr);
1369         return NULL;
1370 }
1371
1372 evtr_t
1373 evtr_open_write(FILE *f)
1374 {
1375         evtr_t evtr;
1376         int i, j;
1377
1378         if (!(evtr = evtr_alloc(f))) {
1379                 return NULL;
1380         }
1381
1382         evtr->flags = EVTRF_WR;
1383         if (!(evtr->fmts = strhash_new()))
1384                 goto free_evtr;
1385         for (i = 0; i < EVTR_NS_MAX; ++i) {
1386                 evtr->strings[i] = strhash_new();
1387                 if (!evtr->strings[i]) {
1388                         for (j = 0; j < i; ++j) {
1389                                 strhash_destroy(evtr->strings[j]);
1390                         }
1391                         goto free_fmts;
1392                 }
1393         }
1394
1395         return evtr;
1396 free_fmts:
1397         strhash_destroy(evtr->fmts);
1398 free_evtr:
1399         free(evtr);
1400         return NULL;
1401 }
1402
1403 static
1404 void
1405 hashtab_destroy(struct hashtab *h)
1406 {
1407         struct hashentry *ent, *next;
1408         int i;
1409         for (i = 0; i < NR_BUCKETS; ++i) {
1410                 for (ent = h->buckets[i]; ent; ent = next) {
1411                         next = ent->next;
1412                         free(ent);
1413                 }
1414         }
1415         free(h);
1416 }
1417
1418 void
1419 evtr_close(evtr_t evtr)
1420 {
1421         int i;
1422
1423         if (evtr->flags & EVTRF_WR) {
1424                 hashtab_destroy(&evtr->fmts->tab);
1425                 for (i = 0; i < EVTR_NS_MAX; ++i)
1426                         hashtab_destroy(&evtr->strings[i]->tab);
1427         } else {
1428                 id_tree_free(&evtr->fmtmap.root);
1429                 for (i = 0; i < EVTR_NS_MAX - 1; ++i) {
1430                         id_tree_free(&evtr->maps[i].root);
1431                 }
1432         }
1433         free(evtr);
1434 }
1435
1436 static
1437 int
1438 evtr_read(evtr_t evtr, void *buf, size_t size)
1439 {
1440         assert(size > 0);
1441         assert_foff_in_sync(evtr);
1442         printd(IO, "evtr_read at %#jx, %zd bytes\n", evtr->bytes, size);
1443         if (fread(buf, size, 1, evtr->f) != 1) {
1444                 if (feof(evtr->f)) {
1445                         evtr->errmsg = "incomplete record";
1446                 } else {
1447                         evtr->errmsg = strerror(errno);
1448                 }
1449                 return !0;
1450         }
1451         evtr->bytes += size;
1452         assert_foff_in_sync(evtr);
1453         return 0;
1454 }
1455
1456 static
1457 int
1458 evtr_load_fmt(evtr_query_t q, char *buf)
1459 {
1460         evtr_t evtr = q->evtr;
1461         struct fmt_event_header *evh = (struct fmt_event_header *)buf;
1462         struct event_fmt *fmt;
1463         char *subsys = NULL, *fmtstr;
1464
1465         if (!(fmt = malloc(sizeof(*fmt)))) {
1466                 evtr->err = errno;
1467                 return !0;
1468         }
1469         if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
1470                       sizeof(*evh) - sizeof(evh->eh))) {
1471                 goto free_fmt;
1472         }
1473         assert(!evh->subsys_len);
1474         if (evh->subsys_len) {
1475                 if (!(subsys = malloc(evh->subsys_len))) {
1476                         evtr->err = errno;
1477                         goto free_fmt;
1478                 }
1479                 if (evtr_read(evtr, subsys, evh->subsys_len)) {
1480                         goto free_subsys;
1481                 }
1482                 fmt->subsys = subsys;
1483         } else {
1484                 fmt->subsys = "";
1485         }
1486         if (!(fmtstr = malloc(evh->fmt_len + 1))) {
1487                 evtr->err = errno;
1488                 goto free_subsys;
1489         }
1490         if (evtr_read(evtr, fmtstr, evh->fmt_len)) {
1491                 goto free_fmtstr;
1492         }
1493         fmtstr[evh->fmt_len] = '\0';
1494         fmt->fmt = fmtstr;
1495
1496         printd(DS, "fmt_map_insert (%d, %s)\n", evh->id, fmt->fmt);
1497         evtr->err = fmt_map_insert(&evtr->fmtmap.root, fmt, evh->id);
1498         switch (evtr->err) {
1499         case ENOMEM:
1500                 evtr->errmsg = "out of memory";
1501                 break;
1502         case EEXIST:
1503                 evtr->errmsg = "redefinition of an id to a "
1504                         "different format (corrupt input)";
1505                 break;
1506         default:
1507                 ;
1508         }
1509         return evtr->err;
1510
1511 free_fmtstr:
1512         free(fmtstr);
1513 free_subsys:
1514         if (subsys)
1515                 free(subsys);
1516 free_fmt:
1517         free(fmt);
1518         return !0;
1519 }
1520
1521 static
1522 int
1523 evtr_load_string(evtr_t evtr, char *buf)
1524 {
1525         char sbuf[PATH_MAX + 1];
1526         struct string_event_header *evh = (struct string_event_header *)buf;
1527
1528         if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
1529                       sizeof(*evh) - sizeof(evh->eh))) {
1530                 return !0;
1531         }
1532         if (evh->len > PATH_MAX) {
1533                 evtr->errmsg = "string too large (corrupt input)";
1534                 return !0;
1535         }
1536         if (evh->len && evtr_read(evtr, sbuf, evh->len)) {
1537                 return !0;
1538         }
1539         sbuf[evh->len] = 0;
1540         if (evh->ns >= EVTR_NS_MAX) {
1541                 evtr->errmsg = "invalid namespace (corrupt input)";
1542                 return !0;
1543         }
1544         validate_string(sbuf);
1545         printd(DS, "evtr_load_string:ns %d id %d : \"%s\"\n", evh->ns, evh->id,
1546                sbuf);
1547         evtr->err = string_map_insert(&evtr->maps[evh->ns - 1].root, sbuf, evh->id);
1548         switch (evtr->err) {
1549         case ENOMEM:
1550                 evtr->errmsg = "out of memory";
1551                 break;
1552         case EEXIST:
1553                 evtr->errmsg = "redefinition of an id to a "
1554                         "different string (corrupt input)";
1555                 break;
1556         default:
1557                 ;
1558         }
1559         return 0;
1560 }
1561
1562 static
1563 int
1564 evtr_skip(evtr_t evtr, off_t bytes)
1565 {
1566         if (fseek(evtr->f, bytes, SEEK_CUR)) {
1567                 evtr->err = errno;
1568                 evtr->errmsg = strerror(errno);
1569                 return !0;
1570         }
1571         evtr->bytes += bytes;
1572         return 0;
1573 }
1574
1575 /*
1576  * Make sure q->buf is at least len bytes
1577  */
1578 static
1579 int
1580 evtr_query_reserve_buf(struct evtr_query *q, int len)
1581 {
1582         void *tmp;
1583
1584         if (q->bufsize >= len)
1585                 return 0;
1586         if (!(tmp = realloc(q->buf, len)))
1587                 return !0;
1588         q->buf = tmp;
1589         q->bufsize = len;
1590         return 0;
1591 }
1592
1593 static
1594 int
1595 evtr_load_probe(evtr_t evtr, evtr_event_t ev, char *buf, struct evtr_query *q)
1596 {
1597         struct probe_event_header *evh = (struct probe_event_header *)buf;
1598         struct cpu *cpu;
1599
1600         if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
1601                       sizeof(*evh) - sizeof(evh->eh)))
1602                 return !0;
1603         memset(ev, '\0', sizeof(*ev));
1604         ev->ts = evh->eh.ts;
1605         ev->type = EVTR_TYPE_PROBE;
1606         ev->line = evh->line;
1607         ev->cpu = evh->cpu;
1608         if ((cpu = evtr_cpu(evtr, evh->cpu))) {
1609                 ev->td = cpu->td;
1610         } else {
1611                 ev->td = NULL;
1612         }
1613         if (evh->file) {
1614                 ev->file = string_map_find(
1615                         &evtr->maps[EVTR_NS_PATH - 1].root,
1616                         evh->file);
1617                 if (!ev->file) {
1618                         evtr->errmsg = "unknown id for file path";
1619                         evtr->err = !0;
1620                         ev->file = "<unknown>";
1621                 } else {
1622                         validate_string(ev->file);
1623                 }
1624         } else {
1625                 ev->file = "<unknown>";
1626         }
1627         if (evh->fmt) {
1628                 const struct event_fmt *fmt;
1629                 if (!(fmt = fmt_map_find(&evtr->fmtmap.root, evh->fmt))) {
1630                         evtr->errmsg = "unknown id for event fmt";
1631                         evtr->err = !0;
1632                         ev->fmt = NULL;
1633                 } else {
1634                         ev->fmt = fmt->fmt;
1635                         validate_string(fmt->fmt);
1636                 }
1637         }
1638         if (evh->datalen) {
1639                 if (evtr_query_reserve_buf(q, evh->datalen + 1)) {
1640                         evtr->err = ENOMEM;
1641                 } else if (!evtr_read(evtr, q->buf, evh->datalen)) {
1642                         struct replace_ctx replctx = {
1643                                 .evtr = evtr,
1644                                 .ts = ev->ts,
1645                         };
1646                         assert(ev->fmt);
1647
1648                         ev->fmtdata = q->buf;
1649                         /*
1650                          * If the format specifies any string pointers, there
1651                          * is a string id stored in the fmtdata. Look it up
1652                          * and replace it with a string pointer before
1653                          * returning it to the user.
1654                          */
1655                         if (mangle_string_ptrs(ev->fmt, __DECONST(uint8_t *,
1656                                                                   ev->fmtdata),
1657                                                replace_strid, &replctx) < 0)
1658                                 return evtr->err;
1659                         if (evtr->err)
1660                                 return evtr->err;
1661                         ((char *)ev->fmtdata)[evh->datalen] = '\0';
1662                         ev->fmtdatalen = evh->datalen;
1663                 }
1664         }
1665         evtr_run_callbacks(ev, q);
1666         return evtr->err;
1667 }
1668
1669 static
1670 int
1671 evtr_skip_to_record(evtr_t evtr)
1672 {
1673         int skip;
1674
1675         skip = REC_ALIGN - (evtr->bytes % REC_ALIGN);
1676         if (skip > 0) {
1677                 if (fseek(evtr->f, skip, SEEK_CUR)) {
1678                         evtr->err = errno;
1679                         evtr->errmsg = strerror(errno);
1680                         return !0;
1681                 }
1682                 evtr->bytes += skip;
1683         }
1684         return 0;
1685 }
1686
1687 static
1688 int
1689 evtr_load_sysinfo(evtr_t evtr)
1690 {
1691         uint16_t ncpus;
1692         int i;
1693
1694         if (evtr_read(evtr, &ncpus, sizeof(ncpus))) {
1695                 return !0;
1696         }
1697         if (evtr->cpus)
1698                 return 0;
1699         evtr->cpus = malloc(ncpus * sizeof(struct cpu));
1700         if (!evtr->cpus) {
1701                 evtr->err = ENOMEM;
1702                 return !0;
1703         }
1704         evtr->ncpus = ncpus;
1705         for (i = 0; i < ncpus; ++i) {
1706                 evtr->cpus[i].td = NULL;
1707                 evtr->cpus[i].freq = -1.0;
1708         }
1709         return 0;
1710 }
1711
1712 static
1713 int
1714 evtr_load_cpuinfo(evtr_t evtr)
1715 {
1716         struct cpuinfo_event_header cih;
1717         struct cpu *cpu;
1718
1719         if (evtr_read(evtr, &cih, sizeof(cih))) {
1720                 return !0;
1721         }
1722         if (cih.freq < 0.0) {
1723                 evtr->errmsg = "cpu freq is negative";
1724                 evtr->err = EINVAL;
1725                 return !0;
1726         }
1727         /*
1728          * Notice that freq is merely a multiplier with
1729          * which we convert a timestamp to seconds; if
1730          * ts is not in cycles, freq is not the frequency.
1731          */
1732         if (!(cpu = evtr_cpu(evtr, cih.cpu))) {
1733                 evtr->errmsg = "freq for invalid cpu";
1734                 evtr->err = EINVAL;
1735                 return !0;
1736         }
1737         cpu->freq = cih.freq;
1738         return 0;
1739 }
1740
1741 static
1742 int
1743 _evtr_next_event(evtr_t evtr, evtr_event_t ev, struct evtr_query *q)
1744 {
1745         char buf[MAX_EVHDR_SIZE];
1746         int ret, err, ntried, nmatched;
1747         struct trace_event_header *evhdr = (struct trace_event_header *)buf;
1748
1749         for (ret = 0; !ret;) {
1750                 if (q->flags & EVTRQF_PENDING) {
1751                         q->off = evtr->bytes;
1752                         memcpy(ev, &q->pending_event, sizeof(*ev));
1753                         q->flags &= ~EVTRQF_PENDING;
1754                         return 0;
1755                 }
1756                 if (evtr_read(evtr, &evhdr->type, 1)) {
1757                         if (feof(evtr->f)) {
1758                                 evtr->errmsg = NULL;
1759                                 evtr->err = 0;
1760                                 return -1;
1761                         }
1762                         return !0;
1763                 }
1764                 /*
1765                  * skip pad records -- this will only happen if there's a
1766                  * variable sized record close to the boundary
1767                  */
1768                 if (evhdr->type == EVTR_TYPE_PAD) {
1769                         evtr_skip_to_record(evtr);
1770                         continue;
1771                 }
1772                 if (evhdr->type == EVTR_TYPE_SYSINFO) {
1773                         evtr_load_sysinfo(evtr);
1774                         continue;
1775                 } else if (evhdr->type == EVTR_TYPE_CPUINFO) {
1776                         evtr_load_cpuinfo(evtr);
1777                         continue;
1778                 }
1779                 if (evtr_read(evtr, buf + 1, sizeof(*evhdr) - 1))
1780                         return feof(evtr->f) ? -1 : !0;
1781                 switch (evhdr->type) {
1782                 case EVTR_TYPE_PROBE:
1783                         ntried = q->ntried;
1784                         nmatched = q->nmatched;
1785                         if ((err = evtr_load_probe(evtr, ev, buf, q))) {
1786                                 if (err == -1) {
1787                                         /* no match */
1788                                         ret = 0;
1789                                 } else {
1790                                         return !0;
1791                                 }
1792                         } else {
1793                                 ret = !0;
1794                         }
1795                         break;
1796                 case EVTR_TYPE_STR:
1797                         if (evtr_load_string(evtr, buf)) {
1798                                 return !0;
1799                         }
1800                         break;
1801                 case EVTR_TYPE_FMT:
1802                         if (evtr_load_fmt(q, buf)) {
1803                                 return !0;
1804                         }
1805                         break;
1806                 default:
1807                         evtr->err = !0;
1808                         evtr->errmsg = "unknown event type (corrupt input?)";
1809                         return !0;
1810                 }
1811                 evtr_skip_to_record(evtr);
1812                 if (ret) {
1813                         if (!evtr_match_filters(q, ev)) {
1814                                 ret = 0;
1815                                 continue;
1816                         }
1817                         q->off = evtr->bytes;
1818                         return 0;
1819                 }
1820         }
1821         /* can't get here */
1822         return !0;
1823 }
1824
1825 static
1826 int
1827 evtr_next_event(evtr_t evtr, evtr_event_t ev)
1828 {
1829         struct evtr_query *q;
1830         int ret;
1831
1832         if (!(q = evtr_query_init(evtr, NULL, 0))) {
1833                 evtr->err = ENOMEM;
1834                 return !0;
1835         }
1836         ret = _evtr_next_event(evtr, ev, q);
1837         evtr_query_destroy(q);
1838         return ret;
1839 }
1840
1841 int
1842 evtr_last_event(evtr_t evtr, evtr_event_t ev)
1843 {
1844         struct stat st;
1845         int fd;
1846         off_t last_boundary;
1847
1848         if (evtr_error(evtr))
1849                 return !0;
1850
1851         fd = fileno(evtr->f);
1852         if (fstat(fd, &st))
1853                 return !0;
1854         /*
1855          * This skips pseudo records, so we can't provide
1856          * an event with all fields filled in this way.
1857          * It's doable, just needs some care. TBD.
1858          */
1859         if (0 && (st.st_mode & S_IFREG)) {
1860                 /*
1861                  * Skip to last boundary, that's the closest to the EOF
1862                  * location that we are sure contains a header so we can
1863                  * pick up the stream.
1864                  */
1865                 last_boundary = (st.st_size / REC_BOUNDARY) * REC_BOUNDARY;
1866                 /* XXX: ->bytes should be in query */
1867                 assert(evtr->bytes == 0);
1868                 evtr_skip(evtr, last_boundary);
1869         }
1870
1871
1872         /*
1873          * If we can't seek, we need to go through the whole file.
1874          * Since you can't seek back, this is pretty useless unless
1875          * you really are interested only in the last event.
1876          */
1877         while (!evtr_next_event(evtr, ev))
1878                 ;
1879         if (evtr_error(evtr))
1880                 return !0;
1881         evtr_rewind(evtr);
1882         return 0;
1883 }
1884
1885 struct evtr_query *
1886 evtr_query_init(evtr_t evtr, evtr_filter_t filt, int nfilt)
1887 {
1888         struct evtr_query *q;
1889         int i;
1890
1891         if (!(q = malloc(sizeof(*q)))) {
1892                 return q;
1893         }
1894         q->bufsize = 2;
1895         if (!(q->buf = malloc(q->bufsize))) {
1896                 goto free_q;
1897         }
1898         if (!(q->symtab = symtab_new()))
1899                 goto free_buf;
1900         q->evtr = evtr;
1901         q->off = 0;
1902         q->filt = filt;
1903         q->nfilt = nfilt;
1904         TAILQ_INIT(&q->unresolved_filtq);
1905         q->nmatched = 0;
1906         q->cbs = NULL;
1907         q->ncbs = 0;
1908         q->flags = 0;
1909         memset(&q->pending_event, '\0', sizeof(q->pending_event));
1910         if (evtr_register_callback(q, &thread_creation_callback, q)) {
1911                 goto free_symtab;
1912         }
1913         if (evtr_register_callback(q, &thread_switch_callback, q)) {
1914                 goto free_cbs;
1915         }
1916         if (evtr_query_needs_parsing(q) &&
1917             evtr_register_callback(q, &parse_callback, q)) {
1918                 goto free_cbs;
1919         }
1920
1921         for (i = 0; i < nfilt; ++i) {
1922                 filt[i].flags = 0;
1923                 if (filt[i].fmt == NULL)
1924                         continue;
1925                 if (evtr_filter_register(q, &filt[i])) {
1926                         evtr_deregister_filters(q, filt, i);
1927                         goto free_symtab;
1928                 }
1929         }
1930
1931         return q;
1932 free_cbs:
1933         evtr_deregister_callbacks(q);
1934 free_symtab:
1935         symtab_destroy(q->symtab);
1936 free_buf:
1937         free(q->buf);
1938 free_q:
1939         free(q);
1940         return NULL;
1941 }
1942
1943 void
1944 evtr_query_destroy(struct evtr_query *q)
1945 {
1946         evtr_deregister_filters(q, q->filt, q->nfilt);
1947
1948         free(q->buf);
1949         free(q);
1950 }
1951
1952 int
1953 evtr_query_next(struct evtr_query *q, evtr_event_t ev)
1954 {
1955         if (evtr_query_error(q))
1956                 return !0;
1957         /* we may support that in the future */
1958         if (q->off != q->evtr->bytes) {
1959                 q->errmsg = "evtr/query offset mismatch";
1960                 return !0;
1961         }
1962         return _evtr_next_event(q->evtr, ev, q);
1963 }
1964
1965 int
1966 evtr_ncpus(evtr_t evtr)
1967 {
1968         return evtr->ncpus;
1969 }
1970
1971 int
1972 evtr_cpufreqs(evtr_t evtr, double *freqs)
1973 {
1974         int i;
1975
1976         if (!freqs)
1977                 return EINVAL;
1978         for (i = 0; i < evtr->ncpus; ++i) {
1979                 freqs[i] = evtr->cpus[i].freq;
1980         }
1981         return 0;
1982 }