evtr
evtr->errmsg = "fmt + name of subsystem is too large";
evtr->err = ERANGE;
if (!strhash_find(evtr->fmts, buf, &id)) {
if ((err = strhash_insert(evtr->fmts, buf, &id))) {
evtr->err = err;
if (evtr_dump_avoid_boundary(evtr, sizeof(fmt) + fmt.subsys_len +
if (evtr_write(evtr, &fmt, sizeof(fmt)))
if (evtr_write(evtr, subsys, fmt.subsys_len))
if (evtr_write(evtr, ev->fmt, fmt.fmt_len))
if (evtr_dump_pad(evtr))
evtr_dump_string(evtr_t evtr, uint64_t ts, const char *str, int ns)
if (!strhash_find(evtr->strings[ns], str, &id)) {
if ((err = strhash_insert(evtr->strings[ns], str, &id))) {
evtr->err = err;
if (evtr_dump_avoid_boundary(evtr, sizeof(s) + s.len))
if (evtr_write(evtr, &s, sizeof(s)))
if (evtr_write(evtr, str, s.len))
if (evtr_dump_pad(evtr))
evtr_t evtr;
return (const char *)(uintptr_t)evtr_dump_string(ctx->evtr, ctx->ts, s,
ret = string_map_find(&ctx->evtr->maps[EVTR_NS_DSTR - 1].root,
ctx->evtr->errmsg = "unknown id for data string";
ctx->evtr->err = !0;
evtr_dump_probe(evtr_t evtr, evtr_event_t ev)
kev.file = evtr_dump_string(evtr, kev.eh.ts, ev->file,
kev.func = evtr_dump_string(evtr, kev.eh.ts, ev->func,
kev.fmt = evtr_dump_fmt(evtr, kev.eh.ts, ev);
.evtr = evtr,
if (evtr->err)
return evtr->err;
if (evtr_dump_avoid_boundary(evtr, sizeof(kev) + ev->fmtdatalen))
if (evtr_write(evtr, &kev, sizeof(kev)))
if (evtr_write(evtr, buf, ev->fmtdatalen))
if (evtr_dump_pad(evtr))
evtr_dump_sysinfo(evtr_t evtr, evtr_event_t ev)
evtr->errmsg = "invalid number of cpus";
if (evtr_dump_avoid_boundary(evtr, sizeof(type) + sizeof(ncpus)))
if (evtr_write(evtr, &type, sizeof(type))) {
if (evtr_write(evtr, &ncpus, sizeof(ncpus))) {
if (evtr_dump_pad(evtr))
evtr_dump_cpuinfo(evtr_t evtr, evtr_event_t ev)
if (evtr_dump_avoid_boundary(evtr, sizeof(type) + sizeof(ci)))
if (evtr_write(evtr, &type, sizeof(type))) {
if (evtr_dump_avoid_boundary(evtr, sizeof(ci)))
if (evtr_write(evtr, &ci, sizeof(ci))) {
if (evtr_dump_pad(evtr))
evtr_rewind(evtr_t evtr)
assert((evtr->flags & EVTRF_WR) == 0);
evtr->bytes = 0;
if (fseek(evtr->f, 0, SEEK_SET)) {
evtr->err = errno;
evtr_dump_event(evtr_t evtr, evtr_event_t ev)
return evtr_dump_probe(evtr, ev);
return evtr_dump_sysinfo(evtr, ev);
return evtr_dump_cpuinfo(evtr, ev);
evtr->errmsg = "unknown event type";
evtr_t evtr;
if (!(evtr = malloc(sizeof(*evtr)))) {
evtr->f = f;
evtr->err = 0;
evtr->errmsg = NULL;
evtr->bytes = 0;
return evtr;
evtr_t evtr;
if (!(evtr = evtr_alloc(f))) {
evtr->flags = 0;
RB_INIT(&evtr->maps[i].root);
RB_INIT(&evtr->fmtmap.root);
RB_INIT(&evtr->threads.root);
evtr->cpus = NULL;
evtr->ncpus = 0;
if (evtr_next_event(evtr, &ev)) {
if (evtr_rewind(evtr))
return evtr;
free(evtr);
evtr_t evtr;
if (!(evtr = evtr_alloc(f))) {
evtr->flags = EVTRF_WR;
if (!(evtr->fmts = strhash_new()))
evtr->strings[i] = strhash_new();
if (!evtr->strings[i]) {
strhash_destroy(evtr->strings[j]);
return evtr;
strhash_destroy(evtr->fmts);
free(evtr);
evtr_close(evtr_t evtr)
if (evtr->flags & EVTRF_WR) {
hashtab_destroy(&evtr->fmts->tab);
hashtab_destroy(&evtr->strings[i]->tab);
id_tree_free(&evtr->fmtmap.root);
id_tree_free(&evtr->maps[i].root);
free(evtr);
evtr_read(evtr_t evtr, void *buf, size_t size)
assert_foff_in_sync(evtr);
printd(IO, "evtr_read at %#jx, %zu bytes\n", evtr->bytes, size);
if (fread(buf, size, 1, evtr->f) != 1) {
if (feof(evtr->f)) {
evtr->errmsg = "incomplete record";
evtr->errmsg = strerror(errno);
evtr->bytes += size;
assert_foff_in_sync(evtr);
evtr_t evtr = q->evtr;
evtr->err = errno;
if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
evtr->err = errno;
if (evtr_read(evtr, subsys, evh->subsys_len)) {
evtr->err = errno;
if (evtr_read(evtr, fmtstr, evh->fmt_len)) {
evtr->err = fmt_map_insert(&evtr->fmtmap.root, fmt, evh->id);
switch (evtr->err) {
evtr->errmsg = "out of memory";
evtr->errmsg = "redefinition of an id to a "
return evtr->err;
evtr_load_string(evtr_t evtr, char *buf)
if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
evtr->errmsg = "string too large (corrupt input)";
if (evh->len && evtr_read(evtr, sbuf, evh->len)) {
evtr->errmsg = "invalid namespace (corrupt input)";
evtr->err = string_map_insert(&evtr->maps[evh->ns - 1].root, sbuf, evh->id);
switch (evtr->err) {
evtr->errmsg = "out of memory";
evtr->errmsg = "redefinition of an id to a "
evtr_skip(evtr_t evtr, off_t bytes)
if (fseek(evtr->f, bytes, SEEK_CUR)) {
evtr->err = errno;
evtr->errmsg = strerror(errno);
evtr->bytes += bytes;
evtr_load_probe(evtr_t evtr, evtr_event_t ev, char *buf, struct evtr_query *q)
if (evtr_read(evtr, buf + sizeof(struct trace_event_header),
if ((cpu = evtr_cpu(evtr, evh->cpu))) {
&evtr->maps[EVTR_NS_PATH - 1].root,
evtr->errmsg = "unknown id for file path";
evtr->err = !0;
if (!(fmt = fmt_map_find(&evtr->fmtmap.root, evh->fmt))) {
evtr->errmsg = "unknown id for event fmt";
evtr->err = !0;
evtr->err = ENOMEM;
} else if (!evtr_read(evtr, q->buf, evh->datalen)) {
.evtr = evtr,
return evtr->err;
if (evtr->err)
return evtr->err;
return evtr->err;
evtr_skip_to_record(evtr_t evtr)
skip = REC_ALIGN - (evtr->bytes % REC_ALIGN);
if (fseek(evtr->f, skip, SEEK_CUR)) {
evtr->err = errno;
evtr->errmsg = strerror(errno);
evtr->bytes += skip;
evtr_load_sysinfo(evtr_t evtr)
if (evtr_read(evtr, &ncpus, sizeof(ncpus))) {
if (evtr->cpus)
evtr->cpus = malloc(ncpus * sizeof(struct cpu));
if (!evtr->cpus) {
evtr->err = ENOMEM;
evtr->ncpus = ncpus;
evtr->cpus[i].td = NULL;
evtr->cpus[i].freq = -1.0;
evtr_load_cpuinfo(evtr_t evtr)
if (evtr_read(evtr, &cih, sizeof(cih))) {
evtr->errmsg = "cpu freq is negative";
evtr->err = EINVAL;
if (!(cpu = evtr_cpu(evtr, cih.cpu))) {
evtr->errmsg = "freq for invalid cpu";
evtr->err = EINVAL;
_evtr_next_event(evtr_t evtr, evtr_event_t ev, struct evtr_query *q)
q->off = evtr->bytes;
if (evtr_read(evtr, &evhdr->type, 1)) {
if (feof(evtr->f)) {
evtr->errmsg = NULL;
evtr->err = 0;
evtr_skip_to_record(evtr);
evtr_load_sysinfo(evtr);
evtr_load_cpuinfo(evtr);
if (evtr_read(evtr, buf + 1, sizeof(*evhdr) - 1))
return feof(evtr->f) ? -1 : !0;
if ((err = evtr_load_probe(evtr, ev, buf, q))) {
if (evtr_load_string(evtr, buf)) {
evtr->err = !0;
evtr->errmsg = "unknown event type (corrupt input?)";
evtr_skip_to_record(evtr);
q->off = evtr->bytes;
evtr_next_event(evtr_t evtr, evtr_event_t ev)
if (!(q = evtr_query_init(evtr, NULL, 0))) {
evtr->err = ENOMEM;
ret = _evtr_next_event(evtr, ev, q);
evtr_last_event(evtr_t evtr, evtr_event_t ev)
if (evtr_error(evtr))
fd = fileno(evtr->f);
assert(evtr->bytes == 0);
evtr_skip(evtr, last_boundary);
while (!evtr_next_event(evtr, ev))
if (evtr_error(evtr))
evtr_rewind(evtr);
evtr_query_init(evtr_t evtr, evtr_filter_t filt, int nfilt)
q->evtr = evtr;
if (q->off != q->evtr->bytes) {
return _evtr_next_event(q->evtr, ev, q);
evtr_ncpus(evtr_t evtr)
return evtr->ncpus;
evtr_cpufreqs(evtr_t evtr, double *freqs)
for (i = 0; i < evtr->ncpus; ++i) {
freqs[i] = evtr->cpus[i].freq;
evtr_t evtr;
evtr_cpu(evtr_t evtr, int c)
if ((c < 0) || (c >= evtr->ncpus))
return &evtr->cpus[c];
evtr_error(evtr_t evtr)
return evtr->err || (evtr->errmsg != NULL);
evtr_errmsg(evtr_t evtr)
return evtr->errmsg ? evtr->errmsg : strerror(evtr->err);
return q->err || (q->errmsg != NULL) || evtr_error(q->evtr);
(evtr_errmsg(q->evtr)));
evtr_t evtr = q->evtr;
thread_map_insert(&evtr->threads, td);
evtr_t evtr = ((evtr_query_t)d)->evtr;
cpu = evtr_cpu(evtr, ev->cpu);
tdp = thread_map_find(&evtr->threads, ktdp);
tdn = thread_map_find(&evtr->threads, ktdn);
tdn = thread_map_find(&evtr->threads, ktdn);
assert_foff_in_sync(evtr_t evtr)
off = ftello(evtr->f);
if (evtr->bytes != off) {
fprintf(stderr, "bytes %jd, off %jd\n", evtr->bytes, off);
evtr_write(evtr_t evtr, const void *buf, size_t bytes)
assert_foff_in_sync(evtr);
if (fwrite(buf, bytes, 1, evtr->f) != 1) {
evtr->err = errno;
evtr->errmsg = strerror(errno);
evtr->bytes += bytes;
assert_foff_in_sync(evtr);
evtr_dump_pad(evtr_t evtr)
pad = REC_ALIGN - (evtr->bytes % REC_ALIGN);
return evtr_write(evtr, buf, pad);
evtr_dump_avoid_boundary(evtr_t evtr, size_t bytes)
pad = REC_BOUNDARY - (evtr->bytes % REC_BOUNDARY);
if (evtr_write(evtr, buf, sizeof(buf))) {
if (evtr_write(evtr, buf, i)) {
evtr_dump_fmt(evtr_t evtr, uint64_t ts, const evtr_event_t ev)
evtr->errmsg = "name of subsystem is too large";
evtr->err = ERANGE;
struct evtr;
typedef struct evtr *evtr_t;
q = evtr_query_init(evtr, &filt, 1);
q = evtr_query_init(evtr, &filt, 1);
q = evtr_query_init(evtr, &filt, 1);
if (!(evtr = evtr_open_read(inf))) {
evtr_close(evtr);
q = evtr_query_init(evtr, filts, nfilts);
if (evtr_rewind(evtr))
(void)evtr;
if ((ct->ncpus = evtr_ncpus(evtr)) <= 0)
if ((i = evtr_cpufreqs(evtr, freqs))) {
evtr_t evtr;
evtr_t evtr = (evtr_t)arg;
if (evtr_dump_event(evtr, &ev)) {
err(1, "%s", evtr_errmsg(evtr));
return devinfo_foreach_device_child(dev, dump_devinfo, evtr);
dump_device_info(evtr_t evtr)
devinfo_foreach_device_child(root, dump_devinfo, evtr);
dump_machine_info(evtr_t evtr)
evtr_dump_event(evtr, &ev);
if (evtr_error(evtr)) {
err(1, "%s", evtr_errmsg(evtr));
evtr_dump_event(evtr, &ev);
if (evtr_error(evtr)) {
err(1, "%s", evtr_errmsg(evtr));
evtr_t evtr = (evtr_t)ctx;
if (evtr_dump_event(evtr, &ev)) {
err(1, "%s", evtr_errmsg(evtr));