1 #define _FILE_OFFSET_BITS 64
8 #include <linux/list.h>
9 #include <linux/kernel.h>
15 #include "trace-event.h"
20 static bool no_buildid_cache
= false;
23 * Create new perf.data header attribute:
25 struct perf_header_attr
*perf_header_attr__new(struct perf_event_attr
*attr
)
27 struct perf_header_attr
*self
= malloc(sizeof(*self
));
33 self
->id
= malloc(sizeof(u64
));
34 if (self
->id
== NULL
) {
43 void perf_header_attr__delete(struct perf_header_attr
*self
)
49 int perf_header_attr__add_id(struct perf_header_attr
*self
, u64 id
)
54 if (self
->ids
> self
->size
) {
55 int nsize
= self
->size
* 2;
56 u64
*nid
= realloc(self
->id
, nsize
* sizeof(u64
));
68 int perf_header__init(struct perf_header
*self
)
71 self
->attr
= malloc(sizeof(void *));
72 return self
->attr
== NULL
? -ENOMEM
: 0;
75 void perf_header__exit(struct perf_header
*self
)
78 for (i
= 0; i
< self
->attrs
; ++i
)
79 perf_header_attr__delete(self
->attr
[i
]);
83 int perf_header__add_attr(struct perf_header
*self
,
84 struct perf_header_attr
*attr
)
89 if (self
->attrs
== self
->size
) {
90 int nsize
= self
->size
* 2;
91 struct perf_header_attr
**nattr
;
93 nattr
= realloc(self
->attr
, nsize
* sizeof(void *));
101 self
->attr
[self
->attrs
++] = attr
;
105 static int event_count
;
106 static struct perf_trace_event_type
*events
;
108 int perf_header__push_event(u64 id
, const char *name
)
110 if (strlen(name
) > MAX_EVENT_NAME
)
111 pr_warning("Event %s will be truncated\n", name
);
114 events
= malloc(sizeof(struct perf_trace_event_type
));
118 struct perf_trace_event_type
*nevents
;
120 nevents
= realloc(events
, (event_count
+ 1) * sizeof(*events
));
125 memset(&events
[event_count
], 0, sizeof(struct perf_trace_event_type
));
126 events
[event_count
].event_id
= id
;
127 strncpy(events
[event_count
].name
, name
, MAX_EVENT_NAME
- 1);
132 char *perf_header__find_event(u64 id
)
135 for (i
= 0 ; i
< event_count
; i
++) {
136 if (events
[i
].event_id
== id
)
137 return events
[i
].name
;
142 static const char *__perf_magic
= "PERFFILE";
144 #define PERF_MAGIC (*(u64 *)__perf_magic)
146 struct perf_file_attr
{
147 struct perf_event_attr attr
;
148 struct perf_file_section ids
;
151 void perf_header__set_feat(struct perf_header
*self
, int feat
)
153 set_bit(feat
, self
->adds_features
);
156 void perf_header__clear_feat(struct perf_header
*self
, int feat
)
158 clear_bit(feat
, self
->adds_features
);
161 bool perf_header__has_feat(const struct perf_header
*self
, int feat
)
163 return test_bit(feat
, self
->adds_features
);
166 static int do_write(int fd
, const void *buf
, size_t size
)
169 int ret
= write(fd
, buf
, size
);
181 #define NAME_ALIGN 64
183 static int write_padded(int fd
, const void *bf
, size_t count
,
184 size_t count_aligned
)
186 static const char zero_buf
[NAME_ALIGN
];
187 int err
= do_write(fd
, bf
, count
);
190 err
= do_write(fd
, zero_buf
, count_aligned
- count
);
195 #define dsos__for_each_with_build_id(pos, head) \
196 list_for_each_entry(pos, head, node) \
197 if (!pos->has_build_id) \
201 static int __dsos__write_buildid_table(struct list_head
*head
, pid_t pid
,
206 dsos__for_each_with_build_id(pos
, head
) {
208 struct build_id_event b
;
213 len
= pos
->long_name_len
+ 1;
214 len
= ALIGN(len
, NAME_ALIGN
);
215 memset(&b
, 0, sizeof(b
));
216 memcpy(&b
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
218 b
.header
.misc
= misc
;
219 b
.header
.size
= sizeof(b
) + len
;
220 err
= do_write(fd
, &b
, sizeof(b
));
223 err
= write_padded(fd
, pos
->long_name
,
224 pos
->long_name_len
+ 1, len
);
232 static int machine__write_buildid_table(struct machine
*self
, int fd
)
235 u16 kmisc
= PERF_RECORD_MISC_KERNEL
,
236 umisc
= PERF_RECORD_MISC_USER
;
238 if (!machine__is_host(self
)) {
239 kmisc
= PERF_RECORD_MISC_GUEST_KERNEL
;
240 umisc
= PERF_RECORD_MISC_GUEST_USER
;
243 err
= __dsos__write_buildid_table(&self
->kernel_dsos
, self
->pid
,
246 err
= __dsos__write_buildid_table(&self
->user_dsos
,
247 self
->pid
, umisc
, fd
);
251 static int dsos__write_buildid_table(struct perf_header
*header
, int fd
)
253 struct perf_session
*session
= container_of(header
,
254 struct perf_session
, header
);
256 int err
= machine__write_buildid_table(&session
->host_machine
, fd
);
261 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
262 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
263 err
= machine__write_buildid_table(pos
, fd
);
270 int build_id_cache__add_s(const char *sbuild_id
, const char *debugdir
,
271 const char *name
, bool is_kallsyms
)
273 const size_t size
= PATH_MAX
;
274 char *realname
= realpath(name
, NULL
),
275 *filename
= malloc(size
),
276 *linkname
= malloc(size
), *targetname
;
279 if (realname
== NULL
|| filename
== NULL
|| linkname
== NULL
)
282 len
= snprintf(filename
, size
, "%s%s%s",
283 debugdir
, is_kallsyms
? "/" : "", realname
);
284 if (mkdir_p(filename
, 0755))
287 snprintf(filename
+ len
, sizeof(filename
) - len
, "/%s", sbuild_id
);
289 if (access(filename
, F_OK
)) {
291 if (copyfile("/proc/kallsyms", filename
))
293 } else if (link(realname
, filename
) && copyfile(name
, filename
))
297 len
= snprintf(linkname
, size
, "%s/.build-id/%.2s",
298 debugdir
, sbuild_id
);
300 if (access(linkname
, X_OK
) && mkdir_p(linkname
, 0755))
303 snprintf(linkname
+ len
, size
- len
, "/%s", sbuild_id
+ 2);
304 targetname
= filename
+ strlen(debugdir
) - 5;
305 memcpy(targetname
, "../..", 5);
307 if (symlink(targetname
, linkname
) == 0)
316 static int build_id_cache__add_b(const u8
*build_id
, size_t build_id_size
,
317 const char *name
, const char *debugdir
,
320 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
322 build_id__sprintf(build_id
, build_id_size
, sbuild_id
);
324 return build_id_cache__add_s(sbuild_id
, debugdir
, name
, is_kallsyms
);
327 int build_id_cache__remove_s(const char *sbuild_id
, const char *debugdir
)
329 const size_t size
= PATH_MAX
;
330 char *filename
= malloc(size
),
331 *linkname
= malloc(size
);
334 if (filename
== NULL
|| linkname
== NULL
)
337 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
338 debugdir
, sbuild_id
, sbuild_id
+ 2);
340 if (access(linkname
, F_OK
))
343 if (readlink(linkname
, filename
, size
) < 0)
346 if (unlink(linkname
))
350 * Since the link is relative, we must make it absolute:
352 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
353 debugdir
, sbuild_id
, filename
);
355 if (unlink(linkname
))
365 static int dso__cache_build_id(struct dso
*self
, const char *debugdir
)
367 bool is_kallsyms
= self
->kernel
&& self
->long_name
[0] != '/';
369 return build_id_cache__add_b(self
->build_id
, sizeof(self
->build_id
),
370 self
->long_name
, debugdir
, is_kallsyms
);
373 static int __dsos__cache_build_ids(struct list_head
*head
, const char *debugdir
)
378 dsos__for_each_with_build_id(pos
, head
)
379 if (dso__cache_build_id(pos
, debugdir
))
385 static int machine__cache_build_ids(struct machine
*self
, const char *debugdir
)
387 int ret
= __dsos__cache_build_ids(&self
->kernel_dsos
, debugdir
);
388 ret
|= __dsos__cache_build_ids(&self
->user_dsos
, debugdir
);
392 static int perf_session__cache_build_ids(struct perf_session
*self
)
396 char debugdir
[PATH_MAX
];
398 snprintf(debugdir
, sizeof(debugdir
), "%s", buildid_dir
);
400 if (mkdir(debugdir
, 0755) != 0 && errno
!= EEXIST
)
403 ret
= machine__cache_build_ids(&self
->host_machine
, debugdir
);
405 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
406 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
407 ret
|= machine__cache_build_ids(pos
, debugdir
);
412 static bool machine__read_build_ids(struct machine
*self
, bool with_hits
)
414 bool ret
= __dsos__read_build_ids(&self
->kernel_dsos
, with_hits
);
415 ret
|= __dsos__read_build_ids(&self
->user_dsos
, with_hits
);
419 static bool perf_session__read_build_ids(struct perf_session
*self
, bool with_hits
)
422 bool ret
= machine__read_build_ids(&self
->host_machine
, with_hits
);
424 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
425 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
426 ret
|= machine__read_build_ids(pos
, with_hits
);
432 static int perf_header__adds_write(struct perf_header
*self
,
433 struct perf_evlist
*evlist
, int fd
)
436 struct perf_session
*session
;
437 struct perf_file_section
*feat_sec
;
442 session
= container_of(self
, struct perf_session
, header
);
444 if (perf_header__has_feat(self
, HEADER_BUILD_ID
&&
445 !perf_session__read_build_ids(session
, true)))
446 perf_header__clear_feat(self
, HEADER_BUILD_ID
);
448 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
452 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
453 if (feat_sec
== NULL
)
456 sec_size
= sizeof(*feat_sec
) * nr_sections
;
458 sec_start
= self
->data_offset
+ self
->data_size
;
459 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
461 if (perf_header__has_feat(self
, HEADER_TRACE_INFO
)) {
462 struct perf_file_section
*trace_sec
;
464 trace_sec
= &feat_sec
[idx
++];
466 /* Write trace info */
467 trace_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
468 read_tracing_data(fd
, &evlist
->entries
);
469 trace_sec
->size
= lseek(fd
, 0, SEEK_CUR
) - trace_sec
->offset
;
472 if (perf_header__has_feat(self
, HEADER_BUILD_ID
)) {
473 struct perf_file_section
*buildid_sec
;
475 buildid_sec
= &feat_sec
[idx
++];
477 /* Write build-ids */
478 buildid_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
479 err
= dsos__write_buildid_table(self
, fd
);
481 pr_debug("failed to write buildid table\n");
484 buildid_sec
->size
= lseek(fd
, 0, SEEK_CUR
) -
486 if (!no_buildid_cache
)
487 perf_session__cache_build_ids(session
);
490 lseek(fd
, sec_start
, SEEK_SET
);
491 err
= do_write(fd
, feat_sec
, sec_size
);
493 pr_debug("failed to write feature section\n");
499 int perf_header__write_pipe(int fd
)
501 struct perf_pipe_file_header f_header
;
504 f_header
= (struct perf_pipe_file_header
){
506 .size
= sizeof(f_header
),
509 err
= do_write(fd
, &f_header
, sizeof(f_header
));
511 pr_debug("failed to write perf pipe header\n");
518 int perf_header__write(struct perf_header
*self
, struct perf_evlist
*evlist
,
519 int fd
, bool at_exit
)
521 struct perf_file_header f_header
;
522 struct perf_file_attr f_attr
;
523 struct perf_header_attr
*attr
;
526 lseek(fd
, sizeof(f_header
), SEEK_SET
);
528 for (i
= 0; i
< self
->attrs
; i
++) {
529 attr
= self
->attr
[i
];
531 attr
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
532 err
= do_write(fd
, attr
->id
, attr
->ids
* sizeof(u64
));
534 pr_debug("failed to write perf header\n");
540 self
->attr_offset
= lseek(fd
, 0, SEEK_CUR
);
542 for (i
= 0; i
< self
->attrs
; i
++) {
543 attr
= self
->attr
[i
];
545 f_attr
= (struct perf_file_attr
){
548 .offset
= attr
->id_offset
,
549 .size
= attr
->ids
* sizeof(u64
),
552 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
554 pr_debug("failed to write perf header attribute\n");
559 self
->event_offset
= lseek(fd
, 0, SEEK_CUR
);
560 self
->event_size
= event_count
* sizeof(struct perf_trace_event_type
);
562 err
= do_write(fd
, events
, self
->event_size
);
564 pr_debug("failed to write perf header events\n");
569 self
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
572 err
= perf_header__adds_write(self
, evlist
, fd
);
577 f_header
= (struct perf_file_header
){
579 .size
= sizeof(f_header
),
580 .attr_size
= sizeof(f_attr
),
582 .offset
= self
->attr_offset
,
583 .size
= self
->attrs
* sizeof(f_attr
),
586 .offset
= self
->data_offset
,
587 .size
= self
->data_size
,
590 .offset
= self
->event_offset
,
591 .size
= self
->event_size
,
595 memcpy(&f_header
.adds_features
, &self
->adds_features
, sizeof(self
->adds_features
));
597 lseek(fd
, 0, SEEK_SET
);
598 err
= do_write(fd
, &f_header
, sizeof(f_header
));
600 pr_debug("failed to write perf header\n");
603 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
609 static int perf_header__getbuffer64(struct perf_header
*self
,
610 int fd
, void *buf
, size_t size
)
612 if (readn(fd
, buf
, size
) <= 0)
615 if (self
->needs_swap
)
616 mem_bswap_64(buf
, size
);
621 int perf_header__process_sections(struct perf_header
*self
, int fd
,
622 int (*process
)(struct perf_file_section
*self
,
623 struct perf_header
*ph
,
626 struct perf_file_section
*feat_sec
;
630 int err
= -1, feat
= 1;
632 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
636 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
640 sec_size
= sizeof(*feat_sec
) * nr_sections
;
642 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
644 if (perf_header__getbuffer64(self
, fd
, feat_sec
, sec_size
))
648 while (idx
< nr_sections
&& feat
< HEADER_LAST_FEATURE
) {
649 if (perf_header__has_feat(self
, feat
)) {
650 struct perf_file_section
*sec
= &feat_sec
[idx
++];
652 err
= process(sec
, self
, feat
, fd
);
663 int perf_file_header__read(struct perf_file_header
*self
,
664 struct perf_header
*ph
, int fd
)
666 lseek(fd
, 0, SEEK_SET
);
668 if (readn(fd
, self
, sizeof(*self
)) <= 0 ||
669 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
672 if (self
->attr_size
!= sizeof(struct perf_file_attr
)) {
673 u64 attr_size
= bswap_64(self
->attr_size
);
675 if (attr_size
!= sizeof(struct perf_file_attr
))
678 mem_bswap_64(self
, offsetof(struct perf_file_header
,
680 ph
->needs_swap
= true;
683 if (self
->size
!= sizeof(*self
)) {
684 /* Support the previous format */
685 if (self
->size
== offsetof(typeof(*self
), adds_features
))
686 bitmap_zero(self
->adds_features
, HEADER_FEAT_BITS
);
691 memcpy(&ph
->adds_features
, &self
->adds_features
,
692 sizeof(ph
->adds_features
));
694 * FIXME: hack that assumes that if we need swap the perf.data file
695 * may be coming from an arch with a different word-size, ergo different
696 * DEFINE_BITMAP format, investigate more later, but for now its mostly
697 * safe to assume that we have a build-id section. Trace files probably
698 * have several other issues in this realm anyway...
700 if (ph
->needs_swap
) {
701 memset(&ph
->adds_features
, 0, sizeof(ph
->adds_features
));
702 perf_header__set_feat(ph
, HEADER_BUILD_ID
);
705 ph
->event_offset
= self
->event_types
.offset
;
706 ph
->event_size
= self
->event_types
.size
;
707 ph
->data_offset
= self
->data
.offset
;
708 ph
->data_size
= self
->data
.size
;
712 static int __event_process_build_id(struct build_id_event
*bev
,
714 struct perf_session
*session
)
717 struct list_head
*head
;
718 struct machine
*machine
;
721 enum dso_kernel_type dso_type
;
723 machine
= perf_session__findnew_machine(session
, bev
->pid
);
727 misc
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
730 case PERF_RECORD_MISC_KERNEL
:
731 dso_type
= DSO_TYPE_KERNEL
;
732 head
= &machine
->kernel_dsos
;
734 case PERF_RECORD_MISC_GUEST_KERNEL
:
735 dso_type
= DSO_TYPE_GUEST_KERNEL
;
736 head
= &machine
->kernel_dsos
;
738 case PERF_RECORD_MISC_USER
:
739 case PERF_RECORD_MISC_GUEST_USER
:
740 dso_type
= DSO_TYPE_USER
;
741 head
= &machine
->user_dsos
;
747 dso
= __dsos__findnew(head
, filename
);
749 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
751 dso__set_build_id(dso
, &bev
->build_id
);
753 if (filename
[0] == '[')
754 dso
->kernel
= dso_type
;
756 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
758 pr_debug("build id event received for %s: %s\n",
759 dso
->long_name
, sbuild_id
);
767 static int perf_header__read_build_ids(struct perf_header
*self
,
768 int input
, u64 offset
, u64 size
)
770 struct perf_session
*session
= container_of(self
,
771 struct perf_session
, header
);
772 struct build_id_event bev
;
773 char filename
[PATH_MAX
];
774 u64 limit
= offset
+ size
;
777 while (offset
< limit
) {
780 if (read(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
783 if (self
->needs_swap
)
784 perf_event_header__bswap(&bev
.header
);
786 len
= bev
.header
.size
- sizeof(bev
);
787 if (read(input
, filename
, len
) != len
)
790 __event_process_build_id(&bev
, filename
, session
);
792 offset
+= bev
.header
.size
;
799 static int perf_file_section__process(struct perf_file_section
*self
,
800 struct perf_header
*ph
,
803 if (lseek(fd
, self
->offset
, SEEK_SET
) == (off_t
)-1) {
804 pr_debug("Failed to lseek to %" PRIu64
" offset for feature "
805 "%d, continuing...\n", self
->offset
, feat
);
810 case HEADER_TRACE_INFO
:
811 trace_report(fd
, false);
814 case HEADER_BUILD_ID
:
815 if (perf_header__read_build_ids(ph
, fd
, self
->offset
, self
->size
))
816 pr_debug("Failed to read buildids, continuing...\n");
819 pr_debug("unknown feature %d, continuing...\n", feat
);
825 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*self
,
826 struct perf_header
*ph
, int fd
,
829 if (readn(fd
, self
, sizeof(*self
)) <= 0 ||
830 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
833 if (repipe
&& do_write(STDOUT_FILENO
, self
, sizeof(*self
)) < 0)
836 if (self
->size
!= sizeof(*self
)) {
837 u64 size
= bswap_64(self
->size
);
839 if (size
!= sizeof(*self
))
842 ph
->needs_swap
= true;
848 static int perf_header__read_pipe(struct perf_session
*session
, int fd
)
850 struct perf_header
*self
= &session
->header
;
851 struct perf_pipe_file_header f_header
;
853 if (perf_file_header__read_pipe(&f_header
, self
, fd
,
854 session
->repipe
) < 0) {
855 pr_debug("incompatible file format\n");
864 int perf_header__read(struct perf_session
*session
, int fd
)
866 struct perf_header
*self
= &session
->header
;
867 struct perf_file_header f_header
;
868 struct perf_file_attr f_attr
;
870 int nr_attrs
, nr_ids
, i
, j
;
872 if (session
->fd_pipe
)
873 return perf_header__read_pipe(session
, fd
);
875 if (perf_file_header__read(&f_header
, self
, fd
) < 0) {
876 pr_debug("incompatible file format\n");
880 nr_attrs
= f_header
.attrs
.size
/ sizeof(f_attr
);
881 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
883 for (i
= 0; i
< nr_attrs
; i
++) {
884 struct perf_header_attr
*attr
;
887 if (perf_header__getbuffer64(self
, fd
, &f_attr
, sizeof(f_attr
)))
890 tmp
= lseek(fd
, 0, SEEK_CUR
);
892 attr
= perf_header_attr__new(&f_attr
.attr
);
896 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
897 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
899 for (j
= 0; j
< nr_ids
; j
++) {
900 if (perf_header__getbuffer64(self
, fd
, &f_id
, sizeof(f_id
)))
903 if (perf_header_attr__add_id(attr
, f_id
) < 0) {
904 perf_header_attr__delete(attr
);
908 if (perf_header__add_attr(self
, attr
) < 0) {
909 perf_header_attr__delete(attr
);
913 lseek(fd
, tmp
, SEEK_SET
);
916 if (f_header
.event_types
.size
) {
917 lseek(fd
, f_header
.event_types
.offset
, SEEK_SET
);
918 events
= malloc(f_header
.event_types
.size
);
921 if (perf_header__getbuffer64(self
, fd
, events
,
922 f_header
.event_types
.size
))
924 event_count
= f_header
.event_types
.size
/ sizeof(struct perf_trace_event_type
);
927 perf_header__process_sections(self
, fd
, perf_file_section__process
);
929 lseek(fd
, self
->data_offset
, SEEK_SET
);
937 u64
perf_header__sample_type(struct perf_header
*header
)
942 for (i
= 0; i
< header
->attrs
; i
++) {
943 struct perf_header_attr
*attr
= header
->attr
[i
];
946 type
= attr
->attr
.sample_type
;
947 else if (type
!= attr
->attr
.sample_type
)
948 die("non matching sample_type");
954 bool perf_header__sample_id_all(const struct perf_header
*header
)
956 bool value
= false, first
= true;
959 for (i
= 0; i
< header
->attrs
; i
++) {
960 struct perf_header_attr
*attr
= header
->attr
[i
];
963 value
= attr
->attr
.sample_id_all
;
965 } else if (value
!= attr
->attr
.sample_id_all
)
966 die("non matching sample_id_all");
972 struct perf_event_attr
*
973 perf_header__find_attr(u64 id
, struct perf_header
*header
)
978 * We set id to -1 if the data file doesn't contain sample
979 * ids. This can happen when the data file contains one type
980 * of event and in that case, the header can still store the
981 * event attribute information. Check for this and avoid
982 * walking through the entire list of ids which may be large.
985 if (header
->attrs
> 0)
986 return &header
->attr
[0]->attr
;
990 for (i
= 0; i
< header
->attrs
; i
++) {
991 struct perf_header_attr
*attr
= header
->attr
[i
];
994 for (j
= 0; j
< attr
->ids
; j
++) {
995 if (attr
->id
[j
] == id
)
1003 int perf_event__synthesize_attr(struct perf_event_attr
*attr
, u16 ids
, u64
*id
,
1004 perf_event__handler_t process
,
1005 struct perf_session
*session
)
1007 union perf_event
*ev
;
1011 size
= sizeof(struct perf_event_attr
);
1012 size
= ALIGN(size
, sizeof(u64
));
1013 size
+= sizeof(struct perf_event_header
);
1014 size
+= ids
* sizeof(u64
);
1021 ev
->attr
.attr
= *attr
;
1022 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
1024 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
1025 ev
->attr
.header
.size
= size
;
1027 err
= process(ev
, NULL
, session
);
1034 int perf_event__synthesize_attrs(struct perf_header
*self
,
1035 perf_event__handler_t process
,
1036 struct perf_session
*session
)
1038 struct perf_header_attr
*attr
;
1041 for (i
= 0; i
< self
->attrs
; i
++) {
1042 attr
= self
->attr
[i
];
1044 err
= perf_event__synthesize_attr(&attr
->attr
, attr
->ids
,
1045 attr
->id
, process
, session
);
1047 pr_debug("failed to create perf header attribute\n");
1055 int perf_event__process_attr(union perf_event
*event
,
1056 struct perf_session
*session
)
1058 struct perf_header_attr
*attr
;
1059 unsigned int i
, ids
, n_ids
;
1061 attr
= perf_header_attr__new(&event
->attr
.attr
);
1065 ids
= event
->header
.size
;
1066 ids
-= (void *)&event
->attr
.id
- (void *)event
;
1067 n_ids
= ids
/ sizeof(u64
);
1069 for (i
= 0; i
< n_ids
; i
++) {
1070 if (perf_header_attr__add_id(attr
, event
->attr
.id
[i
]) < 0) {
1071 perf_header_attr__delete(attr
);
1076 if (perf_header__add_attr(&session
->header
, attr
) < 0) {
1077 perf_header_attr__delete(attr
);
1081 perf_session__update_sample_type(session
);
1086 int perf_event__synthesize_event_type(u64 event_id
, char *name
,
1087 perf_event__handler_t process
,
1088 struct perf_session
*session
)
1090 union perf_event ev
;
1094 memset(&ev
, 0, sizeof(ev
));
1096 ev
.event_type
.event_type
.event_id
= event_id
;
1097 memset(ev
.event_type
.event_type
.name
, 0, MAX_EVENT_NAME
);
1098 strncpy(ev
.event_type
.event_type
.name
, name
, MAX_EVENT_NAME
- 1);
1100 ev
.event_type
.header
.type
= PERF_RECORD_HEADER_EVENT_TYPE
;
1101 size
= strlen(name
);
1102 size
= ALIGN(size
, sizeof(u64
));
1103 ev
.event_type
.header
.size
= sizeof(ev
.event_type
) -
1104 (sizeof(ev
.event_type
.event_type
.name
) - size
);
1106 err
= process(&ev
, NULL
, session
);
1111 int perf_event__synthesize_event_types(perf_event__handler_t process
,
1112 struct perf_session
*session
)
1114 struct perf_trace_event_type
*type
;
1117 for (i
= 0; i
< event_count
; i
++) {
1120 err
= perf_event__synthesize_event_type(type
->event_id
,
1121 type
->name
, process
,
1124 pr_debug("failed to create perf header event type\n");
1132 int perf_event__process_event_type(union perf_event
*event
,
1133 struct perf_session
*session __unused
)
1135 if (perf_header__push_event(event
->event_type
.event_type
.event_id
,
1136 event
->event_type
.event_type
.name
) < 0)
1142 int perf_event__synthesize_tracing_data(int fd
, struct perf_evlist
*evlist
,
1143 perf_event__handler_t process
,
1144 struct perf_session
*session __unused
)
1146 union perf_event ev
;
1147 ssize_t size
= 0, aligned_size
= 0, padding
;
1150 memset(&ev
, 0, sizeof(ev
));
1152 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
1153 size
= read_tracing_data_size(fd
, &evlist
->entries
);
1156 aligned_size
= ALIGN(size
, sizeof(u64
));
1157 padding
= aligned_size
- size
;
1158 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
1159 ev
.tracing_data
.size
= aligned_size
;
1161 process(&ev
, NULL
, session
);
1163 err
= read_tracing_data(fd
, &evlist
->entries
);
1164 write_padded(fd
, NULL
, 0, padding
);
1166 return aligned_size
;
1169 int perf_event__process_tracing_data(union perf_event
*event
,
1170 struct perf_session
*session
)
1172 ssize_t size_read
, padding
, size
= event
->tracing_data
.size
;
1173 off_t offset
= lseek(session
->fd
, 0, SEEK_CUR
);
1176 /* setup for reading amidst mmap */
1177 lseek(session
->fd
, offset
+ sizeof(struct tracing_data_event
),
1180 size_read
= trace_report(session
->fd
, session
->repipe
);
1182 padding
= ALIGN(size_read
, sizeof(u64
)) - size_read
;
1184 if (read(session
->fd
, buf
, padding
) < 0)
1185 die("reading input file");
1186 if (session
->repipe
) {
1187 int retw
= write(STDOUT_FILENO
, buf
, padding
);
1188 if (retw
<= 0 || retw
!= padding
)
1189 die("repiping tracing data padding");
1192 if (size_read
+ padding
!= size
)
1193 die("tracing data size mismatch");
1195 return size_read
+ padding
;
1198 int perf_event__synthesize_build_id(struct dso
*pos
, u16 misc
,
1199 perf_event__handler_t process
,
1200 struct machine
*machine
,
1201 struct perf_session
*session
)
1203 union perf_event ev
;
1210 memset(&ev
, 0, sizeof(ev
));
1212 len
= pos
->long_name_len
+ 1;
1213 len
= ALIGN(len
, NAME_ALIGN
);
1214 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
1215 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
1216 ev
.build_id
.header
.misc
= misc
;
1217 ev
.build_id
.pid
= machine
->pid
;
1218 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
1219 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
1221 err
= process(&ev
, NULL
, session
);
1226 int perf_event__process_build_id(union perf_event
*event
,
1227 struct perf_session
*session
)
1229 __event_process_build_id(&event
->build_id
,
1230 event
->build_id
.filename
,
1235 void disable_buildid_cache(void)
1237 no_buildid_cache
= true;