Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[~shefty/rdma-dev.git] / tools / perf / util / header.c
1 #define _FILE_OFFSET_BITS 64
2
3 #include "util.h"
4 #include <sys/types.h>
5 #include <byteswap.h>
6 #include <unistd.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <linux/list.h>
10 #include <linux/kernel.h>
11 #include <sys/utsname.h>
12
13 #include "evlist.h"
14 #include "evsel.h"
15 #include "header.h"
16 #include "../perf.h"
17 #include "trace-event.h"
18 #include "session.h"
19 #include "symbol.h"
20 #include "debug.h"
21 #include "cpumap.h"
22
23 static bool no_buildid_cache = false;
24
25 static int event_count;
26 static struct perf_trace_event_type *events;
27
28 static u32 header_argc;
29 static const char **header_argv;
30
31 static int dsos__write_buildid_table(struct perf_header *header, int fd);
32 static int perf_session__cache_build_ids(struct perf_session *session);
33
34 int perf_header__push_event(u64 id, const char *name)
35 {
36         if (strlen(name) > MAX_EVENT_NAME)
37                 pr_warning("Event %s will be truncated\n", name);
38
39         if (!events) {
40                 events = malloc(sizeof(struct perf_trace_event_type));
41                 if (events == NULL)
42                         return -ENOMEM;
43         } else {
44                 struct perf_trace_event_type *nevents;
45
46                 nevents = realloc(events, (event_count + 1) * sizeof(*events));
47                 if (nevents == NULL)
48                         return -ENOMEM;
49                 events = nevents;
50         }
51         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
52         events[event_count].event_id = id;
53         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
54         event_count++;
55         return 0;
56 }
57
58 char *perf_header__find_event(u64 id)
59 {
60         int i;
61         for (i = 0 ; i < event_count; i++) {
62                 if (events[i].event_id == id)
63                         return events[i].name;
64         }
65         return NULL;
66 }
67
68 static const char *__perf_magic = "PERFFILE";
69
70 #define PERF_MAGIC      (*(u64 *)__perf_magic)
71
72 struct perf_file_attr {
73         struct perf_event_attr  attr;
74         struct perf_file_section        ids;
75 };
76
77 void perf_header__set_feat(struct perf_header *header, int feat)
78 {
79         set_bit(feat, header->adds_features);
80 }
81
82 void perf_header__clear_feat(struct perf_header *header, int feat)
83 {
84         clear_bit(feat, header->adds_features);
85 }
86
87 bool perf_header__has_feat(const struct perf_header *header, int feat)
88 {
89         return test_bit(feat, header->adds_features);
90 }
91
92 static int do_write(int fd, const void *buf, size_t size)
93 {
94         while (size) {
95                 int ret = write(fd, buf, size);
96
97                 if (ret < 0)
98                         return -errno;
99
100                 size -= ret;
101                 buf += ret;
102         }
103
104         return 0;
105 }
106
107 #define NAME_ALIGN 64
108
109 static int write_padded(int fd, const void *bf, size_t count,
110                         size_t count_aligned)
111 {
112         static const char zero_buf[NAME_ALIGN];
113         int err = do_write(fd, bf, count);
114
115         if (!err)
116                 err = do_write(fd, zero_buf, count_aligned - count);
117
118         return err;
119 }
120
121 static int do_write_string(int fd, const char *str)
122 {
123         u32 len, olen;
124         int ret;
125
126         olen = strlen(str) + 1;
127         len = ALIGN(olen, NAME_ALIGN);
128
129         /* write len, incl. \0 */
130         ret = do_write(fd, &len, sizeof(len));
131         if (ret < 0)
132                 return ret;
133
134         return write_padded(fd, str, olen, len);
135 }
136
137 static char *do_read_string(int fd, struct perf_header *ph)
138 {
139         ssize_t sz, ret;
140         u32 len;
141         char *buf;
142
143         sz = read(fd, &len, sizeof(len));
144         if (sz < (ssize_t)sizeof(len))
145                 return NULL;
146
147         if (ph->needs_swap)
148                 len = bswap_32(len);
149
150         buf = malloc(len);
151         if (!buf)
152                 return NULL;
153
154         ret = read(fd, buf, len);
155         if (ret == (ssize_t)len) {
156                 /*
157                  * strings are padded by zeroes
158                  * thus the actual strlen of buf
159                  * may be less than len
160                  */
161                 return buf;
162         }
163
164         free(buf);
165         return NULL;
166 }
167
168 int
169 perf_header__set_cmdline(int argc, const char **argv)
170 {
171         int i;
172
173         header_argc = (u32)argc;
174
175         /* do not include NULL termination */
176         header_argv = calloc(argc, sizeof(char *));
177         if (!header_argv)
178                 return -ENOMEM;
179
180         /*
181          * must copy argv contents because it gets moved
182          * around during option parsing
183          */
184         for (i = 0; i < argc ; i++)
185                 header_argv[i] = argv[i];
186
187         return 0;
188 }
189
190 static int write_trace_info(int fd, struct perf_header *h __used,
191                             struct perf_evlist *evlist)
192 {
193         return read_tracing_data(fd, &evlist->entries);
194 }
195
196
197 static int write_build_id(int fd, struct perf_header *h,
198                           struct perf_evlist *evlist __used)
199 {
200         struct perf_session *session;
201         int err;
202
203         session = container_of(h, struct perf_session, header);
204
205         err = dsos__write_buildid_table(h, fd);
206         if (err < 0) {
207                 pr_debug("failed to write buildid table\n");
208                 return err;
209         }
210         if (!no_buildid_cache)
211                 perf_session__cache_build_ids(session);
212
213         return 0;
214 }
215
216 static int write_hostname(int fd, struct perf_header *h __used,
217                           struct perf_evlist *evlist __used)
218 {
219         struct utsname uts;
220         int ret;
221
222         ret = uname(&uts);
223         if (ret < 0)
224                 return -1;
225
226         return do_write_string(fd, uts.nodename);
227 }
228
229 static int write_osrelease(int fd, struct perf_header *h __used,
230                            struct perf_evlist *evlist __used)
231 {
232         struct utsname uts;
233         int ret;
234
235         ret = uname(&uts);
236         if (ret < 0)
237                 return -1;
238
239         return do_write_string(fd, uts.release);
240 }
241
242 static int write_arch(int fd, struct perf_header *h __used,
243                       struct perf_evlist *evlist __used)
244 {
245         struct utsname uts;
246         int ret;
247
248         ret = uname(&uts);
249         if (ret < 0)
250                 return -1;
251
252         return do_write_string(fd, uts.machine);
253 }
254
255 static int write_version(int fd, struct perf_header *h __used,
256                          struct perf_evlist *evlist __used)
257 {
258         return do_write_string(fd, perf_version_string);
259 }
260
261 static int write_cpudesc(int fd, struct perf_header *h __used,
262                        struct perf_evlist *evlist __used)
263 {
264 #ifndef CPUINFO_PROC
265 #define CPUINFO_PROC NULL
266 #endif
267         FILE *file;
268         char *buf = NULL;
269         char *s, *p;
270         const char *search = CPUINFO_PROC;
271         size_t len = 0;
272         int ret = -1;
273
274         if (!search)
275                 return -1;
276
277         file = fopen("/proc/cpuinfo", "r");
278         if (!file)
279                 return -1;
280
281         while (getline(&buf, &len, file) > 0) {
282                 ret = strncmp(buf, search, strlen(search));
283                 if (!ret)
284                         break;
285         }
286
287         if (ret)
288                 goto done;
289
290         s = buf;
291
292         p = strchr(buf, ':');
293         if (p && *(p+1) == ' ' && *(p+2))
294                 s = p + 2;
295         p = strchr(s, '\n');
296         if (p)
297                 *p = '\0';
298
299         /* squash extra space characters (branding string) */
300         p = s;
301         while (*p) {
302                 if (isspace(*p)) {
303                         char *r = p + 1;
304                         char *q = r;
305                         *p = ' ';
306                         while (*q && isspace(*q))
307                                 q++;
308                         if (q != (p+1))
309                                 while ((*r++ = *q++));
310                 }
311                 p++;
312         }
313         ret = do_write_string(fd, s);
314 done:
315         free(buf);
316         fclose(file);
317         return ret;
318 }
319
320 static int write_nrcpus(int fd, struct perf_header *h __used,
321                         struct perf_evlist *evlist __used)
322 {
323         long nr;
324         u32 nrc, nra;
325         int ret;
326
327         nr = sysconf(_SC_NPROCESSORS_CONF);
328         if (nr < 0)
329                 return -1;
330
331         nrc = (u32)(nr & UINT_MAX);
332
333         nr = sysconf(_SC_NPROCESSORS_ONLN);
334         if (nr < 0)
335                 return -1;
336
337         nra = (u32)(nr & UINT_MAX);
338
339         ret = do_write(fd, &nrc, sizeof(nrc));
340         if (ret < 0)
341                 return ret;
342
343         return do_write(fd, &nra, sizeof(nra));
344 }
345
346 static int write_event_desc(int fd, struct perf_header *h __used,
347                             struct perf_evlist *evlist)
348 {
349         struct perf_evsel *attr;
350         u32 nre = 0, nri, sz;
351         int ret;
352
353         list_for_each_entry(attr, &evlist->entries, node)
354                 nre++;
355
356         /*
357          * write number of events
358          */
359         ret = do_write(fd, &nre, sizeof(nre));
360         if (ret < 0)
361                 return ret;
362
363         /*
364          * size of perf_event_attr struct
365          */
366         sz = (u32)sizeof(attr->attr);
367         ret = do_write(fd, &sz, sizeof(sz));
368         if (ret < 0)
369                 return ret;
370
371         list_for_each_entry(attr, &evlist->entries, node) {
372
373                 ret = do_write(fd, &attr->attr, sz);
374                 if (ret < 0)
375                         return ret;
376                 /*
377                  * write number of unique id per event
378                  * there is one id per instance of an event
379                  *
380                  * copy into an nri to be independent of the
381                  * type of ids,
382                  */
383                 nri = attr->ids;
384                 ret = do_write(fd, &nri, sizeof(nri));
385                 if (ret < 0)
386                         return ret;
387
388                 /*
389                  * write event string as passed on cmdline
390                  */
391                 ret = do_write_string(fd, attr->name);
392                 if (ret < 0)
393                         return ret;
394                 /*
395                  * write unique ids for this event
396                  */
397                 ret = do_write(fd, attr->id, attr->ids * sizeof(u64));
398                 if (ret < 0)
399                         return ret;
400         }
401         return 0;
402 }
403
404 static int write_cmdline(int fd, struct perf_header *h __used,
405                          struct perf_evlist *evlist __used)
406 {
407         char buf[MAXPATHLEN];
408         char proc[32];
409         u32 i, n;
410         int ret;
411
412         /*
413          * actual atual path to perf binary
414          */
415         sprintf(proc, "/proc/%d/exe", getpid());
416         ret = readlink(proc, buf, sizeof(buf));
417         if (ret <= 0)
418                 return -1;
419
420         /* readlink() does not add null termination */
421         buf[ret] = '\0';
422
423         /* account for binary path */
424         n = header_argc + 1;
425
426         ret = do_write(fd, &n, sizeof(n));
427         if (ret < 0)
428                 return ret;
429
430         ret = do_write_string(fd, buf);
431         if (ret < 0)
432                 return ret;
433
434         for (i = 0 ; i < header_argc; i++) {
435                 ret = do_write_string(fd, header_argv[i]);
436                 if (ret < 0)
437                         return ret;
438         }
439         return 0;
440 }
441
442 #define CORE_SIB_FMT \
443         "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
444 #define THRD_SIB_FMT \
445         "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
446
447 struct cpu_topo {
448         u32 core_sib;
449         u32 thread_sib;
450         char **core_siblings;
451         char **thread_siblings;
452 };
453
454 static int build_cpu_topo(struct cpu_topo *tp, int cpu)
455 {
456         FILE *fp;
457         char filename[MAXPATHLEN];
458         char *buf = NULL, *p;
459         size_t len = 0;
460         u32 i = 0;
461         int ret = -1;
462
463         sprintf(filename, CORE_SIB_FMT, cpu);
464         fp = fopen(filename, "r");
465         if (!fp)
466                 return -1;
467
468         if (getline(&buf, &len, fp) <= 0)
469                 goto done;
470
471         fclose(fp);
472
473         p = strchr(buf, '\n');
474         if (p)
475                 *p = '\0';
476
477         for (i = 0; i < tp->core_sib; i++) {
478                 if (!strcmp(buf, tp->core_siblings[i]))
479                         break;
480         }
481         if (i == tp->core_sib) {
482                 tp->core_siblings[i] = buf;
483                 tp->core_sib++;
484                 buf = NULL;
485                 len = 0;
486         }
487
488         sprintf(filename, THRD_SIB_FMT, cpu);
489         fp = fopen(filename, "r");
490         if (!fp)
491                 goto done;
492
493         if (getline(&buf, &len, fp) <= 0)
494                 goto done;
495
496         p = strchr(buf, '\n');
497         if (p)
498                 *p = '\0';
499
500         for (i = 0; i < tp->thread_sib; i++) {
501                 if (!strcmp(buf, tp->thread_siblings[i]))
502                         break;
503         }
504         if (i == tp->thread_sib) {
505                 tp->thread_siblings[i] = buf;
506                 tp->thread_sib++;
507                 buf = NULL;
508         }
509         ret = 0;
510 done:
511         if(fp)
512                 fclose(fp);
513         free(buf);
514         return ret;
515 }
516
517 static void free_cpu_topo(struct cpu_topo *tp)
518 {
519         u32 i;
520
521         if (!tp)
522                 return;
523
524         for (i = 0 ; i < tp->core_sib; i++)
525                 free(tp->core_siblings[i]);
526
527         for (i = 0 ; i < tp->thread_sib; i++)
528                 free(tp->thread_siblings[i]);
529
530         free(tp);
531 }
532
533 static struct cpu_topo *build_cpu_topology(void)
534 {
535         struct cpu_topo *tp;
536         void *addr;
537         u32 nr, i;
538         size_t sz;
539         long ncpus;
540         int ret = -1;
541
542         ncpus = sysconf(_SC_NPROCESSORS_CONF);
543         if (ncpus < 0)
544                 return NULL;
545
546         nr = (u32)(ncpus & UINT_MAX);
547
548         sz = nr * sizeof(char *);
549
550         addr = calloc(1, sizeof(*tp) + 2 * sz);
551         if (!addr)
552                 return NULL;
553
554         tp = addr;
555
556         addr += sizeof(*tp);
557         tp->core_siblings = addr;
558         addr += sz;
559         tp->thread_siblings = addr;
560
561         for (i = 0; i < nr; i++) {
562                 ret = build_cpu_topo(tp, i);
563                 if (ret < 0)
564                         break;
565         }
566         if (ret) {
567                 free_cpu_topo(tp);
568                 tp = NULL;
569         }
570         return tp;
571 }
572
573 static int write_cpu_topology(int fd, struct perf_header *h __used,
574                           struct perf_evlist *evlist __used)
575 {
576         struct cpu_topo *tp;
577         u32 i;
578         int ret;
579
580         tp = build_cpu_topology();
581         if (!tp)
582                 return -1;
583
584         ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
585         if (ret < 0)
586                 goto done;
587
588         for (i = 0; i < tp->core_sib; i++) {
589                 ret = do_write_string(fd, tp->core_siblings[i]);
590                 if (ret < 0)
591                         goto done;
592         }
593         ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
594         if (ret < 0)
595                 goto done;
596
597         for (i = 0; i < tp->thread_sib; i++) {
598                 ret = do_write_string(fd, tp->thread_siblings[i]);
599                 if (ret < 0)
600                         break;
601         }
602 done:
603         free_cpu_topo(tp);
604         return ret;
605 }
606
607
608
609 static int write_total_mem(int fd, struct perf_header *h __used,
610                           struct perf_evlist *evlist __used)
611 {
612         char *buf = NULL;
613         FILE *fp;
614         size_t len = 0;
615         int ret = -1, n;
616         uint64_t mem;
617
618         fp = fopen("/proc/meminfo", "r");
619         if (!fp)
620                 return -1;
621
622         while (getline(&buf, &len, fp) > 0) {
623                 ret = strncmp(buf, "MemTotal:", 9);
624                 if (!ret)
625                         break;
626         }
627         if (!ret) {
628                 n = sscanf(buf, "%*s %"PRIu64, &mem);
629                 if (n == 1)
630                         ret = do_write(fd, &mem, sizeof(mem));
631         }
632         free(buf);
633         fclose(fp);
634         return ret;
635 }
636
637 static int write_topo_node(int fd, int node)
638 {
639         char str[MAXPATHLEN];
640         char field[32];
641         char *buf = NULL, *p;
642         size_t len = 0;
643         FILE *fp;
644         u64 mem_total, mem_free, mem;
645         int ret = -1;
646
647         sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
648         fp = fopen(str, "r");
649         if (!fp)
650                 return -1;
651
652         while (getline(&buf, &len, fp) > 0) {
653                 /* skip over invalid lines */
654                 if (!strchr(buf, ':'))
655                         continue;
656                 if (sscanf(buf, "%*s %*d %s %"PRIu64, field, &mem) != 2)
657                         goto done;
658                 if (!strcmp(field, "MemTotal:"))
659                         mem_total = mem;
660                 if (!strcmp(field, "MemFree:"))
661                         mem_free = mem;
662         }
663
664         fclose(fp);
665
666         ret = do_write(fd, &mem_total, sizeof(u64));
667         if (ret)
668                 goto done;
669
670         ret = do_write(fd, &mem_free, sizeof(u64));
671         if (ret)
672                 goto done;
673
674         ret = -1;
675         sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
676
677         fp = fopen(str, "r");
678         if (!fp)
679                 goto done;
680
681         if (getline(&buf, &len, fp) <= 0)
682                 goto done;
683
684         p = strchr(buf, '\n');
685         if (p)
686                 *p = '\0';
687
688         ret = do_write_string(fd, buf);
689 done:
690         free(buf);
691         fclose(fp);
692         return ret;
693 }
694
695 static int write_numa_topology(int fd, struct perf_header *h __used,
696                           struct perf_evlist *evlist __used)
697 {
698         char *buf = NULL;
699         size_t len = 0;
700         FILE *fp;
701         struct cpu_map *node_map = NULL;
702         char *c;
703         u32 nr, i, j;
704         int ret = -1;
705
706         fp = fopen("/sys/devices/system/node/online", "r");
707         if (!fp)
708                 return -1;
709
710         if (getline(&buf, &len, fp) <= 0)
711                 goto done;
712
713         c = strchr(buf, '\n');
714         if (c)
715                 *c = '\0';
716
717         node_map = cpu_map__new(buf);
718         if (!node_map)
719                 goto done;
720
721         nr = (u32)node_map->nr;
722
723         ret = do_write(fd, &nr, sizeof(nr));
724         if (ret < 0)
725                 goto done;
726
727         for (i = 0; i < nr; i++) {
728                 j = (u32)node_map->map[i];
729                 ret = do_write(fd, &j, sizeof(j));
730                 if (ret < 0)
731                         break;
732
733                 ret = write_topo_node(fd, i);
734                 if (ret < 0)
735                         break;
736         }
737 done:
738         free(buf);
739         fclose(fp);
740         free(node_map);
741         return ret;
742 }
743
744 /*
745  * default get_cpuid(): nothing gets recorded
746  * actual implementation must be in arch/$(ARCH)/util/header.c
747  */
748 int __attribute__((weak)) get_cpuid(char *buffer __used, size_t sz __used)
749 {
750         return -1;
751 }
752
753 static int write_cpuid(int fd, struct perf_header *h __used,
754                        struct perf_evlist *evlist __used)
755 {
756         char buffer[64];
757         int ret;
758
759         ret = get_cpuid(buffer, sizeof(buffer));
760         if (!ret)
761                 goto write_it;
762
763         return -1;
764 write_it:
765         return do_write_string(fd, buffer);
766 }
767
768 static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
769 {
770         char *str = do_read_string(fd, ph);
771         fprintf(fp, "# hostname : %s\n", str);
772         free(str);
773 }
774
775 static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
776 {
777         char *str = do_read_string(fd, ph);
778         fprintf(fp, "# os release : %s\n", str);
779         free(str);
780 }
781
782 static void print_arch(struct perf_header *ph, int fd, FILE *fp)
783 {
784         char *str = do_read_string(fd, ph);
785         fprintf(fp, "# arch : %s\n", str);
786         free(str);
787 }
788
789 static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
790 {
791         char *str = do_read_string(fd, ph);
792         fprintf(fp, "# cpudesc : %s\n", str);
793         free(str);
794 }
795
796 static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
797 {
798         ssize_t ret;
799         u32 nr;
800
801         ret = read(fd, &nr, sizeof(nr));
802         if (ret != (ssize_t)sizeof(nr))
803                 nr = -1; /* interpreted as error */
804
805         if (ph->needs_swap)
806                 nr = bswap_32(nr);
807
808         fprintf(fp, "# nrcpus online : %u\n", nr);
809
810         ret = read(fd, &nr, sizeof(nr));
811         if (ret != (ssize_t)sizeof(nr))
812                 nr = -1; /* interpreted as error */
813
814         if (ph->needs_swap)
815                 nr = bswap_32(nr);
816
817         fprintf(fp, "# nrcpus avail : %u\n", nr);
818 }
819
820 static void print_version(struct perf_header *ph, int fd, FILE *fp)
821 {
822         char *str = do_read_string(fd, ph);
823         fprintf(fp, "# perf version : %s\n", str);
824         free(str);
825 }
826
827 static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
828 {
829         ssize_t ret;
830         char *str;
831         u32 nr, i;
832
833         ret = read(fd, &nr, sizeof(nr));
834         if (ret != (ssize_t)sizeof(nr))
835                 return;
836
837         if (ph->needs_swap)
838                 nr = bswap_32(nr);
839
840         fprintf(fp, "# cmdline : ");
841
842         for (i = 0; i < nr; i++) {
843                 str = do_read_string(fd, ph);
844                 fprintf(fp, "%s ", str);
845                 free(str);
846         }
847         fputc('\n', fp);
848 }
849
850 static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
851 {
852         ssize_t ret;
853         u32 nr, i;
854         char *str;
855
856         ret = read(fd, &nr, sizeof(nr));
857         if (ret != (ssize_t)sizeof(nr))
858                 return;
859
860         if (ph->needs_swap)
861                 nr = bswap_32(nr);
862
863         for (i = 0; i < nr; i++) {
864                 str = do_read_string(fd, ph);
865                 fprintf(fp, "# sibling cores   : %s\n", str);
866                 free(str);
867         }
868
869         ret = read(fd, &nr, sizeof(nr));
870         if (ret != (ssize_t)sizeof(nr))
871                 return;
872
873         if (ph->needs_swap)
874                 nr = bswap_32(nr);
875
876         for (i = 0; i < nr; i++) {
877                 str = do_read_string(fd, ph);
878                 fprintf(fp, "# sibling threads : %s\n", str);
879                 free(str);
880         }
881 }
882
883 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
884 {
885         struct perf_event_attr attr;
886         uint64_t id;
887         void *buf = NULL;
888         char *str;
889         u32 nre, sz, nr, i, j, msz;
890         int ret;
891
892         /* number of events */
893         ret = read(fd, &nre, sizeof(nre));
894         if (ret != (ssize_t)sizeof(nre))
895                 goto error;
896
897         if (ph->needs_swap)
898                 nre = bswap_32(nre);
899
900         ret = read(fd, &sz, sizeof(sz));
901         if (ret != (ssize_t)sizeof(sz))
902                 goto error;
903
904         if (ph->needs_swap)
905                 sz = bswap_32(sz);
906
907         /*
908          * ensure it is at least to our ABI rev
909          */
910         if (sz < (u32)sizeof(attr))
911                 goto error;
912
913         memset(&attr, 0, sizeof(attr));
914
915         /* read entire region to sync up to next field */
916         buf = malloc(sz);
917         if (!buf)
918                 goto error;
919
920         msz = sizeof(attr);
921         if (sz < msz)
922                 msz = sz;
923
924         for (i = 0 ; i < nre; i++) {
925
926                 ret = read(fd, buf, sz);
927                 if (ret != (ssize_t)sz)
928                         goto error;
929
930                 if (ph->needs_swap)
931                         perf_event__attr_swap(buf);
932
933                 memcpy(&attr, buf, msz);
934
935                 ret = read(fd, &nr, sizeof(nr));
936                 if (ret != (ssize_t)sizeof(nr))
937                         goto error;
938
939                 if (ph->needs_swap)
940                         nr = bswap_32(nr);
941
942                 str = do_read_string(fd, ph);
943                 fprintf(fp, "# event : name = %s, ", str);
944                 free(str);
945
946                 fprintf(fp, "type = %d, config = 0x%"PRIx64
947                             ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
948                                 attr.type,
949                                 (u64)attr.config,
950                                 (u64)attr.config1,
951                                 (u64)attr.config2);
952
953                 fprintf(fp, ", excl_usr = %d, excl_kern = %d",
954                                 attr.exclude_user,
955                                 attr.exclude_kernel);
956
957                 if (nr)
958                         fprintf(fp, ", id = {");
959
960                 for (j = 0 ; j < nr; j++) {
961                         ret = read(fd, &id, sizeof(id));
962                         if (ret != (ssize_t)sizeof(id))
963                                 goto error;
964
965                         if (ph->needs_swap)
966                                 id = bswap_64(id);
967
968                         if (j)
969                                 fputc(',', fp);
970
971                         fprintf(fp, " %"PRIu64, id);
972                 }
973                 if (nr && j == nr)
974                         fprintf(fp, " }");
975                 fputc('\n', fp);
976         }
977         free(buf);
978         return;
979 error:
980         fprintf(fp, "# event desc: not available or unable to read\n");
981 }
982
983 static void print_total_mem(struct perf_header *h __used, int fd, FILE *fp)
984 {
985         uint64_t mem;
986         ssize_t ret;
987
988         ret = read(fd, &mem, sizeof(mem));
989         if (ret != sizeof(mem))
990                 goto error;
991
992         if (h->needs_swap)
993                 mem = bswap_64(mem);
994
995         fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
996         return;
997 error:
998         fprintf(fp, "# total memory : unknown\n");
999 }
1000
1001 static void print_numa_topology(struct perf_header *h __used, int fd, FILE *fp)
1002 {
1003         ssize_t ret;
1004         u32 nr, c, i;
1005         char *str;
1006         uint64_t mem_total, mem_free;
1007
1008         /* nr nodes */
1009         ret = read(fd, &nr, sizeof(nr));
1010         if (ret != (ssize_t)sizeof(nr))
1011                 goto error;
1012
1013         if (h->needs_swap)
1014                 nr = bswap_32(nr);
1015
1016         for (i = 0; i < nr; i++) {
1017
1018                 /* node number */
1019                 ret = read(fd, &c, sizeof(c));
1020                 if (ret != (ssize_t)sizeof(c))
1021                         goto error;
1022
1023                 if (h->needs_swap)
1024                         c = bswap_32(c);
1025
1026                 ret = read(fd, &mem_total, sizeof(u64));
1027                 if (ret != sizeof(u64))
1028                         goto error;
1029
1030                 ret = read(fd, &mem_free, sizeof(u64));
1031                 if (ret != sizeof(u64))
1032                         goto error;
1033
1034                 if (h->needs_swap) {
1035                         mem_total = bswap_64(mem_total);
1036                         mem_free = bswap_64(mem_free);
1037                 }
1038
1039                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
1040                             " free = %"PRIu64" kB\n",
1041                         c,
1042                         mem_total,
1043                         mem_free);
1044
1045                 str = do_read_string(fd, h);
1046                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
1047                 free(str);
1048         }
1049         return;
1050 error:
1051         fprintf(fp, "# numa topology : not available\n");
1052 }
1053
1054 static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
1055 {
1056         char *str = do_read_string(fd, ph);
1057         fprintf(fp, "# cpuid : %s\n", str);
1058         free(str);
1059 }
1060
1061 struct feature_ops {
1062         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
1063         void (*print)(struct perf_header *h, int fd, FILE *fp);
1064         const char *name;
1065         bool full_only;
1066 };
1067
1068 #define FEAT_OPA(n, w, p) \
1069         [n] = { .name = #n, .write = w, .print = p }
1070 #define FEAT_OPF(n, w, p) \
1071         [n] = { .name = #n, .write = w, .print = p, .full_only = true }
1072
1073 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
1074         FEAT_OPA(HEADER_TRACE_INFO, write_trace_info, NULL),
1075         FEAT_OPA(HEADER_BUILD_ID, write_build_id, NULL),
1076         FEAT_OPA(HEADER_HOSTNAME, write_hostname, print_hostname),
1077         FEAT_OPA(HEADER_OSRELEASE, write_osrelease, print_osrelease),
1078         FEAT_OPA(HEADER_VERSION, write_version, print_version),
1079         FEAT_OPA(HEADER_ARCH, write_arch, print_arch),
1080         FEAT_OPA(HEADER_NRCPUS, write_nrcpus, print_nrcpus),
1081         FEAT_OPA(HEADER_CPUDESC, write_cpudesc, print_cpudesc),
1082         FEAT_OPA(HEADER_CPUID, write_cpuid, print_cpuid),
1083         FEAT_OPA(HEADER_TOTAL_MEM, write_total_mem, print_total_mem),
1084         FEAT_OPA(HEADER_EVENT_DESC, write_event_desc, print_event_desc),
1085         FEAT_OPA(HEADER_CMDLINE, write_cmdline, print_cmdline),
1086         FEAT_OPF(HEADER_CPU_TOPOLOGY, write_cpu_topology, print_cpu_topology),
1087         FEAT_OPF(HEADER_NUMA_TOPOLOGY, write_numa_topology, print_numa_topology),
1088 };
1089
1090 struct header_print_data {
1091         FILE *fp;
1092         bool full; /* extended list of headers */
1093 };
1094
1095 static int perf_file_section__fprintf_info(struct perf_file_section *section,
1096                                            struct perf_header *ph,
1097                                            int feat, int fd, void *data)
1098 {
1099         struct header_print_data *hd = data;
1100
1101         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
1102                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
1103                                 "%d, continuing...\n", section->offset, feat);
1104                 return 0;
1105         }
1106         if (feat < HEADER_TRACE_INFO || feat >= HEADER_LAST_FEATURE) {
1107                 pr_warning("unknown feature %d\n", feat);
1108                 return -1;
1109         }
1110         if (!feat_ops[feat].print)
1111                 return 0;
1112
1113         if (!feat_ops[feat].full_only || hd->full)
1114                 feat_ops[feat].print(ph, fd, hd->fp);
1115         else
1116                 fprintf(hd->fp, "# %s info available, use -I to display\n",
1117                         feat_ops[feat].name);
1118
1119         return 0;
1120 }
1121
1122 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
1123 {
1124         struct header_print_data hd;
1125         struct perf_header *header = &session->header;
1126         int fd = session->fd;
1127         hd.fp = fp;
1128         hd.full = full;
1129
1130         perf_header__process_sections(header, fd, &hd,
1131                                       perf_file_section__fprintf_info);
1132         return 0;
1133 }
1134
1135 #define dsos__for_each_with_build_id(pos, head) \
1136         list_for_each_entry(pos, head, node)    \
1137                 if (!pos->has_build_id)         \
1138                         continue;               \
1139                 else
1140
1141 static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
1142                                 u16 misc, int fd)
1143 {
1144         struct dso *pos;
1145
1146         dsos__for_each_with_build_id(pos, head) {
1147                 int err;
1148                 struct build_id_event b;
1149                 size_t len;
1150
1151                 if (!pos->hit)
1152                         continue;
1153                 len = pos->long_name_len + 1;
1154                 len = ALIGN(len, NAME_ALIGN);
1155                 memset(&b, 0, sizeof(b));
1156                 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
1157                 b.pid = pid;
1158                 b.header.misc = misc;
1159                 b.header.size = sizeof(b) + len;
1160                 err = do_write(fd, &b, sizeof(b));
1161                 if (err < 0)
1162                         return err;
1163                 err = write_padded(fd, pos->long_name,
1164                                    pos->long_name_len + 1, len);
1165                 if (err < 0)
1166                         return err;
1167         }
1168
1169         return 0;
1170 }
1171
1172 static int machine__write_buildid_table(struct machine *machine, int fd)
1173 {
1174         int err;
1175         u16 kmisc = PERF_RECORD_MISC_KERNEL,
1176             umisc = PERF_RECORD_MISC_USER;
1177
1178         if (!machine__is_host(machine)) {
1179                 kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
1180                 umisc = PERF_RECORD_MISC_GUEST_USER;
1181         }
1182
1183         err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
1184                                           kmisc, fd);
1185         if (err == 0)
1186                 err = __dsos__write_buildid_table(&machine->user_dsos,
1187                                                   machine->pid, umisc, fd);
1188         return err;
1189 }
1190
1191 static int dsos__write_buildid_table(struct perf_header *header, int fd)
1192 {
1193         struct perf_session *session = container_of(header,
1194                         struct perf_session, header);
1195         struct rb_node *nd;
1196         int err = machine__write_buildid_table(&session->host_machine, fd);
1197
1198         if (err)
1199                 return err;
1200
1201         for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
1202                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1203                 err = machine__write_buildid_table(pos, fd);
1204                 if (err)
1205                         break;
1206         }
1207         return err;
1208 }
1209
1210 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
1211                           const char *name, bool is_kallsyms)
1212 {
1213         const size_t size = PATH_MAX;
1214         char *realname, *filename = zalloc(size),
1215              *linkname = zalloc(size), *targetname;
1216         int len, err = -1;
1217
1218         if (is_kallsyms) {
1219                 if (symbol_conf.kptr_restrict) {
1220                         pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
1221                         return 0;
1222                 }
1223                 realname = (char *)name;
1224         } else
1225                 realname = realpath(name, NULL);
1226
1227         if (realname == NULL || filename == NULL || linkname == NULL)
1228                 goto out_free;
1229
1230         len = snprintf(filename, size, "%s%s%s",
1231                        debugdir, is_kallsyms ? "/" : "", realname);
1232         if (mkdir_p(filename, 0755))
1233                 goto out_free;
1234
1235         snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
1236
1237         if (access(filename, F_OK)) {
1238                 if (is_kallsyms) {
1239                          if (copyfile("/proc/kallsyms", filename))
1240                                 goto out_free;
1241                 } else if (link(realname, filename) && copyfile(name, filename))
1242                         goto out_free;
1243         }
1244
1245         len = snprintf(linkname, size, "%s/.build-id/%.2s",
1246                        debugdir, sbuild_id);
1247
1248         if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
1249                 goto out_free;
1250
1251         snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
1252         targetname = filename + strlen(debugdir) - 5;
1253         memcpy(targetname, "../..", 5);
1254
1255         if (symlink(targetname, linkname) == 0)
1256                 err = 0;
1257 out_free:
1258         if (!is_kallsyms)
1259                 free(realname);
1260         free(filename);
1261         free(linkname);
1262         return err;
1263 }
1264
1265 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
1266                                  const char *name, const char *debugdir,
1267                                  bool is_kallsyms)
1268 {
1269         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1270
1271         build_id__sprintf(build_id, build_id_size, sbuild_id);
1272
1273         return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
1274 }
1275
1276 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
1277 {
1278         const size_t size = PATH_MAX;
1279         char *filename = zalloc(size),
1280              *linkname = zalloc(size);
1281         int err = -1;
1282
1283         if (filename == NULL || linkname == NULL)
1284                 goto out_free;
1285
1286         snprintf(linkname, size, "%s/.build-id/%.2s/%s",
1287                  debugdir, sbuild_id, sbuild_id + 2);
1288
1289         if (access(linkname, F_OK))
1290                 goto out_free;
1291
1292         if (readlink(linkname, filename, size - 1) < 0)
1293                 goto out_free;
1294
1295         if (unlink(linkname))
1296                 goto out_free;
1297
1298         /*
1299          * Since the link is relative, we must make it absolute:
1300          */
1301         snprintf(linkname, size, "%s/.build-id/%.2s/%s",
1302                  debugdir, sbuild_id, filename);
1303
1304         if (unlink(linkname))
1305                 goto out_free;
1306
1307         err = 0;
1308 out_free:
1309         free(filename);
1310         free(linkname);
1311         return err;
1312 }
1313
1314 static int dso__cache_build_id(struct dso *dso, const char *debugdir)
1315 {
1316         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
1317
1318         return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
1319                                      dso->long_name, debugdir, is_kallsyms);
1320 }
1321
1322 static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
1323 {
1324         struct dso *pos;
1325         int err = 0;
1326
1327         dsos__for_each_with_build_id(pos, head)
1328                 if (dso__cache_build_id(pos, debugdir))
1329                         err = -1;
1330
1331         return err;
1332 }
1333
1334 static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
1335 {
1336         int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
1337         ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
1338         return ret;
1339 }
1340
1341 static int perf_session__cache_build_ids(struct perf_session *session)
1342 {
1343         struct rb_node *nd;
1344         int ret;
1345         char debugdir[PATH_MAX];
1346
1347         snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
1348
1349         if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
1350                 return -1;
1351
1352         ret = machine__cache_build_ids(&session->host_machine, debugdir);
1353
1354         for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
1355                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1356                 ret |= machine__cache_build_ids(pos, debugdir);
1357         }
1358         return ret ? -1 : 0;
1359 }
1360
1361 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
1362 {
1363         bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
1364         ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
1365         return ret;
1366 }
1367
1368 static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
1369 {
1370         struct rb_node *nd;
1371         bool ret = machine__read_build_ids(&session->host_machine, with_hits);
1372
1373         for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
1374                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1375                 ret |= machine__read_build_ids(pos, with_hits);
1376         }
1377
1378         return ret;
1379 }
1380
1381 static int do_write_feat(int fd, struct perf_header *h, int type,
1382                          struct perf_file_section **p,
1383                          struct perf_evlist *evlist)
1384 {
1385         int err;
1386         int ret = 0;
1387
1388         if (perf_header__has_feat(h, type)) {
1389
1390                 (*p)->offset = lseek(fd, 0, SEEK_CUR);
1391
1392                 err = feat_ops[type].write(fd, h, evlist);
1393                 if (err < 0) {
1394                         pr_debug("failed to write feature %d\n", type);
1395
1396                         /* undo anything written */
1397                         lseek(fd, (*p)->offset, SEEK_SET);
1398
1399                         return -1;
1400                 }
1401                 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
1402                 (*p)++;
1403         }
1404         return ret;
1405 }
1406
1407 static int perf_header__adds_write(struct perf_header *header,
1408                                    struct perf_evlist *evlist, int fd)
1409 {
1410         int nr_sections;
1411         struct perf_session *session;
1412         struct perf_file_section *feat_sec, *p;
1413         int sec_size;
1414         u64 sec_start;
1415         int err;
1416
1417         session = container_of(header, struct perf_session, header);
1418
1419         if (perf_header__has_feat(header, HEADER_BUILD_ID &&
1420             !perf_session__read_build_ids(session, true)))
1421                 perf_header__clear_feat(header, HEADER_BUILD_ID);
1422
1423         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
1424         if (!nr_sections)
1425                 return 0;
1426
1427         feat_sec = p = calloc(sizeof(*feat_sec), nr_sections);
1428         if (feat_sec == NULL)
1429                 return -ENOMEM;
1430
1431         sec_size = sizeof(*feat_sec) * nr_sections;
1432
1433         sec_start = header->data_offset + header->data_size;
1434         lseek(fd, sec_start + sec_size, SEEK_SET);
1435
1436         err = do_write_feat(fd, header, HEADER_TRACE_INFO, &p, evlist);
1437         if (err)
1438                 goto out_free;
1439
1440         err = do_write_feat(fd, header, HEADER_BUILD_ID, &p, evlist);
1441         if (err) {
1442                 perf_header__clear_feat(header, HEADER_BUILD_ID);
1443                 goto out_free;
1444         }
1445
1446         err = do_write_feat(fd, header, HEADER_HOSTNAME, &p, evlist);
1447         if (err)
1448                 perf_header__clear_feat(header, HEADER_HOSTNAME);
1449
1450         err = do_write_feat(fd, header, HEADER_OSRELEASE, &p, evlist);
1451         if (err)
1452                 perf_header__clear_feat(header, HEADER_OSRELEASE);
1453
1454         err = do_write_feat(fd, header, HEADER_VERSION, &p, evlist);
1455         if (err)
1456                 perf_header__clear_feat(header, HEADER_VERSION);
1457
1458         err = do_write_feat(fd, header, HEADER_ARCH, &p, evlist);
1459         if (err)
1460                 perf_header__clear_feat(header, HEADER_ARCH);
1461
1462         err = do_write_feat(fd, header, HEADER_NRCPUS, &p, evlist);
1463         if (err)
1464                 perf_header__clear_feat(header, HEADER_NRCPUS);
1465
1466         err = do_write_feat(fd, header, HEADER_CPUDESC, &p, evlist);
1467         if (err)
1468                 perf_header__clear_feat(header, HEADER_CPUDESC);
1469
1470         err = do_write_feat(fd, header, HEADER_CPUID, &p, evlist);
1471         if (err)
1472                 perf_header__clear_feat(header, HEADER_CPUID);
1473
1474         err = do_write_feat(fd, header, HEADER_TOTAL_MEM, &p, evlist);
1475         if (err)
1476                 perf_header__clear_feat(header, HEADER_TOTAL_MEM);
1477
1478         err = do_write_feat(fd, header, HEADER_CMDLINE, &p, evlist);
1479         if (err)
1480                 perf_header__clear_feat(header, HEADER_CMDLINE);
1481
1482         err = do_write_feat(fd, header, HEADER_EVENT_DESC, &p, evlist);
1483         if (err)
1484                 perf_header__clear_feat(header, HEADER_EVENT_DESC);
1485
1486         err = do_write_feat(fd, header, HEADER_CPU_TOPOLOGY, &p, evlist);
1487         if (err)
1488                 perf_header__clear_feat(header, HEADER_CPU_TOPOLOGY);
1489
1490         err = do_write_feat(fd, header, HEADER_NUMA_TOPOLOGY, &p, evlist);
1491         if (err)
1492                 perf_header__clear_feat(header, HEADER_NUMA_TOPOLOGY);
1493
1494         lseek(fd, sec_start, SEEK_SET);
1495         /*
1496          * may write more than needed due to dropped feature, but
1497          * this is okay, reader will skip the mising entries
1498          */
1499         err = do_write(fd, feat_sec, sec_size);
1500         if (err < 0)
1501                 pr_debug("failed to write feature section\n");
1502 out_free:
1503         free(feat_sec);
1504         return err;
1505 }
1506
1507 int perf_header__write_pipe(int fd)
1508 {
1509         struct perf_pipe_file_header f_header;
1510         int err;
1511
1512         f_header = (struct perf_pipe_file_header){
1513                 .magic     = PERF_MAGIC,
1514                 .size      = sizeof(f_header),
1515         };
1516
1517         err = do_write(fd, &f_header, sizeof(f_header));
1518         if (err < 0) {
1519                 pr_debug("failed to write perf pipe header\n");
1520                 return err;
1521         }
1522
1523         return 0;
1524 }
1525
1526 int perf_session__write_header(struct perf_session *session,
1527                                struct perf_evlist *evlist,
1528                                int fd, bool at_exit)
1529 {
1530         struct perf_file_header f_header;
1531         struct perf_file_attr   f_attr;
1532         struct perf_header *header = &session->header;
1533         struct perf_evsel *attr, *pair = NULL;
1534         int err;
1535
1536         lseek(fd, sizeof(f_header), SEEK_SET);
1537
1538         if (session->evlist != evlist)
1539                 pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
1540
1541         list_for_each_entry(attr, &evlist->entries, node) {
1542                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
1543                 err = do_write(fd, attr->id, attr->ids * sizeof(u64));
1544                 if (err < 0) {
1545 out_err_write:
1546                         pr_debug("failed to write perf header\n");
1547                         return err;
1548                 }
1549                 if (session->evlist != evlist) {
1550                         err = do_write(fd, pair->id, pair->ids * sizeof(u64));
1551                         if (err < 0)
1552                                 goto out_err_write;
1553                         attr->ids += pair->ids;
1554                         pair = list_entry(pair->node.next, struct perf_evsel, node);
1555                 }
1556         }
1557
1558         header->attr_offset = lseek(fd, 0, SEEK_CUR);
1559
1560         list_for_each_entry(attr, &evlist->entries, node) {
1561                 f_attr = (struct perf_file_attr){
1562                         .attr = attr->attr,
1563                         .ids  = {
1564                                 .offset = attr->id_offset,
1565                                 .size   = attr->ids * sizeof(u64),
1566                         }
1567                 };
1568                 err = do_write(fd, &f_attr, sizeof(f_attr));
1569                 if (err < 0) {
1570                         pr_debug("failed to write perf header attribute\n");
1571                         return err;
1572                 }
1573         }
1574
1575         header->event_offset = lseek(fd, 0, SEEK_CUR);
1576         header->event_size = event_count * sizeof(struct perf_trace_event_type);
1577         if (events) {
1578                 err = do_write(fd, events, header->event_size);
1579                 if (err < 0) {
1580                         pr_debug("failed to write perf header events\n");
1581                         return err;
1582                 }
1583         }
1584
1585         header->data_offset = lseek(fd, 0, SEEK_CUR);
1586
1587         if (at_exit) {
1588                 err = perf_header__adds_write(header, evlist, fd);
1589                 if (err < 0)
1590                         return err;
1591         }
1592
1593         f_header = (struct perf_file_header){
1594                 .magic     = PERF_MAGIC,
1595                 .size      = sizeof(f_header),
1596                 .attr_size = sizeof(f_attr),
1597                 .attrs = {
1598                         .offset = header->attr_offset,
1599                         .size   = evlist->nr_entries * sizeof(f_attr),
1600                 },
1601                 .data = {
1602                         .offset = header->data_offset,
1603                         .size   = header->data_size,
1604                 },
1605                 .event_types = {
1606                         .offset = header->event_offset,
1607                         .size   = header->event_size,
1608                 },
1609         };
1610
1611         memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
1612
1613         lseek(fd, 0, SEEK_SET);
1614         err = do_write(fd, &f_header, sizeof(f_header));
1615         if (err < 0) {
1616                 pr_debug("failed to write perf header\n");
1617                 return err;
1618         }
1619         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
1620
1621         header->frozen = 1;
1622         return 0;
1623 }
1624
1625 static int perf_header__getbuffer64(struct perf_header *header,
1626                                     int fd, void *buf, size_t size)
1627 {
1628         if (readn(fd, buf, size) <= 0)
1629                 return -1;
1630
1631         if (header->needs_swap)
1632                 mem_bswap_64(buf, size);
1633
1634         return 0;
1635 }
1636
1637 int perf_header__process_sections(struct perf_header *header, int fd,
1638                                   void *data,
1639                                   int (*process)(struct perf_file_section *section,
1640                                   struct perf_header *ph,
1641                                   int feat, int fd, void *data))
1642 {
1643         struct perf_file_section *feat_sec;
1644         int nr_sections;
1645         int sec_size;
1646         int idx = 0;
1647         int err = -1, feat = 1;
1648
1649         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
1650         if (!nr_sections)
1651                 return 0;
1652
1653         feat_sec = calloc(sizeof(*feat_sec), nr_sections);
1654         if (!feat_sec)
1655                 return -1;
1656
1657         sec_size = sizeof(*feat_sec) * nr_sections;
1658
1659         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
1660
1661         if (perf_header__getbuffer64(header, fd, feat_sec, sec_size))
1662                 goto out_free;
1663
1664         err = 0;
1665         while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
1666                 if (perf_header__has_feat(header, feat)) {
1667                         struct perf_file_section *sec = &feat_sec[idx++];
1668
1669                         err = process(sec, header, feat, fd, data);
1670                         if (err < 0)
1671                                 break;
1672                 }
1673                 ++feat;
1674         }
1675 out_free:
1676         free(feat_sec);
1677         return err;
1678 }
1679
1680 int perf_file_header__read(struct perf_file_header *header,
1681                            struct perf_header *ph, int fd)
1682 {
1683         lseek(fd, 0, SEEK_SET);
1684
1685         if (readn(fd, header, sizeof(*header)) <= 0 ||
1686             memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
1687                 return -1;
1688
1689         if (header->attr_size != sizeof(struct perf_file_attr)) {
1690                 u64 attr_size = bswap_64(header->attr_size);
1691
1692                 if (attr_size != sizeof(struct perf_file_attr))
1693                         return -1;
1694
1695                 mem_bswap_64(header, offsetof(struct perf_file_header,
1696                                             adds_features));
1697                 ph->needs_swap = true;
1698         }
1699
1700         if (header->size != sizeof(*header)) {
1701                 /* Support the previous format */
1702                 if (header->size == offsetof(typeof(*header), adds_features))
1703                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
1704                 else
1705                         return -1;
1706         } else if (ph->needs_swap) {
1707                 unsigned int i;
1708                 /*
1709                  * feature bitmap is declared as an array of unsigned longs --
1710                  * not good since its size can differ between the host that
1711                  * generated the data file and the host analyzing the file.
1712                  *
1713                  * We need to handle endianness, but we don't know the size of
1714                  * the unsigned long where the file was generated. Take a best
1715                  * guess at determining it: try 64-bit swap first (ie., file
1716                  * created on a 64-bit host), and check if the hostname feature
1717                  * bit is set (this feature bit is forced on as of fbe96f2).
1718                  * If the bit is not, undo the 64-bit swap and try a 32-bit
1719                  * swap. If the hostname bit is still not set (e.g., older data
1720                  * file), punt and fallback to the original behavior --
1721                  * clearing all feature bits and setting buildid.
1722                  */
1723                 for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i)
1724                         header->adds_features[i] = bswap_64(header->adds_features[i]);
1725
1726                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
1727                         for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i) {
1728                                 header->adds_features[i] = bswap_64(header->adds_features[i]);
1729                                 header->adds_features[i] = bswap_32(header->adds_features[i]);
1730                         }
1731                 }
1732
1733                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
1734                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
1735                         set_bit(HEADER_BUILD_ID, header->adds_features);
1736                 }
1737         }
1738
1739         memcpy(&ph->adds_features, &header->adds_features,
1740                sizeof(ph->adds_features));
1741
1742         ph->event_offset = header->event_types.offset;
1743         ph->event_size   = header->event_types.size;
1744         ph->data_offset  = header->data.offset;
1745         ph->data_size    = header->data.size;
1746         return 0;
1747 }
1748
1749 static int __event_process_build_id(struct build_id_event *bev,
1750                                     char *filename,
1751                                     struct perf_session *session)
1752 {
1753         int err = -1;
1754         struct list_head *head;
1755         struct machine *machine;
1756         u16 misc;
1757         struct dso *dso;
1758         enum dso_kernel_type dso_type;
1759
1760         machine = perf_session__findnew_machine(session, bev->pid);
1761         if (!machine)
1762                 goto out;
1763
1764         misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1765
1766         switch (misc) {
1767         case PERF_RECORD_MISC_KERNEL:
1768                 dso_type = DSO_TYPE_KERNEL;
1769                 head = &machine->kernel_dsos;
1770                 break;
1771         case PERF_RECORD_MISC_GUEST_KERNEL:
1772                 dso_type = DSO_TYPE_GUEST_KERNEL;
1773                 head = &machine->kernel_dsos;
1774                 break;
1775         case PERF_RECORD_MISC_USER:
1776         case PERF_RECORD_MISC_GUEST_USER:
1777                 dso_type = DSO_TYPE_USER;
1778                 head = &machine->user_dsos;
1779                 break;
1780         default:
1781                 goto out;
1782         }
1783
1784         dso = __dsos__findnew(head, filename);
1785         if (dso != NULL) {
1786                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1787
1788                 dso__set_build_id(dso, &bev->build_id);
1789
1790                 if (filename[0] == '[')
1791                         dso->kernel = dso_type;
1792
1793                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1794                                   sbuild_id);
1795                 pr_debug("build id event received for %s: %s\n",
1796                          dso->long_name, sbuild_id);
1797         }
1798
1799         err = 0;
1800 out:
1801         return err;
1802 }
1803
1804 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1805                                                  int input, u64 offset, u64 size)
1806 {
1807         struct perf_session *session = container_of(header, struct perf_session, header);
1808         struct {
1809                 struct perf_event_header   header;
1810                 u8                         build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
1811                 char                       filename[0];
1812         } old_bev;
1813         struct build_id_event bev;
1814         char filename[PATH_MAX];
1815         u64 limit = offset + size;
1816
1817         while (offset < limit) {
1818                 ssize_t len;
1819
1820                 if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
1821                         return -1;
1822
1823                 if (header->needs_swap)
1824                         perf_event_header__bswap(&old_bev.header);
1825
1826                 len = old_bev.header.size - sizeof(old_bev);
1827                 if (read(input, filename, len) != len)
1828                         return -1;
1829
1830                 bev.header = old_bev.header;
1831
1832                 /*
1833                  * As the pid is the missing value, we need to fill
1834                  * it properly. The header.misc value give us nice hint.
1835                  */
1836                 bev.pid = HOST_KERNEL_ID;
1837                 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
1838                     bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
1839                         bev.pid = DEFAULT_GUEST_KERNEL_ID;
1840
1841                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1842                 __event_process_build_id(&bev, filename, session);
1843
1844                 offset += bev.header.size;
1845         }
1846
1847         return 0;
1848 }
1849
1850 static int perf_header__read_build_ids(struct perf_header *header,
1851                                        int input, u64 offset, u64 size)
1852 {
1853         struct perf_session *session = container_of(header, struct perf_session, header);
1854         struct build_id_event bev;
1855         char filename[PATH_MAX];
1856         u64 limit = offset + size, orig_offset = offset;
1857         int err = -1;
1858
1859         while (offset < limit) {
1860                 ssize_t len;
1861
1862                 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
1863                         goto out;
1864
1865                 if (header->needs_swap)
1866                         perf_event_header__bswap(&bev.header);
1867
1868                 len = bev.header.size - sizeof(bev);
1869                 if (read(input, filename, len) != len)
1870                         goto out;
1871                 /*
1872                  * The a1645ce1 changeset:
1873                  *
1874                  * "perf: 'perf kvm' tool for monitoring guest performance from host"
1875                  *
1876                  * Added a field to struct build_id_event that broke the file
1877                  * format.
1878                  *
1879                  * Since the kernel build-id is the first entry, process the
1880                  * table using the old format if the well known
1881                  * '[kernel.kallsyms]' string for the kernel build-id has the
1882                  * first 4 characters chopped off (where the pid_t sits).
1883                  */
1884                 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1885                         if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1886                                 return -1;
1887                         return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1888                 }
1889
1890                 __event_process_build_id(&bev, filename, session);
1891
1892                 offset += bev.header.size;
1893         }
1894         err = 0;
1895 out:
1896         return err;
1897 }
1898
1899 static int perf_file_section__process(struct perf_file_section *section,
1900                                       struct perf_header *ph,
1901                                       int feat, int fd, void *data __used)
1902 {
1903         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
1904                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
1905                           "%d, continuing...\n", section->offset, feat);
1906                 return 0;
1907         }
1908
1909         switch (feat) {
1910         case HEADER_TRACE_INFO:
1911                 trace_report(fd, false);
1912                 break;
1913
1914         case HEADER_BUILD_ID:
1915                 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1916                         pr_debug("Failed to read buildids, continuing...\n");
1917                 break;
1918
1919         case HEADER_HOSTNAME:
1920         case HEADER_OSRELEASE:
1921         case HEADER_VERSION:
1922         case HEADER_ARCH:
1923         case HEADER_NRCPUS:
1924         case HEADER_CPUDESC:
1925         case HEADER_CPUID:
1926         case HEADER_TOTAL_MEM:
1927         case HEADER_CMDLINE:
1928         case HEADER_EVENT_DESC:
1929         case HEADER_CPU_TOPOLOGY:
1930         case HEADER_NUMA_TOPOLOGY:
1931                 break;
1932
1933         default:
1934                 pr_debug("unknown feature %d, continuing...\n", feat);
1935         }
1936
1937         return 0;
1938 }
1939
1940 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
1941                                        struct perf_header *ph, int fd,
1942                                        bool repipe)
1943 {
1944         if (readn(fd, header, sizeof(*header)) <= 0 ||
1945             memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
1946                 return -1;
1947
1948         if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
1949                 return -1;
1950
1951         if (header->size != sizeof(*header)) {
1952                 u64 size = bswap_64(header->size);
1953
1954                 if (size != sizeof(*header))
1955                         return -1;
1956
1957                 ph->needs_swap = true;
1958         }
1959
1960         return 0;
1961 }
1962
1963 static int perf_header__read_pipe(struct perf_session *session, int fd)
1964 {
1965         struct perf_header *header = &session->header;
1966         struct perf_pipe_file_header f_header;
1967
1968         if (perf_file_header__read_pipe(&f_header, header, fd,
1969                                         session->repipe) < 0) {
1970                 pr_debug("incompatible file format\n");
1971                 return -EINVAL;
1972         }
1973
1974         session->fd = fd;
1975
1976         return 0;
1977 }
1978
1979 int perf_session__read_header(struct perf_session *session, int fd)
1980 {
1981         struct perf_header *header = &session->header;
1982         struct perf_file_header f_header;
1983         struct perf_file_attr   f_attr;
1984         u64                     f_id;
1985         int nr_attrs, nr_ids, i, j;
1986
1987         session->evlist = perf_evlist__new(NULL, NULL);
1988         if (session->evlist == NULL)
1989                 return -ENOMEM;
1990
1991         if (session->fd_pipe)
1992                 return perf_header__read_pipe(session, fd);
1993
1994         if (perf_file_header__read(&f_header, header, fd) < 0) {
1995                 pr_debug("incompatible file format\n");
1996                 return -EINVAL;
1997         }
1998
1999         nr_attrs = f_header.attrs.size / sizeof(f_attr);
2000         lseek(fd, f_header.attrs.offset, SEEK_SET);
2001
2002         for (i = 0; i < nr_attrs; i++) {
2003                 struct perf_evsel *evsel;
2004                 off_t tmp;
2005
2006                 if (readn(fd, &f_attr, sizeof(f_attr)) <= 0)
2007                         goto out_errno;
2008
2009                 if (header->needs_swap)
2010                         perf_event__attr_swap(&f_attr.attr);
2011
2012                 tmp = lseek(fd, 0, SEEK_CUR);
2013                 evsel = perf_evsel__new(&f_attr.attr, i);
2014
2015                 if (evsel == NULL)
2016                         goto out_delete_evlist;
2017                 /*
2018                  * Do it before so that if perf_evsel__alloc_id fails, this
2019                  * entry gets purged too at perf_evlist__delete().
2020                  */
2021                 perf_evlist__add(session->evlist, evsel);
2022
2023                 nr_ids = f_attr.ids.size / sizeof(u64);
2024                 /*
2025                  * We don't have the cpu and thread maps on the header, so
2026                  * for allocating the perf_sample_id table we fake 1 cpu and
2027                  * hattr->ids threads.
2028                  */
2029                 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
2030                         goto out_delete_evlist;
2031
2032                 lseek(fd, f_attr.ids.offset, SEEK_SET);
2033
2034                 for (j = 0; j < nr_ids; j++) {
2035                         if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
2036                                 goto out_errno;
2037
2038                         perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
2039                 }
2040
2041                 lseek(fd, tmp, SEEK_SET);
2042         }
2043
2044         if (f_header.event_types.size) {
2045                 lseek(fd, f_header.event_types.offset, SEEK_SET);
2046                 events = malloc(f_header.event_types.size);
2047                 if (events == NULL)
2048                         return -ENOMEM;
2049                 if (perf_header__getbuffer64(header, fd, events,
2050                                              f_header.event_types.size))
2051                         goto out_errno;
2052                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
2053         }
2054
2055         perf_header__process_sections(header, fd, NULL,
2056                                       perf_file_section__process);
2057
2058         lseek(fd, header->data_offset, SEEK_SET);
2059
2060         header->frozen = 1;
2061         return 0;
2062 out_errno:
2063         return -errno;
2064
2065 out_delete_evlist:
2066         perf_evlist__delete(session->evlist);
2067         session->evlist = NULL;
2068         return -ENOMEM;
2069 }
2070
2071 int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
2072                                 perf_event__handler_t process,
2073                                 struct perf_session *session)
2074 {
2075         union perf_event *ev;
2076         size_t size;
2077         int err;
2078
2079         size = sizeof(struct perf_event_attr);
2080         size = ALIGN(size, sizeof(u64));
2081         size += sizeof(struct perf_event_header);
2082         size += ids * sizeof(u64);
2083
2084         ev = malloc(size);
2085
2086         if (ev == NULL)
2087                 return -ENOMEM;
2088
2089         ev->attr.attr = *attr;
2090         memcpy(ev->attr.id, id, ids * sizeof(u64));
2091
2092         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2093         ev->attr.header.size = size;
2094
2095         err = process(ev, NULL, session);
2096
2097         free(ev);
2098
2099         return err;
2100 }
2101
2102 int perf_session__synthesize_attrs(struct perf_session *session,
2103                                    perf_event__handler_t process)
2104 {
2105         struct perf_evsel *attr;
2106         int err = 0;
2107
2108         list_for_each_entry(attr, &session->evlist->entries, node) {
2109                 err = perf_event__synthesize_attr(&attr->attr, attr->ids,
2110                                                   attr->id, process, session);
2111                 if (err) {
2112                         pr_debug("failed to create perf header attribute\n");
2113                         return err;
2114                 }
2115         }
2116
2117         return err;
2118 }
2119
2120 int perf_event__process_attr(union perf_event *event,
2121                              struct perf_session *session)
2122 {
2123         unsigned int i, ids, n_ids;
2124         struct perf_evsel *evsel;
2125
2126         if (session->evlist == NULL) {
2127                 session->evlist = perf_evlist__new(NULL, NULL);
2128                 if (session->evlist == NULL)
2129                         return -ENOMEM;
2130         }
2131
2132         evsel = perf_evsel__new(&event->attr.attr,
2133                                 session->evlist->nr_entries);
2134         if (evsel == NULL)
2135                 return -ENOMEM;
2136
2137         perf_evlist__add(session->evlist, evsel);
2138
2139         ids = event->header.size;
2140         ids -= (void *)&event->attr.id - (void *)event;
2141         n_ids = ids / sizeof(u64);
2142         /*
2143          * We don't have the cpu and thread maps on the header, so
2144          * for allocating the perf_sample_id table we fake 1 cpu and
2145          * hattr->ids threads.
2146          */
2147         if (perf_evsel__alloc_id(evsel, 1, n_ids))
2148                 return -ENOMEM;
2149
2150         for (i = 0; i < n_ids; i++) {
2151                 perf_evlist__id_add(session->evlist, evsel, 0, i,
2152                                     event->attr.id[i]);
2153         }
2154
2155         perf_session__update_sample_type(session);
2156
2157         return 0;
2158 }
2159
2160 int perf_event__synthesize_event_type(u64 event_id, char *name,
2161                                       perf_event__handler_t process,
2162                                       struct perf_session *session)
2163 {
2164         union perf_event ev;
2165         size_t size = 0;
2166         int err = 0;
2167
2168         memset(&ev, 0, sizeof(ev));
2169
2170         ev.event_type.event_type.event_id = event_id;
2171         memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
2172         strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
2173
2174         ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
2175         size = strlen(name);
2176         size = ALIGN(size, sizeof(u64));
2177         ev.event_type.header.size = sizeof(ev.event_type) -
2178                 (sizeof(ev.event_type.event_type.name) - size);
2179
2180         err = process(&ev, NULL, session);
2181
2182         return err;
2183 }
2184
2185 int perf_event__synthesize_event_types(perf_event__handler_t process,
2186                                        struct perf_session *session)
2187 {
2188         struct perf_trace_event_type *type;
2189         int i, err = 0;
2190
2191         for (i = 0; i < event_count; i++) {
2192                 type = &events[i];
2193
2194                 err = perf_event__synthesize_event_type(type->event_id,
2195                                                         type->name, process,
2196                                                         session);
2197                 if (err) {
2198                         pr_debug("failed to create perf header event type\n");
2199                         return err;
2200                 }
2201         }
2202
2203         return err;
2204 }
2205
2206 int perf_event__process_event_type(union perf_event *event,
2207                                    struct perf_session *session __unused)
2208 {
2209         if (perf_header__push_event(event->event_type.event_type.event_id,
2210                                     event->event_type.event_type.name) < 0)
2211                 return -ENOMEM;
2212
2213         return 0;
2214 }
2215
2216 int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
2217                                          perf_event__handler_t process,
2218                                    struct perf_session *session __unused)
2219 {
2220         union perf_event ev;
2221         struct tracing_data *tdata;
2222         ssize_t size = 0, aligned_size = 0, padding;
2223         int err __used = 0;
2224
2225         /*
2226          * We are going to store the size of the data followed
2227          * by the data contents. Since the fd descriptor is a pipe,
2228          * we cannot seek back to store the size of the data once
2229          * we know it. Instead we:
2230          *
2231          * - write the tracing data to the temp file
2232          * - get/write the data size to pipe
2233          * - write the tracing data from the temp file
2234          *   to the pipe
2235          */
2236         tdata = tracing_data_get(&evlist->entries, fd, true);
2237         if (!tdata)
2238                 return -1;
2239
2240         memset(&ev, 0, sizeof(ev));
2241
2242         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
2243         size = tdata->size;
2244         aligned_size = ALIGN(size, sizeof(u64));
2245         padding = aligned_size - size;
2246         ev.tracing_data.header.size = sizeof(ev.tracing_data);
2247         ev.tracing_data.size = aligned_size;
2248
2249         process(&ev, NULL, session);
2250
2251         /*
2252          * The put function will copy all the tracing data
2253          * stored in temp file to the pipe.
2254          */
2255         tracing_data_put(tdata);
2256
2257         write_padded(fd, NULL, 0, padding);
2258
2259         return aligned_size;
2260 }
2261
2262 int perf_event__process_tracing_data(union perf_event *event,
2263                                      struct perf_session *session)
2264 {
2265         ssize_t size_read, padding, size = event->tracing_data.size;
2266         off_t offset = lseek(session->fd, 0, SEEK_CUR);
2267         char buf[BUFSIZ];
2268
2269         /* setup for reading amidst mmap */
2270         lseek(session->fd, offset + sizeof(struct tracing_data_event),
2271               SEEK_SET);
2272
2273         size_read = trace_report(session->fd, session->repipe);
2274
2275         padding = ALIGN(size_read, sizeof(u64)) - size_read;
2276
2277         if (read(session->fd, buf, padding) < 0)
2278                 die("reading input file");
2279         if (session->repipe) {
2280                 int retw = write(STDOUT_FILENO, buf, padding);
2281                 if (retw <= 0 || retw != padding)
2282                         die("repiping tracing data padding");
2283         }
2284
2285         if (size_read + padding != size)
2286                 die("tracing data size mismatch");
2287
2288         return size_read + padding;
2289 }
2290
2291 int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
2292                                     perf_event__handler_t process,
2293                                     struct machine *machine,
2294                                     struct perf_session *session)
2295 {
2296         union perf_event ev;
2297         size_t len;
2298         int err = 0;
2299
2300         if (!pos->hit)
2301                 return err;
2302
2303         memset(&ev, 0, sizeof(ev));
2304
2305         len = pos->long_name_len + 1;
2306         len = ALIGN(len, NAME_ALIGN);
2307         memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
2308         ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
2309         ev.build_id.header.misc = misc;
2310         ev.build_id.pid = machine->pid;
2311         ev.build_id.header.size = sizeof(ev.build_id) + len;
2312         memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
2313
2314         err = process(&ev, NULL, session);
2315
2316         return err;
2317 }
2318
2319 int perf_event__process_build_id(union perf_event *event,
2320                                  struct perf_session *session)
2321 {
2322         __event_process_build_id(&event->build_id,
2323                                  event->build_id.filename,
2324                                  session);
2325         return 0;
2326 }
2327
2328 void disable_buildid_cache(void)
2329 {
2330         no_buildid_cache = true;
2331 }