1 #define _FILE_OFFSET_BITS 64
8 #include <linux/list.h>
9 #include <linux/kernel.h>
14 #include "trace-event.h"
19 static bool no_buildid_cache
= false;
22 * Create new perf.data header attribute:
24 struct perf_header_attr
*perf_header_attr__new(struct perf_event_attr
*attr
)
26 struct perf_header_attr
*self
= malloc(sizeof(*self
));
32 self
->id
= malloc(sizeof(u64
));
33 if (self
->id
== NULL
) {
42 void perf_header_attr__delete(struct perf_header_attr
*self
)
48 int perf_header_attr__add_id(struct perf_header_attr
*self
, u64 id
)
53 if (self
->ids
> self
->size
) {
54 int nsize
= self
->size
* 2;
55 u64
*nid
= realloc(self
->id
, nsize
* sizeof(u64
));
67 int perf_header__init(struct perf_header
*self
)
70 self
->attr
= malloc(sizeof(void *));
71 return self
->attr
== NULL
? -ENOMEM
: 0;
74 void perf_header__exit(struct perf_header
*self
)
77 for (i
= 0; i
< self
->attrs
; ++i
)
78 perf_header_attr__delete(self
->attr
[i
]);
82 int perf_header__add_attr(struct perf_header
*self
,
83 struct perf_header_attr
*attr
)
88 if (self
->attrs
== self
->size
) {
89 int nsize
= self
->size
* 2;
90 struct perf_header_attr
**nattr
;
92 nattr
= realloc(self
->attr
, nsize
* sizeof(void *));
100 self
->attr
[self
->attrs
++] = attr
;
104 static int event_count
;
105 static struct perf_trace_event_type
*events
;
107 int perf_header__push_event(u64 id
, const char *name
)
109 if (strlen(name
) > MAX_EVENT_NAME
)
110 pr_warning("Event %s will be truncated\n", name
);
113 events
= malloc(sizeof(struct perf_trace_event_type
));
117 struct perf_trace_event_type
*nevents
;
119 nevents
= realloc(events
, (event_count
+ 1) * sizeof(*events
));
124 memset(&events
[event_count
], 0, sizeof(struct perf_trace_event_type
));
125 events
[event_count
].event_id
= id
;
126 strncpy(events
[event_count
].name
, name
, MAX_EVENT_NAME
- 1);
131 char *perf_header__find_event(u64 id
)
134 for (i
= 0 ; i
< event_count
; i
++) {
135 if (events
[i
].event_id
== id
)
136 return events
[i
].name
;
141 static const char *__perf_magic
= "PERFFILE";
143 #define PERF_MAGIC (*(u64 *)__perf_magic)
145 struct perf_file_attr
{
146 struct perf_event_attr attr
;
147 struct perf_file_section ids
;
150 void perf_header__set_feat(struct perf_header
*self
, int feat
)
152 set_bit(feat
, self
->adds_features
);
155 bool perf_header__has_feat(const struct perf_header
*self
, int feat
)
157 return test_bit(feat
, self
->adds_features
);
160 static int do_write(int fd
, const void *buf
, size_t size
)
163 int ret
= write(fd
, buf
, size
);
175 #define NAME_ALIGN 64
177 static int write_padded(int fd
, const void *bf
, size_t count
,
178 size_t count_aligned
)
180 static const char zero_buf
[NAME_ALIGN
];
181 int err
= do_write(fd
, bf
, count
);
184 err
= do_write(fd
, zero_buf
, count_aligned
- count
);
189 #define dsos__for_each_with_build_id(pos, head) \
190 list_for_each_entry(pos, head, node) \
191 if (!pos->has_build_id) \
195 static int __dsos__write_buildid_table(struct list_head
*head
, pid_t pid
,
200 dsos__for_each_with_build_id(pos
, head
) {
202 struct build_id_event b
;
207 len
= pos
->long_name_len
+ 1;
208 len
= ALIGN(len
, NAME_ALIGN
);
209 memset(&b
, 0, sizeof(b
));
210 memcpy(&b
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
212 b
.header
.misc
= misc
;
213 b
.header
.size
= sizeof(b
) + len
;
214 err
= do_write(fd
, &b
, sizeof(b
));
217 err
= write_padded(fd
, pos
->long_name
,
218 pos
->long_name_len
+ 1, len
);
226 static int machine__write_buildid_table(struct machine
*self
, int fd
)
229 u16 kmisc
= PERF_RECORD_MISC_KERNEL
,
230 umisc
= PERF_RECORD_MISC_USER
;
232 if (!machine__is_host(self
)) {
233 kmisc
= PERF_RECORD_MISC_GUEST_KERNEL
;
234 umisc
= PERF_RECORD_MISC_GUEST_USER
;
237 err
= __dsos__write_buildid_table(&self
->kernel_dsos
, self
->pid
,
240 err
= __dsos__write_buildid_table(&self
->user_dsos
,
241 self
->pid
, umisc
, fd
);
245 static int dsos__write_buildid_table(struct perf_header
*header
, int fd
)
247 struct perf_session
*session
= container_of(header
,
248 struct perf_session
, header
);
250 int err
= machine__write_buildid_table(&session
->host_machine
, fd
);
255 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
256 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
257 err
= machine__write_buildid_table(pos
, fd
);
264 int build_id_cache__add_s(const char *sbuild_id
, const char *debugdir
,
265 const char *name
, bool is_kallsyms
)
267 const size_t size
= PATH_MAX
;
268 char *filename
= malloc(size
),
269 *linkname
= malloc(size
), *targetname
;
272 if (filename
== NULL
|| linkname
== NULL
)
275 len
= snprintf(filename
, size
, "%s%s%s",
276 debugdir
, is_kallsyms
? "/" : "", name
);
277 if (mkdir_p(filename
, 0755))
280 snprintf(filename
+ len
, sizeof(filename
) - len
, "/%s", sbuild_id
);
282 if (access(filename
, F_OK
)) {
284 if (copyfile("/proc/kallsyms", filename
))
286 } else if (link(name
, filename
) && copyfile(name
, filename
))
290 len
= snprintf(linkname
, size
, "%s/.build-id/%.2s",
291 debugdir
, sbuild_id
);
293 if (access(linkname
, X_OK
) && mkdir_p(linkname
, 0755))
296 snprintf(linkname
+ len
, size
- len
, "/%s", sbuild_id
+ 2);
297 targetname
= filename
+ strlen(debugdir
) - 5;
298 memcpy(targetname
, "../..", 5);
300 if (symlink(targetname
, linkname
) == 0)
308 static int build_id_cache__add_b(const u8
*build_id
, size_t build_id_size
,
309 const char *name
, const char *debugdir
,
312 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
314 build_id__sprintf(build_id
, build_id_size
, sbuild_id
);
316 return build_id_cache__add_s(sbuild_id
, debugdir
, name
, is_kallsyms
);
319 int build_id_cache__remove_s(const char *sbuild_id
, const char *debugdir
)
321 const size_t size
= PATH_MAX
;
322 char *filename
= malloc(size
),
323 *linkname
= malloc(size
);
326 if (filename
== NULL
|| linkname
== NULL
)
329 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
330 debugdir
, sbuild_id
, sbuild_id
+ 2);
332 if (access(linkname
, F_OK
))
335 if (readlink(linkname
, filename
, size
) < 0)
338 if (unlink(linkname
))
342 * Since the link is relative, we must make it absolute:
344 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
345 debugdir
, sbuild_id
, filename
);
347 if (unlink(linkname
))
357 static int dso__cache_build_id(struct dso
*self
, const char *debugdir
)
359 bool is_kallsyms
= self
->kernel
&& self
->long_name
[0] != '/';
361 return build_id_cache__add_b(self
->build_id
, sizeof(self
->build_id
),
362 self
->long_name
, debugdir
, is_kallsyms
);
365 static int __dsos__cache_build_ids(struct list_head
*head
, const char *debugdir
)
370 dsos__for_each_with_build_id(pos
, head
)
371 if (dso__cache_build_id(pos
, debugdir
))
377 static int machine__cache_build_ids(struct machine
*self
, const char *debugdir
)
379 int ret
= __dsos__cache_build_ids(&self
->kernel_dsos
, debugdir
);
380 ret
|= __dsos__cache_build_ids(&self
->user_dsos
, debugdir
);
384 static int perf_session__cache_build_ids(struct perf_session
*self
)
388 char debugdir
[PATH_MAX
];
390 snprintf(debugdir
, sizeof(debugdir
), "%s", buildid_dir
);
392 if (mkdir(debugdir
, 0755) != 0 && errno
!= EEXIST
)
395 ret
= machine__cache_build_ids(&self
->host_machine
, debugdir
);
397 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
398 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
399 ret
|= machine__cache_build_ids(pos
, debugdir
);
404 static bool machine__read_build_ids(struct machine
*self
, bool with_hits
)
406 bool ret
= __dsos__read_build_ids(&self
->kernel_dsos
, with_hits
);
407 ret
|= __dsos__read_build_ids(&self
->user_dsos
, with_hits
);
411 static bool perf_session__read_build_ids(struct perf_session
*self
, bool with_hits
)
414 bool ret
= machine__read_build_ids(&self
->host_machine
, with_hits
);
416 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
417 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
418 ret
|= machine__read_build_ids(pos
, with_hits
);
424 static int perf_header__adds_write(struct perf_header
*self
, int fd
)
427 struct perf_session
*session
;
428 struct perf_file_section
*feat_sec
;
433 session
= container_of(self
, struct perf_session
, header
);
434 if (perf_session__read_build_ids(session
, true))
435 perf_header__set_feat(self
, HEADER_BUILD_ID
);
437 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
441 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
442 if (feat_sec
== NULL
)
445 sec_size
= sizeof(*feat_sec
) * nr_sections
;
447 sec_start
= self
->data_offset
+ self
->data_size
;
448 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
450 if (perf_header__has_feat(self
, HEADER_TRACE_INFO
)) {
451 struct perf_file_section
*trace_sec
;
453 trace_sec
= &feat_sec
[idx
++];
455 /* Write trace info */
456 trace_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
457 read_tracing_data(fd
, attrs
, nr_counters
);
458 trace_sec
->size
= lseek(fd
, 0, SEEK_CUR
) - trace_sec
->offset
;
461 if (perf_header__has_feat(self
, HEADER_BUILD_ID
)) {
462 struct perf_file_section
*buildid_sec
;
464 buildid_sec
= &feat_sec
[idx
++];
466 /* Write build-ids */
467 buildid_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
468 err
= dsos__write_buildid_table(self
, fd
);
470 pr_debug("failed to write buildid table\n");
473 buildid_sec
->size
= lseek(fd
, 0, SEEK_CUR
) -
475 if (!no_buildid_cache
)
476 perf_session__cache_build_ids(session
);
479 lseek(fd
, sec_start
, SEEK_SET
);
480 err
= do_write(fd
, feat_sec
, sec_size
);
482 pr_debug("failed to write feature section\n");
488 int perf_header__write_pipe(int fd
)
490 struct perf_pipe_file_header f_header
;
493 f_header
= (struct perf_pipe_file_header
){
495 .size
= sizeof(f_header
),
498 err
= do_write(fd
, &f_header
, sizeof(f_header
));
500 pr_debug("failed to write perf pipe header\n");
507 int perf_header__write(struct perf_header
*self
, int fd
, bool at_exit
)
509 struct perf_file_header f_header
;
510 struct perf_file_attr f_attr
;
511 struct perf_header_attr
*attr
;
514 lseek(fd
, sizeof(f_header
), SEEK_SET
);
516 for (i
= 0; i
< self
->attrs
; i
++) {
517 attr
= self
->attr
[i
];
519 attr
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
520 err
= do_write(fd
, attr
->id
, attr
->ids
* sizeof(u64
));
522 pr_debug("failed to write perf header\n");
528 self
->attr_offset
= lseek(fd
, 0, SEEK_CUR
);
530 for (i
= 0; i
< self
->attrs
; i
++) {
531 attr
= self
->attr
[i
];
533 f_attr
= (struct perf_file_attr
){
536 .offset
= attr
->id_offset
,
537 .size
= attr
->ids
* sizeof(u64
),
540 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
542 pr_debug("failed to write perf header attribute\n");
547 self
->event_offset
= lseek(fd
, 0, SEEK_CUR
);
548 self
->event_size
= event_count
* sizeof(struct perf_trace_event_type
);
550 err
= do_write(fd
, events
, self
->event_size
);
552 pr_debug("failed to write perf header events\n");
557 self
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
560 err
= perf_header__adds_write(self
, fd
);
565 f_header
= (struct perf_file_header
){
567 .size
= sizeof(f_header
),
568 .attr_size
= sizeof(f_attr
),
570 .offset
= self
->attr_offset
,
571 .size
= self
->attrs
* sizeof(f_attr
),
574 .offset
= self
->data_offset
,
575 .size
= self
->data_size
,
578 .offset
= self
->event_offset
,
579 .size
= self
->event_size
,
583 memcpy(&f_header
.adds_features
, &self
->adds_features
, sizeof(self
->adds_features
));
585 lseek(fd
, 0, SEEK_SET
);
586 err
= do_write(fd
, &f_header
, sizeof(f_header
));
588 pr_debug("failed to write perf header\n");
591 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
597 static int perf_header__getbuffer64(struct perf_header
*self
,
598 int fd
, void *buf
, size_t size
)
600 if (do_read(fd
, buf
, size
) <= 0)
603 if (self
->needs_swap
)
604 mem_bswap_64(buf
, size
);
609 int perf_header__process_sections(struct perf_header
*self
, int fd
,
610 int (*process
)(struct perf_file_section
*self
,
611 struct perf_header
*ph
,
614 struct perf_file_section
*feat_sec
;
618 int err
= -1, feat
= 1;
620 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
624 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
628 sec_size
= sizeof(*feat_sec
) * nr_sections
;
630 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
632 if (perf_header__getbuffer64(self
, fd
, feat_sec
, sec_size
))
636 while (idx
< nr_sections
&& feat
< HEADER_LAST_FEATURE
) {
637 if (perf_header__has_feat(self
, feat
)) {
638 struct perf_file_section
*sec
= &feat_sec
[idx
++];
640 err
= process(sec
, self
, feat
, fd
);
651 int perf_file_header__read(struct perf_file_header
*self
,
652 struct perf_header
*ph
, int fd
)
654 lseek(fd
, 0, SEEK_SET
);
656 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
657 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
660 if (self
->attr_size
!= sizeof(struct perf_file_attr
)) {
661 u64 attr_size
= bswap_64(self
->attr_size
);
663 if (attr_size
!= sizeof(struct perf_file_attr
))
666 mem_bswap_64(self
, offsetof(struct perf_file_header
,
668 ph
->needs_swap
= true;
671 if (self
->size
!= sizeof(*self
)) {
672 /* Support the previous format */
673 if (self
->size
== offsetof(typeof(*self
), adds_features
))
674 bitmap_zero(self
->adds_features
, HEADER_FEAT_BITS
);
679 memcpy(&ph
->adds_features
, &self
->adds_features
,
680 sizeof(ph
->adds_features
));
682 * FIXME: hack that assumes that if we need swap the perf.data file
683 * may be coming from an arch with a different word-size, ergo different
684 * DEFINE_BITMAP format, investigate more later, but for now its mostly
685 * safe to assume that we have a build-id section. Trace files probably
686 * have several other issues in this realm anyway...
688 if (ph
->needs_swap
) {
689 memset(&ph
->adds_features
, 0, sizeof(ph
->adds_features
));
690 perf_header__set_feat(ph
, HEADER_BUILD_ID
);
693 ph
->event_offset
= self
->event_types
.offset
;
694 ph
->event_size
= self
->event_types
.size
;
695 ph
->data_offset
= self
->data
.offset
;
696 ph
->data_size
= self
->data
.size
;
700 static int __event_process_build_id(struct build_id_event
*bev
,
702 struct perf_session
*session
)
705 struct list_head
*head
;
706 struct machine
*machine
;
709 enum dso_kernel_type dso_type
;
711 machine
= perf_session__findnew_machine(session
, bev
->pid
);
715 misc
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
718 case PERF_RECORD_MISC_KERNEL
:
719 dso_type
= DSO_TYPE_KERNEL
;
720 head
= &machine
->kernel_dsos
;
722 case PERF_RECORD_MISC_GUEST_KERNEL
:
723 dso_type
= DSO_TYPE_GUEST_KERNEL
;
724 head
= &machine
->kernel_dsos
;
726 case PERF_RECORD_MISC_USER
:
727 case PERF_RECORD_MISC_GUEST_USER
:
728 dso_type
= DSO_TYPE_USER
;
729 head
= &machine
->user_dsos
;
735 dso
= __dsos__findnew(head
, filename
);
737 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
739 dso__set_build_id(dso
, &bev
->build_id
);
741 if (filename
[0] == '[')
742 dso
->kernel
= dso_type
;
744 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
746 pr_debug("build id event received for %s: %s\n",
747 dso
->long_name
, sbuild_id
);
755 static int perf_header__read_build_ids(struct perf_header
*self
,
756 int input
, u64 offset
, u64 size
)
758 struct perf_session
*session
= container_of(self
,
759 struct perf_session
, header
);
760 struct build_id_event bev
;
761 char filename
[PATH_MAX
];
762 u64 limit
= offset
+ size
;
765 while (offset
< limit
) {
768 if (read(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
771 if (self
->needs_swap
)
772 perf_event_header__bswap(&bev
.header
);
774 len
= bev
.header
.size
- sizeof(bev
);
775 if (read(input
, filename
, len
) != len
)
778 __event_process_build_id(&bev
, filename
, session
);
780 offset
+= bev
.header
.size
;
787 static int perf_file_section__process(struct perf_file_section
*self
,
788 struct perf_header
*ph
,
791 if (lseek(fd
, self
->offset
, SEEK_SET
) == (off_t
)-1) {
792 pr_debug("Failed to lseek to %Ld offset for feature %d, "
793 "continuing...\n", self
->offset
, feat
);
798 case HEADER_TRACE_INFO
:
799 trace_report(fd
, false);
802 case HEADER_BUILD_ID
:
803 if (perf_header__read_build_ids(ph
, fd
, self
->offset
, self
->size
))
804 pr_debug("Failed to read buildids, continuing...\n");
807 pr_debug("unknown feature %d, continuing...\n", feat
);
813 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*self
,
814 struct perf_header
*ph
, int fd
,
817 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
818 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
821 if (repipe
&& do_write(STDOUT_FILENO
, self
, sizeof(*self
)) < 0)
824 if (self
->size
!= sizeof(*self
)) {
825 u64 size
= bswap_64(self
->size
);
827 if (size
!= sizeof(*self
))
830 ph
->needs_swap
= true;
836 static int perf_header__read_pipe(struct perf_session
*session
, int fd
)
838 struct perf_header
*self
= &session
->header
;
839 struct perf_pipe_file_header f_header
;
841 if (perf_file_header__read_pipe(&f_header
, self
, fd
,
842 session
->repipe
) < 0) {
843 pr_debug("incompatible file format\n");
852 int perf_header__read(struct perf_session
*session
, int fd
)
854 struct perf_header
*self
= &session
->header
;
855 struct perf_file_header f_header
;
856 struct perf_file_attr f_attr
;
858 int nr_attrs
, nr_ids
, i
, j
;
860 if (session
->fd_pipe
)
861 return perf_header__read_pipe(session
, fd
);
863 if (perf_file_header__read(&f_header
, self
, fd
) < 0) {
864 pr_debug("incompatible file format\n");
868 nr_attrs
= f_header
.attrs
.size
/ sizeof(f_attr
);
869 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
871 for (i
= 0; i
< nr_attrs
; i
++) {
872 struct perf_header_attr
*attr
;
875 if (perf_header__getbuffer64(self
, fd
, &f_attr
, sizeof(f_attr
)))
878 tmp
= lseek(fd
, 0, SEEK_CUR
);
880 attr
= perf_header_attr__new(&f_attr
.attr
);
884 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
885 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
887 for (j
= 0; j
< nr_ids
; j
++) {
888 if (perf_header__getbuffer64(self
, fd
, &f_id
, sizeof(f_id
)))
891 if (perf_header_attr__add_id(attr
, f_id
) < 0) {
892 perf_header_attr__delete(attr
);
896 if (perf_header__add_attr(self
, attr
) < 0) {
897 perf_header_attr__delete(attr
);
901 lseek(fd
, tmp
, SEEK_SET
);
904 if (f_header
.event_types
.size
) {
905 lseek(fd
, f_header
.event_types
.offset
, SEEK_SET
);
906 events
= malloc(f_header
.event_types
.size
);
909 if (perf_header__getbuffer64(self
, fd
, events
,
910 f_header
.event_types
.size
))
912 event_count
= f_header
.event_types
.size
/ sizeof(struct perf_trace_event_type
);
915 perf_header__process_sections(self
, fd
, perf_file_section__process
);
917 lseek(fd
, self
->data_offset
, SEEK_SET
);
925 u64
perf_header__sample_type(struct perf_header
*header
)
930 for (i
= 0; i
< header
->attrs
; i
++) {
931 struct perf_header_attr
*attr
= header
->attr
[i
];
934 type
= attr
->attr
.sample_type
;
935 else if (type
!= attr
->attr
.sample_type
)
936 die("non matching sample_type");
942 struct perf_event_attr
*
943 perf_header__find_attr(u64 id
, struct perf_header
*header
)
948 * We set id to -1 if the data file doesn't contain sample
949 * ids. Check for this and avoid walking through the entire
950 * list of ids which may be large.
955 for (i
= 0; i
< header
->attrs
; i
++) {
956 struct perf_header_attr
*attr
= header
->attr
[i
];
959 for (j
= 0; j
< attr
->ids
; j
++) {
960 if (attr
->id
[j
] == id
)
968 int event__synthesize_attr(struct perf_event_attr
*attr
, u16 ids
, u64
*id
,
969 event__handler_t process
,
970 struct perf_session
*session
)
976 size
= sizeof(struct perf_event_attr
);
977 size
= ALIGN(size
, sizeof(u64
));
978 size
+= sizeof(struct perf_event_header
);
979 size
+= ids
* sizeof(u64
);
983 ev
->attr
.attr
= *attr
;
984 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
986 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
987 ev
->attr
.header
.size
= size
;
989 err
= process(ev
, session
);
996 int event__synthesize_attrs(struct perf_header
*self
,
997 event__handler_t process
,
998 struct perf_session
*session
)
1000 struct perf_header_attr
*attr
;
1003 for (i
= 0; i
< self
->attrs
; i
++) {
1004 attr
= self
->attr
[i
];
1006 err
= event__synthesize_attr(&attr
->attr
, attr
->ids
, attr
->id
,
1009 pr_debug("failed to create perf header attribute\n");
1017 int event__process_attr(event_t
*self
, struct perf_session
*session
)
1019 struct perf_header_attr
*attr
;
1020 unsigned int i
, ids
, n_ids
;
1022 attr
= perf_header_attr__new(&self
->attr
.attr
);
1026 ids
= self
->header
.size
;
1027 ids
-= (void *)&self
->attr
.id
- (void *)self
;
1028 n_ids
= ids
/ sizeof(u64
);
1030 for (i
= 0; i
< n_ids
; i
++) {
1031 if (perf_header_attr__add_id(attr
, self
->attr
.id
[i
]) < 0) {
1032 perf_header_attr__delete(attr
);
1037 if (perf_header__add_attr(&session
->header
, attr
) < 0) {
1038 perf_header_attr__delete(attr
);
1042 perf_session__update_sample_type(session
);
1047 int event__synthesize_event_type(u64 event_id
, char *name
,
1048 event__handler_t process
,
1049 struct perf_session
*session
)
1055 memset(&ev
, 0, sizeof(ev
));
1057 ev
.event_type
.event_type
.event_id
= event_id
;
1058 memset(ev
.event_type
.event_type
.name
, 0, MAX_EVENT_NAME
);
1059 strncpy(ev
.event_type
.event_type
.name
, name
, MAX_EVENT_NAME
- 1);
1061 ev
.event_type
.header
.type
= PERF_RECORD_HEADER_EVENT_TYPE
;
1062 size
= strlen(name
);
1063 size
= ALIGN(size
, sizeof(u64
));
1064 ev
.event_type
.header
.size
= sizeof(ev
.event_type
) -
1065 (sizeof(ev
.event_type
.event_type
.name
) - size
);
1067 err
= process(&ev
, session
);
1072 int event__synthesize_event_types(event__handler_t process
,
1073 struct perf_session
*session
)
1075 struct perf_trace_event_type
*type
;
1078 for (i
= 0; i
< event_count
; i
++) {
1081 err
= event__synthesize_event_type(type
->event_id
, type
->name
,
1084 pr_debug("failed to create perf header event type\n");
1092 int event__process_event_type(event_t
*self
,
1093 struct perf_session
*session __unused
)
1095 if (perf_header__push_event(self
->event_type
.event_type
.event_id
,
1096 self
->event_type
.event_type
.name
) < 0)
1102 int event__synthesize_tracing_data(int fd
, struct perf_event_attr
*pattrs
,
1104 event__handler_t process
,
1105 struct perf_session
*session __unused
)
1108 ssize_t size
= 0, aligned_size
= 0, padding
;
1111 memset(&ev
, 0, sizeof(ev
));
1113 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
1114 size
= read_tracing_data_size(fd
, pattrs
, nb_events
);
1117 aligned_size
= ALIGN(size
, sizeof(u64
));
1118 padding
= aligned_size
- size
;
1119 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
1120 ev
.tracing_data
.size
= aligned_size
;
1122 process(&ev
, session
);
1124 err
= read_tracing_data(fd
, pattrs
, nb_events
);
1125 write_padded(fd
, NULL
, 0, padding
);
1127 return aligned_size
;
1130 int event__process_tracing_data(event_t
*self
,
1131 struct perf_session
*session
)
1133 ssize_t size_read
, padding
, size
= self
->tracing_data
.size
;
1134 off_t offset
= lseek(session
->fd
, 0, SEEK_CUR
);
1137 /* setup for reading amidst mmap */
1138 lseek(session
->fd
, offset
+ sizeof(struct tracing_data_event
),
1141 size_read
= trace_report(session
->fd
, session
->repipe
);
1143 padding
= ALIGN(size_read
, sizeof(u64
)) - size_read
;
1145 if (read(session
->fd
, buf
, padding
) < 0)
1146 die("reading input file");
1147 if (session
->repipe
) {
1148 int retw
= write(STDOUT_FILENO
, buf
, padding
);
1149 if (retw
<= 0 || retw
!= padding
)
1150 die("repiping tracing data padding");
1153 if (size_read
+ padding
!= size
)
1154 die("tracing data size mismatch");
1156 return size_read
+ padding
;
1159 int event__synthesize_build_id(struct dso
*pos
, u16 misc
,
1160 event__handler_t process
,
1161 struct machine
*machine
,
1162 struct perf_session
*session
)
1171 memset(&ev
, 0, sizeof(ev
));
1173 len
= pos
->long_name_len
+ 1;
1174 len
= ALIGN(len
, NAME_ALIGN
);
1175 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
1176 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
1177 ev
.build_id
.header
.misc
= misc
;
1178 ev
.build_id
.pid
= machine
->pid
;
1179 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
1180 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
1182 err
= process(&ev
, session
);
1187 int event__process_build_id(event_t
*self
,
1188 struct perf_session
*session
)
1190 __event_process_build_id(&self
->build_id
,
1191 self
->build_id
.filename
,
1196 void disable_buildid_cache(void)
1198 no_buildid_cache
= true;