1 #define _FILE_OFFSET_BITS 64
8 #include <linux/list.h>
9 #include <linux/kernel.h>
14 #include "trace-event.h"
20 * Create new perf.data header attribute:
22 struct perf_header_attr
*perf_header_attr__new(struct perf_event_attr
*attr
)
24 struct perf_header_attr
*self
= malloc(sizeof(*self
));
30 self
->id
= malloc(sizeof(u64
));
31 if (self
->id
== NULL
) {
40 void perf_header_attr__delete(struct perf_header_attr
*self
)
46 int perf_header_attr__add_id(struct perf_header_attr
*self
, u64 id
)
51 if (self
->ids
> self
->size
) {
52 int nsize
= self
->size
* 2;
53 u64
*nid
= realloc(self
->id
, nsize
* sizeof(u64
));
65 int perf_header__init(struct perf_header
*self
)
68 self
->attr
= malloc(sizeof(void *));
69 return self
->attr
== NULL
? -ENOMEM
: 0;
72 void perf_header__exit(struct perf_header
*self
)
75 for (i
= 0; i
< self
->attrs
; ++i
)
76 perf_header_attr__delete(self
->attr
[i
]);
80 int perf_header__add_attr(struct perf_header
*self
,
81 struct perf_header_attr
*attr
)
86 if (self
->attrs
== self
->size
) {
87 int nsize
= self
->size
* 2;
88 struct perf_header_attr
**nattr
;
90 nattr
= realloc(self
->attr
, nsize
* sizeof(void *));
98 self
->attr
[self
->attrs
++] = attr
;
102 static int event_count
;
103 static struct perf_trace_event_type
*events
;
105 int perf_header__push_event(u64 id
, const char *name
)
107 if (strlen(name
) > MAX_EVENT_NAME
)
108 pr_warning("Event %s will be truncated\n", name
);
111 events
= malloc(sizeof(struct perf_trace_event_type
));
115 struct perf_trace_event_type
*nevents
;
117 nevents
= realloc(events
, (event_count
+ 1) * sizeof(*events
));
122 memset(&events
[event_count
], 0, sizeof(struct perf_trace_event_type
));
123 events
[event_count
].event_id
= id
;
124 strncpy(events
[event_count
].name
, name
, MAX_EVENT_NAME
- 1);
129 char *perf_header__find_event(u64 id
)
132 for (i
= 0 ; i
< event_count
; i
++) {
133 if (events
[i
].event_id
== id
)
134 return events
[i
].name
;
139 static const char *__perf_magic
= "PERFFILE";
141 #define PERF_MAGIC (*(u64 *)__perf_magic)
143 struct perf_file_attr
{
144 struct perf_event_attr attr
;
145 struct perf_file_section ids
;
148 void perf_header__set_feat(struct perf_header
*self
, int feat
)
150 set_bit(feat
, self
->adds_features
);
153 bool perf_header__has_feat(const struct perf_header
*self
, int feat
)
155 return test_bit(feat
, self
->adds_features
);
158 static int do_write(int fd
, const void *buf
, size_t size
)
161 int ret
= write(fd
, buf
, size
);
173 #define NAME_ALIGN 64
175 static int write_padded(int fd
, const void *bf
, size_t count
,
176 size_t count_aligned
)
178 static const char zero_buf
[NAME_ALIGN
];
179 int err
= do_write(fd
, bf
, count
);
182 err
= do_write(fd
, zero_buf
, count_aligned
- count
);
187 #define dsos__for_each_with_build_id(pos, head) \
188 list_for_each_entry(pos, head, node) \
189 if (!pos->has_build_id) \
193 static int __dsos__write_buildid_table(struct list_head
*head
, pid_t pid
,
198 dsos__for_each_with_build_id(pos
, head
) {
200 struct build_id_event b
;
205 len
= pos
->long_name_len
+ 1;
206 len
= ALIGN(len
, NAME_ALIGN
);
207 memset(&b
, 0, sizeof(b
));
208 memcpy(&b
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
210 b
.header
.misc
= misc
;
211 b
.header
.size
= sizeof(b
) + len
;
212 err
= do_write(fd
, &b
, sizeof(b
));
215 err
= write_padded(fd
, pos
->long_name
,
216 pos
->long_name_len
+ 1, len
);
224 static int machine__write_buildid_table(struct machine
*self
, int fd
)
227 u16 kmisc
= PERF_RECORD_MISC_KERNEL
,
228 umisc
= PERF_RECORD_MISC_USER
;
230 if (!machine__is_host(self
)) {
231 kmisc
= PERF_RECORD_MISC_GUEST_KERNEL
;
232 umisc
= PERF_RECORD_MISC_GUEST_USER
;
235 err
= __dsos__write_buildid_table(&self
->kernel_dsos
, self
->pid
,
238 err
= __dsos__write_buildid_table(&self
->user_dsos
,
239 self
->pid
, umisc
, fd
);
243 static int dsos__write_buildid_table(struct perf_header
*header
, int fd
)
245 struct perf_session
*session
= container_of(header
,
246 struct perf_session
, header
);
248 int err
= machine__write_buildid_table(&session
->host_machine
, fd
);
253 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
254 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
255 err
= machine__write_buildid_table(pos
, fd
);
262 int build_id_cache__add_s(const char *sbuild_id
, const char *debugdir
,
263 const char *name
, bool is_kallsyms
)
265 const size_t size
= PATH_MAX
;
266 char *filename
= malloc(size
),
267 *linkname
= malloc(size
), *targetname
;
270 if (filename
== NULL
|| linkname
== NULL
)
273 len
= snprintf(filename
, size
, "%s%s%s",
274 debugdir
, is_kallsyms
? "/" : "", name
);
275 if (mkdir_p(filename
, 0755))
278 snprintf(filename
+ len
, sizeof(filename
) - len
, "/%s", sbuild_id
);
280 if (access(filename
, F_OK
)) {
282 if (copyfile("/proc/kallsyms", filename
))
284 } else if (link(name
, filename
) && copyfile(name
, filename
))
288 len
= snprintf(linkname
, size
, "%s/.build-id/%.2s",
289 debugdir
, sbuild_id
);
291 if (access(linkname
, X_OK
) && mkdir_p(linkname
, 0755))
294 snprintf(linkname
+ len
, size
- len
, "/%s", sbuild_id
+ 2);
295 targetname
= filename
+ strlen(debugdir
) - 5;
296 memcpy(targetname
, "../..", 5);
298 if (symlink(targetname
, linkname
) == 0)
306 static int build_id_cache__add_b(const u8
*build_id
, size_t build_id_size
,
307 const char *name
, const char *debugdir
,
310 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
312 build_id__sprintf(build_id
, build_id_size
, sbuild_id
);
314 return build_id_cache__add_s(sbuild_id
, debugdir
, name
, is_kallsyms
);
317 int build_id_cache__remove_s(const char *sbuild_id
, const char *debugdir
)
319 const size_t size
= PATH_MAX
;
320 char *filename
= malloc(size
),
321 *linkname
= malloc(size
);
324 if (filename
== NULL
|| linkname
== NULL
)
327 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
328 debugdir
, sbuild_id
, sbuild_id
+ 2);
330 if (access(linkname
, F_OK
))
333 if (readlink(linkname
, filename
, size
) < 0)
336 if (unlink(linkname
))
340 * Since the link is relative, we must make it absolute:
342 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
343 debugdir
, sbuild_id
, filename
);
345 if (unlink(linkname
))
355 static int dso__cache_build_id(struct dso
*self
, const char *debugdir
)
357 bool is_kallsyms
= self
->kernel
&& self
->long_name
[0] != '/';
359 return build_id_cache__add_b(self
->build_id
, sizeof(self
->build_id
),
360 self
->long_name
, debugdir
, is_kallsyms
);
363 static int __dsos__cache_build_ids(struct list_head
*head
, const char *debugdir
)
368 dsos__for_each_with_build_id(pos
, head
)
369 if (dso__cache_build_id(pos
, debugdir
))
375 static int machine__cache_build_ids(struct machine
*self
, const char *debugdir
)
377 int ret
= __dsos__cache_build_ids(&self
->kernel_dsos
, debugdir
);
378 ret
|= __dsos__cache_build_ids(&self
->user_dsos
, debugdir
);
382 static int perf_session__cache_build_ids(struct perf_session
*self
)
386 char debugdir
[PATH_MAX
];
388 snprintf(debugdir
, sizeof(debugdir
), "%s/%s", getenv("HOME"),
391 if (mkdir(debugdir
, 0755) != 0 && errno
!= EEXIST
)
394 ret
= machine__cache_build_ids(&self
->host_machine
, debugdir
);
396 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
397 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
398 ret
|= machine__cache_build_ids(pos
, debugdir
);
403 static bool machine__read_build_ids(struct machine
*self
, bool with_hits
)
405 bool ret
= __dsos__read_build_ids(&self
->kernel_dsos
, with_hits
);
406 ret
|= __dsos__read_build_ids(&self
->user_dsos
, with_hits
);
410 static bool perf_session__read_build_ids(struct perf_session
*self
, bool with_hits
)
413 bool ret
= machine__read_build_ids(&self
->host_machine
, with_hits
);
415 for (nd
= rb_first(&self
->machines
); nd
; nd
= rb_next(nd
)) {
416 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
417 ret
|= machine__read_build_ids(pos
, with_hits
);
423 static int perf_header__adds_write(struct perf_header
*self
, int fd
)
426 struct perf_session
*session
;
427 struct perf_file_section
*feat_sec
;
432 session
= container_of(self
, struct perf_session
, header
);
433 if (perf_session__read_build_ids(session
, true))
434 perf_header__set_feat(self
, HEADER_BUILD_ID
);
436 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
440 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
441 if (feat_sec
== NULL
)
444 sec_size
= sizeof(*feat_sec
) * nr_sections
;
446 sec_start
= self
->data_offset
+ self
->data_size
;
447 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
449 if (perf_header__has_feat(self
, HEADER_TRACE_INFO
)) {
450 struct perf_file_section
*trace_sec
;
452 trace_sec
= &feat_sec
[idx
++];
454 /* Write trace info */
455 trace_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
456 read_tracing_data(fd
, attrs
, nr_counters
);
457 trace_sec
->size
= lseek(fd
, 0, SEEK_CUR
) - trace_sec
->offset
;
460 if (perf_header__has_feat(self
, HEADER_BUILD_ID
)) {
461 struct perf_file_section
*buildid_sec
;
463 buildid_sec
= &feat_sec
[idx
++];
465 /* Write build-ids */
466 buildid_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
467 err
= dsos__write_buildid_table(self
, fd
);
469 pr_debug("failed to write buildid table\n");
472 buildid_sec
->size
= lseek(fd
, 0, SEEK_CUR
) -
474 perf_session__cache_build_ids(session
);
477 lseek(fd
, sec_start
, SEEK_SET
);
478 err
= do_write(fd
, feat_sec
, sec_size
);
480 pr_debug("failed to write feature section\n");
486 int perf_header__write_pipe(int fd
)
488 struct perf_pipe_file_header f_header
;
491 f_header
= (struct perf_pipe_file_header
){
493 .size
= sizeof(f_header
),
496 err
= do_write(fd
, &f_header
, sizeof(f_header
));
498 pr_debug("failed to write perf pipe header\n");
505 int perf_header__write(struct perf_header
*self
, int fd
, bool at_exit
)
507 struct perf_file_header f_header
;
508 struct perf_file_attr f_attr
;
509 struct perf_header_attr
*attr
;
512 lseek(fd
, sizeof(f_header
), SEEK_SET
);
514 for (i
= 0; i
< self
->attrs
; i
++) {
515 attr
= self
->attr
[i
];
517 attr
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
518 err
= do_write(fd
, attr
->id
, attr
->ids
* sizeof(u64
));
520 pr_debug("failed to write perf header\n");
526 self
->attr_offset
= lseek(fd
, 0, SEEK_CUR
);
528 for (i
= 0; i
< self
->attrs
; i
++) {
529 attr
= self
->attr
[i
];
531 f_attr
= (struct perf_file_attr
){
534 .offset
= attr
->id_offset
,
535 .size
= attr
->ids
* sizeof(u64
),
538 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
540 pr_debug("failed to write perf header attribute\n");
545 self
->event_offset
= lseek(fd
, 0, SEEK_CUR
);
546 self
->event_size
= event_count
* sizeof(struct perf_trace_event_type
);
548 err
= do_write(fd
, events
, self
->event_size
);
550 pr_debug("failed to write perf header events\n");
555 self
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
558 err
= perf_header__adds_write(self
, fd
);
563 f_header
= (struct perf_file_header
){
565 .size
= sizeof(f_header
),
566 .attr_size
= sizeof(f_attr
),
568 .offset
= self
->attr_offset
,
569 .size
= self
->attrs
* sizeof(f_attr
),
572 .offset
= self
->data_offset
,
573 .size
= self
->data_size
,
576 .offset
= self
->event_offset
,
577 .size
= self
->event_size
,
581 memcpy(&f_header
.adds_features
, &self
->adds_features
, sizeof(self
->adds_features
));
583 lseek(fd
, 0, SEEK_SET
);
584 err
= do_write(fd
, &f_header
, sizeof(f_header
));
586 pr_debug("failed to write perf header\n");
589 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
595 static int perf_header__getbuffer64(struct perf_header
*self
,
596 int fd
, void *buf
, size_t size
)
598 if (do_read(fd
, buf
, size
) <= 0)
601 if (self
->needs_swap
)
602 mem_bswap_64(buf
, size
);
607 int perf_header__process_sections(struct perf_header
*self
, int fd
,
608 int (*process
)(struct perf_file_section
*self
,
609 struct perf_header
*ph
,
612 struct perf_file_section
*feat_sec
;
616 int err
= -1, feat
= 1;
618 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
622 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
626 sec_size
= sizeof(*feat_sec
) * nr_sections
;
628 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
630 if (perf_header__getbuffer64(self
, fd
, feat_sec
, sec_size
))
634 while (idx
< nr_sections
&& feat
< HEADER_LAST_FEATURE
) {
635 if (perf_header__has_feat(self
, feat
)) {
636 struct perf_file_section
*sec
= &feat_sec
[idx
++];
638 err
= process(sec
, self
, feat
, fd
);
649 int perf_file_header__read(struct perf_file_header
*self
,
650 struct perf_header
*ph
, int fd
)
652 lseek(fd
, 0, SEEK_SET
);
654 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
655 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
658 if (self
->attr_size
!= sizeof(struct perf_file_attr
)) {
659 u64 attr_size
= bswap_64(self
->attr_size
);
661 if (attr_size
!= sizeof(struct perf_file_attr
))
664 mem_bswap_64(self
, offsetof(struct perf_file_header
,
666 ph
->needs_swap
= true;
669 if (self
->size
!= sizeof(*self
)) {
670 /* Support the previous format */
671 if (self
->size
== offsetof(typeof(*self
), adds_features
))
672 bitmap_zero(self
->adds_features
, HEADER_FEAT_BITS
);
677 memcpy(&ph
->adds_features
, &self
->adds_features
,
678 sizeof(ph
->adds_features
));
680 * FIXME: hack that assumes that if we need swap the perf.data file
681 * may be coming from an arch with a different word-size, ergo different
682 * DEFINE_BITMAP format, investigate more later, but for now its mostly
683 * safe to assume that we have a build-id section. Trace files probably
684 * have several other issues in this realm anyway...
686 if (ph
->needs_swap
) {
687 memset(&ph
->adds_features
, 0, sizeof(ph
->adds_features
));
688 perf_header__set_feat(ph
, HEADER_BUILD_ID
);
691 ph
->event_offset
= self
->event_types
.offset
;
692 ph
->event_size
= self
->event_types
.size
;
693 ph
->data_offset
= self
->data
.offset
;
694 ph
->data_size
= self
->data
.size
;
698 static int __event_process_build_id(struct build_id_event
*bev
,
700 struct perf_session
*session
)
703 struct list_head
*head
;
704 struct machine
*machine
;
707 enum dso_kernel_type dso_type
;
709 machine
= perf_session__findnew_machine(session
, bev
->pid
);
713 misc
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
716 case PERF_RECORD_MISC_KERNEL
:
717 dso_type
= DSO_TYPE_KERNEL
;
718 head
= &machine
->kernel_dsos
;
720 case PERF_RECORD_MISC_GUEST_KERNEL
:
721 dso_type
= DSO_TYPE_GUEST_KERNEL
;
722 head
= &machine
->kernel_dsos
;
724 case PERF_RECORD_MISC_USER
:
725 case PERF_RECORD_MISC_GUEST_USER
:
726 dso_type
= DSO_TYPE_USER
;
727 head
= &machine
->user_dsos
;
733 dso
= __dsos__findnew(head
, filename
);
735 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
737 dso__set_build_id(dso
, &bev
->build_id
);
739 if (filename
[0] == '[')
740 dso
->kernel
= dso_type
;
742 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
744 pr_debug("build id event received for %s: %s\n",
745 dso
->long_name
, sbuild_id
);
753 static int perf_header__read_build_ids(struct perf_header
*self
,
754 int input
, u64 offset
, u64 size
)
756 struct perf_session
*session
= container_of(self
,
757 struct perf_session
, header
);
758 struct build_id_event bev
;
759 char filename
[PATH_MAX
];
760 u64 limit
= offset
+ size
;
763 while (offset
< limit
) {
766 if (read(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
769 if (self
->needs_swap
)
770 perf_event_header__bswap(&bev
.header
);
772 len
= bev
.header
.size
- sizeof(bev
);
773 if (read(input
, filename
, len
) != len
)
776 __event_process_build_id(&bev
, filename
, session
);
778 offset
+= bev
.header
.size
;
785 static int perf_file_section__process(struct perf_file_section
*self
,
786 struct perf_header
*ph
,
789 if (lseek(fd
, self
->offset
, SEEK_SET
) == (off_t
)-1) {
790 pr_debug("Failed to lseek to %Ld offset for feature %d, "
791 "continuing...\n", self
->offset
, feat
);
796 case HEADER_TRACE_INFO
:
797 trace_report(fd
, false);
800 case HEADER_BUILD_ID
:
801 if (perf_header__read_build_ids(ph
, fd
, self
->offset
, self
->size
))
802 pr_debug("Failed to read buildids, continuing...\n");
805 pr_debug("unknown feature %d, continuing...\n", feat
);
811 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*self
,
812 struct perf_header
*ph
, int fd
,
815 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
816 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
819 if (repipe
&& do_write(STDOUT_FILENO
, self
, sizeof(*self
)) < 0)
822 if (self
->size
!= sizeof(*self
)) {
823 u64 size
= bswap_64(self
->size
);
825 if (size
!= sizeof(*self
))
828 ph
->needs_swap
= true;
834 static int perf_header__read_pipe(struct perf_session
*session
, int fd
)
836 struct perf_header
*self
= &session
->header
;
837 struct perf_pipe_file_header f_header
;
839 if (perf_file_header__read_pipe(&f_header
, self
, fd
,
840 session
->repipe
) < 0) {
841 pr_debug("incompatible file format\n");
850 int perf_header__read(struct perf_session
*session
, int fd
)
852 struct perf_header
*self
= &session
->header
;
853 struct perf_file_header f_header
;
854 struct perf_file_attr f_attr
;
856 int nr_attrs
, nr_ids
, i
, j
;
858 if (session
->fd_pipe
)
859 return perf_header__read_pipe(session
, fd
);
861 if (perf_file_header__read(&f_header
, self
, fd
) < 0) {
862 pr_debug("incompatible file format\n");
866 nr_attrs
= f_header
.attrs
.size
/ sizeof(f_attr
);
867 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
869 for (i
= 0; i
< nr_attrs
; i
++) {
870 struct perf_header_attr
*attr
;
873 if (perf_header__getbuffer64(self
, fd
, &f_attr
, sizeof(f_attr
)))
876 tmp
= lseek(fd
, 0, SEEK_CUR
);
878 attr
= perf_header_attr__new(&f_attr
.attr
);
882 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
883 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
885 for (j
= 0; j
< nr_ids
; j
++) {
886 if (perf_header__getbuffer64(self
, fd
, &f_id
, sizeof(f_id
)))
889 if (perf_header_attr__add_id(attr
, f_id
) < 0) {
890 perf_header_attr__delete(attr
);
894 if (perf_header__add_attr(self
, attr
) < 0) {
895 perf_header_attr__delete(attr
);
899 lseek(fd
, tmp
, SEEK_SET
);
902 if (f_header
.event_types
.size
) {
903 lseek(fd
, f_header
.event_types
.offset
, SEEK_SET
);
904 events
= malloc(f_header
.event_types
.size
);
907 if (perf_header__getbuffer64(self
, fd
, events
,
908 f_header
.event_types
.size
))
910 event_count
= f_header
.event_types
.size
/ sizeof(struct perf_trace_event_type
);
913 perf_header__process_sections(self
, fd
, perf_file_section__process
);
915 lseek(fd
, self
->data_offset
, SEEK_SET
);
923 u64
perf_header__sample_type(struct perf_header
*header
)
928 for (i
= 0; i
< header
->attrs
; i
++) {
929 struct perf_header_attr
*attr
= header
->attr
[i
];
932 type
= attr
->attr
.sample_type
;
933 else if (type
!= attr
->attr
.sample_type
)
934 die("non matching sample_type");
940 struct perf_event_attr
*
941 perf_header__find_attr(u64 id
, struct perf_header
*header
)
946 * We set id to -1 if the data file doesn't contain sample
947 * ids. Check for this and avoid walking through the entire
948 * list of ids which may be large.
953 for (i
= 0; i
< header
->attrs
; i
++) {
954 struct perf_header_attr
*attr
= header
->attr
[i
];
957 for (j
= 0; j
< attr
->ids
; j
++) {
958 if (attr
->id
[j
] == id
)
966 int event__synthesize_attr(struct perf_event_attr
*attr
, u16 ids
, u64
*id
,
967 event__handler_t process
,
968 struct perf_session
*session
)
974 size
= sizeof(struct perf_event_attr
);
975 size
= ALIGN(size
, sizeof(u64
));
976 size
+= sizeof(struct perf_event_header
);
977 size
+= ids
* sizeof(u64
);
981 ev
->attr
.attr
= *attr
;
982 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
984 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
985 ev
->attr
.header
.size
= size
;
987 err
= process(ev
, session
);
994 int event__synthesize_attrs(struct perf_header
*self
,
995 event__handler_t process
,
996 struct perf_session
*session
)
998 struct perf_header_attr
*attr
;
1001 for (i
= 0; i
< self
->attrs
; i
++) {
1002 attr
= self
->attr
[i
];
1004 err
= event__synthesize_attr(&attr
->attr
, attr
->ids
, attr
->id
,
1007 pr_debug("failed to create perf header attribute\n");
1015 int event__process_attr(event_t
*self
, struct perf_session
*session
)
1017 struct perf_header_attr
*attr
;
1018 unsigned int i
, ids
, n_ids
;
1020 attr
= perf_header_attr__new(&self
->attr
.attr
);
1024 ids
= self
->header
.size
;
1025 ids
-= (void *)&self
->attr
.id
- (void *)self
;
1026 n_ids
= ids
/ sizeof(u64
);
1028 for (i
= 0; i
< n_ids
; i
++) {
1029 if (perf_header_attr__add_id(attr
, self
->attr
.id
[i
]) < 0) {
1030 perf_header_attr__delete(attr
);
1035 if (perf_header__add_attr(&session
->header
, attr
) < 0) {
1036 perf_header_attr__delete(attr
);
1040 perf_session__update_sample_type(session
);
1045 int event__synthesize_event_type(u64 event_id
, char *name
,
1046 event__handler_t process
,
1047 struct perf_session
*session
)
1053 memset(&ev
, 0, sizeof(ev
));
1055 ev
.event_type
.event_type
.event_id
= event_id
;
1056 memset(ev
.event_type
.event_type
.name
, 0, MAX_EVENT_NAME
);
1057 strncpy(ev
.event_type
.event_type
.name
, name
, MAX_EVENT_NAME
- 1);
1059 ev
.event_type
.header
.type
= PERF_RECORD_HEADER_EVENT_TYPE
;
1060 size
= strlen(name
);
1061 size
= ALIGN(size
, sizeof(u64
));
1062 ev
.event_type
.header
.size
= sizeof(ev
.event_type
) -
1063 (sizeof(ev
.event_type
.event_type
.name
) - size
);
1065 err
= process(&ev
, session
);
1070 int event__synthesize_event_types(event__handler_t process
,
1071 struct perf_session
*session
)
1073 struct perf_trace_event_type
*type
;
1076 for (i
= 0; i
< event_count
; i
++) {
1079 err
= event__synthesize_event_type(type
->event_id
, type
->name
,
1082 pr_debug("failed to create perf header event type\n");
1090 int event__process_event_type(event_t
*self
,
1091 struct perf_session
*session __unused
)
1093 if (perf_header__push_event(self
->event_type
.event_type
.event_id
,
1094 self
->event_type
.event_type
.name
) < 0)
1100 int event__synthesize_tracing_data(int fd
, struct perf_event_attr
*pattrs
,
1102 event__handler_t process
,
1103 struct perf_session
*session __unused
)
1106 ssize_t size
= 0, aligned_size
= 0, padding
;
1109 memset(&ev
, 0, sizeof(ev
));
1111 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
1112 size
= read_tracing_data_size(fd
, pattrs
, nb_events
);
1115 aligned_size
= ALIGN(size
, sizeof(u64
));
1116 padding
= aligned_size
- size
;
1117 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
1118 ev
.tracing_data
.size
= aligned_size
;
1120 process(&ev
, session
);
1122 err
= read_tracing_data(fd
, pattrs
, nb_events
);
1123 write_padded(fd
, NULL
, 0, padding
);
1125 return aligned_size
;
1128 int event__process_tracing_data(event_t
*self
,
1129 struct perf_session
*session
)
1131 ssize_t size_read
, padding
, size
= self
->tracing_data
.size
;
1132 off_t offset
= lseek(session
->fd
, 0, SEEK_CUR
);
1135 /* setup for reading amidst mmap */
1136 lseek(session
->fd
, offset
+ sizeof(struct tracing_data_event
),
1139 size_read
= trace_report(session
->fd
, session
->repipe
);
1141 padding
= ALIGN(size_read
, sizeof(u64
)) - size_read
;
1143 if (read(session
->fd
, buf
, padding
) < 0)
1144 die("reading input file");
1145 if (session
->repipe
) {
1146 int retw
= write(STDOUT_FILENO
, buf
, padding
);
1147 if (retw
<= 0 || retw
!= padding
)
1148 die("repiping tracing data padding");
1151 if (size_read
+ padding
!= size
)
1152 die("tracing data size mismatch");
1154 return size_read
+ padding
;
1157 int event__synthesize_build_id(struct dso
*pos
, u16 misc
,
1158 event__handler_t process
,
1159 struct machine
*machine
,
1160 struct perf_session
*session
)
1169 memset(&ev
, 0, sizeof(ev
));
1171 len
= pos
->long_name_len
+ 1;
1172 len
= ALIGN(len
, NAME_ALIGN
);
1173 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
1174 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
1175 ev
.build_id
.header
.misc
= misc
;
1176 ev
.build_id
.pid
= machine
->pid
;
1177 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
1178 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
1180 err
= process(&ev
, session
);
1185 int event__process_build_id(event_t
*self
,
1186 struct perf_session
*session
)
1188 __event_process_build_id(&self
->build_id
,
1189 self
->build_id
.filename
,