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 dsos__write_buildid_table(struct perf_header
*header
, int fd
)
226 struct perf_session
*session
= container_of(header
,
227 struct perf_session
, header
);
232 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
233 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
234 if (machine__is_host(pos
)) {
235 kmisc
= PERF_RECORD_MISC_KERNEL
;
236 umisc
= PERF_RECORD_MISC_USER
;
238 kmisc
= PERF_RECORD_MISC_GUEST_KERNEL
;
239 umisc
= PERF_RECORD_MISC_GUEST_USER
;
242 err
= __dsos__write_buildid_table(&pos
->kernel_dsos
, pos
->pid
,
245 err
= __dsos__write_buildid_table(&pos
->user_dsos
,
246 pos
->pid
, umisc
, fd
);
253 int build_id_cache__add_s(const char *sbuild_id
, const char *debugdir
,
254 const char *name
, bool is_kallsyms
)
256 const size_t size
= PATH_MAX
;
257 char *filename
= malloc(size
),
258 *linkname
= malloc(size
), *targetname
;
261 if (filename
== NULL
|| linkname
== NULL
)
264 len
= snprintf(filename
, size
, "%s%s%s",
265 debugdir
, is_kallsyms
? "/" : "", name
);
266 if (mkdir_p(filename
, 0755))
269 snprintf(filename
+ len
, sizeof(filename
) - len
, "/%s", sbuild_id
);
271 if (access(filename
, F_OK
)) {
273 if (copyfile("/proc/kallsyms", filename
))
275 } else if (link(name
, filename
) && copyfile(name
, filename
))
279 len
= snprintf(linkname
, size
, "%s/.build-id/%.2s",
280 debugdir
, sbuild_id
);
282 if (access(linkname
, X_OK
) && mkdir_p(linkname
, 0755))
285 snprintf(linkname
+ len
, size
- len
, "/%s", sbuild_id
+ 2);
286 targetname
= filename
+ strlen(debugdir
) - 5;
287 memcpy(targetname
, "../..", 5);
289 if (symlink(targetname
, linkname
) == 0)
297 static int build_id_cache__add_b(const u8
*build_id
, size_t build_id_size
,
298 const char *name
, const char *debugdir
,
301 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
303 build_id__sprintf(build_id
, build_id_size
, sbuild_id
);
305 return build_id_cache__add_s(sbuild_id
, debugdir
, name
, is_kallsyms
);
308 int build_id_cache__remove_s(const char *sbuild_id
, const char *debugdir
)
310 const size_t size
= PATH_MAX
;
311 char *filename
= malloc(size
),
312 *linkname
= malloc(size
);
315 if (filename
== NULL
|| linkname
== NULL
)
318 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
319 debugdir
, sbuild_id
, sbuild_id
+ 2);
321 if (access(linkname
, F_OK
))
324 if (readlink(linkname
, filename
, size
) < 0)
327 if (unlink(linkname
))
331 * Since the link is relative, we must make it absolute:
333 snprintf(linkname
, size
, "%s/.build-id/%.2s/%s",
334 debugdir
, sbuild_id
, filename
);
336 if (unlink(linkname
))
346 static int dso__cache_build_id(struct dso
*self
, const char *debugdir
)
348 bool is_kallsyms
= self
->kernel
&& self
->long_name
[0] != '/';
350 return build_id_cache__add_b(self
->build_id
, sizeof(self
->build_id
),
351 self
->long_name
, debugdir
, is_kallsyms
);
354 static int __dsos__cache_build_ids(struct list_head
*head
, const char *debugdir
)
359 dsos__for_each_with_build_id(pos
, head
)
360 if (dso__cache_build_id(pos
, debugdir
))
366 static int dsos__cache_build_ids(struct perf_header
*self
)
368 struct perf_session
*session
= container_of(self
,
369 struct perf_session
, header
);
372 char debugdir
[PATH_MAX
];
374 snprintf(debugdir
, sizeof(debugdir
), "%s/%s", getenv("HOME"),
377 if (mkdir(debugdir
, 0755) != 0 && errno
!= EEXIST
)
380 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
381 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
382 ret
|= __dsos__cache_build_ids(&pos
->kernel_dsos
, debugdir
);
383 ret
|= __dsos__cache_build_ids(&pos
->user_dsos
, debugdir
);
388 static bool dsos__read_build_ids(struct perf_header
*self
, bool with_hits
)
391 struct perf_session
*session
= container_of(self
,
392 struct perf_session
, header
);
395 for (nd
= rb_first(&session
->machines
); nd
; nd
= rb_next(nd
)) {
396 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
397 ret
|= __dsos__read_build_ids(&pos
->kernel_dsos
, with_hits
);
398 ret
|= __dsos__read_build_ids(&pos
->user_dsos
, with_hits
);
404 static int perf_header__adds_write(struct perf_header
*self
, int fd
)
407 struct perf_file_section
*feat_sec
;
412 if (dsos__read_build_ids(self
, true))
413 perf_header__set_feat(self
, HEADER_BUILD_ID
);
415 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
419 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
420 if (feat_sec
== NULL
)
423 sec_size
= sizeof(*feat_sec
) * nr_sections
;
425 sec_start
= self
->data_offset
+ self
->data_size
;
426 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
428 if (perf_header__has_feat(self
, HEADER_TRACE_INFO
)) {
429 struct perf_file_section
*trace_sec
;
431 trace_sec
= &feat_sec
[idx
++];
433 /* Write trace info */
434 trace_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
435 read_tracing_data(fd
, attrs
, nr_counters
);
436 trace_sec
->size
= lseek(fd
, 0, SEEK_CUR
) - trace_sec
->offset
;
439 if (perf_header__has_feat(self
, HEADER_BUILD_ID
)) {
440 struct perf_file_section
*buildid_sec
;
442 buildid_sec
= &feat_sec
[idx
++];
444 /* Write build-ids */
445 buildid_sec
->offset
= lseek(fd
, 0, SEEK_CUR
);
446 err
= dsos__write_buildid_table(self
, fd
);
448 pr_debug("failed to write buildid table\n");
451 buildid_sec
->size
= lseek(fd
, 0, SEEK_CUR
) -
453 dsos__cache_build_ids(self
);
456 lseek(fd
, sec_start
, SEEK_SET
);
457 err
= do_write(fd
, feat_sec
, sec_size
);
459 pr_debug("failed to write feature section\n");
465 int perf_header__write_pipe(int fd
)
467 struct perf_pipe_file_header f_header
;
470 f_header
= (struct perf_pipe_file_header
){
472 .size
= sizeof(f_header
),
475 err
= do_write(fd
, &f_header
, sizeof(f_header
));
477 pr_debug("failed to write perf pipe header\n");
484 int perf_header__write(struct perf_header
*self
, int fd
, bool at_exit
)
486 struct perf_file_header f_header
;
487 struct perf_file_attr f_attr
;
488 struct perf_header_attr
*attr
;
491 lseek(fd
, sizeof(f_header
), SEEK_SET
);
494 for (i
= 0; i
< self
->attrs
; i
++) {
495 attr
= self
->attr
[i
];
497 attr
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
498 err
= do_write(fd
, attr
->id
, attr
->ids
* sizeof(u64
));
500 pr_debug("failed to write perf header\n");
506 self
->attr_offset
= lseek(fd
, 0, SEEK_CUR
);
508 for (i
= 0; i
< self
->attrs
; i
++) {
509 attr
= self
->attr
[i
];
511 f_attr
= (struct perf_file_attr
){
514 .offset
= attr
->id_offset
,
515 .size
= attr
->ids
* sizeof(u64
),
518 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
520 pr_debug("failed to write perf header attribute\n");
525 self
->event_offset
= lseek(fd
, 0, SEEK_CUR
);
526 self
->event_size
= event_count
* sizeof(struct perf_trace_event_type
);
528 err
= do_write(fd
, events
, self
->event_size
);
530 pr_debug("failed to write perf header events\n");
535 self
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
538 err
= perf_header__adds_write(self
, fd
);
543 f_header
= (struct perf_file_header
){
545 .size
= sizeof(f_header
),
546 .attr_size
= sizeof(f_attr
),
548 .offset
= self
->attr_offset
,
549 .size
= self
->attrs
* sizeof(f_attr
),
552 .offset
= self
->data_offset
,
553 .size
= self
->data_size
,
556 .offset
= self
->event_offset
,
557 .size
= self
->event_size
,
561 memcpy(&f_header
.adds_features
, &self
->adds_features
, sizeof(self
->adds_features
));
563 lseek(fd
, 0, SEEK_SET
);
564 err
= do_write(fd
, &f_header
, sizeof(f_header
));
566 pr_debug("failed to write perf header\n");
569 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
575 static int perf_header__getbuffer64(struct perf_header
*self
,
576 int fd
, void *buf
, size_t size
)
578 if (do_read(fd
, buf
, size
) <= 0)
581 if (self
->needs_swap
)
582 mem_bswap_64(buf
, size
);
587 int perf_header__process_sections(struct perf_header
*self
, int fd
,
588 int (*process
)(struct perf_file_section
*self
,
589 struct perf_header
*ph
,
592 struct perf_file_section
*feat_sec
;
596 int err
= -1, feat
= 1;
598 nr_sections
= bitmap_weight(self
->adds_features
, HEADER_FEAT_BITS
);
602 feat_sec
= calloc(sizeof(*feat_sec
), nr_sections
);
606 sec_size
= sizeof(*feat_sec
) * nr_sections
;
608 lseek(fd
, self
->data_offset
+ self
->data_size
, SEEK_SET
);
610 if (perf_header__getbuffer64(self
, fd
, feat_sec
, sec_size
))
614 while (idx
< nr_sections
&& feat
< HEADER_LAST_FEATURE
) {
615 if (perf_header__has_feat(self
, feat
)) {
616 struct perf_file_section
*sec
= &feat_sec
[idx
++];
618 err
= process(sec
, self
, feat
, fd
);
629 int perf_file_header__read(struct perf_file_header
*self
,
630 struct perf_header
*ph
, int fd
)
632 lseek(fd
, 0, SEEK_SET
);
634 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
635 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
638 if (self
->attr_size
!= sizeof(struct perf_file_attr
)) {
639 u64 attr_size
= bswap_64(self
->attr_size
);
641 if (attr_size
!= sizeof(struct perf_file_attr
))
644 mem_bswap_64(self
, offsetof(struct perf_file_header
,
646 ph
->needs_swap
= true;
649 if (self
->size
!= sizeof(*self
)) {
650 /* Support the previous format */
651 if (self
->size
== offsetof(typeof(*self
), adds_features
))
652 bitmap_zero(self
->adds_features
, HEADER_FEAT_BITS
);
657 memcpy(&ph
->adds_features
, &self
->adds_features
,
658 sizeof(ph
->adds_features
));
660 * FIXME: hack that assumes that if we need swap the perf.data file
661 * may be coming from an arch with a different word-size, ergo different
662 * DEFINE_BITMAP format, investigate more later, but for now its mostly
663 * safe to assume that we have a build-id section. Trace files probably
664 * have several other issues in this realm anyway...
666 if (ph
->needs_swap
) {
667 memset(&ph
->adds_features
, 0, sizeof(ph
->adds_features
));
668 perf_header__set_feat(ph
, HEADER_BUILD_ID
);
671 ph
->event_offset
= self
->event_types
.offset
;
672 ph
->event_size
= self
->event_types
.size
;
673 ph
->data_offset
= self
->data
.offset
;
674 ph
->data_size
= self
->data
.size
;
678 static int __event_process_build_id(struct build_id_event
*bev
,
680 struct perf_session
*session
)
683 struct list_head
*head
;
684 struct machine
*machine
;
687 enum dso_kernel_type dso_type
;
689 machine
= perf_session__findnew_machine(session
, bev
->pid
);
693 misc
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
696 case PERF_RECORD_MISC_KERNEL
:
697 dso_type
= DSO_TYPE_KERNEL
;
698 head
= &machine
->kernel_dsos
;
700 case PERF_RECORD_MISC_GUEST_KERNEL
:
701 dso_type
= DSO_TYPE_GUEST_KERNEL
;
702 head
= &machine
->kernel_dsos
;
704 case PERF_RECORD_MISC_USER
:
705 case PERF_RECORD_MISC_GUEST_USER
:
706 dso_type
= DSO_TYPE_USER
;
707 head
= &machine
->user_dsos
;
713 dso
= __dsos__findnew(head
, filename
);
715 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
717 dso__set_build_id(dso
, &bev
->build_id
);
719 if (filename
[0] == '[')
720 dso
->kernel
= dso_type
;
722 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
724 pr_debug("build id event received for %s: %s\n",
725 dso
->long_name
, sbuild_id
);
733 static int perf_header__read_build_ids(struct perf_header
*self
,
734 int input
, u64 offset
, u64 size
)
736 struct perf_session
*session
= container_of(self
,
737 struct perf_session
, header
);
738 struct build_id_event bev
;
739 char filename
[PATH_MAX
];
740 u64 limit
= offset
+ size
;
743 while (offset
< limit
) {
746 if (read(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
749 if (self
->needs_swap
)
750 perf_event_header__bswap(&bev
.header
);
752 len
= bev
.header
.size
- sizeof(bev
);
753 if (read(input
, filename
, len
) != len
)
756 __event_process_build_id(&bev
, filename
, session
);
758 offset
+= bev
.header
.size
;
765 static int perf_file_section__process(struct perf_file_section
*self
,
766 struct perf_header
*ph
,
769 if (lseek(fd
, self
->offset
, SEEK_SET
) == (off_t
)-1) {
770 pr_debug("Failed to lseek to %Ld offset for feature %d, "
771 "continuing...\n", self
->offset
, feat
);
776 case HEADER_TRACE_INFO
:
777 trace_report(fd
, false);
780 case HEADER_BUILD_ID
:
781 if (perf_header__read_build_ids(ph
, fd
, self
->offset
, self
->size
))
782 pr_debug("Failed to read buildids, continuing...\n");
785 pr_debug("unknown feature %d, continuing...\n", feat
);
791 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*self
,
792 struct perf_header
*ph
, int fd
,
795 if (do_read(fd
, self
, sizeof(*self
)) <= 0 ||
796 memcmp(&self
->magic
, __perf_magic
, sizeof(self
->magic
)))
799 if (repipe
&& do_write(STDOUT_FILENO
, self
, sizeof(*self
)) < 0)
802 if (self
->size
!= sizeof(*self
)) {
803 u64 size
= bswap_64(self
->size
);
805 if (size
!= sizeof(*self
))
808 ph
->needs_swap
= true;
814 static int perf_header__read_pipe(struct perf_session
*session
, int fd
)
816 struct perf_header
*self
= &session
->header
;
817 struct perf_pipe_file_header f_header
;
819 if (perf_file_header__read_pipe(&f_header
, self
, fd
,
820 session
->repipe
) < 0) {
821 pr_debug("incompatible file format\n");
830 int perf_header__read(struct perf_session
*session
, int fd
)
832 struct perf_header
*self
= &session
->header
;
833 struct perf_file_header f_header
;
834 struct perf_file_attr f_attr
;
836 int nr_attrs
, nr_ids
, i
, j
;
838 if (session
->fd_pipe
)
839 return perf_header__read_pipe(session
, fd
);
841 if (perf_file_header__read(&f_header
, self
, fd
) < 0) {
842 pr_debug("incompatible file format\n");
846 nr_attrs
= f_header
.attrs
.size
/ sizeof(f_attr
);
847 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
849 for (i
= 0; i
< nr_attrs
; i
++) {
850 struct perf_header_attr
*attr
;
853 if (perf_header__getbuffer64(self
, fd
, &f_attr
, sizeof(f_attr
)))
856 tmp
= lseek(fd
, 0, SEEK_CUR
);
858 attr
= perf_header_attr__new(&f_attr
.attr
);
862 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
863 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
865 for (j
= 0; j
< nr_ids
; j
++) {
866 if (perf_header__getbuffer64(self
, fd
, &f_id
, sizeof(f_id
)))
869 if (perf_header_attr__add_id(attr
, f_id
) < 0) {
870 perf_header_attr__delete(attr
);
874 if (perf_header__add_attr(self
, attr
) < 0) {
875 perf_header_attr__delete(attr
);
879 lseek(fd
, tmp
, SEEK_SET
);
882 if (f_header
.event_types
.size
) {
883 lseek(fd
, f_header
.event_types
.offset
, SEEK_SET
);
884 events
= malloc(f_header
.event_types
.size
);
887 if (perf_header__getbuffer64(self
, fd
, events
,
888 f_header
.event_types
.size
))
890 event_count
= f_header
.event_types
.size
/ sizeof(struct perf_trace_event_type
);
893 perf_header__process_sections(self
, fd
, perf_file_section__process
);
895 lseek(fd
, self
->data_offset
, SEEK_SET
);
903 u64
perf_header__sample_type(struct perf_header
*header
)
908 for (i
= 0; i
< header
->attrs
; i
++) {
909 struct perf_header_attr
*attr
= header
->attr
[i
];
912 type
= attr
->attr
.sample_type
;
913 else if (type
!= attr
->attr
.sample_type
)
914 die("non matching sample_type");
920 struct perf_event_attr
*
921 perf_header__find_attr(u64 id
, struct perf_header
*header
)
926 * We set id to -1 if the data file doesn't contain sample
927 * ids. Check for this and avoid walking through the entire
928 * list of ids which may be large.
933 for (i
= 0; i
< header
->attrs
; i
++) {
934 struct perf_header_attr
*attr
= header
->attr
[i
];
937 for (j
= 0; j
< attr
->ids
; j
++) {
938 if (attr
->id
[j
] == id
)
946 int event__synthesize_attr(struct perf_event_attr
*attr
, u16 ids
, u64
*id
,
947 event__handler_t process
,
948 struct perf_session
*session
)
954 size
= sizeof(struct perf_event_attr
);
955 size
= ALIGN(size
, sizeof(u64
));
956 size
+= sizeof(struct perf_event_header
);
957 size
+= ids
* sizeof(u64
);
961 ev
->attr
.attr
= *attr
;
962 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
964 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
965 ev
->attr
.header
.size
= size
;
967 err
= process(ev
, session
);
974 int event__synthesize_attrs(struct perf_header
*self
,
975 event__handler_t process
,
976 struct perf_session
*session
)
978 struct perf_header_attr
*attr
;
981 for (i
= 0; i
< self
->attrs
; i
++) {
982 attr
= self
->attr
[i
];
984 err
= event__synthesize_attr(&attr
->attr
, attr
->ids
, attr
->id
,
987 pr_debug("failed to create perf header attribute\n");
995 int event__process_attr(event_t
*self
, struct perf_session
*session
)
997 struct perf_header_attr
*attr
;
998 unsigned int i
, ids
, n_ids
;
1000 attr
= perf_header_attr__new(&self
->attr
.attr
);
1004 ids
= self
->header
.size
;
1005 ids
-= (void *)&self
->attr
.id
- (void *)self
;
1006 n_ids
= ids
/ sizeof(u64
);
1008 for (i
= 0; i
< n_ids
; i
++) {
1009 if (perf_header_attr__add_id(attr
, self
->attr
.id
[i
]) < 0) {
1010 perf_header_attr__delete(attr
);
1015 if (perf_header__add_attr(&session
->header
, attr
) < 0) {
1016 perf_header_attr__delete(attr
);
1020 perf_session__update_sample_type(session
);
1025 int event__synthesize_event_type(u64 event_id
, char *name
,
1026 event__handler_t process
,
1027 struct perf_session
*session
)
1033 memset(&ev
, 0, sizeof(ev
));
1035 ev
.event_type
.event_type
.event_id
= event_id
;
1036 memset(ev
.event_type
.event_type
.name
, 0, MAX_EVENT_NAME
);
1037 strncpy(ev
.event_type
.event_type
.name
, name
, MAX_EVENT_NAME
- 1);
1039 ev
.event_type
.header
.type
= PERF_RECORD_HEADER_EVENT_TYPE
;
1040 size
= strlen(name
);
1041 size
= ALIGN(size
, sizeof(u64
));
1042 ev
.event_type
.header
.size
= sizeof(ev
.event_type
) -
1043 (sizeof(ev
.event_type
.event_type
.name
) - size
);
1045 err
= process(&ev
, session
);
1050 int event__synthesize_event_types(event__handler_t process
,
1051 struct perf_session
*session
)
1053 struct perf_trace_event_type
*type
;
1056 for (i
= 0; i
< event_count
; i
++) {
1059 err
= event__synthesize_event_type(type
->event_id
, type
->name
,
1062 pr_debug("failed to create perf header event type\n");
1070 int event__process_event_type(event_t
*self
,
1071 struct perf_session
*session __unused
)
1073 if (perf_header__push_event(self
->event_type
.event_type
.event_id
,
1074 self
->event_type
.event_type
.name
) < 0)
1080 int event__synthesize_tracing_data(int fd
, struct perf_event_attr
*pattrs
,
1082 event__handler_t process
,
1083 struct perf_session
*session __unused
)
1086 ssize_t size
= 0, aligned_size
= 0, padding
;
1089 memset(&ev
, 0, sizeof(ev
));
1091 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
1092 size
= read_tracing_data_size(fd
, pattrs
, nb_events
);
1095 aligned_size
= ALIGN(size
, sizeof(u64
));
1096 padding
= aligned_size
- size
;
1097 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
1098 ev
.tracing_data
.size
= aligned_size
;
1100 process(&ev
, session
);
1102 err
= read_tracing_data(fd
, pattrs
, nb_events
);
1103 write_padded(fd
, NULL
, 0, padding
);
1105 return aligned_size
;
1108 int event__process_tracing_data(event_t
*self
,
1109 struct perf_session
*session
)
1111 ssize_t size_read
, padding
, size
= self
->tracing_data
.size
;
1112 off_t offset
= lseek(session
->fd
, 0, SEEK_CUR
);
1115 /* setup for reading amidst mmap */
1116 lseek(session
->fd
, offset
+ sizeof(struct tracing_data_event
),
1119 size_read
= trace_report(session
->fd
, session
->repipe
);
1121 padding
= ALIGN(size_read
, sizeof(u64
)) - size_read
;
1123 if (read(session
->fd
, buf
, padding
) < 0)
1124 die("reading input file");
1125 if (session
->repipe
) {
1126 int retw
= write(STDOUT_FILENO
, buf
, padding
);
1127 if (retw
<= 0 || retw
!= padding
)
1128 die("repiping tracing data padding");
1131 if (size_read
+ padding
!= size
)
1132 die("tracing data size mismatch");
1134 return size_read
+ padding
;
1137 int event__synthesize_build_id(struct dso
*pos
, u16 misc
,
1138 event__handler_t process
,
1139 struct machine
*machine
,
1140 struct perf_session
*session
)
1149 memset(&ev
, 0, sizeof(ev
));
1151 len
= pos
->long_name_len
+ 1;
1152 len
= ALIGN(len
, NAME_ALIGN
);
1153 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
1154 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
1155 ev
.build_id
.header
.misc
= misc
;
1156 ev
.build_id
.pid
= machine
->pid
;
1157 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
1158 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
1160 err
= process(&ev
, session
);
1165 int event__process_build_id(event_t
*self
,
1166 struct perf_session
*session
)
1168 __event_process_build_id(&self
->build_id
,
1169 self
->build_id
.filename
,