7 #include <linux/list.h>
8 #include <linux/kernel.h>
9 #include <linux/bitops.h>
10 #include <sys/utsname.h>
16 #include "trace-event.h"
26 #include <api/fs/fs.h>
31 * must be a numerical value to let the endianness
32 * determine the memory layout. That way we are able
33 * to detect endianness when reading the perf.data file
36 * we check for legacy (PERFFILE) format.
38 static const char *__perf_magic1
= "PERFFILE";
39 static const u64 __perf_magic2
= 0x32454c4946524550ULL
;
40 static const u64 __perf_magic2_sw
= 0x50455246494c4532ULL
;
42 #define PERF_MAGIC __perf_magic2
44 struct perf_file_attr
{
45 struct perf_event_attr attr
;
46 struct perf_file_section ids
;
49 void perf_header__set_feat(struct perf_header
*header
, int feat
)
51 set_bit(feat
, header
->adds_features
);
54 void perf_header__clear_feat(struct perf_header
*header
, int feat
)
56 clear_bit(feat
, header
->adds_features
);
59 bool perf_header__has_feat(const struct perf_header
*header
, int feat
)
61 return test_bit(feat
, header
->adds_features
);
64 static int do_write(int fd
, const void *buf
, size_t size
)
67 int ret
= write(fd
, buf
, size
);
79 int write_padded(int fd
, const void *bf
, size_t count
, size_t count_aligned
)
81 static const char zero_buf
[NAME_ALIGN
];
82 int err
= do_write(fd
, bf
, count
);
85 err
= do_write(fd
, zero_buf
, count_aligned
- count
);
90 #define string_size(str) \
91 (PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))
93 static int do_write_string(int fd
, const char *str
)
98 olen
= strlen(str
) + 1;
99 len
= PERF_ALIGN(olen
, NAME_ALIGN
);
101 /* write len, incl. \0 */
102 ret
= do_write(fd
, &len
, sizeof(len
));
106 return write_padded(fd
, str
, olen
, len
);
109 static char *do_read_string(int fd
, struct perf_header
*ph
)
115 sz
= readn(fd
, &len
, sizeof(len
));
116 if (sz
< (ssize_t
)sizeof(len
))
126 ret
= readn(fd
, buf
, len
);
127 if (ret
== (ssize_t
)len
) {
129 * strings are padded by zeroes
130 * thus the actual strlen of buf
131 * may be less than len
140 static int write_tracing_data(int fd
, struct perf_header
*h __maybe_unused
,
141 struct perf_evlist
*evlist
)
143 return read_tracing_data(fd
, &evlist
->entries
);
147 static int write_build_id(int fd
, struct perf_header
*h
,
148 struct perf_evlist
*evlist __maybe_unused
)
150 struct perf_session
*session
;
153 session
= container_of(h
, struct perf_session
, header
);
155 if (!perf_session__read_build_ids(session
, true))
158 err
= perf_session__write_buildid_table(session
, fd
);
160 pr_debug("failed to write buildid table\n");
163 perf_session__cache_build_ids(session
);
168 static int write_hostname(int fd
, struct perf_header
*h __maybe_unused
,
169 struct perf_evlist
*evlist __maybe_unused
)
178 return do_write_string(fd
, uts
.nodename
);
181 static int write_osrelease(int fd
, struct perf_header
*h __maybe_unused
,
182 struct perf_evlist
*evlist __maybe_unused
)
191 return do_write_string(fd
, uts
.release
);
194 static int write_arch(int fd
, struct perf_header
*h __maybe_unused
,
195 struct perf_evlist
*evlist __maybe_unused
)
204 return do_write_string(fd
, uts
.machine
);
207 static int write_version(int fd
, struct perf_header
*h __maybe_unused
,
208 struct perf_evlist
*evlist __maybe_unused
)
210 return do_write_string(fd
, perf_version_string
);
213 static int __write_cpudesc(int fd
, const char *cpuinfo_proc
)
218 const char *search
= cpuinfo_proc
;
225 file
= fopen("/proc/cpuinfo", "r");
229 while (getline(&buf
, &len
, file
) > 0) {
230 ret
= strncmp(buf
, search
, strlen(search
));
242 p
= strchr(buf
, ':');
243 if (p
&& *(p
+1) == ' ' && *(p
+2))
249 /* squash extra space characters (branding string) */
256 while (*q
&& isspace(*q
))
259 while ((*r
++ = *q
++));
263 ret
= do_write_string(fd
, s
);
270 static int write_cpudesc(int fd
, struct perf_header
*h __maybe_unused
,
271 struct perf_evlist
*evlist __maybe_unused
)
274 #define CPUINFO_PROC {"model name", }
276 const char *cpuinfo_procs
[] = CPUINFO_PROC
;
279 for (i
= 0; i
< ARRAY_SIZE(cpuinfo_procs
); i
++) {
281 ret
= __write_cpudesc(fd
, cpuinfo_procs
[i
]);
289 static int write_nrcpus(int fd
, struct perf_header
*h __maybe_unused
,
290 struct perf_evlist
*evlist __maybe_unused
)
296 nr
= sysconf(_SC_NPROCESSORS_CONF
);
300 nrc
= (u32
)(nr
& UINT_MAX
);
302 nr
= sysconf(_SC_NPROCESSORS_ONLN
);
306 nra
= (u32
)(nr
& UINT_MAX
);
308 ret
= do_write(fd
, &nrc
, sizeof(nrc
));
312 return do_write(fd
, &nra
, sizeof(nra
));
315 static int write_event_desc(int fd
, struct perf_header
*h __maybe_unused
,
316 struct perf_evlist
*evlist
)
318 struct perf_evsel
*evsel
;
322 nre
= evlist
->nr_entries
;
325 * write number of events
327 ret
= do_write(fd
, &nre
, sizeof(nre
));
332 * size of perf_event_attr struct
334 sz
= (u32
)sizeof(evsel
->attr
);
335 ret
= do_write(fd
, &sz
, sizeof(sz
));
339 evlist__for_each(evlist
, evsel
) {
340 ret
= do_write(fd
, &evsel
->attr
, sz
);
344 * write number of unique id per event
345 * there is one id per instance of an event
347 * copy into an nri to be independent of the
351 ret
= do_write(fd
, &nri
, sizeof(nri
));
356 * write event string as passed on cmdline
358 ret
= do_write_string(fd
, perf_evsel__name(evsel
));
362 * write unique ids for this event
364 ret
= do_write(fd
, evsel
->id
, evsel
->ids
* sizeof(u64
));
371 static int write_cmdline(int fd
, struct perf_header
*h __maybe_unused
,
372 struct perf_evlist
*evlist __maybe_unused
)
374 char buf
[MAXPATHLEN
];
380 * actual atual path to perf binary
382 sprintf(proc
, "/proc/%d/exe", getpid());
383 ret
= readlink(proc
, buf
, sizeof(buf
));
387 /* readlink() does not add null termination */
390 /* account for binary path */
391 n
= perf_env
.nr_cmdline
+ 1;
393 ret
= do_write(fd
, &n
, sizeof(n
));
397 ret
= do_write_string(fd
, buf
);
401 for (i
= 0 ; i
< perf_env
.nr_cmdline
; i
++) {
402 ret
= do_write_string(fd
, perf_env
.cmdline_argv
[i
]);
409 #define CORE_SIB_FMT \
410 "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
411 #define THRD_SIB_FMT \
412 "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
418 char **core_siblings
;
419 char **thread_siblings
;
422 static int build_cpu_topo(struct cpu_topo
*tp
, int cpu
)
425 char filename
[MAXPATHLEN
];
426 char *buf
= NULL
, *p
;
432 sprintf(filename
, CORE_SIB_FMT
, cpu
);
433 fp
= fopen(filename
, "r");
437 sret
= getline(&buf
, &len
, fp
);
442 p
= strchr(buf
, '\n');
446 for (i
= 0; i
< tp
->core_sib
; i
++) {
447 if (!strcmp(buf
, tp
->core_siblings
[i
]))
450 if (i
== tp
->core_sib
) {
451 tp
->core_siblings
[i
] = buf
;
459 sprintf(filename
, THRD_SIB_FMT
, cpu
);
460 fp
= fopen(filename
, "r");
464 if (getline(&buf
, &len
, fp
) <= 0)
467 p
= strchr(buf
, '\n');
471 for (i
= 0; i
< tp
->thread_sib
; i
++) {
472 if (!strcmp(buf
, tp
->thread_siblings
[i
]))
475 if (i
== tp
->thread_sib
) {
476 tp
->thread_siblings
[i
] = buf
;
488 static void free_cpu_topo(struct cpu_topo
*tp
)
495 for (i
= 0 ; i
< tp
->core_sib
; i
++)
496 zfree(&tp
->core_siblings
[i
]);
498 for (i
= 0 ; i
< tp
->thread_sib
; i
++)
499 zfree(&tp
->thread_siblings
[i
]);
504 static struct cpu_topo
*build_cpu_topology(void)
513 ncpus
= sysconf(_SC_NPROCESSORS_CONF
);
517 nr
= (u32
)(ncpus
& UINT_MAX
);
519 sz
= nr
* sizeof(char *);
521 addr
= calloc(1, sizeof(*tp
) + 2 * sz
);
528 tp
->core_siblings
= addr
;
530 tp
->thread_siblings
= addr
;
532 for (i
= 0; i
< nr
; i
++) {
533 ret
= build_cpu_topo(tp
, i
);
544 static int write_cpu_topology(int fd
, struct perf_header
*h __maybe_unused
,
545 struct perf_evlist
*evlist __maybe_unused
)
551 tp
= build_cpu_topology();
555 ret
= do_write(fd
, &tp
->core_sib
, sizeof(tp
->core_sib
));
559 for (i
= 0; i
< tp
->core_sib
; i
++) {
560 ret
= do_write_string(fd
, tp
->core_siblings
[i
]);
564 ret
= do_write(fd
, &tp
->thread_sib
, sizeof(tp
->thread_sib
));
568 for (i
= 0; i
< tp
->thread_sib
; i
++) {
569 ret
= do_write_string(fd
, tp
->thread_siblings
[i
]);
574 ret
= perf_env__read_cpu_topology_map(&perf_env
);
578 for (j
= 0; j
< perf_env
.nr_cpus_avail
; j
++) {
579 ret
= do_write(fd
, &perf_env
.cpu
[j
].core_id
,
580 sizeof(perf_env
.cpu
[j
].core_id
));
583 ret
= do_write(fd
, &perf_env
.cpu
[j
].socket_id
,
584 sizeof(perf_env
.cpu
[j
].socket_id
));
595 static int write_total_mem(int fd
, struct perf_header
*h __maybe_unused
,
596 struct perf_evlist
*evlist __maybe_unused
)
604 fp
= fopen("/proc/meminfo", "r");
608 while (getline(&buf
, &len
, fp
) > 0) {
609 ret
= strncmp(buf
, "MemTotal:", 9);
614 n
= sscanf(buf
, "%*s %"PRIu64
, &mem
);
616 ret
= do_write(fd
, &mem
, sizeof(mem
));
624 static int write_topo_node(int fd
, int node
)
626 char str
[MAXPATHLEN
];
628 char *buf
= NULL
, *p
;
631 u64 mem_total
, mem_free
, mem
;
634 sprintf(str
, "/sys/devices/system/node/node%d/meminfo", node
);
635 fp
= fopen(str
, "r");
639 while (getline(&buf
, &len
, fp
) > 0) {
640 /* skip over invalid lines */
641 if (!strchr(buf
, ':'))
643 if (sscanf(buf
, "%*s %*d %31s %"PRIu64
, field
, &mem
) != 2)
645 if (!strcmp(field
, "MemTotal:"))
647 if (!strcmp(field
, "MemFree:"))
654 ret
= do_write(fd
, &mem_total
, sizeof(u64
));
658 ret
= do_write(fd
, &mem_free
, sizeof(u64
));
663 sprintf(str
, "/sys/devices/system/node/node%d/cpulist", node
);
665 fp
= fopen(str
, "r");
669 if (getline(&buf
, &len
, fp
) <= 0)
672 p
= strchr(buf
, '\n');
676 ret
= do_write_string(fd
, buf
);
684 static int write_numa_topology(int fd
, struct perf_header
*h __maybe_unused
,
685 struct perf_evlist
*evlist __maybe_unused
)
690 struct cpu_map
*node_map
= NULL
;
695 fp
= fopen("/sys/devices/system/node/online", "r");
699 if (getline(&buf
, &len
, fp
) <= 0)
702 c
= strchr(buf
, '\n');
706 node_map
= cpu_map__new(buf
);
710 nr
= (u32
)node_map
->nr
;
712 ret
= do_write(fd
, &nr
, sizeof(nr
));
716 for (i
= 0; i
< nr
; i
++) {
717 j
= (u32
)node_map
->map
[i
];
718 ret
= do_write(fd
, &j
, sizeof(j
));
722 ret
= write_topo_node(fd
, i
);
729 cpu_map__put(node_map
);
736 * struct pmu_mappings {
745 static int write_pmu_mappings(int fd
, struct perf_header
*h __maybe_unused
,
746 struct perf_evlist
*evlist __maybe_unused
)
748 struct perf_pmu
*pmu
= NULL
;
749 off_t offset
= lseek(fd
, 0, SEEK_CUR
);
753 /* write real pmu_num later */
754 ret
= do_write(fd
, &pmu_num
, sizeof(pmu_num
));
758 while ((pmu
= perf_pmu__scan(pmu
))) {
763 ret
= do_write(fd
, &pmu
->type
, sizeof(pmu
->type
));
767 ret
= do_write_string(fd
, pmu
->name
);
772 if (pwrite(fd
, &pmu_num
, sizeof(pmu_num
), offset
) != sizeof(pmu_num
)) {
774 lseek(fd
, offset
, SEEK_SET
);
784 * struct group_descs {
786 * struct group_desc {
793 static int write_group_desc(int fd
, struct perf_header
*h __maybe_unused
,
794 struct perf_evlist
*evlist
)
796 u32 nr_groups
= evlist
->nr_groups
;
797 struct perf_evsel
*evsel
;
800 ret
= do_write(fd
, &nr_groups
, sizeof(nr_groups
));
804 evlist__for_each(evlist
, evsel
) {
805 if (perf_evsel__is_group_leader(evsel
) &&
806 evsel
->nr_members
> 1) {
807 const char *name
= evsel
->group_name
?: "{anon_group}";
808 u32 leader_idx
= evsel
->idx
;
809 u32 nr_members
= evsel
->nr_members
;
811 ret
= do_write_string(fd
, name
);
815 ret
= do_write(fd
, &leader_idx
, sizeof(leader_idx
));
819 ret
= do_write(fd
, &nr_members
, sizeof(nr_members
));
828 * default get_cpuid(): nothing gets recorded
829 * actual implementation must be in arch/$(ARCH)/util/header.c
831 int __attribute__ ((weak
)) get_cpuid(char *buffer __maybe_unused
,
832 size_t sz __maybe_unused
)
837 static int write_cpuid(int fd
, struct perf_header
*h __maybe_unused
,
838 struct perf_evlist
*evlist __maybe_unused
)
843 ret
= get_cpuid(buffer
, sizeof(buffer
));
849 return do_write_string(fd
, buffer
);
852 static int write_branch_stack(int fd __maybe_unused
,
853 struct perf_header
*h __maybe_unused
,
854 struct perf_evlist
*evlist __maybe_unused
)
859 static int write_auxtrace(int fd
, struct perf_header
*h
,
860 struct perf_evlist
*evlist __maybe_unused
)
862 struct perf_session
*session
;
865 session
= container_of(h
, struct perf_session
, header
);
867 err
= auxtrace_index__write(fd
, &session
->auxtrace_index
);
869 pr_err("Failed to write auxtrace index\n");
873 static int cpu_cache_level__sort(const void *a
, const void *b
)
875 struct cpu_cache_level
*cache_a
= (struct cpu_cache_level
*)a
;
876 struct cpu_cache_level
*cache_b
= (struct cpu_cache_level
*)b
;
878 return cache_a
->level
- cache_b
->level
;
881 static bool cpu_cache_level__cmp(struct cpu_cache_level
*a
, struct cpu_cache_level
*b
)
883 if (a
->level
!= b
->level
)
886 if (a
->line_size
!= b
->line_size
)
889 if (a
->sets
!= b
->sets
)
892 if (a
->ways
!= b
->ways
)
895 if (strcmp(a
->type
, b
->type
))
898 if (strcmp(a
->size
, b
->size
))
901 if (strcmp(a
->map
, b
->map
))
907 static int cpu_cache_level__read(struct cpu_cache_level
*cache
, u32 cpu
, u16 level
)
909 char path
[PATH_MAX
], file
[PATH_MAX
];
913 scnprintf(path
, PATH_MAX
, "devices/system/cpu/cpu%d/cache/index%d/", cpu
, level
);
914 scnprintf(file
, PATH_MAX
, "%s/%s", sysfs__mountpoint(), path
);
919 scnprintf(file
, PATH_MAX
, "%s/level", path
);
920 if (sysfs__read_int(file
, (int *) &cache
->level
))
923 scnprintf(file
, PATH_MAX
, "%s/coherency_line_size", path
);
924 if (sysfs__read_int(file
, (int *) &cache
->line_size
))
927 scnprintf(file
, PATH_MAX
, "%s/number_of_sets", path
);
928 if (sysfs__read_int(file
, (int *) &cache
->sets
))
931 scnprintf(file
, PATH_MAX
, "%s/ways_of_associativity", path
);
932 if (sysfs__read_int(file
, (int *) &cache
->ways
))
935 scnprintf(file
, PATH_MAX
, "%s/type", path
);
936 if (sysfs__read_str(file
, &cache
->type
, &len
))
939 cache
->type
[len
] = 0;
940 cache
->type
= rtrim(cache
->type
);
942 scnprintf(file
, PATH_MAX
, "%s/size", path
);
943 if (sysfs__read_str(file
, &cache
->size
, &len
)) {
948 cache
->size
[len
] = 0;
949 cache
->size
= rtrim(cache
->size
);
951 scnprintf(file
, PATH_MAX
, "%s/shared_cpu_list", path
);
952 if (sysfs__read_str(file
, &cache
->map
, &len
)) {
959 cache
->map
= rtrim(cache
->map
);
963 static void cpu_cache_level__fprintf(FILE *out
, struct cpu_cache_level
*c
)
965 fprintf(out
, "L%d %-15s %8s [%s]\n", c
->level
, c
->type
, c
->size
, c
->map
);
968 static int build_caches(struct cpu_cache_level caches
[], u32 size
, u32
*cntp
)
975 ncpus
= sysconf(_SC_NPROCESSORS_CONF
);
979 nr
= (u32
)(ncpus
& UINT_MAX
);
981 for (cpu
= 0; cpu
< nr
; cpu
++) {
982 for (level
= 0; level
< 10; level
++) {
983 struct cpu_cache_level c
;
986 err
= cpu_cache_level__read(&c
, cpu
, level
);
993 for (i
= 0; i
< cnt
; i
++) {
994 if (cpu_cache_level__cmp(&c
, &caches
[i
]))
1001 cpu_cache_level__free(&c
);
1003 if (WARN_ONCE(cnt
== size
, "way too many cpu caches.."))
1012 #define MAX_CACHES 2000
1014 static int write_cache(int fd
, struct perf_header
*h __maybe_unused
,
1015 struct perf_evlist
*evlist __maybe_unused
)
1017 struct cpu_cache_level caches
[MAX_CACHES
];
1018 u32 cnt
= 0, i
, version
= 1;
1021 ret
= build_caches(caches
, MAX_CACHES
, &cnt
);
1025 qsort(&caches
, cnt
, sizeof(struct cpu_cache_level
), cpu_cache_level__sort
);
1027 ret
= do_write(fd
, &version
, sizeof(u32
));
1031 ret
= do_write(fd
, &cnt
, sizeof(u32
));
1035 for (i
= 0; i
< cnt
; i
++) {
1036 struct cpu_cache_level
*c
= &caches
[i
];
1039 ret = do_write(fd, &c->v, sizeof(u32)); \
1050 ret = do_write_string(fd, (const char *) c->v); \
1061 for (i
= 0; i
< cnt
; i
++)
1062 cpu_cache_level__free(&caches
[i
]);
1066 static int write_stat(int fd __maybe_unused
,
1067 struct perf_header
*h __maybe_unused
,
1068 struct perf_evlist
*evlist __maybe_unused
)
1073 static void print_hostname(struct perf_header
*ph
, int fd __maybe_unused
,
1076 fprintf(fp
, "# hostname : %s\n", ph
->env
.hostname
);
1079 static void print_osrelease(struct perf_header
*ph
, int fd __maybe_unused
,
1082 fprintf(fp
, "# os release : %s\n", ph
->env
.os_release
);
1085 static void print_arch(struct perf_header
*ph
, int fd __maybe_unused
, FILE *fp
)
1087 fprintf(fp
, "# arch : %s\n", ph
->env
.arch
);
1090 static void print_cpudesc(struct perf_header
*ph
, int fd __maybe_unused
,
1093 fprintf(fp
, "# cpudesc : %s\n", ph
->env
.cpu_desc
);
1096 static void print_nrcpus(struct perf_header
*ph
, int fd __maybe_unused
,
1099 fprintf(fp
, "# nrcpus online : %u\n", ph
->env
.nr_cpus_online
);
1100 fprintf(fp
, "# nrcpus avail : %u\n", ph
->env
.nr_cpus_avail
);
1103 static void print_version(struct perf_header
*ph
, int fd __maybe_unused
,
1106 fprintf(fp
, "# perf version : %s\n", ph
->env
.version
);
1109 static void print_cmdline(struct perf_header
*ph
, int fd __maybe_unused
,
1114 nr
= ph
->env
.nr_cmdline
;
1116 fprintf(fp
, "# cmdline : ");
1118 for (i
= 0; i
< nr
; i
++)
1119 fprintf(fp
, "%s ", ph
->env
.cmdline_argv
[i
]);
1123 static void print_cpu_topology(struct perf_header
*ph
, int fd __maybe_unused
,
1128 int cpu_nr
= ph
->env
.nr_cpus_online
;
1130 nr
= ph
->env
.nr_sibling_cores
;
1131 str
= ph
->env
.sibling_cores
;
1133 for (i
= 0; i
< nr
; i
++) {
1134 fprintf(fp
, "# sibling cores : %s\n", str
);
1135 str
+= strlen(str
) + 1;
1138 nr
= ph
->env
.nr_sibling_threads
;
1139 str
= ph
->env
.sibling_threads
;
1141 for (i
= 0; i
< nr
; i
++) {
1142 fprintf(fp
, "# sibling threads : %s\n", str
);
1143 str
+= strlen(str
) + 1;
1146 if (ph
->env
.cpu
!= NULL
) {
1147 for (i
= 0; i
< cpu_nr
; i
++)
1148 fprintf(fp
, "# CPU %d: Core ID %d, Socket ID %d\n", i
,
1149 ph
->env
.cpu
[i
].core_id
, ph
->env
.cpu
[i
].socket_id
);
1151 fprintf(fp
, "# Core ID and Socket ID information is not available\n");
1154 static void free_event_desc(struct perf_evsel
*events
)
1156 struct perf_evsel
*evsel
;
1161 for (evsel
= events
; evsel
->attr
.size
; evsel
++) {
1162 zfree(&evsel
->name
);
1169 static struct perf_evsel
*
1170 read_event_desc(struct perf_header
*ph
, int fd
)
1172 struct perf_evsel
*evsel
, *events
= NULL
;
1175 u32 nre
, sz
, nr
, i
, j
;
1179 /* number of events */
1180 ret
= readn(fd
, &nre
, sizeof(nre
));
1181 if (ret
!= (ssize_t
)sizeof(nre
))
1185 nre
= bswap_32(nre
);
1187 ret
= readn(fd
, &sz
, sizeof(sz
));
1188 if (ret
!= (ssize_t
)sizeof(sz
))
1194 /* buffer to hold on file attr struct */
1199 /* the last event terminates with evsel->attr.size == 0: */
1200 events
= calloc(nre
+ 1, sizeof(*events
));
1204 msz
= sizeof(evsel
->attr
);
1208 for (i
= 0, evsel
= events
; i
< nre
; evsel
++, i
++) {
1212 * must read entire on-file attr struct to
1213 * sync up with layout.
1215 ret
= readn(fd
, buf
, sz
);
1216 if (ret
!= (ssize_t
)sz
)
1220 perf_event__attr_swap(buf
);
1222 memcpy(&evsel
->attr
, buf
, msz
);
1224 ret
= readn(fd
, &nr
, sizeof(nr
));
1225 if (ret
!= (ssize_t
)sizeof(nr
))
1228 if (ph
->needs_swap
) {
1230 evsel
->needs_swap
= true;
1233 evsel
->name
= do_read_string(fd
, ph
);
1238 id
= calloc(nr
, sizeof(*id
));
1244 for (j
= 0 ; j
< nr
; j
++) {
1245 ret
= readn(fd
, id
, sizeof(*id
));
1246 if (ret
!= (ssize_t
)sizeof(*id
))
1249 *id
= bswap_64(*id
);
1257 free_event_desc(events
);
1262 static int __desc_attr__fprintf(FILE *fp
, const char *name
, const char *val
,
1263 void *priv
__attribute__((unused
)))
1265 return fprintf(fp
, ", %s = %s", name
, val
);
1268 static void print_event_desc(struct perf_header
*ph
, int fd
, FILE *fp
)
1270 struct perf_evsel
*evsel
, *events
= read_event_desc(ph
, fd
);
1275 fprintf(fp
, "# event desc: not available or unable to read\n");
1279 for (evsel
= events
; evsel
->attr
.size
; evsel
++) {
1280 fprintf(fp
, "# event : name = %s, ", evsel
->name
);
1283 fprintf(fp
, ", id = {");
1284 for (j
= 0, id
= evsel
->id
; j
< evsel
->ids
; j
++, id
++) {
1287 fprintf(fp
, " %"PRIu64
, *id
);
1292 perf_event_attr__fprintf(fp
, &evsel
->attr
, __desc_attr__fprintf
, NULL
);
1297 free_event_desc(events
);
1300 static void print_total_mem(struct perf_header
*ph
, int fd __maybe_unused
,
1303 fprintf(fp
, "# total memory : %Lu kB\n", ph
->env
.total_mem
);
1306 static void print_numa_topology(struct perf_header
*ph
, int fd __maybe_unused
,
1311 uint64_t mem_total
, mem_free
;
1314 nr
= ph
->env
.nr_numa_nodes
;
1315 str
= ph
->env
.numa_nodes
;
1317 for (i
= 0; i
< nr
; i
++) {
1319 c
= strtoul(str
, &tmp
, 0);
1324 mem_total
= strtoull(str
, &tmp
, 0);
1329 mem_free
= strtoull(str
, &tmp
, 0);
1333 fprintf(fp
, "# node%u meminfo : total = %"PRIu64
" kB,"
1334 " free = %"PRIu64
" kB\n",
1335 c
, mem_total
, mem_free
);
1338 fprintf(fp
, "# node%u cpu list : %s\n", c
, str
);
1340 str
+= strlen(str
) + 1;
1344 fprintf(fp
, "# numa topology : not available\n");
1347 static void print_cpuid(struct perf_header
*ph
, int fd __maybe_unused
, FILE *fp
)
1349 fprintf(fp
, "# cpuid : %s\n", ph
->env
.cpuid
);
1352 static void print_branch_stack(struct perf_header
*ph __maybe_unused
,
1353 int fd __maybe_unused
, FILE *fp
)
1355 fprintf(fp
, "# contains samples with branch stack\n");
1358 static void print_auxtrace(struct perf_header
*ph __maybe_unused
,
1359 int fd __maybe_unused
, FILE *fp
)
1361 fprintf(fp
, "# contains AUX area data (e.g. instruction trace)\n");
1364 static void print_stat(struct perf_header
*ph __maybe_unused
,
1365 int fd __maybe_unused
, FILE *fp
)
1367 fprintf(fp
, "# contains stat data\n");
1370 static void print_cache(struct perf_header
*ph __maybe_unused
,
1371 int fd __maybe_unused
, FILE *fp __maybe_unused
)
1375 fprintf(fp
, "# CPU cache info:\n");
1376 for (i
= 0; i
< ph
->env
.caches_cnt
; i
++) {
1378 cpu_cache_level__fprintf(fp
, &ph
->env
.caches
[i
]);
1382 static void print_pmu_mappings(struct perf_header
*ph
, int fd __maybe_unused
,
1385 const char *delimiter
= "# pmu mappings: ";
1390 pmu_num
= ph
->env
.nr_pmu_mappings
;
1392 fprintf(fp
, "# pmu mappings: not available\n");
1396 str
= ph
->env
.pmu_mappings
;
1399 type
= strtoul(str
, &tmp
, 0);
1404 fprintf(fp
, "%s%s = %" PRIu32
, delimiter
, str
, type
);
1407 str
+= strlen(str
) + 1;
1416 fprintf(fp
, "# pmu mappings: unable to read\n");
1419 static void print_group_desc(struct perf_header
*ph
, int fd __maybe_unused
,
1422 struct perf_session
*session
;
1423 struct perf_evsel
*evsel
;
1426 session
= container_of(ph
, struct perf_session
, header
);
1428 evlist__for_each(session
->evlist
, evsel
) {
1429 if (perf_evsel__is_group_leader(evsel
) &&
1430 evsel
->nr_members
> 1) {
1431 fprintf(fp
, "# group: %s{%s", evsel
->group_name
?: "",
1432 perf_evsel__name(evsel
));
1434 nr
= evsel
->nr_members
- 1;
1436 fprintf(fp
, ",%s", perf_evsel__name(evsel
));
1444 static int __event_process_build_id(struct build_id_event
*bev
,
1446 struct perf_session
*session
)
1449 struct machine
*machine
;
1452 enum dso_kernel_type dso_type
;
1454 machine
= perf_session__findnew_machine(session
, bev
->pid
);
1458 cpumode
= bev
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1461 case PERF_RECORD_MISC_KERNEL
:
1462 dso_type
= DSO_TYPE_KERNEL
;
1464 case PERF_RECORD_MISC_GUEST_KERNEL
:
1465 dso_type
= DSO_TYPE_GUEST_KERNEL
;
1467 case PERF_RECORD_MISC_USER
:
1468 case PERF_RECORD_MISC_GUEST_USER
:
1469 dso_type
= DSO_TYPE_USER
;
1475 dso
= machine__findnew_dso(machine
, filename
);
1477 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
1479 dso__set_build_id(dso
, &bev
->build_id
);
1481 if (!is_kernel_module(filename
, cpumode
))
1482 dso
->kernel
= dso_type
;
1484 build_id__sprintf(dso
->build_id
, sizeof(dso
->build_id
),
1486 pr_debug("build id event received for %s: %s\n",
1487 dso
->long_name
, sbuild_id
);
1496 static int perf_header__read_build_ids_abi_quirk(struct perf_header
*header
,
1497 int input
, u64 offset
, u64 size
)
1499 struct perf_session
*session
= container_of(header
, struct perf_session
, header
);
1501 struct perf_event_header header
;
1502 u8 build_id
[PERF_ALIGN(BUILD_ID_SIZE
, sizeof(u64
))];
1505 struct build_id_event bev
;
1506 char filename
[PATH_MAX
];
1507 u64 limit
= offset
+ size
;
1509 while (offset
< limit
) {
1512 if (readn(input
, &old_bev
, sizeof(old_bev
)) != sizeof(old_bev
))
1515 if (header
->needs_swap
)
1516 perf_event_header__bswap(&old_bev
.header
);
1518 len
= old_bev
.header
.size
- sizeof(old_bev
);
1519 if (readn(input
, filename
, len
) != len
)
1522 bev
.header
= old_bev
.header
;
1525 * As the pid is the missing value, we need to fill
1526 * it properly. The header.misc value give us nice hint.
1528 bev
.pid
= HOST_KERNEL_ID
;
1529 if (bev
.header
.misc
== PERF_RECORD_MISC_GUEST_USER
||
1530 bev
.header
.misc
== PERF_RECORD_MISC_GUEST_KERNEL
)
1531 bev
.pid
= DEFAULT_GUEST_KERNEL_ID
;
1533 memcpy(bev
.build_id
, old_bev
.build_id
, sizeof(bev
.build_id
));
1534 __event_process_build_id(&bev
, filename
, session
);
1536 offset
+= bev
.header
.size
;
1542 static int perf_header__read_build_ids(struct perf_header
*header
,
1543 int input
, u64 offset
, u64 size
)
1545 struct perf_session
*session
= container_of(header
, struct perf_session
, header
);
1546 struct build_id_event bev
;
1547 char filename
[PATH_MAX
];
1548 u64 limit
= offset
+ size
, orig_offset
= offset
;
1551 while (offset
< limit
) {
1554 if (readn(input
, &bev
, sizeof(bev
)) != sizeof(bev
))
1557 if (header
->needs_swap
)
1558 perf_event_header__bswap(&bev
.header
);
1560 len
= bev
.header
.size
- sizeof(bev
);
1561 if (readn(input
, filename
, len
) != len
)
1564 * The a1645ce1 changeset:
1566 * "perf: 'perf kvm' tool for monitoring guest performance from host"
1568 * Added a field to struct build_id_event that broke the file
1571 * Since the kernel build-id is the first entry, process the
1572 * table using the old format if the well known
1573 * '[kernel.kallsyms]' string for the kernel build-id has the
1574 * first 4 characters chopped off (where the pid_t sits).
1576 if (memcmp(filename
, "nel.kallsyms]", 13) == 0) {
1577 if (lseek(input
, orig_offset
, SEEK_SET
) == (off_t
)-1)
1579 return perf_header__read_build_ids_abi_quirk(header
, input
, offset
, size
);
1582 __event_process_build_id(&bev
, filename
, session
);
1584 offset
+= bev
.header
.size
;
1591 static int process_tracing_data(struct perf_file_section
*section __maybe_unused
,
1592 struct perf_header
*ph __maybe_unused
,
1595 ssize_t ret
= trace_report(fd
, data
, false);
1596 return ret
< 0 ? -1 : 0;
1599 static int process_build_id(struct perf_file_section
*section
,
1600 struct perf_header
*ph
, int fd
,
1601 void *data __maybe_unused
)
1603 if (perf_header__read_build_ids(ph
, fd
, section
->offset
, section
->size
))
1604 pr_debug("Failed to read buildids, continuing...\n");
1608 static int process_hostname(struct perf_file_section
*section __maybe_unused
,
1609 struct perf_header
*ph
, int fd
,
1610 void *data __maybe_unused
)
1612 ph
->env
.hostname
= do_read_string(fd
, ph
);
1613 return ph
->env
.hostname
? 0 : -ENOMEM
;
1616 static int process_osrelease(struct perf_file_section
*section __maybe_unused
,
1617 struct perf_header
*ph
, int fd
,
1618 void *data __maybe_unused
)
1620 ph
->env
.os_release
= do_read_string(fd
, ph
);
1621 return ph
->env
.os_release
? 0 : -ENOMEM
;
1624 static int process_version(struct perf_file_section
*section __maybe_unused
,
1625 struct perf_header
*ph
, int fd
,
1626 void *data __maybe_unused
)
1628 ph
->env
.version
= do_read_string(fd
, ph
);
1629 return ph
->env
.version
? 0 : -ENOMEM
;
1632 static int process_arch(struct perf_file_section
*section __maybe_unused
,
1633 struct perf_header
*ph
, int fd
,
1634 void *data __maybe_unused
)
1636 ph
->env
.arch
= do_read_string(fd
, ph
);
1637 return ph
->env
.arch
? 0 : -ENOMEM
;
1640 static int process_nrcpus(struct perf_file_section
*section __maybe_unused
,
1641 struct perf_header
*ph
, int fd
,
1642 void *data __maybe_unused
)
1647 ret
= readn(fd
, &nr
, sizeof(nr
));
1648 if (ret
!= sizeof(nr
))
1654 ph
->env
.nr_cpus_avail
= nr
;
1656 ret
= readn(fd
, &nr
, sizeof(nr
));
1657 if (ret
!= sizeof(nr
))
1663 ph
->env
.nr_cpus_online
= nr
;
1667 static int process_cpudesc(struct perf_file_section
*section __maybe_unused
,
1668 struct perf_header
*ph
, int fd
,
1669 void *data __maybe_unused
)
1671 ph
->env
.cpu_desc
= do_read_string(fd
, ph
);
1672 return ph
->env
.cpu_desc
? 0 : -ENOMEM
;
1675 static int process_cpuid(struct perf_file_section
*section __maybe_unused
,
1676 struct perf_header
*ph
, int fd
,
1677 void *data __maybe_unused
)
1679 ph
->env
.cpuid
= do_read_string(fd
, ph
);
1680 return ph
->env
.cpuid
? 0 : -ENOMEM
;
1683 static int process_total_mem(struct perf_file_section
*section __maybe_unused
,
1684 struct perf_header
*ph
, int fd
,
1685 void *data __maybe_unused
)
1690 ret
= readn(fd
, &mem
, sizeof(mem
));
1691 if (ret
!= sizeof(mem
))
1695 mem
= bswap_64(mem
);
1697 ph
->env
.total_mem
= mem
;
1701 static struct perf_evsel
*
1702 perf_evlist__find_by_index(struct perf_evlist
*evlist
, int idx
)
1704 struct perf_evsel
*evsel
;
1706 evlist__for_each(evlist
, evsel
) {
1707 if (evsel
->idx
== idx
)
1715 perf_evlist__set_event_name(struct perf_evlist
*evlist
,
1716 struct perf_evsel
*event
)
1718 struct perf_evsel
*evsel
;
1723 evsel
= perf_evlist__find_by_index(evlist
, event
->idx
);
1730 evsel
->name
= strdup(event
->name
);
1734 process_event_desc(struct perf_file_section
*section __maybe_unused
,
1735 struct perf_header
*header
, int fd
,
1736 void *data __maybe_unused
)
1738 struct perf_session
*session
;
1739 struct perf_evsel
*evsel
, *events
= read_event_desc(header
, fd
);
1744 session
= container_of(header
, struct perf_session
, header
);
1745 for (evsel
= events
; evsel
->attr
.size
; evsel
++)
1746 perf_evlist__set_event_name(session
->evlist
, evsel
);
1748 free_event_desc(events
);
1753 static int process_cmdline(struct perf_file_section
*section
,
1754 struct perf_header
*ph
, int fd
,
1755 void *data __maybe_unused
)
1758 char *str
, *cmdline
= NULL
, **argv
= NULL
;
1761 ret
= readn(fd
, &nr
, sizeof(nr
));
1762 if (ret
!= sizeof(nr
))
1768 ph
->env
.nr_cmdline
= nr
;
1770 cmdline
= zalloc(section
->size
+ nr
+ 1);
1774 argv
= zalloc(sizeof(char *) * (nr
+ 1));
1778 for (i
= 0; i
< nr
; i
++) {
1779 str
= do_read_string(fd
, ph
);
1783 argv
[i
] = cmdline
+ len
;
1784 memcpy(argv
[i
], str
, strlen(str
) + 1);
1785 len
+= strlen(str
) + 1;
1788 ph
->env
.cmdline
= cmdline
;
1789 ph
->env
.cmdline_argv
= (const char **) argv
;
1798 static int process_cpu_topology(struct perf_file_section
*section
,
1799 struct perf_header
*ph
, int fd
,
1800 void *data __maybe_unused
)
1806 int cpu_nr
= ph
->env
.nr_cpus_online
;
1809 ph
->env
.cpu
= calloc(cpu_nr
, sizeof(*ph
->env
.cpu
));
1813 ret
= readn(fd
, &nr
, sizeof(nr
));
1814 if (ret
!= sizeof(nr
))
1820 ph
->env
.nr_sibling_cores
= nr
;
1821 size
+= sizeof(u32
);
1822 strbuf_init(&sb
, 128);
1824 for (i
= 0; i
< nr
; i
++) {
1825 str
= do_read_string(fd
, ph
);
1829 /* include a NULL character at the end */
1830 strbuf_add(&sb
, str
, strlen(str
) + 1);
1831 size
+= string_size(str
);
1834 ph
->env
.sibling_cores
= strbuf_detach(&sb
, NULL
);
1836 ret
= readn(fd
, &nr
, sizeof(nr
));
1837 if (ret
!= sizeof(nr
))
1843 ph
->env
.nr_sibling_threads
= nr
;
1844 size
+= sizeof(u32
);
1846 for (i
= 0; i
< nr
; i
++) {
1847 str
= do_read_string(fd
, ph
);
1851 /* include a NULL character at the end */
1852 strbuf_add(&sb
, str
, strlen(str
) + 1);
1853 size
+= string_size(str
);
1856 ph
->env
.sibling_threads
= strbuf_detach(&sb
, NULL
);
1859 * The header may be from old perf,
1860 * which doesn't include core id and socket id information.
1862 if (section
->size
<= size
) {
1863 zfree(&ph
->env
.cpu
);
1867 for (i
= 0; i
< (u32
)cpu_nr
; i
++) {
1868 ret
= readn(fd
, &nr
, sizeof(nr
));
1869 if (ret
!= sizeof(nr
))
1875 if (nr
> (u32
)cpu_nr
) {
1876 pr_debug("core_id number is too big."
1877 "You may need to upgrade the perf tool.\n");
1880 ph
->env
.cpu
[i
].core_id
= nr
;
1882 ret
= readn(fd
, &nr
, sizeof(nr
));
1883 if (ret
!= sizeof(nr
))
1889 if (nr
> (u32
)cpu_nr
) {
1890 pr_debug("socket_id number is too big."
1891 "You may need to upgrade the perf tool.\n");
1895 ph
->env
.cpu
[i
].socket_id
= nr
;
1901 strbuf_release(&sb
);
1903 zfree(&ph
->env
.cpu
);
1907 static int process_numa_topology(struct perf_file_section
*section __maybe_unused
,
1908 struct perf_header
*ph
, int fd
,
1909 void *data __maybe_unused
)
1914 uint64_t mem_total
, mem_free
;
1918 ret
= readn(fd
, &nr
, sizeof(nr
));
1919 if (ret
!= sizeof(nr
))
1925 ph
->env
.nr_numa_nodes
= nr
;
1926 strbuf_init(&sb
, 256);
1928 for (i
= 0; i
< nr
; i
++) {
1930 ret
= readn(fd
, &node
, sizeof(node
));
1931 if (ret
!= sizeof(node
))
1934 ret
= readn(fd
, &mem_total
, sizeof(u64
));
1935 if (ret
!= sizeof(u64
))
1938 ret
= readn(fd
, &mem_free
, sizeof(u64
));
1939 if (ret
!= sizeof(u64
))
1942 if (ph
->needs_swap
) {
1943 node
= bswap_32(node
);
1944 mem_total
= bswap_64(mem_total
);
1945 mem_free
= bswap_64(mem_free
);
1948 strbuf_addf(&sb
, "%u:%"PRIu64
":%"PRIu64
":",
1949 node
, mem_total
, mem_free
);
1951 str
= do_read_string(fd
, ph
);
1955 /* include a NULL character at the end */
1956 strbuf_add(&sb
, str
, strlen(str
) + 1);
1959 ph
->env
.numa_nodes
= strbuf_detach(&sb
, NULL
);
1963 strbuf_release(&sb
);
1967 static int process_pmu_mappings(struct perf_file_section
*section __maybe_unused
,
1968 struct perf_header
*ph
, int fd
,
1969 void *data __maybe_unused
)
1977 ret
= readn(fd
, &pmu_num
, sizeof(pmu_num
));
1978 if (ret
!= sizeof(pmu_num
))
1982 pmu_num
= bswap_32(pmu_num
);
1985 pr_debug("pmu mappings not available\n");
1989 ph
->env
.nr_pmu_mappings
= pmu_num
;
1990 strbuf_init(&sb
, 128);
1993 if (readn(fd
, &type
, sizeof(type
)) != sizeof(type
))
1996 type
= bswap_32(type
);
1998 name
= do_read_string(fd
, ph
);
2002 strbuf_addf(&sb
, "%u:%s", type
, name
);
2003 /* include a NULL character at the end */
2004 strbuf_add(&sb
, "", 1);
2006 if (!strcmp(name
, "msr"))
2007 ph
->env
.msr_pmu_type
= type
;
2012 ph
->env
.pmu_mappings
= strbuf_detach(&sb
, NULL
);
2016 strbuf_release(&sb
);
2020 static int process_group_desc(struct perf_file_section
*section __maybe_unused
,
2021 struct perf_header
*ph
, int fd
,
2022 void *data __maybe_unused
)
2025 u32 i
, nr
, nr_groups
;
2026 struct perf_session
*session
;
2027 struct perf_evsel
*evsel
, *leader
= NULL
;
2034 if (readn(fd
, &nr_groups
, sizeof(nr_groups
)) != sizeof(nr_groups
))
2038 nr_groups
= bswap_32(nr_groups
);
2040 ph
->env
.nr_groups
= nr_groups
;
2042 pr_debug("group desc not available\n");
2046 desc
= calloc(nr_groups
, sizeof(*desc
));
2050 for (i
= 0; i
< nr_groups
; i
++) {
2051 desc
[i
].name
= do_read_string(fd
, ph
);
2055 if (readn(fd
, &desc
[i
].leader_idx
, sizeof(u32
)) != sizeof(u32
))
2058 if (readn(fd
, &desc
[i
].nr_members
, sizeof(u32
)) != sizeof(u32
))
2061 if (ph
->needs_swap
) {
2062 desc
[i
].leader_idx
= bswap_32(desc
[i
].leader_idx
);
2063 desc
[i
].nr_members
= bswap_32(desc
[i
].nr_members
);
2068 * Rebuild group relationship based on the group_desc
2070 session
= container_of(ph
, struct perf_session
, header
);
2071 session
->evlist
->nr_groups
= nr_groups
;
2074 evlist__for_each(session
->evlist
, evsel
) {
2075 if (evsel
->idx
== (int) desc
[i
].leader_idx
) {
2076 evsel
->leader
= evsel
;
2077 /* {anon_group} is a dummy name */
2078 if (strcmp(desc
[i
].name
, "{anon_group}")) {
2079 evsel
->group_name
= desc
[i
].name
;
2080 desc
[i
].name
= NULL
;
2082 evsel
->nr_members
= desc
[i
].nr_members
;
2084 if (i
>= nr_groups
|| nr
> 0) {
2085 pr_debug("invalid group desc\n");
2090 nr
= evsel
->nr_members
- 1;
2093 /* This is a group member */
2094 evsel
->leader
= leader
;
2100 if (i
!= nr_groups
|| nr
!= 0) {
2101 pr_debug("invalid group desc\n");
2107 for (i
= 0; i
< nr_groups
; i
++)
2108 zfree(&desc
[i
].name
);
2114 static int process_auxtrace(struct perf_file_section
*section
,
2115 struct perf_header
*ph
, int fd
,
2116 void *data __maybe_unused
)
2118 struct perf_session
*session
;
2121 session
= container_of(ph
, struct perf_session
, header
);
2123 err
= auxtrace_index__process(fd
, section
->size
, session
,
2126 pr_err("Failed to process auxtrace index\n");
2130 static int process_cache(struct perf_file_section
*section __maybe_unused
,
2131 struct perf_header
*ph __maybe_unused
, int fd __maybe_unused
,
2132 void *data __maybe_unused
)
2134 struct cpu_cache_level
*caches
;
2135 u32 cnt
, i
, version
;
2137 if (readn(fd
, &version
, sizeof(version
)) != sizeof(version
))
2141 version
= bswap_32(version
);
2146 if (readn(fd
, &cnt
, sizeof(cnt
)) != sizeof(cnt
))
2150 cnt
= bswap_32(cnt
);
2152 caches
= zalloc(sizeof(*caches
) * cnt
);
2156 for (i
= 0; i
< cnt
; i
++) {
2157 struct cpu_cache_level c
;
2160 if (readn(fd, &c.v, sizeof(u32)) != sizeof(u32))\
2161 goto out_free_caches; \
2162 if (ph->needs_swap) \
2163 c.v = bswap_32(c.v); \
2172 c.v = do_read_string(fd, ph); \
2174 goto out_free_caches;
2184 ph
->env
.caches
= caches
;
2185 ph
->env
.caches_cnt
= cnt
;
2192 struct feature_ops
{
2193 int (*write
)(int fd
, struct perf_header
*h
, struct perf_evlist
*evlist
);
2194 void (*print
)(struct perf_header
*h
, int fd
, FILE *fp
);
2195 int (*process
)(struct perf_file_section
*section
,
2196 struct perf_header
*h
, int fd
, void *data
);
2201 #define FEAT_OPA(n, func) \
2202 [n] = { .name = #n, .write = write_##func, .print = print_##func }
2203 #define FEAT_OPP(n, func) \
2204 [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2205 .process = process_##func }
2206 #define FEAT_OPF(n, func) \
2207 [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2208 .process = process_##func, .full_only = true }
2210 /* feature_ops not implemented: */
2211 #define print_tracing_data NULL
2212 #define print_build_id NULL
2214 static const struct feature_ops feat_ops
[HEADER_LAST_FEATURE
] = {
2215 FEAT_OPP(HEADER_TRACING_DATA
, tracing_data
),
2216 FEAT_OPP(HEADER_BUILD_ID
, build_id
),
2217 FEAT_OPP(HEADER_HOSTNAME
, hostname
),
2218 FEAT_OPP(HEADER_OSRELEASE
, osrelease
),
2219 FEAT_OPP(HEADER_VERSION
, version
),
2220 FEAT_OPP(HEADER_ARCH
, arch
),
2221 FEAT_OPP(HEADER_NRCPUS
, nrcpus
),
2222 FEAT_OPP(HEADER_CPUDESC
, cpudesc
),
2223 FEAT_OPP(HEADER_CPUID
, cpuid
),
2224 FEAT_OPP(HEADER_TOTAL_MEM
, total_mem
),
2225 FEAT_OPP(HEADER_EVENT_DESC
, event_desc
),
2226 FEAT_OPP(HEADER_CMDLINE
, cmdline
),
2227 FEAT_OPF(HEADER_CPU_TOPOLOGY
, cpu_topology
),
2228 FEAT_OPF(HEADER_NUMA_TOPOLOGY
, numa_topology
),
2229 FEAT_OPA(HEADER_BRANCH_STACK
, branch_stack
),
2230 FEAT_OPP(HEADER_PMU_MAPPINGS
, pmu_mappings
),
2231 FEAT_OPP(HEADER_GROUP_DESC
, group_desc
),
2232 FEAT_OPP(HEADER_AUXTRACE
, auxtrace
),
2233 FEAT_OPA(HEADER_STAT
, stat
),
2234 FEAT_OPF(HEADER_CACHE
, cache
),
2237 struct header_print_data
{
2239 bool full
; /* extended list of headers */
2242 static int perf_file_section__fprintf_info(struct perf_file_section
*section
,
2243 struct perf_header
*ph
,
2244 int feat
, int fd
, void *data
)
2246 struct header_print_data
*hd
= data
;
2248 if (lseek(fd
, section
->offset
, SEEK_SET
) == (off_t
)-1) {
2249 pr_debug("Failed to lseek to %" PRIu64
" offset for feature "
2250 "%d, continuing...\n", section
->offset
, feat
);
2253 if (feat
>= HEADER_LAST_FEATURE
) {
2254 pr_warning("unknown feature %d\n", feat
);
2257 if (!feat_ops
[feat
].print
)
2260 if (!feat_ops
[feat
].full_only
|| hd
->full
)
2261 feat_ops
[feat
].print(ph
, fd
, hd
->fp
);
2263 fprintf(hd
->fp
, "# %s info available, use -I to display\n",
2264 feat_ops
[feat
].name
);
2269 int perf_header__fprintf_info(struct perf_session
*session
, FILE *fp
, bool full
)
2271 struct header_print_data hd
;
2272 struct perf_header
*header
= &session
->header
;
2273 int fd
= perf_data_file__fd(session
->file
);
2277 perf_header__process_sections(header
, fd
, &hd
,
2278 perf_file_section__fprintf_info
);
2282 static int do_write_feat(int fd
, struct perf_header
*h
, int type
,
2283 struct perf_file_section
**p
,
2284 struct perf_evlist
*evlist
)
2289 if (perf_header__has_feat(h
, type
)) {
2290 if (!feat_ops
[type
].write
)
2293 (*p
)->offset
= lseek(fd
, 0, SEEK_CUR
);
2295 err
= feat_ops
[type
].write(fd
, h
, evlist
);
2297 pr_debug("failed to write feature %d\n", type
);
2299 /* undo anything written */
2300 lseek(fd
, (*p
)->offset
, SEEK_SET
);
2304 (*p
)->size
= lseek(fd
, 0, SEEK_CUR
) - (*p
)->offset
;
2310 static int perf_header__adds_write(struct perf_header
*header
,
2311 struct perf_evlist
*evlist
, int fd
)
2314 struct perf_file_section
*feat_sec
, *p
;
2320 nr_sections
= bitmap_weight(header
->adds_features
, HEADER_FEAT_BITS
);
2324 feat_sec
= p
= calloc(nr_sections
, sizeof(*feat_sec
));
2325 if (feat_sec
== NULL
)
2328 sec_size
= sizeof(*feat_sec
) * nr_sections
;
2330 sec_start
= header
->feat_offset
;
2331 lseek(fd
, sec_start
+ sec_size
, SEEK_SET
);
2333 for_each_set_bit(feat
, header
->adds_features
, HEADER_FEAT_BITS
) {
2334 if (do_write_feat(fd
, header
, feat
, &p
, evlist
))
2335 perf_header__clear_feat(header
, feat
);
2338 lseek(fd
, sec_start
, SEEK_SET
);
2340 * may write more than needed due to dropped feature, but
2341 * this is okay, reader will skip the mising entries
2343 err
= do_write(fd
, feat_sec
, sec_size
);
2345 pr_debug("failed to write feature section\n");
2350 int perf_header__write_pipe(int fd
)
2352 struct perf_pipe_file_header f_header
;
2355 f_header
= (struct perf_pipe_file_header
){
2356 .magic
= PERF_MAGIC
,
2357 .size
= sizeof(f_header
),
2360 err
= do_write(fd
, &f_header
, sizeof(f_header
));
2362 pr_debug("failed to write perf pipe header\n");
2369 int perf_session__write_header(struct perf_session
*session
,
2370 struct perf_evlist
*evlist
,
2371 int fd
, bool at_exit
)
2373 struct perf_file_header f_header
;
2374 struct perf_file_attr f_attr
;
2375 struct perf_header
*header
= &session
->header
;
2376 struct perf_evsel
*evsel
;
2380 lseek(fd
, sizeof(f_header
), SEEK_SET
);
2382 evlist__for_each(session
->evlist
, evsel
) {
2383 evsel
->id_offset
= lseek(fd
, 0, SEEK_CUR
);
2384 err
= do_write(fd
, evsel
->id
, evsel
->ids
* sizeof(u64
));
2386 pr_debug("failed to write perf header\n");
2391 attr_offset
= lseek(fd
, 0, SEEK_CUR
);
2393 evlist__for_each(evlist
, evsel
) {
2394 f_attr
= (struct perf_file_attr
){
2395 .attr
= evsel
->attr
,
2397 .offset
= evsel
->id_offset
,
2398 .size
= evsel
->ids
* sizeof(u64
),
2401 err
= do_write(fd
, &f_attr
, sizeof(f_attr
));
2403 pr_debug("failed to write perf header attribute\n");
2408 if (!header
->data_offset
)
2409 header
->data_offset
= lseek(fd
, 0, SEEK_CUR
);
2410 header
->feat_offset
= header
->data_offset
+ header
->data_size
;
2413 err
= perf_header__adds_write(header
, evlist
, fd
);
2418 f_header
= (struct perf_file_header
){
2419 .magic
= PERF_MAGIC
,
2420 .size
= sizeof(f_header
),
2421 .attr_size
= sizeof(f_attr
),
2423 .offset
= attr_offset
,
2424 .size
= evlist
->nr_entries
* sizeof(f_attr
),
2427 .offset
= header
->data_offset
,
2428 .size
= header
->data_size
,
2430 /* event_types is ignored, store zeros */
2433 memcpy(&f_header
.adds_features
, &header
->adds_features
, sizeof(header
->adds_features
));
2435 lseek(fd
, 0, SEEK_SET
);
2436 err
= do_write(fd
, &f_header
, sizeof(f_header
));
2438 pr_debug("failed to write perf header\n");
2441 lseek(fd
, header
->data_offset
+ header
->data_size
, SEEK_SET
);
2446 static int perf_header__getbuffer64(struct perf_header
*header
,
2447 int fd
, void *buf
, size_t size
)
2449 if (readn(fd
, buf
, size
) <= 0)
2452 if (header
->needs_swap
)
2453 mem_bswap_64(buf
, size
);
2458 int perf_header__process_sections(struct perf_header
*header
, int fd
,
2460 int (*process
)(struct perf_file_section
*section
,
2461 struct perf_header
*ph
,
2462 int feat
, int fd
, void *data
))
2464 struct perf_file_section
*feat_sec
, *sec
;
2470 nr_sections
= bitmap_weight(header
->adds_features
, HEADER_FEAT_BITS
);
2474 feat_sec
= sec
= calloc(nr_sections
, sizeof(*feat_sec
));
2478 sec_size
= sizeof(*feat_sec
) * nr_sections
;
2480 lseek(fd
, header
->feat_offset
, SEEK_SET
);
2482 err
= perf_header__getbuffer64(header
, fd
, feat_sec
, sec_size
);
2486 for_each_set_bit(feat
, header
->adds_features
, HEADER_LAST_FEATURE
) {
2487 err
= process(sec
++, header
, feat
, fd
, data
);
2497 static const int attr_file_abi_sizes
[] = {
2498 [0] = PERF_ATTR_SIZE_VER0
,
2499 [1] = PERF_ATTR_SIZE_VER1
,
2500 [2] = PERF_ATTR_SIZE_VER2
,
2501 [3] = PERF_ATTR_SIZE_VER3
,
2502 [4] = PERF_ATTR_SIZE_VER4
,
2507 * In the legacy file format, the magic number is not used to encode endianness.
2508 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
2509 * on ABI revisions, we need to try all combinations for all endianness to
2510 * detect the endianness.
2512 static int try_all_file_abis(uint64_t hdr_sz
, struct perf_header
*ph
)
2514 uint64_t ref_size
, attr_size
;
2517 for (i
= 0 ; attr_file_abi_sizes
[i
]; i
++) {
2518 ref_size
= attr_file_abi_sizes
[i
]
2519 + sizeof(struct perf_file_section
);
2520 if (hdr_sz
!= ref_size
) {
2521 attr_size
= bswap_64(hdr_sz
);
2522 if (attr_size
!= ref_size
)
2525 ph
->needs_swap
= true;
2527 pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
2532 /* could not determine endianness */
2536 #define PERF_PIPE_HDR_VER0 16
2538 static const size_t attr_pipe_abi_sizes
[] = {
2539 [0] = PERF_PIPE_HDR_VER0
,
2544 * In the legacy pipe format, there is an implicit assumption that endiannesss
2545 * between host recording the samples, and host parsing the samples is the
2546 * same. This is not always the case given that the pipe output may always be
2547 * redirected into a file and analyzed on a different machine with possibly a
2548 * different endianness and perf_event ABI revsions in the perf tool itself.
2550 static int try_all_pipe_abis(uint64_t hdr_sz
, struct perf_header
*ph
)
2555 for (i
= 0 ; attr_pipe_abi_sizes
[i
]; i
++) {
2556 if (hdr_sz
!= attr_pipe_abi_sizes
[i
]) {
2557 attr_size
= bswap_64(hdr_sz
);
2558 if (attr_size
!= hdr_sz
)
2561 ph
->needs_swap
= true;
2563 pr_debug("Pipe ABI%d perf.data file detected\n", i
);
2569 bool is_perf_magic(u64 magic
)
2571 if (!memcmp(&magic
, __perf_magic1
, sizeof(magic
))
2572 || magic
== __perf_magic2
2573 || magic
== __perf_magic2_sw
)
2579 static int check_magic_endian(u64 magic
, uint64_t hdr_sz
,
2580 bool is_pipe
, struct perf_header
*ph
)
2584 /* check for legacy format */
2585 ret
= memcmp(&magic
, __perf_magic1
, sizeof(magic
));
2587 ph
->version
= PERF_HEADER_VERSION_1
;
2588 pr_debug("legacy perf.data format\n");
2590 return try_all_pipe_abis(hdr_sz
, ph
);
2592 return try_all_file_abis(hdr_sz
, ph
);
2595 * the new magic number serves two purposes:
2596 * - unique number to identify actual perf.data files
2597 * - encode endianness of file
2599 ph
->version
= PERF_HEADER_VERSION_2
;
2601 /* check magic number with one endianness */
2602 if (magic
== __perf_magic2
)
2605 /* check magic number with opposite endianness */
2606 if (magic
!= __perf_magic2_sw
)
2609 ph
->needs_swap
= true;
2614 int perf_file_header__read(struct perf_file_header
*header
,
2615 struct perf_header
*ph
, int fd
)
2619 lseek(fd
, 0, SEEK_SET
);
2621 ret
= readn(fd
, header
, sizeof(*header
));
2625 if (check_magic_endian(header
->magic
,
2626 header
->attr_size
, false, ph
) < 0) {
2627 pr_debug("magic/endian check failed\n");
2631 if (ph
->needs_swap
) {
2632 mem_bswap_64(header
, offsetof(struct perf_file_header
,
2636 if (header
->size
!= sizeof(*header
)) {
2637 /* Support the previous format */
2638 if (header
->size
== offsetof(typeof(*header
), adds_features
))
2639 bitmap_zero(header
->adds_features
, HEADER_FEAT_BITS
);
2642 } else if (ph
->needs_swap
) {
2644 * feature bitmap is declared as an array of unsigned longs --
2645 * not good since its size can differ between the host that
2646 * generated the data file and the host analyzing the file.
2648 * We need to handle endianness, but we don't know the size of
2649 * the unsigned long where the file was generated. Take a best
2650 * guess at determining it: try 64-bit swap first (ie., file
2651 * created on a 64-bit host), and check if the hostname feature
2652 * bit is set (this feature bit is forced on as of fbe96f2).
2653 * If the bit is not, undo the 64-bit swap and try a 32-bit
2654 * swap. If the hostname bit is still not set (e.g., older data
2655 * file), punt and fallback to the original behavior --
2656 * clearing all feature bits and setting buildid.
2658 mem_bswap_64(&header
->adds_features
,
2659 BITS_TO_U64(HEADER_FEAT_BITS
));
2661 if (!test_bit(HEADER_HOSTNAME
, header
->adds_features
)) {
2663 mem_bswap_64(&header
->adds_features
,
2664 BITS_TO_U64(HEADER_FEAT_BITS
));
2667 mem_bswap_32(&header
->adds_features
,
2668 BITS_TO_U32(HEADER_FEAT_BITS
));
2671 if (!test_bit(HEADER_HOSTNAME
, header
->adds_features
)) {
2672 bitmap_zero(header
->adds_features
, HEADER_FEAT_BITS
);
2673 set_bit(HEADER_BUILD_ID
, header
->adds_features
);
2677 memcpy(&ph
->adds_features
, &header
->adds_features
,
2678 sizeof(ph
->adds_features
));
2680 ph
->data_offset
= header
->data
.offset
;
2681 ph
->data_size
= header
->data
.size
;
2682 ph
->feat_offset
= header
->data
.offset
+ header
->data
.size
;
2686 static int perf_file_section__process(struct perf_file_section
*section
,
2687 struct perf_header
*ph
,
2688 int feat
, int fd
, void *data
)
2690 if (lseek(fd
, section
->offset
, SEEK_SET
) == (off_t
)-1) {
2691 pr_debug("Failed to lseek to %" PRIu64
" offset for feature "
2692 "%d, continuing...\n", section
->offset
, feat
);
2696 if (feat
>= HEADER_LAST_FEATURE
) {
2697 pr_debug("unknown feature %d, continuing...\n", feat
);
2701 if (!feat_ops
[feat
].process
)
2704 return feat_ops
[feat
].process(section
, ph
, fd
, data
);
2707 static int perf_file_header__read_pipe(struct perf_pipe_file_header
*header
,
2708 struct perf_header
*ph
, int fd
,
2713 ret
= readn(fd
, header
, sizeof(*header
));
2717 if (check_magic_endian(header
->magic
, header
->size
, true, ph
) < 0) {
2718 pr_debug("endian/magic failed\n");
2723 header
->size
= bswap_64(header
->size
);
2725 if (repipe
&& do_write(STDOUT_FILENO
, header
, sizeof(*header
)) < 0)
2731 static int perf_header__read_pipe(struct perf_session
*session
)
2733 struct perf_header
*header
= &session
->header
;
2734 struct perf_pipe_file_header f_header
;
2736 if (perf_file_header__read_pipe(&f_header
, header
,
2737 perf_data_file__fd(session
->file
),
2738 session
->repipe
) < 0) {
2739 pr_debug("incompatible file format\n");
2746 static int read_attr(int fd
, struct perf_header
*ph
,
2747 struct perf_file_attr
*f_attr
)
2749 struct perf_event_attr
*attr
= &f_attr
->attr
;
2751 size_t our_sz
= sizeof(f_attr
->attr
);
2754 memset(f_attr
, 0, sizeof(*f_attr
));
2756 /* read minimal guaranteed structure */
2757 ret
= readn(fd
, attr
, PERF_ATTR_SIZE_VER0
);
2759 pr_debug("cannot read %d bytes of header attr\n",
2760 PERF_ATTR_SIZE_VER0
);
2764 /* on file perf_event_attr size */
2772 sz
= PERF_ATTR_SIZE_VER0
;
2773 } else if (sz
> our_sz
) {
2774 pr_debug("file uses a more recent and unsupported ABI"
2775 " (%zu bytes extra)\n", sz
- our_sz
);
2778 /* what we have not yet read and that we know about */
2779 left
= sz
- PERF_ATTR_SIZE_VER0
;
2782 ptr
+= PERF_ATTR_SIZE_VER0
;
2784 ret
= readn(fd
, ptr
, left
);
2786 /* read perf_file_section, ids are read in caller */
2787 ret
= readn(fd
, &f_attr
->ids
, sizeof(f_attr
->ids
));
2789 return ret
<= 0 ? -1 : 0;
2792 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel
*evsel
,
2793 struct pevent
*pevent
)
2795 struct event_format
*event
;
2798 /* already prepared */
2799 if (evsel
->tp_format
)
2802 if (pevent
== NULL
) {
2803 pr_debug("broken or missing trace data\n");
2807 event
= pevent_find_event(pevent
, evsel
->attr
.config
);
2812 snprintf(bf
, sizeof(bf
), "%s:%s", event
->system
, event
->name
);
2813 evsel
->name
= strdup(bf
);
2814 if (evsel
->name
== NULL
)
2818 evsel
->tp_format
= event
;
2822 static int perf_evlist__prepare_tracepoint_events(struct perf_evlist
*evlist
,
2823 struct pevent
*pevent
)
2825 struct perf_evsel
*pos
;
2827 evlist__for_each(evlist
, pos
) {
2828 if (pos
->attr
.type
== PERF_TYPE_TRACEPOINT
&&
2829 perf_evsel__prepare_tracepoint_event(pos
, pevent
))
2836 int perf_session__read_header(struct perf_session
*session
)
2838 struct perf_data_file
*file
= session
->file
;
2839 struct perf_header
*header
= &session
->header
;
2840 struct perf_file_header f_header
;
2841 struct perf_file_attr f_attr
;
2843 int nr_attrs
, nr_ids
, i
, j
;
2844 int fd
= perf_data_file__fd(file
);
2846 session
->evlist
= perf_evlist__new();
2847 if (session
->evlist
== NULL
)
2850 session
->evlist
->env
= &header
->env
;
2851 session
->machines
.host
.env
= &header
->env
;
2852 if (perf_data_file__is_pipe(file
))
2853 return perf_header__read_pipe(session
);
2855 if (perf_file_header__read(&f_header
, header
, fd
) < 0)
2859 * Sanity check that perf.data was written cleanly; data size is
2860 * initialized to 0 and updated only if the on_exit function is run.
2861 * If data size is still 0 then the file contains only partial
2862 * information. Just warn user and process it as much as it can.
2864 if (f_header
.data
.size
== 0) {
2865 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
2866 "Was the 'perf record' command properly terminated?\n",
2870 nr_attrs
= f_header
.attrs
.size
/ f_header
.attr_size
;
2871 lseek(fd
, f_header
.attrs
.offset
, SEEK_SET
);
2873 for (i
= 0; i
< nr_attrs
; i
++) {
2874 struct perf_evsel
*evsel
;
2877 if (read_attr(fd
, header
, &f_attr
) < 0)
2880 if (header
->needs_swap
) {
2881 f_attr
.ids
.size
= bswap_64(f_attr
.ids
.size
);
2882 f_attr
.ids
.offset
= bswap_64(f_attr
.ids
.offset
);
2883 perf_event__attr_swap(&f_attr
.attr
);
2886 tmp
= lseek(fd
, 0, SEEK_CUR
);
2887 evsel
= perf_evsel__new(&f_attr
.attr
);
2890 goto out_delete_evlist
;
2892 evsel
->needs_swap
= header
->needs_swap
;
2894 * Do it before so that if perf_evsel__alloc_id fails, this
2895 * entry gets purged too at perf_evlist__delete().
2897 perf_evlist__add(session
->evlist
, evsel
);
2899 nr_ids
= f_attr
.ids
.size
/ sizeof(u64
);
2901 * We don't have the cpu and thread maps on the header, so
2902 * for allocating the perf_sample_id table we fake 1 cpu and
2903 * hattr->ids threads.
2905 if (perf_evsel__alloc_id(evsel
, 1, nr_ids
))
2906 goto out_delete_evlist
;
2908 lseek(fd
, f_attr
.ids
.offset
, SEEK_SET
);
2910 for (j
= 0; j
< nr_ids
; j
++) {
2911 if (perf_header__getbuffer64(header
, fd
, &f_id
, sizeof(f_id
)))
2914 perf_evlist__id_add(session
->evlist
, evsel
, 0, j
, f_id
);
2917 lseek(fd
, tmp
, SEEK_SET
);
2920 symbol_conf
.nr_events
= nr_attrs
;
2922 perf_header__process_sections(header
, fd
, &session
->tevent
,
2923 perf_file_section__process
);
2925 if (perf_evlist__prepare_tracepoint_events(session
->evlist
,
2926 session
->tevent
.pevent
))
2927 goto out_delete_evlist
;
2934 perf_evlist__delete(session
->evlist
);
2935 session
->evlist
= NULL
;
2939 int perf_event__synthesize_attr(struct perf_tool
*tool
,
2940 struct perf_event_attr
*attr
, u32 ids
, u64
*id
,
2941 perf_event__handler_t process
)
2943 union perf_event
*ev
;
2947 size
= sizeof(struct perf_event_attr
);
2948 size
= PERF_ALIGN(size
, sizeof(u64
));
2949 size
+= sizeof(struct perf_event_header
);
2950 size
+= ids
* sizeof(u64
);
2957 ev
->attr
.attr
= *attr
;
2958 memcpy(ev
->attr
.id
, id
, ids
* sizeof(u64
));
2960 ev
->attr
.header
.type
= PERF_RECORD_HEADER_ATTR
;
2961 ev
->attr
.header
.size
= (u16
)size
;
2963 if (ev
->attr
.header
.size
== size
)
2964 err
= process(tool
, ev
, NULL
, NULL
);
2973 static struct event_update_event
*
2974 event_update_event__new(size_t size
, u64 type
, u64 id
)
2976 struct event_update_event
*ev
;
2978 size
+= sizeof(*ev
);
2979 size
= PERF_ALIGN(size
, sizeof(u64
));
2983 ev
->header
.type
= PERF_RECORD_EVENT_UPDATE
;
2984 ev
->header
.size
= (u16
)size
;
2992 perf_event__synthesize_event_update_unit(struct perf_tool
*tool
,
2993 struct perf_evsel
*evsel
,
2994 perf_event__handler_t process
)
2996 struct event_update_event
*ev
;
2997 size_t size
= strlen(evsel
->unit
);
3000 ev
= event_update_event__new(size
+ 1, PERF_EVENT_UPDATE__UNIT
, evsel
->id
[0]);
3004 strncpy(ev
->data
, evsel
->unit
, size
);
3005 err
= process(tool
, (union perf_event
*)ev
, NULL
, NULL
);
3011 perf_event__synthesize_event_update_scale(struct perf_tool
*tool
,
3012 struct perf_evsel
*evsel
,
3013 perf_event__handler_t process
)
3015 struct event_update_event
*ev
;
3016 struct event_update_event_scale
*ev_data
;
3019 ev
= event_update_event__new(sizeof(*ev_data
), PERF_EVENT_UPDATE__SCALE
, evsel
->id
[0]);
3023 ev_data
= (struct event_update_event_scale
*) ev
->data
;
3024 ev_data
->scale
= evsel
->scale
;
3025 err
= process(tool
, (union perf_event
*) ev
, NULL
, NULL
);
3031 perf_event__synthesize_event_update_name(struct perf_tool
*tool
,
3032 struct perf_evsel
*evsel
,
3033 perf_event__handler_t process
)
3035 struct event_update_event
*ev
;
3036 size_t len
= strlen(evsel
->name
);
3039 ev
= event_update_event__new(len
+ 1, PERF_EVENT_UPDATE__NAME
, evsel
->id
[0]);
3043 strncpy(ev
->data
, evsel
->name
, len
);
3044 err
= process(tool
, (union perf_event
*) ev
, NULL
, NULL
);
3050 perf_event__synthesize_event_update_cpus(struct perf_tool
*tool
,
3051 struct perf_evsel
*evsel
,
3052 perf_event__handler_t process
)
3054 size_t size
= sizeof(struct event_update_event
);
3055 struct event_update_event
*ev
;
3059 if (!evsel
->own_cpus
)
3062 ev
= cpu_map_data__alloc(evsel
->own_cpus
, &size
, &type
, &max
);
3066 ev
->header
.type
= PERF_RECORD_EVENT_UPDATE
;
3067 ev
->header
.size
= (u16
)size
;
3068 ev
->type
= PERF_EVENT_UPDATE__CPUS
;
3069 ev
->id
= evsel
->id
[0];
3071 cpu_map_data__synthesize((struct cpu_map_data
*) ev
->data
,
3075 err
= process(tool
, (union perf_event
*) ev
, NULL
, NULL
);
3080 size_t perf_event__fprintf_event_update(union perf_event
*event
, FILE *fp
)
3082 struct event_update_event
*ev
= &event
->event_update
;
3083 struct event_update_event_scale
*ev_scale
;
3084 struct event_update_event_cpus
*ev_cpus
;
3085 struct cpu_map
*map
;
3088 ret
= fprintf(fp
, "\n... id: %" PRIu64
"\n", ev
->id
);
3091 case PERF_EVENT_UPDATE__SCALE
:
3092 ev_scale
= (struct event_update_event_scale
*) ev
->data
;
3093 ret
+= fprintf(fp
, "... scale: %f\n", ev_scale
->scale
);
3095 case PERF_EVENT_UPDATE__UNIT
:
3096 ret
+= fprintf(fp
, "... unit: %s\n", ev
->data
);
3098 case PERF_EVENT_UPDATE__NAME
:
3099 ret
+= fprintf(fp
, "... name: %s\n", ev
->data
);
3101 case PERF_EVENT_UPDATE__CPUS
:
3102 ev_cpus
= (struct event_update_event_cpus
*) ev
->data
;
3103 ret
+= fprintf(fp
, "... ");
3105 map
= cpu_map__new_data(&ev_cpus
->cpus
);
3107 ret
+= cpu_map__fprintf(map
, fp
);
3109 ret
+= fprintf(fp
, "failed to get cpus\n");
3112 ret
+= fprintf(fp
, "... unknown type\n");
3119 int perf_event__synthesize_attrs(struct perf_tool
*tool
,
3120 struct perf_session
*session
,
3121 perf_event__handler_t process
)
3123 struct perf_evsel
*evsel
;
3126 evlist__for_each(session
->evlist
, evsel
) {
3127 err
= perf_event__synthesize_attr(tool
, &evsel
->attr
, evsel
->ids
,
3128 evsel
->id
, process
);
3130 pr_debug("failed to create perf header attribute\n");
3138 int perf_event__process_attr(struct perf_tool
*tool __maybe_unused
,
3139 union perf_event
*event
,
3140 struct perf_evlist
**pevlist
)
3143 struct perf_evsel
*evsel
;
3144 struct perf_evlist
*evlist
= *pevlist
;
3146 if (evlist
== NULL
) {
3147 *pevlist
= evlist
= perf_evlist__new();
3152 evsel
= perf_evsel__new(&event
->attr
.attr
);
3156 perf_evlist__add(evlist
, evsel
);
3158 ids
= event
->header
.size
;
3159 ids
-= (void *)&event
->attr
.id
- (void *)event
;
3160 n_ids
= ids
/ sizeof(u64
);
3162 * We don't have the cpu and thread maps on the header, so
3163 * for allocating the perf_sample_id table we fake 1 cpu and
3164 * hattr->ids threads.
3166 if (perf_evsel__alloc_id(evsel
, 1, n_ids
))
3169 for (i
= 0; i
< n_ids
; i
++) {
3170 perf_evlist__id_add(evlist
, evsel
, 0, i
, event
->attr
.id
[i
]);
3173 symbol_conf
.nr_events
= evlist
->nr_entries
;
3178 int perf_event__process_event_update(struct perf_tool
*tool __maybe_unused
,
3179 union perf_event
*event
,
3180 struct perf_evlist
**pevlist
)
3182 struct event_update_event
*ev
= &event
->event_update
;
3183 struct event_update_event_scale
*ev_scale
;
3184 struct event_update_event_cpus
*ev_cpus
;
3185 struct perf_evlist
*evlist
;
3186 struct perf_evsel
*evsel
;
3187 struct cpu_map
*map
;
3189 if (!pevlist
|| *pevlist
== NULL
)
3194 evsel
= perf_evlist__id2evsel(evlist
, ev
->id
);
3199 case PERF_EVENT_UPDATE__UNIT
:
3200 evsel
->unit
= strdup(ev
->data
);
3202 case PERF_EVENT_UPDATE__NAME
:
3203 evsel
->name
= strdup(ev
->data
);
3205 case PERF_EVENT_UPDATE__SCALE
:
3206 ev_scale
= (struct event_update_event_scale
*) ev
->data
;
3207 evsel
->scale
= ev_scale
->scale
;
3208 case PERF_EVENT_UPDATE__CPUS
:
3209 ev_cpus
= (struct event_update_event_cpus
*) ev
->data
;
3211 map
= cpu_map__new_data(&ev_cpus
->cpus
);
3213 evsel
->own_cpus
= map
;
3215 pr_err("failed to get event_update cpus\n");
3223 int perf_event__synthesize_tracing_data(struct perf_tool
*tool
, int fd
,
3224 struct perf_evlist
*evlist
,
3225 perf_event__handler_t process
)
3227 union perf_event ev
;
3228 struct tracing_data
*tdata
;
3229 ssize_t size
= 0, aligned_size
= 0, padding
;
3230 int err __maybe_unused
= 0;
3233 * We are going to store the size of the data followed
3234 * by the data contents. Since the fd descriptor is a pipe,
3235 * we cannot seek back to store the size of the data once
3236 * we know it. Instead we:
3238 * - write the tracing data to the temp file
3239 * - get/write the data size to pipe
3240 * - write the tracing data from the temp file
3243 tdata
= tracing_data_get(&evlist
->entries
, fd
, true);
3247 memset(&ev
, 0, sizeof(ev
));
3249 ev
.tracing_data
.header
.type
= PERF_RECORD_HEADER_TRACING_DATA
;
3251 aligned_size
= PERF_ALIGN(size
, sizeof(u64
));
3252 padding
= aligned_size
- size
;
3253 ev
.tracing_data
.header
.size
= sizeof(ev
.tracing_data
);
3254 ev
.tracing_data
.size
= aligned_size
;
3256 process(tool
, &ev
, NULL
, NULL
);
3259 * The put function will copy all the tracing data
3260 * stored in temp file to the pipe.
3262 tracing_data_put(tdata
);
3264 write_padded(fd
, NULL
, 0, padding
);
3266 return aligned_size
;
3269 int perf_event__process_tracing_data(struct perf_tool
*tool __maybe_unused
,
3270 union perf_event
*event
,
3271 struct perf_session
*session
)
3273 ssize_t size_read
, padding
, size
= event
->tracing_data
.size
;
3274 int fd
= perf_data_file__fd(session
->file
);
3275 off_t offset
= lseek(fd
, 0, SEEK_CUR
);
3278 /* setup for reading amidst mmap */
3279 lseek(fd
, offset
+ sizeof(struct tracing_data_event
),
3282 size_read
= trace_report(fd
, &session
->tevent
,
3284 padding
= PERF_ALIGN(size_read
, sizeof(u64
)) - size_read
;
3286 if (readn(fd
, buf
, padding
) < 0) {
3287 pr_err("%s: reading input file", __func__
);
3290 if (session
->repipe
) {
3291 int retw
= write(STDOUT_FILENO
, buf
, padding
);
3292 if (retw
<= 0 || retw
!= padding
) {
3293 pr_err("%s: repiping tracing data padding", __func__
);
3298 if (size_read
+ padding
!= size
) {
3299 pr_err("%s: tracing data size mismatch", __func__
);
3303 perf_evlist__prepare_tracepoint_events(session
->evlist
,
3304 session
->tevent
.pevent
);
3306 return size_read
+ padding
;
3309 int perf_event__synthesize_build_id(struct perf_tool
*tool
,
3310 struct dso
*pos
, u16 misc
,
3311 perf_event__handler_t process
,
3312 struct machine
*machine
)
3314 union perf_event ev
;
3321 memset(&ev
, 0, sizeof(ev
));
3323 len
= pos
->long_name_len
+ 1;
3324 len
= PERF_ALIGN(len
, NAME_ALIGN
);
3325 memcpy(&ev
.build_id
.build_id
, pos
->build_id
, sizeof(pos
->build_id
));
3326 ev
.build_id
.header
.type
= PERF_RECORD_HEADER_BUILD_ID
;
3327 ev
.build_id
.header
.misc
= misc
;
3328 ev
.build_id
.pid
= machine
->pid
;
3329 ev
.build_id
.header
.size
= sizeof(ev
.build_id
) + len
;
3330 memcpy(&ev
.build_id
.filename
, pos
->long_name
, pos
->long_name_len
);
3332 err
= process(tool
, &ev
, NULL
, machine
);
3337 int perf_event__process_build_id(struct perf_tool
*tool __maybe_unused
,
3338 union perf_event
*event
,
3339 struct perf_session
*session
)
3341 __event_process_build_id(&event
->build_id
,
3342 event
->build_id
.filename
,