Lines Matching refs:event
39 union perf_event *event, u64 file_offset)
69 src = (void *)event + sizeof(struct perf_record_compressed);
70 src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
99 union perf_event *event,
177 struct ordered_event *event)
182 return perf_session__deliver_event(session, event->event,
183 session->tool, event->file_offset);
247 * kernel MMAP event, in perf_event__process_mmap().
309 union perf_event *event
317 union perf_event *event __maybe_unused,
326 union perf_event *event __maybe_unused,
331 perf_event__fprintf_event_update(event, stdout);
338 union perf_event *event __maybe_unused,
348 union perf_event *event __maybe_unused,
357 union perf_event *event __maybe_unused,
365 union perf_event *event,
384 union perf_event *event)
388 skipn(perf_data__fd(session->data), event->auxtrace.size);
389 return event->auxtrace.size;
393 union perf_event *event __maybe_unused)
402 union perf_event *event __maybe_unused)
405 perf_event__fprintf_thread_map(event, stdout);
413 union perf_event *event __maybe_unused)
416 perf_event__fprintf_cpu_map(event, stdout);
424 union perf_event *event __maybe_unused)
427 perf_event__fprintf_stat_config(event, stdout);
434 union perf_event *event)
437 perf_event__fprintf_stat(event, stdout);
444 union perf_event *event)
447 perf_event__fprintf_stat_round(event, stdout);
454 union perf_event *event __maybe_unused,
541 static void swap_sample_id_all(union perf_event *event, void *data)
543 void *end = (void *) event + event->header.size;
550 static void perf_event__all64_swap(union perf_event *event,
553 struct perf_event_header *hdr = &event->header;
554 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
557 static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
559 event->comm.pid = bswap_32(event->comm.pid);
560 event->comm.tid = bswap_32(event->comm.tid);
563 void *data = &event->comm.comm;
566 swap_sample_id_all(event, data);
570 static void perf_event__mmap_swap(union perf_event *event,
573 event->mmap.pid = bswap_32(event->mmap.pid);
574 event->mmap.tid = bswap_32(event->mmap.tid);
575 event->mmap.start = bswap_64(event->mmap.start);
576 event->mmap.len = bswap_64(event->mmap.len);
577 event->mmap.pgoff = bswap_64(event->mmap.pgoff);
580 void *data = &event->mmap.filename;
583 swap_sample_id_all(event, data);
587 static void perf_event__mmap2_swap(union perf_event *event,
590 event->mmap2.pid = bswap_32(event->mmap2.pid);
591 event->mmap2.tid = bswap_32(event->mmap2.tid);
592 event->mmap2.start = bswap_64(event->mmap2.start);
593 event->mmap2.len = bswap_64(event->mmap2.len);
594 event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
595 event->mmap2.maj = bswap_32(event->mmap2.maj);
596 event->mmap2.min = bswap_32(event->mmap2.min);
597 event->mmap2.ino = bswap_64(event->mmap2.ino);
598 event->mmap2.ino_generation = bswap_64(event->mmap2.ino_generation);
601 void *data = &event->mmap2.filename;
604 swap_sample_id_all(event, data);
607 static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
609 event->fork.pid = bswap_32(event->fork.pid);
610 event->fork.tid = bswap_32(event->fork.tid);
611 event->fork.ppid = bswap_32(event->fork.ppid);
612 event->fork.ptid = bswap_32(event->fork.ptid);
613 event->fork.time = bswap_64(event->fork.time);
616 swap_sample_id_all(event, &event->fork + 1);
619 static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
621 event->read.pid = bswap_32(event->read.pid);
622 event->read.tid = bswap_32(event->read.tid);
623 event->read.value = bswap_64(event->read.value);
624 event->read.time_enabled = bswap_64(event->read.time_enabled);
625 event->read.time_running = bswap_64(event->read.time_running);
626 event->read.id = bswap_64(event->read.id);
629 swap_sample_id_all(event, &event->read + 1);
632 static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
634 event->aux.aux_offset = bswap_64(event->aux.aux_offset);
635 event->aux.aux_size = bswap_64(event->aux.aux_size);
636 event->aux.flags = bswap_64(event->aux.flags);
639 swap_sample_id_all(event, &event->aux + 1);
642 static void perf_event__itrace_start_swap(union perf_event *event,
645 event->itrace_start.pid = bswap_32(event->itrace_start.pid);
646 event->itrace_start.tid = bswap_32(event->itrace_start.tid);
649 swap_sample_id_all(event, &event->itrace_start + 1);
652 static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
654 if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
655 event->context_switch.next_prev_pid =
656 bswap_32(event->context_switch.next_prev_pid);
657 event->context_switch.next_prev_tid =
658 bswap_32(event->context_switch.next_prev_tid);
662 swap_sample_id_all(event, &event->context_switch + 1);
665 static void perf_event__text_poke_swap(union perf_event *event, bool sample_id_all)
667 event->text_poke.addr = bswap_64(event->text_poke.addr);
668 event->text_poke.old_len = bswap_16(event->text_poke.old_len);
669 event->text_poke.new_len = bswap_16(event->text_poke.new_len);
672 size_t len = sizeof(event->text_poke.old_len) +
673 sizeof(event->text_poke.new_len) +
674 event->text_poke.old_len +
675 event->text_poke.new_len;
676 void *data = &event->text_poke.old_len;
679 swap_sample_id_all(event, data);
683 static void perf_event__throttle_swap(union perf_event *event,
686 event->throttle.time = bswap_64(event->throttle.time);
687 event->throttle.id = bswap_64(event->throttle.id);
688 event->throttle.stream_id = bswap_64(event->throttle.stream_id);
691 swap_sample_id_all(event, &event->throttle + 1);
694 static void perf_event__namespaces_swap(union perf_event *event,
699 event->namespaces.pid = bswap_32(event->namespaces.pid);
700 event->namespaces.tid = bswap_32(event->namespaces.tid);
701 event->namespaces.nr_namespaces = bswap_64(event->namespaces.nr_namespaces);
703 for (i = 0; i < event->namespaces.nr_namespaces; i++) {
704 struct perf_ns_link_info *ns = &event->namespaces.link_info[i];
711 swap_sample_id_all(event, &event->namespaces.link_info[i]);
714 static void perf_event__cgroup_swap(union perf_event *event, bool sample_id_all)
716 event->cgroup.id = bswap_64(event->cgroup.id);
719 void *data = &event->cgroup.path;
722 swap_sample_id_all(event, data);
804 static void perf_event__hdr_attr_swap(union perf_event *event,
809 perf_event__attr_swap(&event->attr.attr);
811 size = event->header.size;
812 size -= (void *)&event->attr.id - (void *)event;
813 mem_bswap_64(event->attr.id, size);
816 static void perf_event__event_update_swap(union perf_event *event,
819 event->event_update.type = bswap_64(event->event_update.type);
820 event->event_update.id = bswap_64(event->event_update.id);
823 static void perf_event__event_type_swap(union perf_event *event,
826 event->event_type.event_type.event_id =
827 bswap_64(event->event_type.event_type.event_id);
830 static void perf_event__tracing_data_swap(union perf_event *event,
833 event->tracing_data.size = bswap_32(event->tracing_data.size);
836 static void perf_event__auxtrace_info_swap(union perf_event *event,
841 event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);
843 size = event->header.size;
844 size -= (void *)&event->auxtrace_info.priv - (void *)event;
845 mem_bswap_64(event->auxtrace_info.priv, size);
848 static void perf_event__auxtrace_swap(union perf_event *event,
851 event->auxtrace.size = bswap_64(event->auxtrace.size);
852 event->auxtrace.offset = bswap_64(event->auxtrace.offset);
853 event->auxtrace.reference = bswap_64(event->auxtrace.reference);
854 event->auxtrace.idx = bswap_32(event->auxtrace.idx);
855 event->auxtrace.tid = bswap_32(event->auxtrace.tid);
856 event->auxtrace.cpu = bswap_32(event->auxtrace.cpu);
859 static void perf_event__auxtrace_error_swap(union perf_event *event,
862 event->auxtrace_error.type = bswap_32(event->auxtrace_error.type);
863 event->auxtrace_error.code = bswap_32(event->auxtrace_error.code);
864 event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu);
865 event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid);
866 event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid);
867 event->auxtrace_error.fmt = bswap_32(event->auxtrace_error.fmt);
868 event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip);
869 if (event->auxtrace_error.fmt)
870 event->auxtrace_error.time = bswap_64(event->auxtrace_error.time);
873 static void perf_event__thread_map_swap(union perf_event *event,
878 event->thread_map.nr = bswap_64(event->thread_map.nr);
880 for (i = 0; i < event->thread_map.nr; i++)
881 event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid);
884 static void perf_event__cpu_map_swap(union perf_event *event,
887 struct perf_record_cpu_map_data *data = &event->cpu_map.data;
920 static void perf_event__stat_config_swap(union perf_event *event,
925 size = event->stat_config.nr * sizeof(event->stat_config.data[0]);
927 mem_bswap_64(&event->stat_config.nr, size);
930 static void perf_event__stat_swap(union perf_event *event,
933 event->stat.id = bswap_64(event->stat.id);
934 event->stat.thread = bswap_32(event->stat.thread);
935 event->stat.cpu = bswap_32(event->stat.cpu);
936 event->stat.val = bswap_64(event->stat.val);
937 event->stat.ena = bswap_64(event->stat.ena);
938 event->stat.run = bswap_64(event->stat.run);
941 static void perf_event__stat_round_swap(union perf_event *event,
944 event->stat_round.type = bswap_64(event->stat_round.type);
945 event->stat_round.time = bswap_64(event->stat_round.time);
948 static void perf_event__time_conv_swap(union perf_event *event,
951 event->time_conv.time_shift = bswap_64(event->time_conv.time_shift);
952 event->time_conv.time_mult = bswap_64(event->time_conv.time_mult);
953 event->time_conv.time_zero = bswap_64(event->time_conv.time_zero);
955 if (event_contains(event->time_conv, time_cycles)) {
956 event->time_conv.time_cycles = bswap_64(event->time_conv.time_cycles);
957 event->time_conv.time_mask = bswap_64(event->time_conv.time_mask);
961 typedef void (*perf_event__swap_op)(union perf_event *event,
1003 * event.
1041 union perf_event *event __maybe_unused,
1049 int perf_session__queue_event(struct perf_session *s, union perf_event *event,
1052 return ordered_events__queue(&s->ordered_events, event, timestamp, file_offset);
1208 union perf_event *event,
1213 if (event->header.type != PERF_RECORD_SAMPLE &&
1256 static void dump_event(struct evlist *evlist, union perf_event *event,
1262 printf("\n%#" PRIx64 " [%#x]: event: %d\n",
1263 file_offset, event->header.size, event->header.type);
1265 trace_event(event);
1266 if (event->header.type == PERF_RECORD_SAMPLE && evlist->trace_event_sample_raw)
1267 evlist->trace_event_sample_raw(evlist, event, sample);
1270 perf_evlist__print_tstamp(evlist, event, sample);
1273 event->header.size, perf_event__name(event->header.type));
1276 static void dump_sample(struct evsel *evsel, union perf_event *event,
1285 event->header.misc, sample->pid, sample->tid, sample->ip,
1321 static void dump_read(struct evsel *evsel, union perf_event *event)
1323 struct perf_record_read *read_event = &event->read;
1329 printf(": %d %d %s %" PRI_lu64 "\n", event->read.pid, event->read.tid,
1330 evsel__name(evsel), event->read.value);
1348 union perf_event *event,
1358 if (event->header.type == PERF_RECORD_MMAP
1359 || event->header.type == PERF_RECORD_MMAP2)
1360 pid = event->mmap.pid;
1375 union perf_event *event,
1402 return tool->sample(tool, event, sample, evsel, machine);
1407 union perf_event *event,
1415 ret = deliver_sample_value(evlist, tool, event, sample,
1428 union perf_event *event,
1439 return tool->sample(tool, event, sample, evsel, machine);
1443 return deliver_sample_group(evlist, tool, event, sample,
1446 return deliver_sample_value(evlist, tool, event, sample,
1452 union perf_event *event,
1459 dump_event(evlist, event, file_offset, sample);
1463 machine = machines__find_for_cpumode(machines, event, sample);
1465 switch (event->header.type) {
1471 dump_sample(evsel, event, sample);
1476 return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
1478 return tool->mmap(tool, event, sample, machine);
1480 if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT)
1482 return tool->mmap2(tool, event, sample, machine);
1484 return tool->comm(tool, event, sample, machine);
1486 return tool->namespaces(tool, event, sample, machine);
1488 return tool->cgroup(tool, event, sample, machine);
1490 return tool->fork(tool, event, sample, machine);
1492 return tool->exit(tool, event, sample, machine);
1495 evlist->stats.total_lost += event->lost.lost;
1496 return tool->lost(tool, event, sample, machine);
1499 evlist->stats.total_lost_samples += event->lost_samples.lost;
1500 return tool->lost_samples(tool, event, sample, machine);
1502 dump_read(evsel, event);
1503 return tool->read(tool, event, sample, evsel, machine);
1505 return tool->throttle(tool, event, sample, machine);
1507 return tool->unthrottle(tool, event, sample, machine);
1510 if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
1512 if (event->aux.flags & PERF_AUX_FLAG_PARTIAL)
1515 return tool->aux(tool, event, sample, machine);
1517 return tool->itrace_start(tool, event, sample, machine);
1520 return tool->context_switch(tool, event, sample, machine);
1522 return tool->ksymbol(tool, event, sample, machine);
1524 return tool->bpf(tool, event, sample, machine);
1526 return tool->text_poke(tool, event, sample, machine);
1534 union perf_event *event,
1541 ret = perf_evlist__parse_sample(session->evlist, event, &sample);
1547 ret = auxtrace__process_event(session, event, &sample, tool);
1554 event, &sample, tool, file_offset);
1563 union perf_event *event,
1572 if (event->header.type != PERF_RECORD_COMPRESSED ||
1574 dump_event(session->evlist, event, file_offset, &sample);
1577 switch (event->header.type) {
1579 err = tool->attr(tool, event, &session->evlist);
1586 return tool->event_update(tool, event, &session->evlist);
1601 return tool->tracing_data(session, event);
1603 return tool->build_id(session, event);
1605 return tool->finished_round(tool, event, oe);
1607 return tool->id_index(session, event);
1609 return tool->auxtrace_info(session, event);
1612 lseek(fd, file_offset + event->header.size, SEEK_SET);
1613 return tool->auxtrace(session, event);
1615 perf_session__auxtrace_error_inc(session, event);
1616 return tool->auxtrace_error(session, event);
1618 return tool->thread_map(session, event);
1620 return tool->cpu_map(session, event);
1622 return tool->stat_config(session, event);
1624 return tool->stat(session, event);
1626 return tool->stat_round(session, event);
1628 session->time_conv = event->time_conv;
1629 return tool->time_conv(session, event);
1631 return tool->feature(session, event);
1633 err = tool->compressed(session, event, file_offset);
1635 dump_event(session->evlist, event, file_offset, &sample);
1643 union perf_event *event,
1649 events_stats__inc(&evlist->stats, event->header.type);
1651 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1652 return perf_session__process_user_event(session, event, 0);
1654 return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
1657 static void event_swap(union perf_event *event, bool sample_id_all)
1661 swap = perf_event__swap_ops[event->header.type];
1663 swap(event, sample_id_all);
1671 union perf_event *event;
1676 event = file_offset - session->one_mmap_offset +
1694 event = (union perf_event *)buf;
1697 perf_event_header__bswap(&event->header);
1699 if (event->header.size < hdr_sz || event->header.size > buf_sz)
1703 rest = event->header.size - hdr_sz;
1709 event_swap(event, evlist__sample_id_all(session->evlist));
1713 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
1714 perf_evlist__parse_sample(session->evlist, event, sample))
1717 *event_ptr = event;
1727 union perf_event *event;
1732 PERF_SAMPLE_MAX_SIZE, &event,
1737 err = cb(session, event, offset, data);
1741 offset += event->header.size;
1742 if (event->header.type == PERF_RECORD_AUXTRACE)
1743 offset += event->auxtrace.size;
1751 union perf_event *event, u64 file_offset)
1758 event_swap(event, evlist__sample_id_all(evlist));
1760 if (event->header.type >= PERF_RECORD_HEADER_MAX)
1763 events_stats__inc(&evlist->stats, event->header.type);
1765 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1766 return perf_session__process_user_event(session, event, file_offset);
1771 ret = perf_evlist__parse_sample_timestamp(evlist, event, ×tamp);
1775 ret = perf_session__queue_event(session, event, timestamp, file_offset);
1780 return perf_session__deliver_event(session, event, tool, file_offset);
1955 union perf_event *event;
1973 event = buf;
1974 err = readn(fd, event, sizeof(struct perf_event_header));
1979 pr_err("failed to read event header\n");
1984 perf_event_header__bswap(&event->header);
1986 size = event->header.size;
1988 pr_err("bad event header size\n");
1995 pr_err("failed to allocate memory to read event\n");
2000 event = buf;
2002 p = event;
2009 pr_err("unexpected end of event stream\n");
2013 pr_err("failed to read event data\n");
2018 if ((skip = perf_session__process_event(session, event, head)) < 0) {
2020 head, event->header.size, event->header.type);
2058 union perf_event *event;
2063 * the size of the event in the headers.
2065 if (head + sizeof(event->header) > mmap_size)
2068 event = (union perf_event *)(buf + head);
2070 perf_event_header__bswap(&event->header);
2072 event_size = event->header.size;
2074 return event;
2076 /* We're not fetching the event so swap back again */
2078 perf_event_header__bswap(&event->header);
2080 /* Check if the event fits into the next mmapped buf. */
2087 pr_debug("%s: head=%#" PRIx64 " event->header.size=%#x, mmap_size=%#zx:"
2115 union perf_event *event = fetch_decomp_event(decomp->head, decomp->size, decomp->data,
2118 if (!event)
2121 size = event->header.size;
2124 (skip = perf_session__process_event(session, event, file_pos)) < 0) {
2126 decomp->file_pos + decomp->head, event->header.size, event->header.type);
2154 union perf_event *event,
2173 union perf_event *event;
2216 event = fetch_mmaped_event(head, mmap_size, buf, session->header.needs_swap);
2217 if (IS_ERR(event))
2218 return PTR_ERR(event);
2220 if (!event) {
2232 size = event->header.size;
2237 (skip = rd->process(session, event, file_pos)) < 0) {
2239 file_offset + head, event->header.size,
2240 event->header.type, strerror(-skip));
2268 union perf_event *event,
2271 return perf_session__process_event(session, event, file_offset);
2476 union perf_event *event)
2479 struct perf_record_id_index *ie = &event->id_index;