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 void perf_header__clear_feat(struct perf_header
*self
, int feat
)
157 clear_bit(feat
, self
->adds_features
);
160 bool perf_header__has_feat(const struct perf_header
*self
, int feat
)
162 return test_bit(feat
, self
->adds_features
);
165 static int do_write(int fd
, const void *buf
, size_t size
)
168 int ret
= write(fd
, buf
, size
);
180 #define NAME_ALIGN 64
182 static int write_padded(int fd
, const void *bf
, size_t count
,
183 size_t count_aligned
)
185 static const char zero_buf
[NAME_ALIGN
];
186 int err
= do_write(fd
, bf
, count
);
189 err
= do_write(fd
, zero_buf
, count_aligned
- count
);
194 #define dsos__for_each_with_build_id(pos, head) \
195 list_for_each_entry(pos, head, node) \
196 if (!pos->has_build_id) \
200 static int __dsos__write_buildid_table(struct list_head
*head
, pid_t pid
,
205 dsos__for_each_with_build_id(pos
, head
) {
207 struct build_id_event b
;
212 len
= pos
->long_name_len
+ 1;
213 len
= ALIGN(len
, NAME_ALIGN
);
214 memset(&b
, 0, sizeof(b
));
215 memcpy(&b
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
217 b
.header
.misc
= misc
;
218 b
.header
.size
= sizeof(b
) + len
;
219 err
= do_write(fd
, &b
, sizeof(b
));
222 err
= write_padded(fd
, pos
->long_name
,
223 pos
->long_name_len
+ 1, len
);
231 static int machine__write_buildid_table(struct machine
*self
, int fd
)
234 u16 kmisc
= PERF_RECORD_MISC_KERNEL
,
235 umisc
= PERF_RECORD_MISC_USER
;
237 if (!machine__is_host(self
)) {
238 kmisc
= PERF_RECORD_MISC_GUEST_KERNEL
;
239 umisc
= PERF_RECORD_MISC_GUEST_USER
;
242 err
= __dsos__write_buildid_table(&self
->kernel_dsos
, self
->pid
,
245 err
= __dsos__write_buildid_table(&self
->user_dsos
,
246 self
->pid
, umisc
, fd
);
250 static int dsos__write_buildid_table(struct perf_header
*header
, int fd
)
252 struct perf_session
*session
= container_of(header
,
253 struct perf_session
, header
);
255 int err
= machine__write_buildid_table(&session
->host_machine
, fd
);
260 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
261 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
262 err
= machine__write_buildid_table(pos
, fd
);
269 int build_id_cache__add_s(const char *sbuild_id
, const char *debugdir
,
270 const char *name
, bool is_kallsyms
)
272 const size_t size
= PATH_MAX
;
273 char *filename
= malloc(size
),
274 *linkname
= malloc(size
), *targetname
;
277 if (filename
== NULL
|| linkname
== NULL
)
280 len
= snprintf(filename
, size
, "%s%s%s",
281 debugdir
, is_kallsyms
? "/" : "", name
);
282 if (mkdir_p(filename
, 0755))
285 snprintf(filename
+ len
, sizeof(filename
) - len
, "/%s", sbuild_id
);
287 if (access(filename
, F_OK
)) {
289 if (copyfile("/proc/kallsyms", filename
))
291 } else if (link(name
, filename
) && copyfile(name
, filename
))
295 len
= snprintf(linkname
, size
, "%s/.build-id/%.2s",
296 debugdir
, sbuild_id
);
298 if (access(linkname
, X_OK
) && mkdir_p(linkname
, 0755))
301 snprintf(linkname
+ len
, size
- len
, "/%s", sbuild_id
+ 2);
302 targetname
= filename
+ strlen(debugdir
) - 5;
303 memcpy(targetname
, "../..", 5);
305 if (symlink(targetname
, linkname
) == 0)
313 static int build_id_cache__add_b(const u8
*build_id
, size_t build_id_size
,
314 const char *name
, const char *debugdir
,
317 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
319 build_id__sprintf(build_id
, build_id_size
, sbuild_id
);
321 return build_id_cache__add_s(sbuild_id
, debugdir
, name
, is_kallsyms
);
324 int build_id_cache__remove_s(const char *sbuild_id
, const char *debugdir
)
326 const size_t size
= PATH_MAX
;
327 char *filename
= malloc(size
),
328 *linkname
= malloc(size
);
331 if (filename
== NULL
|| linkname
== NULL
)
334 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
335 debugdir
, sbuild_id
, sbuild_id
+ 2);
337 if (access(linkname
, F_OK
))
340 if (readlink(linkname
, filename
, size
) < 0)
343 if (unlink(linkname
))
347 * Since the link is relative, we must make it absolute:
349 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
350 debugdir
, sbuild_id
, filename
);
352 if (unlink(linkname
))
362 static int dso__cache_build_id(struct dso
*self
, const char *debugdir
)
364 bool is_kallsyms
= self
->kernel
&& self
->long_name
[0] != '/';
366 return build_id_cache__add_b(self
->build_id
, sizeof(self
->build_id
),
367 self
->long_name
, debugdir
, is_kallsyms
);
370 static int __dsos__cache_build_ids(struct list_head
*head
, const char *debugdir
)
375 dsos__for_each_with_build_id(pos
, head
)
376 if (dso__cache_build_id(pos
, debugdir
))
382 static int machine__cache_build_ids(struct machine
*self
, const char *debugdir
)
384 int ret
= __dsos__cache_build_ids(&self
->kernel_dsos
, debugdir
);
385 ret
|= __dsos__cache_build_ids(&self
->user_dsos
, debugdir
);
389 static int perf_session__cache_build_ids(struct perf_session
*self
)
393 char debugdir
[PATH_MAX
];
395 snprintf(debugdir
, sizeof(debugdir
), "%s", buildid_dir
);
397 if (mkdir(debugdir
, 0755) != 0 && errno
!= EEXIST
)
400 ret
= machine__cache_build_ids(&self
->host_machine
, debugdir
);
402 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
403 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
404 ret
|= machine__cache_build_ids(pos
, debugdir
);
409 static bool machine__read_build_ids(struct machine
*self
, bool with_hits
)
411 bool ret
= __dsos__read_build_ids(&self
->kernel_dsos
, with_hits
);
412 ret
|= __dsos__read_build_ids(&self
->user_dsos
, with_hits
);
416 static bool perf_session__read_build_ids(struct perf_session
*self
, bool with_hits
)
419 bool ret
= machine__read_build_ids(&self
->host_machine
, with_hits
);
421 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
422 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
423 ret
|= machine__read_build_ids(pos
, with_hits
);
429 static int perf_header__adds_write(struct perf_header
*self
, int fd
)
432 struct perf_session
*session
;
433 struct perf_file_section
*feat_sec
;
438 session
= container_of(self
, struct perf_session
, header
);
440 if (perf_header__has_feat(self
, HEADER_BUILD_ID
&&
441 !perf_session__read_build_ids(session
, true)))
442 perf_header__clear_feat(self
, HEADER_BUILD_ID
);
444 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
448 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
449 if (feat_sec
== NULL
)
452 sec_size
= sizeof(*feat_sec
) * nr_sections
;
454 sec_start
= self
->data_offset
+ self
->data_size
;
455 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
457 if (perf_header__has_feat(self
, HEADER_TRACE_INFO
)) {
458 struct perf_file_section
*trace_sec
;
460 trace_sec
= &feat_sec
[idx
++];
462 /* Write trace info */
463 trace_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
464 read_tracing_data(fd
, attrs
, nr_counters
);
465 trace_sec
->size
= lseek(fd
, 0, SEEK_CUR
) - trace_sec
->offset
;
468 if (perf_header__has_feat(self
, HEADER_BUILD_ID
)) {
469 struct perf_file_section
*buildid_sec
;
471 buildid_sec
= &feat_sec
[idx
++];
473 /* Write build-ids */
474 buildid_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
475 err
= dsos__write_buildid_table(self
, fd
);
477 pr_debug("failed to write buildid table\n");
480 buildid_sec
->size
= lseek(fd
, 0, SEEK_CUR
) -
482 if (!no_buildid_cache
)
483 perf_session__cache_build_ids(session
);
486 lseek(fd
, sec_start
, SEEK_SET
);
487 err
= do_write(fd
, feat_sec
, sec_size
);
489 pr_debug("failed to write feature section\n");
495 int perf_header__write_pipe(int fd
)
497 struct perf_pipe_file_header f_header
;
500 f_header
= (struct perf_pipe_file_header
){
502 .size
= sizeof(f_header
),
505 err
= do_write(fd
, &f_header
, sizeof(f_header
));
507 pr_debug("failed to write perf pipe header\n");
514 int perf_header__write(struct perf_header
*self
, int fd
, bool at_exit
)
516 struct perf_file_header f_header
;
517 struct perf_file_attr f_attr
;
518 struct perf_header_attr
*attr
;
521 lseek(fd
, sizeof(f_header
), SEEK_SET
);
523 for (i
= 0; i
< self
->attrs
; i
++) {
524 attr
= self
->attr
[i
];
526 attr
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
527 err
= do_write(fd
, attr
->id
, attr
->ids
* sizeof(u64
));
529 pr_debug("failed to write perf header\n");
535 self
->attr_offset
= lseek(fd
, 0, SEEK_CUR
);
537 for (i
= 0; i
< self
->attrs
; i
++) {
538 attr
= self
->attr
[i
];
540 f_attr
= (struct perf_file_attr
){
543 .offset
= attr
->id_offset
,
544 .size
= attr
->ids
* sizeof(u64
),
547 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
549 pr_debug("failed to write perf header attribute\n");
554 self
->event_offset
= lseek(fd
, 0, SEEK_CUR
);
555 self
->event_size
= event_count
* sizeof(struct perf_trace_event_type
);
557 err
= do_write(fd
, events
, self
->event_size
);
559 pr_debug("failed to write perf header events\n");
564 self
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
567 err
= perf_header__adds_write(self
, fd
);
572 f_header
= (struct perf_file_header
){
574 .size
= sizeof(f_header
),
575 .attr_size
= sizeof(f_attr
),
577 .offset
= self
->attr_offset
,
578 .size
= self
->attrs
* sizeof(f_attr
),
581 .offset
= self
->data_offset
,
582 .size
= self
->data_size
,
585 .offset
= self
->event_offset
,
586 .size
= self
->event_size
,
590 memcpy(&f_header
.adds_features
, &self
->adds_features
, sizeof(self
->adds_features
));
592 lseek(fd
, 0, SEEK_SET
);
593 err
= do_write(fd
, &f_header
, sizeof(f_header
));
595 pr_debug("failed to write perf header\n");
598 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
604 static int perf_header__getbuffer64(struct perf_header
*self
,
605 int fd
, void *buf
, size_t size
)
607 if (do_read(fd
, buf
, size
) <= 0)
610 if (self
->needs_swap
)
611 mem_bswap_64(buf
, size
);
616 int perf_header__process_sections(struct perf_header
*self
, int fd
,
617 int (*process
)(struct perf_file_section
*self
,
618 struct perf_header
*ph
,
621 struct perf_file_section
*feat_sec
;
625 int err
= -1, feat
= 1;
627 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
631 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
635 sec_size
= sizeof(*feat_sec
) * nr_sections
;
637 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
639 if (perf_header__getbuffer64(self
, fd
, feat_sec
, sec_size
))
643 while (idx
< nr_sections
&& feat
< HEADER_LAST_FEATURE
) {
644 if (perf_header__has_feat(self
, feat
)) {
645 struct perf_file_section
*sec
= &feat_sec
[idx
++];
647 err
= process(sec
, self
, feat
, fd
);
658 int perf_file_header__read(struct perf_file_header
*self
,
659 struct perf_header
*ph
, int fd
)
661 lseek(fd
, 0, SEEK_SET
);
663 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
664 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
667 if (self
->attr_size
!= sizeof(struct perf_file_attr
)) {
668 u64 attr_size
= bswap_64(self
->attr_size
);
670 if (attr_size
!= sizeof(struct perf_file_attr
))
673 mem_bswap_64(self
, offsetof(struct perf_file_header
,
675 ph
->needs_swap
= true;
678 if (self
->size
!= sizeof(*self
)) {
679 /* Support the previous format */
680 if (self
->size
== offsetof(typeof(*self
), adds_features
))
681 bitmap_zero(self
->adds_features
, HEADER_FEAT_BITS
);
686 memcpy(&ph
->adds_features
, &self
->adds_features
,
687 sizeof(ph
->adds_features
));
689 * FIXME: hack that assumes that if we need swap the perf.data file
690 * may be coming from an arch with a different word-size, ergo different
691 * DEFINE_BITMAP format, investigate more later, but for now its mostly
692 * safe to assume that we have a build-id section. Trace files probably
693 * have several other issues in this realm anyway...
695 if (ph
->needs_swap
) {
696 memset(&ph
->adds_features
, 0, sizeof(ph
->adds_features
));
697 perf_header__set_feat(ph
, HEADER_BUILD_ID
);
700 ph
->event_offset
= self
->event_types
.offset
;
701 ph
->event_size
= self
->event_types
.size
;
702 ph
->data_offset
= self
->data
.offset
;
703 ph
->data_size
= self
->data
.size
;
707 static int __event_process_build_id(struct build_id_event
*bev
,
709 struct perf_session
*session
)
712 struct list_head
*head
;
713 struct machine
*machine
;
716 enum dso_kernel_type dso_type
;
718 machine
= perf_session__findnew_machine(session
, bev
->pid
);
722 misc
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
725 case PERF_RECORD_MISC_KERNEL
:
726 dso_type
= DSO_TYPE_KERNEL
;
727 head
= &machine
->kernel_dsos
;
729 case PERF_RECORD_MISC_GUEST_KERNEL
:
730 dso_type
= DSO_TYPE_GUEST_KERNEL
;
731 head
= &machine
->kernel_dsos
;
733 case PERF_RECORD_MISC_USER
:
734 case PERF_RECORD_MISC_GUEST_USER
:
735 dso_type
= DSO_TYPE_USER
;
736 head
= &machine
->user_dsos
;
742 dso
= __dsos__findnew(head
, filename
);
744 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
746 dso__set_build_id(dso
, &bev
->build_id
);
748 if (filename
[0] == '[')
749 dso
->kernel
= dso_type
;
751 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
753 pr_debug("build id event received for %s: %s\n",
754 dso
->long_name
, sbuild_id
);
762 static int perf_header__read_build_ids(struct perf_header
*self
,
763 int input
, u64 offset
, u64 size
)
765 struct perf_session
*session
= container_of(self
,
766 struct perf_session
, header
);
767 struct build_id_event bev
;
768 char filename
[PATH_MAX
];
769 u64 limit
= offset
+ size
;
772 while (offset
< limit
) {
775 if (read(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
778 if (self
->needs_swap
)
779 perf_event_header__bswap(&bev
.header
);
781 len
= bev
.header
.size
- sizeof(bev
);
782 if (read(input
, filename
, len
) != len
)
785 __event_process_build_id(&bev
, filename
, session
);
787 offset
+= bev
.header
.size
;
794 static int perf_file_section__process(struct perf_file_section
*self
,
795 struct perf_header
*ph
,
798 if (lseek(fd
, self
->offset
, SEEK_SET
) == (off_t
)-1) {
799 pr_debug("Failed to lseek to %Ld offset for feature %d, "
800 "continuing...\n", self
->offset
, feat
);
805 case HEADER_TRACE_INFO
:
806 trace_report(fd
, false);
809 case HEADER_BUILD_ID
:
810 if (perf_header__read_build_ids(ph
, fd
, self
->offset
, self
->size
))
811 pr_debug("Failed to read buildids, continuing...\n");
814 pr_debug("unknown feature %d, continuing...\n", feat
);
820 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*self
,
821 struct perf_header
*ph
, int fd
,
824 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
825 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
828 if (repipe
&& do_write(STDOUT_FILENO
, self
, sizeof(*self
)) < 0)
831 if (self
->size
!= sizeof(*self
)) {
832 u64 size
= bswap_64(self
->size
);
834 if (size
!= sizeof(*self
))
837 ph
->needs_swap
= true;
843 static int perf_header__read_pipe(struct perf_session
*session
, int fd
)
845 struct perf_header
*self
= &session
->header
;
846 struct perf_pipe_file_header f_header
;
848 if (perf_file_header__read_pipe(&f_header
, self
, fd
,
849 session
->repipe
) < 0) {
850 pr_debug("incompatible file format\n");
859 int perf_header__read(struct perf_session
*session
, int fd
)
861 struct perf_header
*self
= &session
->header
;
862 struct perf_file_header f_header
;
863 struct perf_file_attr f_attr
;
865 int nr_attrs
, nr_ids
, i
, j
;
867 if (session
->fd_pipe
)
868 return perf_header__read_pipe(session
, fd
);
870 if (perf_file_header__read(&f_header
, self
, fd
) < 0) {
871 pr_debug("incompatible file format\n");
875 nr_attrs
= f_header
.attrs
.size
/ sizeof(f_attr
);
876 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
878 for (i
= 0; i
< nr_attrs
; i
++) {
879 struct perf_header_attr
*attr
;
882 if (perf_header__getbuffer64(self
, fd
, &f_attr
, sizeof(f_attr
)))
885 tmp
= lseek(fd
, 0, SEEK_CUR
);
887 attr
= perf_header_attr__new(&f_attr
.attr
);
891 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
892 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
894 for (j
= 0; j
< nr_ids
; j
++) {
895 if (perf_header__getbuffer64(self
, fd
, &f_id
, sizeof(f_id
)))
898 if (perf_header_attr__add_id(attr
, f_id
) < 0) {
899 perf_header_attr__delete(attr
);
903 if (perf_header__add_attr(self
, attr
) < 0) {
904 perf_header_attr__delete(attr
);
908 lseek(fd
, tmp
, SEEK_SET
);
911 if (f_header
.event_types
.size
) {
912 lseek(fd
, f_header
.event_types
.offset
, SEEK_SET
);
913 events
= malloc(f_header
.event_types
.size
);
916 if (perf_header__getbuffer64(self
, fd
, events
,
917 f_header
.event_types
.size
))
919 event_count
= f_header
.event_types
.size
/ sizeof(struct perf_trace_event_type
);
922 perf_header__process_sections(self
, fd
, perf_file_section__process
);
924 lseek(fd
, self
->data_offset
, SEEK_SET
);
932 u64
perf_header__sample_type(struct perf_header
*header
)
937 for (i
= 0; i
< header
->attrs
; i
++) {
938 struct perf_header_attr
*attr
= header
->attr
[i
];
941 type
= attr
->attr
.sample_type
;
942 else if (type
!= attr
->attr
.sample_type
)
943 die("non matching sample_type");
949 bool perf_header__sample_id_all(const struct perf_header
*header
)
951 bool value
= false, first
= true;
954 for (i
= 0; i
< header
->attrs
; i
++) {
955 struct perf_header_attr
*attr
= header
->attr
[i
];
958 value
= attr
->attr
.sample_id_all
;
960 } else if (value
!= attr
->attr
.sample_id_all
)
961 die("non matching sample_id_all");
967 struct perf_event_attr
*
968 perf_header__find_attr(u64 id
, struct perf_header
*header
)
973 * We set id to -1 if the data file doesn't contain sample
974 * ids. This can happen when the data file contains one type
975 * of event and in that case, the header can still store the
976 * event attribute information. Check for this and avoid
977 * walking through the entire list of ids which may be large.
980 if (header
->attrs
> 0)
981 return &header
->attr
[0]->attr
;
985 for (i
= 0; i
< header
->attrs
; i
++) {
986 struct perf_header_attr
*attr
= header
->attr
[i
];
989 for (j
= 0; j
< attr
->ids
; j
++) {
990 if (attr
->id
[j
] == id
)
998 int event__synthesize_attr(struct perf_event_attr
*attr
, u16 ids
, u64
*id
,
999 event__handler_t process
,
1000 struct perf_session
*session
)
1006 size
= sizeof(struct perf_event_attr
);
1007 size
= ALIGN(size
, sizeof(u64
));
1008 size
+= sizeof(struct perf_event_header
);
1009 size
+= ids
* sizeof(u64
);
1016 ev
->attr
.attr
= *attr
;
1017 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
1019 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
1020 ev
->attr
.header
.size
= size
;
1022 err
= process(ev
, NULL
, session
);
1029 int event__synthesize_attrs(struct perf_header
*self
, event__handler_t process
,
1030 struct perf_session
*session
)
1032 struct perf_header_attr
*attr
;
1035 for (i
= 0; i
< self
->attrs
; i
++) {
1036 attr
= self
->attr
[i
];
1038 err
= event__synthesize_attr(&attr
->attr
, attr
->ids
, attr
->id
,
1041 pr_debug("failed to create perf header attribute\n");
1049 int event__process_attr(event_t
*self
, struct perf_session
*session
)
1051 struct perf_header_attr
*attr
;
1052 unsigned int i
, ids
, n_ids
;
1054 attr
= perf_header_attr__new(&self
->attr
.attr
);
1058 ids
= self
->header
.size
;
1059 ids
-= (void *)&self
->attr
.id
- (void *)self
;
1060 n_ids
= ids
/ sizeof(u64
);
1062 for (i
= 0; i
< n_ids
; i
++) {
1063 if (perf_header_attr__add_id(attr
, self
->attr
.id
[i
]) < 0) {
1064 perf_header_attr__delete(attr
);
1069 if (perf_header__add_attr(&session
->header
, attr
) < 0) {
1070 perf_header_attr__delete(attr
);
1074 perf_session__update_sample_type(session
);
1079 int event__synthesize_event_type(u64 event_id
, char *name
,
1080 event__handler_t process
,
1081 struct perf_session
*session
)
1087 memset(&ev
, 0, sizeof(ev
));
1089 ev
.event_type
.event_type
.event_id
= event_id
;
1090 memset(ev
.event_type
.event_type
.name
, 0, MAX_EVENT_NAME
);
1091 strncpy(ev
.event_type
.event_type
.name
, name
, MAX_EVENT_NAME
- 1);
1093 ev
.event_type
.header
.type
= PERF_RECORD_HEADER_EVENT_TYPE
;
1094 size
= strlen(name
);
1095 size
= ALIGN(size
, sizeof(u64
));
1096 ev
.event_type
.header
.size
= sizeof(ev
.event_type
) -
1097 (sizeof(ev
.event_type
.event_type
.name
) - size
);
1099 err
= process(&ev
, NULL
, session
);
1104 int event__synthesize_event_types(event__handler_t process
,
1105 struct perf_session
*session
)
1107 struct perf_trace_event_type
*type
;
1110 for (i
= 0; i
< event_count
; i
++) {
1113 err
= event__synthesize_event_type(type
->event_id
, type
->name
,
1116 pr_debug("failed to create perf header event type\n");
1124 int event__process_event_type(event_t
*self
,
1125 struct perf_session
*session __unused
)
1127 if (perf_header__push_event(self
->event_type
.event_type
.event_id
,
1128 self
->event_type
.event_type
.name
) < 0)
1134 int event__synthesize_tracing_data(int fd
, struct perf_event_attr
*pattrs
,
1136 event__handler_t process
,
1137 struct perf_session
*session __unused
)
1140 ssize_t size
= 0, aligned_size
= 0, padding
;
1143 memset(&ev
, 0, sizeof(ev
));
1145 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
1146 size
= read_tracing_data_size(fd
, pattrs
, nb_events
);
1149 aligned_size
= ALIGN(size
, sizeof(u64
));
1150 padding
= aligned_size
- size
;
1151 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
1152 ev
.tracing_data
.size
= aligned_size
;
1154 process(&ev
, NULL
, session
);
1156 err
= read_tracing_data(fd
, pattrs
, nb_events
);
1157 write_padded(fd
, NULL
, 0, padding
);
1159 return aligned_size
;
1162 int event__process_tracing_data(event_t
*self
,
1163 struct perf_session
*session
)
1165 ssize_t size_read
, padding
, size
= self
->tracing_data
.size
;
1166 off_t offset
= lseek(session
->fd
, 0, SEEK_CUR
);
1169 /* setup for reading amidst mmap */
1170 lseek(session
->fd
, offset
+ sizeof(struct tracing_data_event
),
1173 size_read
= trace_report(session
->fd
, session
->repipe
);
1175 padding
= ALIGN(size_read
, sizeof(u64
)) - size_read
;
1177 if (read(session
->fd
, buf
, padding
) < 0)
1178 die("reading input file");
1179 if (session
->repipe
) {
1180 int retw
= write(STDOUT_FILENO
, buf
, padding
);
1181 if (retw
<= 0 || retw
!= padding
)
1182 die("repiping tracing data padding");
1185 if (size_read
+ padding
!= size
)
1186 die("tracing data size mismatch");
1188 return size_read
+ padding
;
1191 int event__synthesize_build_id(struct dso
*pos
, u16 misc
,
1192 event__handler_t process
,
1193 struct machine
*machine
,
1194 struct perf_session
*session
)
1203 memset(&ev
, 0, sizeof(ev
));
1205 len
= pos
->long_name_len
+ 1;
1206 len
= ALIGN(len
, NAME_ALIGN
);
1207 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
1208 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
1209 ev
.build_id
.header
.misc
= misc
;
1210 ev
.build_id
.pid
= machine
->pid
;
1211 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
1212 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
1214 err
= process(&ev
, NULL
, session
);
1219 int event__process_build_id(event_t
*self
,
1220 struct perf_session
*session
)
1222 __event_process_build_id(&self
->build_id
,
1223 self
->build_id
.filename
,
1228 void disable_buildid_cache(void)
1230 no_buildid_cache
= true;