~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/header.c

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include "util.h"
  2 #include <sys/types.h>
  3 #include <byteswap.h>
  4 #include <unistd.h>
  5 #include <stdio.h>
  6 #include <stdlib.h>
  7 #include <linux/list.h>
  8 #include <linux/kernel.h>
  9 #include <linux/bitops.h>
 10 #include <sys/utsname.h>
 11 
 12 #include "evlist.h"
 13 #include "evsel.h"
 14 #include "header.h"
 15 #include "../perf.h"
 16 #include "trace-event.h"
 17 #include "session.h"
 18 #include "symbol.h"
 19 #include "debug.h"
 20 #include "cpumap.h"
 21 #include "pmu.h"
 22 #include "vdso.h"
 23 #include "strbuf.h"
 24 #include "build-id.h"
 25 #include "data.h"
 26 #include <api/fs/fs.h>
 27 #include "asm/bug.h"
 28 
 29 /*
 30  * magic2 = "PERFILE2"
 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
 34  * back.
 35  *
 36  * we check for legacy (PERFFILE) format.
 37  */
 38 static const char *__perf_magic1 = "PERFFILE";
 39 static const u64 __perf_magic2    = 0x32454c4946524550ULL;
 40 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
 41 
 42 #define PERF_MAGIC      __perf_magic2
 43 
 44 struct perf_file_attr {
 45         struct perf_event_attr  attr;
 46         struct perf_file_section        ids;
 47 };
 48 
 49 void perf_header__set_feat(struct perf_header *header, int feat)
 50 {
 51         set_bit(feat, header->adds_features);
 52 }
 53 
 54 void perf_header__clear_feat(struct perf_header *header, int feat)
 55 {
 56         clear_bit(feat, header->adds_features);
 57 }
 58 
 59 bool perf_header__has_feat(const struct perf_header *header, int feat)
 60 {
 61         return test_bit(feat, header->adds_features);
 62 }
 63 
 64 static int do_write(int fd, const void *buf, size_t size)
 65 {
 66         while (size) {
 67                 int ret = write(fd, buf, size);
 68 
 69                 if (ret < 0)
 70                         return -errno;
 71 
 72                 size -= ret;
 73                 buf += ret;
 74         }
 75 
 76         return 0;
 77 }
 78 
 79 int write_padded(int fd, const void *bf, size_t count, size_t count_aligned)
 80 {
 81         static const char zero_buf[NAME_ALIGN];
 82         int err = do_write(fd, bf, count);
 83 
 84         if (!err)
 85                 err = do_write(fd, zero_buf, count_aligned - count);
 86 
 87         return err;
 88 }
 89 
 90 #define string_size(str)                                                \
 91         (PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))
 92 
 93 static int do_write_string(int fd, const char *str)
 94 {
 95         u32 len, olen;
 96         int ret;
 97 
 98         olen = strlen(str) + 1;
 99         len = PERF_ALIGN(olen, NAME_ALIGN);
100 
101         /* write len, incl. \0 */
102         ret = do_write(fd, &len, sizeof(len));
103         if (ret < 0)
104                 return ret;
105 
106         return write_padded(fd, str, olen, len);
107 }
108 
109 static char *do_read_string(int fd, struct perf_header *ph)
110 {
111         ssize_t sz, ret;
112         u32 len;
113         char *buf;
114 
115         sz = readn(fd, &len, sizeof(len));
116         if (sz < (ssize_t)sizeof(len))
117                 return NULL;
118 
119         if (ph->needs_swap)
120                 len = bswap_32(len);
121 
122         buf = malloc(len);
123         if (!buf)
124                 return NULL;
125 
126         ret = readn(fd, buf, len);
127         if (ret == (ssize_t)len) {
128                 /*
129                  * strings are padded by zeroes
130                  * thus the actual strlen of buf
131                  * may be less than len
132                  */
133                 return buf;
134         }
135 
136         free(buf);
137         return NULL;
138 }
139 
140 static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,
141                             struct perf_evlist *evlist)
142 {
143         return read_tracing_data(fd, &evlist->entries);
144 }
145 
146 
147 static int write_build_id(int fd, struct perf_header *h,
148                           struct perf_evlist *evlist __maybe_unused)
149 {
150         struct perf_session *session;
151         int err;
152 
153         session = container_of(h, struct perf_session, header);
154 
155         if (!perf_session__read_build_ids(session, true))
156                 return -1;
157 
158         err = perf_session__write_buildid_table(session, fd);
159         if (err < 0) {
160                 pr_debug("failed to write buildid table\n");
161                 return err;
162         }
163         perf_session__cache_build_ids(session);
164 
165         return 0;
166 }
167 
168 static int write_hostname(int fd, struct perf_header *h __maybe_unused,
169                           struct perf_evlist *evlist __maybe_unused)
170 {
171         struct utsname uts;
172         int ret;
173 
174         ret = uname(&uts);
175         if (ret < 0)
176                 return -1;
177 
178         return do_write_string(fd, uts.nodename);
179 }
180 
181 static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
182                            struct perf_evlist *evlist __maybe_unused)
183 {
184         struct utsname uts;
185         int ret;
186 
187         ret = uname(&uts);
188         if (ret < 0)
189                 return -1;
190 
191         return do_write_string(fd, uts.release);
192 }
193 
194 static int write_arch(int fd, struct perf_header *h __maybe_unused,
195                       struct perf_evlist *evlist __maybe_unused)
196 {
197         struct utsname uts;
198         int ret;
199 
200         ret = uname(&uts);
201         if (ret < 0)
202                 return -1;
203 
204         return do_write_string(fd, uts.machine);
205 }
206 
207 static int write_version(int fd, struct perf_header *h __maybe_unused,
208                          struct perf_evlist *evlist __maybe_unused)
209 {
210         return do_write_string(fd, perf_version_string);
211 }
212 
213 static int __write_cpudesc(int fd, const char *cpuinfo_proc)
214 {
215         FILE *file;
216         char *buf = NULL;
217         char *s, *p;
218         const char *search = cpuinfo_proc;
219         size_t len = 0;
220         int ret = -1;
221 
222         if (!search)
223                 return -1;
224 
225         file = fopen("/proc/cpuinfo", "r");
226         if (!file)
227                 return -1;
228 
229         while (getline(&buf, &len, file) > 0) {
230                 ret = strncmp(buf, search, strlen(search));
231                 if (!ret)
232                         break;
233         }
234 
235         if (ret) {
236                 ret = -1;
237                 goto done;
238         }
239 
240         s = buf;
241 
242         p = strchr(buf, ':');
243         if (p && *(p+1) == ' ' && *(p+2))
244                 s = p + 2;
245         p = strchr(s, '\n');
246         if (p)
247                 *p = '\0';
248 
249         /* squash extra space characters (branding string) */
250         p = s;
251         while (*p) {
252                 if (isspace(*p)) {
253                         char *r = p + 1;
254                         char *q = r;
255                         *p = ' ';
256                         while (*q && isspace(*q))
257                                 q++;
258                         if (q != (p+1))
259                                 while ((*r++ = *q++));
260                 }
261                 p++;
262         }
263         ret = do_write_string(fd, s);
264 done:
265         free(buf);
266         fclose(file);
267         return ret;
268 }
269 
270 static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
271                        struct perf_evlist *evlist __maybe_unused)
272 {
273 #ifndef CPUINFO_PROC
274 #define CPUINFO_PROC {"model name", }
275 #endif
276         const char *cpuinfo_procs[] = CPUINFO_PROC;
277         unsigned int i;
278 
279         for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
280                 int ret;
281                 ret = __write_cpudesc(fd, cpuinfo_procs[i]);
282                 if (ret >= 0)
283                         return ret;
284         }
285         return -1;
286 }
287 
288 
289 static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
290                         struct perf_evlist *evlist __maybe_unused)
291 {
292         long nr;
293         u32 nrc, nra;
294         int ret;
295 
296         nr = sysconf(_SC_NPROCESSORS_CONF);
297         if (nr < 0)
298                 return -1;
299 
300         nrc = (u32)(nr & UINT_MAX);
301 
302         nr = sysconf(_SC_NPROCESSORS_ONLN);
303         if (nr < 0)
304                 return -1;
305 
306         nra = (u32)(nr & UINT_MAX);
307 
308         ret = do_write(fd, &nrc, sizeof(nrc));
309         if (ret < 0)
310                 return ret;
311 
312         return do_write(fd, &nra, sizeof(nra));
313 }
314 
315 static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
316                             struct perf_evlist *evlist)
317 {
318         struct perf_evsel *evsel;
319         u32 nre, nri, sz;
320         int ret;
321 
322         nre = evlist->nr_entries;
323 
324         /*
325          * write number of events
326          */
327         ret = do_write(fd, &nre, sizeof(nre));
328         if (ret < 0)
329                 return ret;
330 
331         /*
332          * size of perf_event_attr struct
333          */
334         sz = (u32)sizeof(evsel->attr);
335         ret = do_write(fd, &sz, sizeof(sz));
336         if (ret < 0)
337                 return ret;
338 
339         evlist__for_each(evlist, evsel) {
340                 ret = do_write(fd, &evsel->attr, sz);
341                 if (ret < 0)
342                         return ret;
343                 /*
344                  * write number of unique id per event
345                  * there is one id per instance of an event
346                  *
347                  * copy into an nri to be independent of the
348                  * type of ids,
349                  */
350                 nri = evsel->ids;
351                 ret = do_write(fd, &nri, sizeof(nri));
352                 if (ret < 0)
353                         return ret;
354 
355                 /*
356                  * write event string as passed on cmdline
357                  */
358                 ret = do_write_string(fd, perf_evsel__name(evsel));
359                 if (ret < 0)
360                         return ret;
361                 /*
362                  * write unique ids for this event
363                  */
364                 ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
365                 if (ret < 0)
366                         return ret;
367         }
368         return 0;
369 }
370 
371 static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
372                          struct perf_evlist *evlist __maybe_unused)
373 {
374         char buf[MAXPATHLEN];
375         char proc[32];
376         u32 n;
377         int i, ret;
378 
379         /*
380          * actual atual path to perf binary
381          */
382         sprintf(proc, "/proc/%d/exe", getpid());
383         ret = readlink(proc, buf, sizeof(buf));
384         if (ret <= 0)
385                 return -1;
386 
387         /* readlink() does not add null termination */
388         buf[ret] = '\0';
389 
390         /* account for binary path */
391         n = perf_env.nr_cmdline + 1;
392 
393         ret = do_write(fd, &n, sizeof(n));
394         if (ret < 0)
395                 return ret;
396 
397         ret = do_write_string(fd, buf);
398         if (ret < 0)
399                 return ret;
400 
401         for (i = 0 ; i < perf_env.nr_cmdline; i++) {
402                 ret = do_write_string(fd, perf_env.cmdline_argv[i]);
403                 if (ret < 0)
404                         return ret;
405         }
406         return 0;
407 }
408 
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"
413 
414 struct cpu_topo {
415         u32 cpu_nr;
416         u32 core_sib;
417         u32 thread_sib;
418         char **core_siblings;
419         char **thread_siblings;
420 };
421 
422 static int build_cpu_topo(struct cpu_topo *tp, int cpu)
423 {
424         FILE *fp;
425         char filename[MAXPATHLEN];
426         char *buf = NULL, *p;
427         size_t len = 0;
428         ssize_t sret;
429         u32 i = 0;
430         int ret = -1;
431 
432         sprintf(filename, CORE_SIB_FMT, cpu);
433         fp = fopen(filename, "r");
434         if (!fp)
435                 goto try_threads;
436 
437         sret = getline(&buf, &len, fp);
438         fclose(fp);
439         if (sret <= 0)
440                 goto try_threads;
441 
442         p = strchr(buf, '\n');
443         if (p)
444                 *p = '\0';
445 
446         for (i = 0; i < tp->core_sib; i++) {
447                 if (!strcmp(buf, tp->core_siblings[i]))
448                         break;
449         }
450         if (i == tp->core_sib) {
451                 tp->core_siblings[i] = buf;
452                 tp->core_sib++;
453                 buf = NULL;
454                 len = 0;
455         }
456         ret = 0;
457 
458 try_threads:
459         sprintf(filename, THRD_SIB_FMT, cpu);
460         fp = fopen(filename, "r");
461         if (!fp)
462                 goto done;
463 
464         if (getline(&buf, &len, fp) <= 0)
465                 goto done;
466 
467         p = strchr(buf, '\n');
468         if (p)
469                 *p = '\0';
470 
471         for (i = 0; i < tp->thread_sib; i++) {
472                 if (!strcmp(buf, tp->thread_siblings[i]))
473                         break;
474         }
475         if (i == tp->thread_sib) {
476                 tp->thread_siblings[i] = buf;
477                 tp->thread_sib++;
478                 buf = NULL;
479         }
480         ret = 0;
481 done:
482         if(fp)
483                 fclose(fp);
484         free(buf);
485         return ret;
486 }
487 
488 static void free_cpu_topo(struct cpu_topo *tp)
489 {
490         u32 i;
491 
492         if (!tp)
493                 return;
494 
495         for (i = 0 ; i < tp->core_sib; i++)
496                 zfree(&tp->core_siblings[i]);
497 
498         for (i = 0 ; i < tp->thread_sib; i++)
499                 zfree(&tp->thread_siblings[i]);
500 
501         free(tp);
502 }
503 
504 static struct cpu_topo *build_cpu_topology(void)
505 {
506         struct cpu_topo *tp;
507         void *addr;
508         u32 nr, i;
509         size_t sz;
510         long ncpus;
511         int ret = -1;
512 
513         ncpus = sysconf(_SC_NPROCESSORS_CONF);
514         if (ncpus < 0)
515                 return NULL;
516 
517         nr = (u32)(ncpus & UINT_MAX);
518 
519         sz = nr * sizeof(char *);
520 
521         addr = calloc(1, sizeof(*tp) + 2 * sz);
522         if (!addr)
523                 return NULL;
524 
525         tp = addr;
526         tp->cpu_nr = nr;
527         addr += sizeof(*tp);
528         tp->core_siblings = addr;
529         addr += sz;
530         tp->thread_siblings = addr;
531 
532         for (i = 0; i < nr; i++) {
533                 ret = build_cpu_topo(tp, i);
534                 if (ret < 0)
535                         break;
536         }
537         if (ret) {
538                 free_cpu_topo(tp);
539                 tp = NULL;
540         }
541         return tp;
542 }
543 
544 static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused,
545                           struct perf_evlist *evlist __maybe_unused)
546 {
547         struct cpu_topo *tp;
548         u32 i;
549         int ret, j;
550 
551         tp = build_cpu_topology();
552         if (!tp)
553                 return -1;
554 
555         ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
556         if (ret < 0)
557                 goto done;
558 
559         for (i = 0; i < tp->core_sib; i++) {
560                 ret = do_write_string(fd, tp->core_siblings[i]);
561                 if (ret < 0)
562                         goto done;
563         }
564         ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
565         if (ret < 0)
566                 goto done;
567 
568         for (i = 0; i < tp->thread_sib; i++) {
569                 ret = do_write_string(fd, tp->thread_siblings[i]);
570                 if (ret < 0)
571                         break;
572         }
573 
574         ret = perf_env__read_cpu_topology_map(&perf_env);
575         if (ret < 0)
576                 goto done;
577 
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));
581                 if (ret < 0)
582                         return ret;
583                 ret = do_write(fd, &perf_env.cpu[j].socket_id,
584                                sizeof(perf_env.cpu[j].socket_id));
585                 if (ret < 0)
586                         return ret;
587         }
588 done:
589         free_cpu_topo(tp);
590         return ret;
591 }
592 
593 
594 
595 static int write_total_mem(int fd, struct perf_header *h __maybe_unused,
596                           struct perf_evlist *evlist __maybe_unused)
597 {
598         char *buf = NULL;
599         FILE *fp;
600         size_t len = 0;
601         int ret = -1, n;
602         uint64_t mem;
603 
604         fp = fopen("/proc/meminfo", "r");
605         if (!fp)
606                 return -1;
607 
608         while (getline(&buf, &len, fp) > 0) {
609                 ret = strncmp(buf, "MemTotal:", 9);
610                 if (!ret)
611                         break;
612         }
613         if (!ret) {
614                 n = sscanf(buf, "%*s %"PRIu64, &mem);
615                 if (n == 1)
616                         ret = do_write(fd, &mem, sizeof(mem));
617         } else
618                 ret = -1;
619         free(buf);
620         fclose(fp);
621         return ret;
622 }
623 
624 static int write_topo_node(int fd, int node)
625 {
626         char str[MAXPATHLEN];
627         char field[32];
628         char *buf = NULL, *p;
629         size_t len = 0;
630         FILE *fp;
631         u64 mem_total, mem_free, mem;
632         int ret = -1;
633 
634         sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
635         fp = fopen(str, "r");
636         if (!fp)
637                 return -1;
638 
639         while (getline(&buf, &len, fp) > 0) {
640                 /* skip over invalid lines */
641                 if (!strchr(buf, ':'))
642                         continue;
643                 if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)
644                         goto done;
645                 if (!strcmp(field, "MemTotal:"))
646                         mem_total = mem;
647                 if (!strcmp(field, "MemFree:"))
648                         mem_free = mem;
649         }
650 
651         fclose(fp);
652         fp = NULL;
653 
654         ret = do_write(fd, &mem_total, sizeof(u64));
655         if (ret)
656                 goto done;
657 
658         ret = do_write(fd, &mem_free, sizeof(u64));
659         if (ret)
660                 goto done;
661 
662         ret = -1;
663         sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
664 
665         fp = fopen(str, "r");
666         if (!fp)
667                 goto done;
668 
669         if (getline(&buf, &len, fp) <= 0)
670                 goto done;
671 
672         p = strchr(buf, '\n');
673         if (p)
674                 *p = '\0';
675 
676         ret = do_write_string(fd, buf);
677 done:
678         free(buf);
679         if (fp)
680                 fclose(fp);
681         return ret;
682 }
683 
684 static int write_numa_topology(int fd, struct perf_header *h __maybe_unused,
685                           struct perf_evlist *evlist __maybe_unused)
686 {
687         char *buf = NULL;
688         size_t len = 0;
689         FILE *fp;
690         struct cpu_map *node_map = NULL;
691         char *c;
692         u32 nr, i, j;
693         int ret = -1;
694 
695         fp = fopen("/sys/devices/system/node/online", "r");
696         if (!fp)
697                 return -1;
698 
699         if (getline(&buf, &len, fp) <= 0)
700                 goto done;
701 
702         c = strchr(buf, '\n');
703         if (c)
704                 *c = '\0';
705 
706         node_map = cpu_map__new(buf);
707         if (!node_map)
708                 goto done;
709 
710         nr = (u32)node_map->nr;
711 
712         ret = do_write(fd, &nr, sizeof(nr));
713         if (ret < 0)
714                 goto done;
715 
716         for (i = 0; i < nr; i++) {
717                 j = (u32)node_map->map[i];
718                 ret = do_write(fd, &j, sizeof(j));
719                 if (ret < 0)
720                         break;
721 
722                 ret = write_topo_node(fd, i);
723                 if (ret < 0)
724                         break;
725         }
726 done:
727         free(buf);
728         fclose(fp);
729         cpu_map__put(node_map);
730         return ret;
731 }
732 
733 /*
734  * File format:
735  *
736  * struct pmu_mappings {
737  *      u32     pmu_num;
738  *      struct pmu_map {
739  *              u32     type;
740  *              char    name[];
741  *      }[pmu_num];
742  * };
743  */
744 
745 static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
746                               struct perf_evlist *evlist __maybe_unused)
747 {
748         struct perf_pmu *pmu = NULL;
749         off_t offset = lseek(fd, 0, SEEK_CUR);
750         __u32 pmu_num = 0;
751         int ret;
752 
753         /* write real pmu_num later */
754         ret = do_write(fd, &pmu_num, sizeof(pmu_num));
755         if (ret < 0)
756                 return ret;
757 
758         while ((pmu = perf_pmu__scan(pmu))) {
759                 if (!pmu->name)
760                         continue;
761                 pmu_num++;
762 
763                 ret = do_write(fd, &pmu->type, sizeof(pmu->type));
764                 if (ret < 0)
765                         return ret;
766 
767                 ret = do_write_string(fd, pmu->name);
768                 if (ret < 0)
769                         return ret;
770         }
771 
772         if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
773                 /* discard all */
774                 lseek(fd, offset, SEEK_SET);
775                 return -1;
776         }
777 
778         return 0;
779 }
780 
781 /*
782  * File format:
783  *
784  * struct group_descs {
785  *      u32     nr_groups;
786  *      struct group_desc {
787  *              char    name[];
788  *              u32     leader_idx;
789  *              u32     nr_members;
790  *      }[nr_groups];
791  * };
792  */
793 static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
794                             struct perf_evlist *evlist)
795 {
796         u32 nr_groups = evlist->nr_groups;
797         struct perf_evsel *evsel;
798         int ret;
799 
800         ret = do_write(fd, &nr_groups, sizeof(nr_groups));
801         if (ret < 0)
802                 return ret;
803 
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;
810 
811                         ret = do_write_string(fd, name);
812                         if (ret < 0)
813                                 return ret;
814 
815                         ret = do_write(fd, &leader_idx, sizeof(leader_idx));
816                         if (ret < 0)
817                                 return ret;
818 
819                         ret = do_write(fd, &nr_members, sizeof(nr_members));
820                         if (ret < 0)
821                                 return ret;
822                 }
823         }
824         return 0;
825 }
826 
827 /*
828  * default get_cpuid(): nothing gets recorded
829  * actual implementation must be in arch/$(ARCH)/util/header.c
830  */
831 int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused,
832                                      size_t sz __maybe_unused)
833 {
834         return -1;
835 }
836 
837 static int write_cpuid(int fd, struct perf_header *h __maybe_unused,
838                        struct perf_evlist *evlist __maybe_unused)
839 {
840         char buffer[64];
841         int ret;
842 
843         ret = get_cpuid(buffer, sizeof(buffer));
844         if (!ret)
845                 goto write_it;
846 
847         return -1;
848 write_it:
849         return do_write_string(fd, buffer);
850 }
851 
852 static int write_branch_stack(int fd __maybe_unused,
853                               struct perf_header *h __maybe_unused,
854                        struct perf_evlist *evlist __maybe_unused)
855 {
856         return 0;
857 }
858 
859 static int write_auxtrace(int fd, struct perf_header *h,
860                           struct perf_evlist *evlist __maybe_unused)
861 {
862         struct perf_session *session;
863         int err;
864 
865         session = container_of(h, struct perf_session, header);
866 
867         err = auxtrace_index__write(fd, &session->auxtrace_index);
868         if (err < 0)
869                 pr_err("Failed to write auxtrace index\n");
870         return err;
871 }
872 
873 static int cpu_cache_level__sort(const void *a, const void *b)
874 {
875         struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
876         struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b;
877 
878         return cache_a->level - cache_b->level;
879 }
880 
881 static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b)
882 {
883         if (a->level != b->level)
884                 return false;
885 
886         if (a->line_size != b->line_size)
887                 return false;
888 
889         if (a->sets != b->sets)
890                 return false;
891 
892         if (a->ways != b->ways)
893                 return false;
894 
895         if (strcmp(a->type, b->type))
896                 return false;
897 
898         if (strcmp(a->size, b->size))
899                 return false;
900 
901         if (strcmp(a->map, b->map))
902                 return false;
903 
904         return true;
905 }
906 
907 static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level)
908 {
909         char path[PATH_MAX], file[PATH_MAX];
910         struct stat st;
911         size_t len;
912 
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);
915 
916         if (stat(file, &st))
917                 return 1;
918 
919         scnprintf(file, PATH_MAX, "%s/level", path);
920         if (sysfs__read_int(file, (int *) &cache->level))
921                 return -1;
922 
923         scnprintf(file, PATH_MAX, "%s/coherency_line_size", path);
924         if (sysfs__read_int(file, (int *) &cache->line_size))
925                 return -1;
926 
927         scnprintf(file, PATH_MAX, "%s/number_of_sets", path);
928         if (sysfs__read_int(file, (int *) &cache->sets))
929                 return -1;
930 
931         scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path);
932         if (sysfs__read_int(file, (int *) &cache->ways))
933                 return -1;
934 
935         scnprintf(file, PATH_MAX, "%s/type", path);
936         if (sysfs__read_str(file, &cache->type, &len))
937                 return -1;
938 
939         cache->type[len] = 0;
940         cache->type = rtrim(cache->type);
941 
942         scnprintf(file, PATH_MAX, "%s/size", path);
943         if (sysfs__read_str(file, &cache->size, &len)) {
944                 free(cache->type);
945                 return -1;
946         }
947 
948         cache->size[len] = 0;
949         cache->size = rtrim(cache->size);
950 
951         scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path);
952         if (sysfs__read_str(file, &cache->map, &len)) {
953                 free(cache->map);
954                 free(cache->type);
955                 return -1;
956         }
957 
958         cache->map[len] = 0;
959         cache->map = rtrim(cache->map);
960         return 0;
961 }
962 
963 static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c)
964 {
965         fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map);
966 }
967 
968 static int build_caches(struct cpu_cache_level caches[], u32 size, u32 *cntp)
969 {
970         u32 i, cnt = 0;
971         long ncpus;
972         u32 nr, cpu;
973         u16 level;
974 
975         ncpus = sysconf(_SC_NPROCESSORS_CONF);
976         if (ncpus < 0)
977                 return -1;
978 
979         nr = (u32)(ncpus & UINT_MAX);
980 
981         for (cpu = 0; cpu < nr; cpu++) {
982                 for (level = 0; level < 10; level++) {
983                         struct cpu_cache_level c;
984                         int err;
985 
986                         err = cpu_cache_level__read(&c, cpu, level);
987                         if (err < 0)
988                                 return err;
989 
990                         if (err == 1)
991                                 break;
992 
993                         for (i = 0; i < cnt; i++) {
994                                 if (cpu_cache_level__cmp(&c, &caches[i]))
995                                         break;
996                         }
997 
998                         if (i == cnt)
999                                 caches[cnt++] = c;
1000                         else
1001                                 cpu_cache_level__free(&c);
1002 
1003                         if (WARN_ONCE(cnt == size, "way too many cpu caches.."))
1004                                 goto out;
1005                 }
1006         }
1007  out:
1008         *cntp = cnt;
1009         return 0;
1010 }
1011 
1012 #define MAX_CACHES 2000
1013 
1014 static int write_cache(int fd, struct perf_header *h __maybe_unused,
1015                           struct perf_evlist *evlist __maybe_unused)
1016 {
1017         struct cpu_cache_level caches[MAX_CACHES];
1018         u32 cnt = 0, i, version = 1;
1019         int ret;
1020 
1021         ret = build_caches(caches, MAX_CACHES, &cnt);
1022         if (ret)
1023                 goto out;
1024 
1025         qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort);
1026 
1027         ret = do_write(fd, &version, sizeof(u32));
1028         if (ret < 0)
1029                 goto out;
1030 
1031         ret = do_write(fd, &cnt, sizeof(u32));
1032         if (ret < 0)
1033                 goto out;
1034 
1035         for (i = 0; i < cnt; i++) {
1036                 struct cpu_cache_level *c = &caches[i];
1037 
1038                 #define _W(v)                                   \
1039                         ret = do_write(fd, &c->v, sizeof(u32)); \
1040                         if (ret < 0)                            \
1041                                 goto out;
1042 
1043                 _W(level)
1044                 _W(line_size)
1045                 _W(sets)
1046                 _W(ways)
1047                 #undef _W
1048 
1049                 #define _W(v)                                           \
1050                         ret = do_write_string(fd, (const char *) c->v); \
1051                         if (ret < 0)                                    \
1052                                 goto out;
1053 
1054                 _W(type)
1055                 _W(size)
1056                 _W(map)
1057                 #undef _W
1058         }
1059 
1060 out:
1061         for (i = 0; i < cnt; i++)
1062                 cpu_cache_level__free(&caches[i]);
1063         return ret;
1064 }
1065 
1066 static int write_stat(int fd __maybe_unused,
1067                       struct perf_header *h __maybe_unused,
1068                       struct perf_evlist *evlist __maybe_unused)
1069 {
1070         return 0;
1071 }
1072 
1073 static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
1074                            FILE *fp)
1075 {
1076         fprintf(fp, "# hostname : %s\n", ph->env.hostname);
1077 }
1078 
1079 static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
1080                             FILE *fp)
1081 {
1082         fprintf(fp, "# os release : %s\n", ph->env.os_release);
1083 }
1084 
1085 static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
1086 {
1087         fprintf(fp, "# arch : %s\n", ph->env.arch);
1088 }
1089 
1090 static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
1091                           FILE *fp)
1092 {
1093         fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc);
1094 }
1095 
1096 static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
1097                          FILE *fp)
1098 {
1099         fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online);
1100         fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail);
1101 }
1102 
1103 static void print_version(struct perf_header *ph, int fd __maybe_unused,
1104                           FILE *fp)
1105 {
1106         fprintf(fp, "# perf version : %s\n", ph->env.version);
1107 }
1108 
1109 static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
1110                           FILE *fp)
1111 {
1112         int nr, i;
1113 
1114         nr = ph->env.nr_cmdline;
1115 
1116         fprintf(fp, "# cmdline : ");
1117 
1118         for (i = 0; i < nr; i++)
1119                 fprintf(fp, "%s ", ph->env.cmdline_argv[i]);
1120         fputc('\n', fp);
1121 }
1122 
1123 static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
1124                                FILE *fp)
1125 {
1126         int nr, i;
1127         char *str;
1128         int cpu_nr = ph->env.nr_cpus_online;
1129 
1130         nr = ph->env.nr_sibling_cores;
1131         str = ph->env.sibling_cores;
1132 
1133         for (i = 0; i < nr; i++) {
1134                 fprintf(fp, "# sibling cores   : %s\n", str);
1135                 str += strlen(str) + 1;
1136         }
1137 
1138         nr = ph->env.nr_sibling_threads;
1139         str = ph->env.sibling_threads;
1140 
1141         for (i = 0; i < nr; i++) {
1142                 fprintf(fp, "# sibling threads : %s\n", str);
1143                 str += strlen(str) + 1;
1144         }
1145 
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);
1150         } else
1151                 fprintf(fp, "# Core ID and Socket ID information is not available\n");
1152 }
1153 
1154 static void free_event_desc(struct perf_evsel *events)
1155 {
1156         struct perf_evsel *evsel;
1157 
1158         if (!events)
1159                 return;
1160 
1161         for (evsel = events; evsel->attr.size; evsel++) {
1162                 zfree(&evsel->name);
1163                 zfree(&evsel->id);
1164         }
1165 
1166         free(events);
1167 }
1168 
1169 static struct perf_evsel *
1170 read_event_desc(struct perf_header *ph, int fd)
1171 {
1172         struct perf_evsel *evsel, *events = NULL;
1173         u64 *id;
1174         void *buf = NULL;
1175         u32 nre, sz, nr, i, j;
1176         ssize_t ret;
1177         size_t msz;
1178 
1179         /* number of events */
1180         ret = readn(fd, &nre, sizeof(nre));
1181         if (ret != (ssize_t)sizeof(nre))
1182                 goto error;
1183 
1184         if (ph->needs_swap)
1185                 nre = bswap_32(nre);
1186 
1187         ret = readn(fd, &sz, sizeof(sz));
1188         if (ret != (ssize_t)sizeof(sz))
1189                 goto error;
1190 
1191         if (ph->needs_swap)
1192                 sz = bswap_32(sz);
1193 
1194         /* buffer to hold on file attr struct */
1195         buf = malloc(sz);
1196         if (!buf)
1197                 goto error;
1198 
1199         /* the last event terminates with evsel->attr.size == 0: */
1200         events = calloc(nre + 1, sizeof(*events));
1201         if (!events)
1202                 goto error;
1203 
1204         msz = sizeof(evsel->attr);
1205         if (sz < msz)
1206                 msz = sz;
1207 
1208         for (i = 0, evsel = events; i < nre; evsel++, i++) {
1209                 evsel->idx = i;
1210 
1211                 /*
1212                  * must read entire on-file attr struct to
1213                  * sync up with layout.
1214                  */
1215                 ret = readn(fd, buf, sz);
1216                 if (ret != (ssize_t)sz)
1217                         goto error;
1218 
1219                 if (ph->needs_swap)
1220                         perf_event__attr_swap(buf);
1221 
1222                 memcpy(&evsel->attr, buf, msz);
1223 
1224                 ret = readn(fd, &nr, sizeof(nr));
1225                 if (ret != (ssize_t)sizeof(nr))
1226                         goto error;
1227 
1228                 if (ph->needs_swap) {
1229                         nr = bswap_32(nr);
1230                         evsel->needs_swap = true;
1231                 }
1232 
1233                 evsel->name = do_read_string(fd, ph);
1234 
1235                 if (!nr)
1236                         continue;
1237 
1238                 id = calloc(nr, sizeof(*id));
1239                 if (!id)
1240                         goto error;
1241                 evsel->ids = nr;
1242                 evsel->id = id;
1243 
1244                 for (j = 0 ; j < nr; j++) {
1245                         ret = readn(fd, id, sizeof(*id));
1246                         if (ret != (ssize_t)sizeof(*id))
1247                                 goto error;
1248                         if (ph->needs_swap)
1249                                 *id = bswap_64(*id);
1250                         id++;
1251                 }
1252         }
1253 out:
1254         free(buf);
1255         return events;
1256 error:
1257         free_event_desc(events);
1258         events = NULL;
1259         goto out;
1260 }
1261 
1262 static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
1263                                 void *priv __attribute__((unused)))
1264 {
1265         return fprintf(fp, ", %s = %s", name, val);
1266 }
1267 
1268 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
1269 {
1270         struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
1271         u32 j;
1272         u64 *id;
1273 
1274         if (!events) {
1275                 fprintf(fp, "# event desc: not available or unable to read\n");
1276                 return;
1277         }
1278 
1279         for (evsel = events; evsel->attr.size; evsel++) {
1280                 fprintf(fp, "# event : name = %s, ", evsel->name);
1281 
1282                 if (evsel->ids) {
1283                         fprintf(fp, ", id = {");
1284                         for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
1285                                 if (j)
1286                                         fputc(',', fp);
1287                                 fprintf(fp, " %"PRIu64, *id);
1288                         }
1289                         fprintf(fp, " }");
1290                 }
1291 
1292                 perf_event_attr__fprintf(fp, &evsel->attr, __desc_attr__fprintf, NULL);
1293 
1294                 fputc('\n', fp);
1295         }
1296 
1297         free_event_desc(events);
1298 }
1299 
1300 static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
1301                             FILE *fp)
1302 {
1303         fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
1304 }
1305 
1306 static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
1307                                 FILE *fp)
1308 {
1309         u32 nr, c, i;
1310         char *str, *tmp;
1311         uint64_t mem_total, mem_free;
1312 
1313         /* nr nodes */
1314         nr = ph->env.nr_numa_nodes;
1315         str = ph->env.numa_nodes;
1316 
1317         for (i = 0; i < nr; i++) {
1318                 /* node number */
1319                 c = strtoul(str, &tmp, 0);
1320                 if (*tmp != ':')
1321                         goto error;
1322 
1323                 str = tmp + 1;
1324                 mem_total = strtoull(str, &tmp, 0);
1325                 if (*tmp != ':')
1326                         goto error;
1327 
1328                 str = tmp + 1;
1329                 mem_free = strtoull(str, &tmp, 0);
1330                 if (*tmp != ':')
1331                         goto error;
1332 
1333                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
1334                             " free = %"PRIu64" kB\n",
1335                         c, mem_total, mem_free);
1336 
1337                 str = tmp + 1;
1338                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
1339 
1340                 str += strlen(str) + 1;
1341         }
1342         return;
1343 error:
1344         fprintf(fp, "# numa topology : not available\n");
1345 }
1346 
1347 static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
1348 {
1349         fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
1350 }
1351 
1352 static void print_branch_stack(struct perf_header *ph __maybe_unused,
1353                                int fd __maybe_unused, FILE *fp)
1354 {
1355         fprintf(fp, "# contains samples with branch stack\n");
1356 }
1357 
1358 static void print_auxtrace(struct perf_header *ph __maybe_unused,
1359                            int fd __maybe_unused, FILE *fp)
1360 {
1361         fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
1362 }
1363 
1364 static void print_stat(struct perf_header *ph __maybe_unused,
1365                        int fd __maybe_unused, FILE *fp)
1366 {
1367         fprintf(fp, "# contains stat data\n");
1368 }
1369 
1370 static void print_cache(struct perf_header *ph __maybe_unused,
1371                         int fd __maybe_unused, FILE *fp __maybe_unused)
1372 {
1373         int i;
1374 
1375         fprintf(fp, "# CPU cache info:\n");
1376         for (i = 0; i < ph->env.caches_cnt; i++) {
1377                 fprintf(fp, "#  ");
1378                 cpu_cache_level__fprintf(fp, &ph->env.caches[i]);
1379         }
1380 }
1381 
1382 static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
1383                                FILE *fp)
1384 {
1385         const char *delimiter = "# pmu mappings: ";
1386         char *str, *tmp;
1387         u32 pmu_num;
1388         u32 type;
1389 
1390         pmu_num = ph->env.nr_pmu_mappings;
1391         if (!pmu_num) {
1392                 fprintf(fp, "# pmu mappings: not available\n");
1393                 return;
1394         }
1395 
1396         str = ph->env.pmu_mappings;
1397 
1398         while (pmu_num) {
1399                 type = strtoul(str, &tmp, 0);
1400                 if (*tmp != ':')
1401                         goto error;
1402 
1403                 str = tmp + 1;
1404                 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
1405 
1406                 delimiter = ", ";
1407                 str += strlen(str) + 1;
1408                 pmu_num--;
1409         }
1410 
1411         fprintf(fp, "\n");
1412 
1413         if (!pmu_num)
1414                 return;
1415 error:
1416         fprintf(fp, "# pmu mappings: unable to read\n");
1417 }
1418 
1419 static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
1420                              FILE *fp)
1421 {
1422         struct perf_session *session;
1423         struct perf_evsel *evsel;
1424         u32 nr = 0;
1425 
1426         session = container_of(ph, struct perf_session, header);
1427 
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));
1433 
1434                         nr = evsel->nr_members - 1;
1435                 } else if (nr) {
1436                         fprintf(fp, ",%s", perf_evsel__name(evsel));
1437 
1438                         if (--nr == 0)
1439                                 fprintf(fp, "}\n");
1440                 }
1441         }
1442 }
1443 
1444 static int __event_process_build_id(struct build_id_event *bev,
1445                                     char *filename,
1446                                     struct perf_session *session)
1447 {
1448         int err = -1;
1449         struct machine *machine;
1450         u16 cpumode;
1451         struct dso *dso;
1452         enum dso_kernel_type dso_type;
1453 
1454         machine = perf_session__findnew_machine(session, bev->pid);
1455         if (!machine)
1456                 goto out;
1457 
1458         cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1459 
1460         switch (cpumode) {
1461         case PERF_RECORD_MISC_KERNEL:
1462                 dso_type = DSO_TYPE_KERNEL;
1463                 break;
1464         case PERF_RECORD_MISC_GUEST_KERNEL:
1465                 dso_type = DSO_TYPE_GUEST_KERNEL;
1466                 break;
1467         case PERF_RECORD_MISC_USER:
1468         case PERF_RECORD_MISC_GUEST_USER:
1469                 dso_type = DSO_TYPE_USER;
1470                 break;
1471         default:
1472                 goto out;
1473         }
1474 
1475         dso = machine__findnew_dso(machine, filename);
1476         if (dso != NULL) {
1477                 char sbuild_id[SBUILD_ID_SIZE];
1478 
1479                 dso__set_build_id(dso, &bev->build_id);
1480 
1481                 if (!is_kernel_module(filename, cpumode))
1482                         dso->kernel = dso_type;
1483 
1484                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1485                                   sbuild_id);
1486                 pr_debug("build id event received for %s: %s\n",
1487                          dso->long_name, sbuild_id);
1488                 dso__put(dso);
1489         }
1490 
1491         err = 0;
1492 out:
1493         return err;
1494 }
1495 
1496 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1497                                                  int input, u64 offset, u64 size)
1498 {
1499         struct perf_session *session = container_of(header, struct perf_session, header);
1500         struct {
1501                 struct perf_event_header   header;
1502                 u8                         build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
1503                 char                       filename[0];
1504         } old_bev;
1505         struct build_id_event bev;
1506         char filename[PATH_MAX];
1507         u64 limit = offset + size;
1508 
1509         while (offset < limit) {
1510                 ssize_t len;
1511 
1512                 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
1513                         return -1;
1514 
1515                 if (header->needs_swap)
1516                         perf_event_header__bswap(&old_bev.header);
1517 
1518                 len = old_bev.header.size - sizeof(old_bev);
1519                 if (readn(input, filename, len) != len)
1520                         return -1;
1521 
1522                 bev.header = old_bev.header;
1523 
1524                 /*
1525                  * As the pid is the missing value, we need to fill
1526                  * it properly. The header.misc value give us nice hint.
1527                  */
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;
1532 
1533                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1534                 __event_process_build_id(&bev, filename, session);
1535 
1536                 offset += bev.header.size;
1537         }
1538 
1539         return 0;
1540 }
1541 
1542 static int perf_header__read_build_ids(struct perf_header *header,
1543                                        int input, u64 offset, u64 size)
1544 {
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;
1549         int err = -1;
1550 
1551         while (offset < limit) {
1552                 ssize_t len;
1553 
1554                 if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
1555                         goto out;
1556 
1557                 if (header->needs_swap)
1558                         perf_event_header__bswap(&bev.header);
1559 
1560                 len = bev.header.size - sizeof(bev);
1561                 if (readn(input, filename, len) != len)
1562                         goto out;
1563                 /*
1564                  * The a1645ce1 changeset:
1565                  *
1566                  * "perf: 'perf kvm' tool for monitoring guest performance from host"
1567                  *
1568                  * Added a field to struct build_id_event that broke the file
1569                  * format.
1570                  *
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).
1575                  */
1576                 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1577                         if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1578                                 return -1;
1579                         return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1580                 }
1581 
1582                 __event_process_build_id(&bev, filename, session);
1583 
1584                 offset += bev.header.size;
1585         }
1586         err = 0;
1587 out:
1588         return err;
1589 }
1590 
1591 static int process_tracing_data(struct perf_file_section *section __maybe_unused,
1592                                 struct perf_header *ph __maybe_unused,
1593                                 int fd, void *data)
1594 {
1595         ssize_t ret = trace_report(fd, data, false);
1596         return ret < 0 ? -1 : 0;
1597 }
1598 
1599 static int process_build_id(struct perf_file_section *section,
1600                             struct perf_header *ph, int fd,
1601                             void *data __maybe_unused)
1602 {
1603         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1604                 pr_debug("Failed to read buildids, continuing...\n");
1605         return 0;
1606 }
1607 
1608 static int process_hostname(struct perf_file_section *section __maybe_unused,
1609                             struct perf_header *ph, int fd,
1610                             void *data __maybe_unused)
1611 {
1612         ph->env.hostname = do_read_string(fd, ph);
1613         return ph->env.hostname ? 0 : -ENOMEM;
1614 }
1615 
1616 static int process_osrelease(struct perf_file_section *section __maybe_unused,
1617                              struct perf_header *ph, int fd,
1618                              void *data __maybe_unused)
1619 {
1620         ph->env.os_release = do_read_string(fd, ph);
1621         return ph->env.os_release ? 0 : -ENOMEM;
1622 }
1623 
1624 static int process_version(struct perf_file_section *section __maybe_unused,
1625                            struct perf_header *ph, int fd,
1626                            void *data __maybe_unused)
1627 {
1628         ph->env.version = do_read_string(fd, ph);
1629         return ph->env.version ? 0 : -ENOMEM;
1630 }
1631 
1632 static int process_arch(struct perf_file_section *section __maybe_unused,
1633                         struct perf_header *ph, int fd,
1634                         void *data __maybe_unused)
1635 {
1636         ph->env.arch = do_read_string(fd, ph);
1637         return ph->env.arch ? 0 : -ENOMEM;
1638 }
1639 
1640 static int process_nrcpus(struct perf_file_section *section __maybe_unused,
1641                           struct perf_header *ph, int fd,
1642                           void *data __maybe_unused)
1643 {
1644         ssize_t ret;
1645         u32 nr;
1646 
1647         ret = readn(fd, &nr, sizeof(nr));
1648         if (ret != sizeof(nr))
1649                 return -1;
1650 
1651         if (ph->needs_swap)
1652                 nr = bswap_32(nr);
1653 
1654         ph->env.nr_cpus_avail = nr;
1655 
1656         ret = readn(fd, &nr, sizeof(nr));
1657         if (ret != sizeof(nr))
1658                 return -1;
1659 
1660         if (ph->needs_swap)
1661                 nr = bswap_32(nr);
1662 
1663         ph->env.nr_cpus_online = nr;
1664         return 0;
1665 }
1666 
1667 static int process_cpudesc(struct perf_file_section *section __maybe_unused,
1668                            struct perf_header *ph, int fd,
1669                            void *data __maybe_unused)
1670 {
1671         ph->env.cpu_desc = do_read_string(fd, ph);
1672         return ph->env.cpu_desc ? 0 : -ENOMEM;
1673 }
1674 
1675 static int process_cpuid(struct perf_file_section *section __maybe_unused,
1676                          struct perf_header *ph,  int fd,
1677                          void *data __maybe_unused)
1678 {
1679         ph->env.cpuid = do_read_string(fd, ph);
1680         return ph->env.cpuid ? 0 : -ENOMEM;
1681 }
1682 
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)
1686 {
1687         uint64_t mem;
1688         ssize_t ret;
1689 
1690         ret = readn(fd, &mem, sizeof(mem));
1691         if (ret != sizeof(mem))
1692                 return -1;
1693 
1694         if (ph->needs_swap)
1695                 mem = bswap_64(mem);
1696 
1697         ph->env.total_mem = mem;
1698         return 0;
1699 }
1700 
1701 static struct perf_evsel *
1702 perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
1703 {
1704         struct perf_evsel *evsel;
1705 
1706         evlist__for_each(evlist, evsel) {
1707                 if (evsel->idx == idx)
1708                         return evsel;
1709         }
1710 
1711         return NULL;
1712 }
1713 
1714 static void
1715 perf_evlist__set_event_name(struct perf_evlist *evlist,
1716                             struct perf_evsel *event)
1717 {
1718         struct perf_evsel *evsel;
1719 
1720         if (!event->name)
1721                 return;
1722 
1723         evsel = perf_evlist__find_by_index(evlist, event->idx);
1724         if (!evsel)
1725                 return;
1726 
1727         if (evsel->name)
1728                 return;
1729 
1730         evsel->name = strdup(event->name);
1731 }
1732 
1733 static int
1734 process_event_desc(struct perf_file_section *section __maybe_unused,
1735                    struct perf_header *header, int fd,
1736                    void *data __maybe_unused)
1737 {
1738         struct perf_session *session;
1739         struct perf_evsel *evsel, *events = read_event_desc(header, fd);
1740 
1741         if (!events)
1742                 return 0;
1743 
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);
1747 
1748         free_event_desc(events);
1749 
1750         return 0;
1751 }
1752 
1753 static int process_cmdline(struct perf_file_section *section,
1754                            struct perf_header *ph, int fd,
1755                            void *data __maybe_unused)
1756 {
1757         ssize_t ret;
1758         char *str, *cmdline = NULL, **argv = NULL;
1759         u32 nr, i, len = 0;
1760 
1761         ret = readn(fd, &nr, sizeof(nr));
1762         if (ret != sizeof(nr))
1763                 return -1;
1764 
1765         if (ph->needs_swap)
1766                 nr = bswap_32(nr);
1767 
1768         ph->env.nr_cmdline = nr;
1769 
1770         cmdline = zalloc(section->size + nr + 1);
1771         if (!cmdline)
1772                 return -1;
1773 
1774         argv = zalloc(sizeof(char *) * (nr + 1));
1775         if (!argv)
1776                 goto error;
1777 
1778         for (i = 0; i < nr; i++) {
1779                 str = do_read_string(fd, ph);
1780                 if (!str)
1781                         goto error;
1782 
1783                 argv[i] = cmdline + len;
1784                 memcpy(argv[i], str, strlen(str) + 1);
1785                 len += strlen(str) + 1;
1786                 free(str);
1787         }
1788         ph->env.cmdline = cmdline;
1789         ph->env.cmdline_argv = (const char **) argv;
1790         return 0;
1791 
1792 error:
1793         free(argv);
1794         free(cmdline);
1795         return -1;
1796 }
1797 
1798 static int process_cpu_topology(struct perf_file_section *section,
1799                                 struct perf_header *ph, int fd,
1800                                 void *data __maybe_unused)
1801 {
1802         ssize_t ret;
1803         u32 nr, i;
1804         char *str;
1805         struct strbuf sb;
1806         int cpu_nr = ph->env.nr_cpus_online;
1807         u64 size = 0;
1808 
1809         ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
1810         if (!ph->env.cpu)
1811                 return -1;
1812 
1813         ret = readn(fd, &nr, sizeof(nr));
1814         if (ret != sizeof(nr))
1815                 goto free_cpu;
1816 
1817         if (ph->needs_swap)
1818                 nr = bswap_32(nr);
1819 
1820         ph->env.nr_sibling_cores = nr;
1821         size += sizeof(u32);
1822         if (strbuf_init(&sb, 128) < 0)
1823                 goto free_cpu;
1824 
1825         for (i = 0; i < nr; i++) {
1826                 str = do_read_string(fd, ph);
1827                 if (!str)
1828                         goto error;
1829 
1830                 /* include a NULL character at the end */
1831                 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
1832                         goto error;
1833                 size += string_size(str);
1834                 free(str);
1835         }
1836         ph->env.sibling_cores = strbuf_detach(&sb, NULL);
1837 
1838         ret = readn(fd, &nr, sizeof(nr));
1839         if (ret != sizeof(nr))
1840                 return -1;
1841 
1842         if (ph->needs_swap)
1843                 nr = bswap_32(nr);
1844 
1845         ph->env.nr_sibling_threads = nr;
1846         size += sizeof(u32);
1847 
1848         for (i = 0; i < nr; i++) {
1849                 str = do_read_string(fd, ph);
1850                 if (!str)
1851                         goto error;
1852 
1853                 /* include a NULL character at the end */
1854                 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
1855                         goto error;
1856                 size += string_size(str);
1857                 free(str);
1858         }
1859         ph->env.sibling_threads = strbuf_detach(&sb, NULL);
1860 
1861         /*
1862          * The header may be from old perf,
1863          * which doesn't include core id and socket id information.
1864          */
1865         if (section->size <= size) {
1866                 zfree(&ph->env.cpu);
1867                 return 0;
1868         }
1869 
1870         for (i = 0; i < (u32)cpu_nr; i++) {
1871                 ret = readn(fd, &nr, sizeof(nr));
1872                 if (ret != sizeof(nr))
1873                         goto free_cpu;
1874 
1875                 if (ph->needs_swap)
1876                         nr = bswap_32(nr);
1877 
1878                 ph->env.cpu[i].core_id = nr;
1879 
1880                 ret = readn(fd, &nr, sizeof(nr));
1881                 if (ret != sizeof(nr))
1882                         goto free_cpu;
1883 
1884                 if (ph->needs_swap)
1885                         nr = bswap_32(nr);
1886 
1887                 if (nr > (u32)cpu_nr) {
1888                         pr_debug("socket_id number is too big."
1889                                  "You may need to upgrade the perf tool.\n");
1890                         goto free_cpu;
1891                 }
1892 
1893                 ph->env.cpu[i].socket_id = nr;
1894         }
1895 
1896         return 0;
1897 
1898 error:
1899         strbuf_release(&sb);
1900 free_cpu:
1901         zfree(&ph->env.cpu);
1902         return -1;
1903 }
1904 
1905 static int process_numa_topology(struct perf_file_section *section __maybe_unused,
1906                                  struct perf_header *ph, int fd,
1907                                  void *data __maybe_unused)
1908 {
1909         ssize_t ret;
1910         u32 nr, node, i;
1911         char *str;
1912         uint64_t mem_total, mem_free;
1913         struct strbuf sb;
1914 
1915         /* nr nodes */
1916         ret = readn(fd, &nr, sizeof(nr));
1917         if (ret != sizeof(nr))
1918                 return -1;
1919 
1920         if (ph->needs_swap)
1921                 nr = bswap_32(nr);
1922 
1923         ph->env.nr_numa_nodes = nr;
1924         if (strbuf_init(&sb, 256) < 0)
1925                 return -1;
1926 
1927         for (i = 0; i < nr; i++) {
1928                 /* node number */
1929                 ret = readn(fd, &node, sizeof(node));
1930                 if (ret != sizeof(node))
1931                         goto error;
1932 
1933                 ret = readn(fd, &mem_total, sizeof(u64));
1934                 if (ret != sizeof(u64))
1935                         goto error;
1936 
1937                 ret = readn(fd, &mem_free, sizeof(u64));
1938                 if (ret != sizeof(u64))
1939                         goto error;
1940 
1941                 if (ph->needs_swap) {
1942                         node = bswap_32(node);
1943                         mem_total = bswap_64(mem_total);
1944                         mem_free = bswap_64(mem_free);
1945                 }
1946 
1947                 if (strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
1948                                 node, mem_total, mem_free) < 0)
1949                         goto error;
1950 
1951                 str = do_read_string(fd, ph);
1952                 if (!str)
1953                         goto error;
1954 
1955                 /* include a NULL character at the end */
1956                 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
1957                         goto error;
1958                 free(str);
1959         }
1960         ph->env.numa_nodes = strbuf_detach(&sb, NULL);
1961         return 0;
1962 
1963 error:
1964         strbuf_release(&sb);
1965         return -1;
1966 }
1967 
1968 static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
1969                                 struct perf_header *ph, int fd,
1970                                 void *data __maybe_unused)
1971 {
1972         ssize_t ret;
1973         char *name;
1974         u32 pmu_num;
1975         u32 type;
1976         struct strbuf sb;
1977 
1978         ret = readn(fd, &pmu_num, sizeof(pmu_num));
1979         if (ret != sizeof(pmu_num))
1980                 return -1;
1981 
1982         if (ph->needs_swap)
1983                 pmu_num = bswap_32(pmu_num);
1984 
1985         if (!pmu_num) {
1986                 pr_debug("pmu mappings not available\n");
1987                 return 0;
1988         }
1989 
1990         ph->env.nr_pmu_mappings = pmu_num;
1991         if (strbuf_init(&sb, 128) < 0)
1992                 return -1;
1993 
1994         while (pmu_num) {
1995                 if (readn(fd, &type, sizeof(type)) != sizeof(type))
1996                         goto error;
1997                 if (ph->needs_swap)
1998                         type = bswap_32(type);
1999 
2000                 name = do_read_string(fd, ph);
2001                 if (!name)
2002                         goto error;
2003 
2004                 if (strbuf_addf(&sb, "%u:%s", type, name) < 0)
2005                         goto error;
2006                 /* include a NULL character at the end */
2007                 if (strbuf_add(&sb, "", 1) < 0)
2008                         goto error;
2009 
2010                 if (!strcmp(name, "msr"))
2011                         ph->env.msr_pmu_type = type;
2012 
2013                 free(name);
2014                 pmu_num--;
2015         }
2016         ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2017         return 0;
2018 
2019 error:
2020         strbuf_release(&sb);
2021         return -1;
2022 }
2023 
2024 static int process_group_desc(struct perf_file_section *section __maybe_unused,
2025                               struct perf_header *ph, int fd,
2026                               void *data __maybe_unused)
2027 {
2028         size_t ret = -1;
2029         u32 i, nr, nr_groups;
2030         struct perf_session *session;
2031         struct perf_evsel *evsel, *leader = NULL;
2032         struct group_desc {
2033                 char *name;
2034                 u32 leader_idx;
2035                 u32 nr_members;
2036         } *desc;
2037 
2038         if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
2039                 return -1;
2040 
2041         if (ph->needs_swap)
2042                 nr_groups = bswap_32(nr_groups);
2043 
2044         ph->env.nr_groups = nr_groups;
2045         if (!nr_groups) {
2046                 pr_debug("group desc not available\n");
2047                 return 0;
2048         }
2049 
2050         desc = calloc(nr_groups, sizeof(*desc));
2051         if (!desc)
2052                 return -1;
2053 
2054         for (i = 0; i < nr_groups; i++) {
2055                 desc[i].name = do_read_string(fd, ph);
2056                 if (!desc[i].name)
2057                         goto out_free;
2058 
2059                 if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
2060                         goto out_free;
2061 
2062                 if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
2063                         goto out_free;
2064 
2065                 if (ph->needs_swap) {
2066                         desc[i].leader_idx = bswap_32(desc[i].leader_idx);
2067                         desc[i].nr_members = bswap_32(desc[i].nr_members);
2068                 }
2069         }
2070 
2071         /*
2072          * Rebuild group relationship based on the group_desc
2073          */
2074         session = container_of(ph, struct perf_session, header);
2075         session->evlist->nr_groups = nr_groups;
2076 
2077         i = nr = 0;
2078         evlist__for_each(session->evlist, evsel) {
2079                 if (evsel->idx == (int) desc[i].leader_idx) {
2080                         evsel->leader = evsel;
2081                         /* {anon_group} is a dummy name */
2082                         if (strcmp(desc[i].name, "{anon_group}")) {
2083                                 evsel->group_name = desc[i].name;
2084                                 desc[i].name = NULL;
2085                         }
2086                         evsel->nr_members = desc[i].nr_members;
2087 
2088                         if (i >= nr_groups || nr > 0) {
2089                                 pr_debug("invalid group desc\n");
2090                                 goto out_free;
2091                         }
2092 
2093                         leader = evsel;
2094                         nr = evsel->nr_members - 1;
2095                         i++;
2096                 } else if (nr) {
2097                         /* This is a group member */
2098                         evsel->leader = leader;
2099 
2100                         nr--;
2101                 }
2102         }
2103 
2104         if (i != nr_groups || nr != 0) {
2105                 pr_debug("invalid group desc\n");
2106                 goto out_free;
2107         }
2108 
2109         ret = 0;
2110 out_free:
2111         for (i = 0; i < nr_groups; i++)
2112                 zfree(&desc[i].name);
2113         free(desc);
2114 
2115         return ret;
2116 }
2117 
2118 static int process_auxtrace(struct perf_file_section *section,
2119                             struct perf_header *ph, int fd,
2120                             void *data __maybe_unused)
2121 {
2122         struct perf_session *session;
2123         int err;
2124 
2125         session = container_of(ph, struct perf_session, header);
2126 
2127         err = auxtrace_index__process(fd, section->size, session,
2128                                       ph->needs_swap);
2129         if (err < 0)
2130                 pr_err("Failed to process auxtrace index\n");
2131         return err;
2132 }
2133 
2134 static int process_cache(struct perf_file_section *section __maybe_unused,
2135                          struct perf_header *ph __maybe_unused, int fd __maybe_unused,
2136                          void *data __maybe_unused)
2137 {
2138         struct cpu_cache_level *caches;
2139         u32 cnt, i, version;
2140 
2141         if (readn(fd, &version, sizeof(version)) != sizeof(version))
2142                 return -1;
2143 
2144         if (ph->needs_swap)
2145                 version = bswap_32(version);
2146 
2147         if (version != 1)
2148                 return -1;
2149 
2150         if (readn(fd, &cnt, sizeof(cnt)) != sizeof(cnt))
2151                 return -1;
2152 
2153         if (ph->needs_swap)
2154                 cnt = bswap_32(cnt);
2155 
2156         caches = zalloc(sizeof(*caches) * cnt);
2157         if (!caches)
2158                 return -1;
2159 
2160         for (i = 0; i < cnt; i++) {
2161                 struct cpu_cache_level c;
2162 
2163                 #define _R(v)                                           \
2164                         if (readn(fd, &c.v, sizeof(u32)) != sizeof(u32))\
2165                                 goto out_free_caches;                   \
2166                         if (ph->needs_swap)                             \
2167                                 c.v = bswap_32(c.v);                    \
2168 
2169                 _R(level)
2170                 _R(line_size)
2171                 _R(sets)
2172                 _R(ways)
2173                 #undef _R
2174 
2175                 #define _R(v)                           \
2176                         c.v = do_read_string(fd, ph);   \
2177                         if (!c.v)                       \
2178                                 goto out_free_caches;
2179 
2180                 _R(type)
2181                 _R(size)
2182                 _R(map)
2183                 #undef _R
2184 
2185                 caches[i] = c;
2186         }
2187 
2188         ph->env.caches = caches;
2189         ph->env.caches_cnt = cnt;
2190         return 0;
2191 out_free_caches:
2192         free(caches);
2193         return -1;
2194 }
2195 
2196 struct feature_ops {
2197         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
2198         void (*print)(struct perf_header *h, int fd, FILE *fp);
2199         int (*process)(struct perf_file_section *section,
2200                        struct perf_header *h, int fd, void *data);
2201         const char *name;
2202         bool full_only;
2203 };
2204 
2205 #define FEAT_OPA(n, func) \
2206         [n] = { .name = #n, .write = write_##func, .print = print_##func }
2207 #define FEAT_OPP(n, func) \
2208         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2209                 .process = process_##func }
2210 #define FEAT_OPF(n, func) \
2211         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2212                 .process = process_##func, .full_only = true }
2213 
2214 /* feature_ops not implemented: */
2215 #define print_tracing_data      NULL
2216 #define print_build_id          NULL
2217 
2218 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
2219         FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
2220         FEAT_OPP(HEADER_BUILD_ID,       build_id),
2221         FEAT_OPP(HEADER_HOSTNAME,       hostname),
2222         FEAT_OPP(HEADER_OSRELEASE,      osrelease),
2223         FEAT_OPP(HEADER_VERSION,        version),
2224         FEAT_OPP(HEADER_ARCH,           arch),
2225         FEAT_OPP(HEADER_NRCPUS,         nrcpus),
2226         FEAT_OPP(HEADER_CPUDESC,        cpudesc),
2227         FEAT_OPP(HEADER_CPUID,          cpuid),
2228         FEAT_OPP(HEADER_TOTAL_MEM,      total_mem),
2229         FEAT_OPP(HEADER_EVENT_DESC,     event_desc),
2230         FEAT_OPP(HEADER_CMDLINE,        cmdline),
2231         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
2232         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
2233         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
2234         FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
2235         FEAT_OPP(HEADER_GROUP_DESC,     group_desc),
2236         FEAT_OPP(HEADER_AUXTRACE,       auxtrace),
2237         FEAT_OPA(HEADER_STAT,           stat),
2238         FEAT_OPF(HEADER_CACHE,          cache),
2239 };
2240 
2241 struct header_print_data {
2242         FILE *fp;
2243         bool full; /* extended list of headers */
2244 };
2245 
2246 static int perf_file_section__fprintf_info(struct perf_file_section *section,
2247                                            struct perf_header *ph,
2248                                            int feat, int fd, void *data)
2249 {
2250         struct header_print_data *hd = data;
2251 
2252         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
2253                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
2254                                 "%d, continuing...\n", section->offset, feat);
2255                 return 0;
2256         }
2257         if (feat >= HEADER_LAST_FEATURE) {
2258                 pr_warning("unknown feature %d\n", feat);
2259                 return 0;
2260         }
2261         if (!feat_ops[feat].print)
2262                 return 0;
2263 
2264         if (!feat_ops[feat].full_only || hd->full)
2265                 feat_ops[feat].print(ph, fd, hd->fp);
2266         else
2267                 fprintf(hd->fp, "# %s info available, use -I to display\n",
2268                         feat_ops[feat].name);
2269 
2270         return 0;
2271 }
2272 
2273 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
2274 {
2275         struct header_print_data hd;
2276         struct perf_header *header = &session->header;
2277         int fd = perf_data_file__fd(session->file);
2278         hd.fp = fp;
2279         hd.full = full;
2280 
2281         perf_header__process_sections(header, fd, &hd,
2282                                       perf_file_section__fprintf_info);
2283         return 0;
2284 }
2285 
2286 static int do_write_feat(int fd, struct perf_header *h, int type,
2287                          struct perf_file_section **p,
2288                          struct perf_evlist *evlist)
2289 {
2290         int err;
2291         int ret = 0;
2292 
2293         if (perf_header__has_feat(h, type)) {
2294                 if (!feat_ops[type].write)
2295                         return -1;
2296 
2297                 (*p)->offset = lseek(fd, 0, SEEK_CUR);
2298 
2299                 err = feat_ops[type].write(fd, h, evlist);
2300                 if (err < 0) {
2301                         pr_debug("failed to write feature %d\n", type);
2302 
2303                         /* undo anything written */
2304                         lseek(fd, (*p)->offset, SEEK_SET);
2305 
2306                         return -1;
2307                 }
2308                 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
2309                 (*p)++;
2310         }
2311         return ret;
2312 }
2313 
2314 static int perf_header__adds_write(struct perf_header *header,
2315                                    struct perf_evlist *evlist, int fd)
2316 {
2317         int nr_sections;
2318         struct perf_file_section *feat_sec, *p;
2319         int sec_size;
2320         u64 sec_start;
2321         int feat;
2322         int err;
2323 
2324         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
2325         if (!nr_sections)
2326                 return 0;
2327 
2328         feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
2329         if (feat_sec == NULL)
2330                 return -ENOMEM;
2331 
2332         sec_size = sizeof(*feat_sec) * nr_sections;
2333 
2334         sec_start = header->feat_offset;
2335         lseek(fd, sec_start + sec_size, SEEK_SET);
2336 
2337         for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
2338                 if (do_write_feat(fd, header, feat, &p, evlist))
2339                         perf_header__clear_feat(header, feat);
2340         }
2341 
2342         lseek(fd, sec_start, SEEK_SET);
2343         /*
2344          * may write more than needed due to dropped feature, but
2345          * this is okay, reader will skip the mising entries
2346          */
2347         err = do_write(fd, feat_sec, sec_size);
2348         if (err < 0)
2349                 pr_debug("failed to write feature section\n");
2350         free(feat_sec);
2351         return err;
2352 }
2353 
2354 int perf_header__write_pipe(int fd)
2355 {
2356         struct perf_pipe_file_header f_header;
2357         int err;
2358 
2359         f_header = (struct perf_pipe_file_header){
2360                 .magic     = PERF_MAGIC,
2361                 .size      = sizeof(f_header),
2362         };
2363 
2364         err = do_write(fd, &f_header, sizeof(f_header));
2365         if (err < 0) {
2366                 pr_debug("failed to write perf pipe header\n");
2367                 return err;
2368         }
2369 
2370         return 0;
2371 }
2372 
2373 int perf_session__write_header(struct perf_session *session,
2374                                struct perf_evlist *evlist,
2375                                int fd, bool at_exit)
2376 {
2377         struct perf_file_header f_header;
2378         struct perf_file_attr   f_attr;
2379         struct perf_header *header = &session->header;
2380         struct perf_evsel *evsel;
2381         u64 attr_offset;
2382         int err;
2383 
2384         lseek(fd, sizeof(f_header), SEEK_SET);
2385 
2386         evlist__for_each(session->evlist, evsel) {
2387                 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
2388                 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
2389                 if (err < 0) {
2390                         pr_debug("failed to write perf header\n");
2391                         return err;
2392                 }
2393         }
2394 
2395         attr_offset = lseek(fd, 0, SEEK_CUR);
2396 
2397         evlist__for_each(evlist, evsel) {
2398                 f_attr = (struct perf_file_attr){
2399                         .attr = evsel->attr,
2400                         .ids  = {
2401                                 .offset = evsel->id_offset,
2402                                 .size   = evsel->ids * sizeof(u64),
2403                         }
2404                 };
2405                 err = do_write(fd, &f_attr, sizeof(f_attr));
2406                 if (err < 0) {
2407                         pr_debug("failed to write perf header attribute\n");
2408                         return err;
2409                 }
2410         }
2411 
2412         if (!header->data_offset)
2413                 header->data_offset = lseek(fd, 0, SEEK_CUR);
2414         header->feat_offset = header->data_offset + header->data_size;
2415 
2416         if (at_exit) {
2417                 err = perf_header__adds_write(header, evlist, fd);
2418                 if (err < 0)
2419                         return err;
2420         }
2421 
2422         f_header = (struct perf_file_header){
2423                 .magic     = PERF_MAGIC,
2424                 .size      = sizeof(f_header),
2425                 .attr_size = sizeof(f_attr),
2426                 .attrs = {
2427                         .offset = attr_offset,
2428                         .size   = evlist->nr_entries * sizeof(f_attr),
2429                 },
2430                 .data = {
2431                         .offset = header->data_offset,
2432                         .size   = header->data_size,
2433                 },
2434                 /* event_types is ignored, store zeros */
2435         };
2436 
2437         memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
2438 
2439         lseek(fd, 0, SEEK_SET);
2440         err = do_write(fd, &f_header, sizeof(f_header));
2441         if (err < 0) {
2442                 pr_debug("failed to write perf header\n");
2443                 return err;
2444         }
2445         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
2446 
2447         return 0;
2448 }
2449 
2450 static int perf_header__getbuffer64(struct perf_header *header,
2451                                     int fd, void *buf, size_t size)
2452 {
2453         if (readn(fd, buf, size) <= 0)
2454                 return -1;
2455 
2456         if (header->needs_swap)
2457                 mem_bswap_64(buf, size);
2458 
2459         return 0;
2460 }
2461 
2462 int perf_header__process_sections(struct perf_header *header, int fd,
2463                                   void *data,
2464                                   int (*process)(struct perf_file_section *section,
2465                                                  struct perf_header *ph,
2466                                                  int feat, int fd, void *data))
2467 {
2468         struct perf_file_section *feat_sec, *sec;
2469         int nr_sections;
2470         int sec_size;
2471         int feat;
2472         int err;
2473 
2474         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
2475         if (!nr_sections)
2476                 return 0;
2477 
2478         feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
2479         if (!feat_sec)
2480                 return -1;
2481 
2482         sec_size = sizeof(*feat_sec) * nr_sections;
2483 
2484         lseek(fd, header->feat_offset, SEEK_SET);
2485 
2486         err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
2487         if (err < 0)
2488                 goto out_free;
2489 
2490         for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
2491                 err = process(sec++, header, feat, fd, data);
2492                 if (err < 0)
2493                         goto out_free;
2494         }
2495         err = 0;
2496 out_free:
2497         free(feat_sec);
2498         return err;
2499 }
2500 
2501 static const int attr_file_abi_sizes[] = {
2502         [0] = PERF_ATTR_SIZE_VER0,
2503         [1] = PERF_ATTR_SIZE_VER1,
2504         [2] = PERF_ATTR_SIZE_VER2,
2505         [3] = PERF_ATTR_SIZE_VER3,
2506         [4] = PERF_ATTR_SIZE_VER4,
2507         0,
2508 };
2509 
2510 /*
2511  * In the legacy file format, the magic number is not used to encode endianness.
2512  * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
2513  * on ABI revisions, we need to try all combinations for all endianness to
2514  * detect the endianness.
2515  */
2516 static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
2517 {
2518         uint64_t ref_size, attr_size;
2519         int i;
2520 
2521         for (i = 0 ; attr_file_abi_sizes[i]; i++) {
2522                 ref_size = attr_file_abi_sizes[i]
2523                          + sizeof(struct perf_file_section);
2524                 if (hdr_sz != ref_size) {
2525                         attr_size = bswap_64(hdr_sz);
2526                         if (attr_size != ref_size)
2527                                 continue;
2528 
2529                         ph->needs_swap = true;
2530                 }
2531                 pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
2532                          i,
2533                          ph->needs_swap);
2534                 return 0;
2535         }
2536         /* could not determine endianness */
2537         return -1;
2538 }
2539 
2540 #define PERF_PIPE_HDR_VER0      16
2541 
2542 static const size_t attr_pipe_abi_sizes[] = {
2543         [0] = PERF_PIPE_HDR_VER0,
2544         0,
2545 };
2546 
2547 /*
2548  * In the legacy pipe format, there is an implicit assumption that endiannesss
2549  * between host recording the samples, and host parsing the samples is the
2550  * same. This is not always the case given that the pipe output may always be
2551  * redirected into a file and analyzed on a different machine with possibly a
2552  * different endianness and perf_event ABI revsions in the perf tool itself.
2553  */
2554 static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
2555 {
2556         u64 attr_size;
2557         int i;
2558 
2559         for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
2560                 if (hdr_sz != attr_pipe_abi_sizes[i]) {
2561                         attr_size = bswap_64(hdr_sz);
2562                         if (attr_size != hdr_sz)
2563                                 continue;
2564 
2565                         ph->needs_swap = true;
2566                 }
2567                 pr_debug("Pipe ABI%d perf.data file detected\n", i);
2568                 return 0;
2569         }
2570         return -1;
2571 }
2572 
2573 bool is_perf_magic(u64 magic)
2574 {
2575         if (!memcmp(&magic, __perf_magic1, sizeof(magic))
2576                 || magic == __perf_magic2
2577                 || magic == __perf_magic2_sw)
2578                 return true;
2579 
2580         return false;
2581 }
2582 
2583 static int check_magic_endian(u64 magic, uint64_t hdr_sz,
2584                               bool is_pipe, struct perf_header *ph)
2585 {
2586         int ret;
2587 
2588         /* check for legacy format */
2589         ret = memcmp(&magic, __perf_magic1, sizeof(magic));
2590         if (ret == 0) {
2591                 ph->version = PERF_HEADER_VERSION_1;
2592                 pr_debug("legacy perf.data format\n");
2593                 if (is_pipe)
2594                         return try_all_pipe_abis(hdr_sz, ph);
2595 
2596                 return try_all_file_abis(hdr_sz, ph);
2597         }
2598         /*
2599          * the new magic number serves two purposes:
2600          * - unique number to identify actual perf.data files
2601          * - encode endianness of file
2602          */
2603         ph->version = PERF_HEADER_VERSION_2;
2604 
2605         /* check magic number with one endianness */
2606         if (magic == __perf_magic2)
2607                 return 0;
2608 
2609         /* check magic number with opposite endianness */
2610         if (magic != __perf_magic2_sw)
2611                 return -1;
2612 
2613         ph->needs_swap = true;
2614 
2615         return 0;
2616 }
2617 
2618 int perf_file_header__read(struct perf_file_header *header,
2619                            struct perf_header *ph, int fd)
2620 {
2621         ssize_t ret;
2622 
2623         lseek(fd, 0, SEEK_SET);
2624 
2625         ret = readn(fd, header, sizeof(*header));
2626         if (ret <= 0)
2627                 return -1;
2628 
2629         if (check_magic_endian(header->magic,
2630                                header->attr_size, false, ph) < 0) {
2631                 pr_debug("magic/endian check failed\n");
2632                 return -1;
2633         }
2634 
2635         if (ph->needs_swap) {
2636                 mem_bswap_64(header, offsetof(struct perf_file_header,
2637                              adds_features));
2638         }
2639 
2640         if (header->size != sizeof(*header)) {
2641                 /* Support the previous format */
2642                 if (header->size == offsetof(typeof(*header), adds_features))
2643                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
2644                 else
2645                         return -1;
2646         } else if (ph->needs_swap) {
2647                 /*
2648                  * feature bitmap is declared as an array of unsigned longs --
2649                  * not good since its size can differ between the host that
2650                  * generated the data file and the host analyzing the file.
2651                  *
2652                  * We need to handle endianness, but we don't know the size of
2653                  * the unsigned long where the file was generated. Take a best
2654                  * guess at determining it: try 64-bit swap first (ie., file
2655                  * created on a 64-bit host), and check if the hostname feature
2656                  * bit is set (this feature bit is forced on as of fbe96f2).
2657                  * If the bit is not, undo the 64-bit swap and try a 32-bit
2658                  * swap. If the hostname bit is still not set (e.g., older data
2659                  * file), punt and fallback to the original behavior --
2660                  * clearing all feature bits and setting buildid.
2661                  */
2662                 mem_bswap_64(&header->adds_features,
2663                             BITS_TO_U64(HEADER_FEAT_BITS));
2664 
2665                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
2666                         /* unswap as u64 */
2667                         mem_bswap_64(&header->adds_features,
2668                                     BITS_TO_U64(HEADER_FEAT_BITS));
2669 
2670                         /* unswap as u32 */
2671                         mem_bswap_32(&header->adds_features,
2672                                     BITS_TO_U32(HEADER_FEAT_BITS));
2673                 }
2674 
2675                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
2676                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
2677                         set_bit(HEADER_BUILD_ID, header->adds_features);
2678                 }
2679         }
2680 
2681         memcpy(&ph->adds_features, &header->adds_features,
2682                sizeof(ph->adds_features));
2683 
2684         ph->data_offset  = header->data.offset;
2685         ph->data_size    = header->data.size;
2686         ph->feat_offset  = header->data.offset + header->data.size;
2687         return 0;
2688 }
2689 
2690 static int perf_file_section__process(struct perf_file_section *section,
2691                                       struct perf_header *ph,
2692                                       int feat, int fd, void *data)
2693 {
2694         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
2695                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
2696                           "%d, continuing...\n", section->offset, feat);
2697                 return 0;
2698         }
2699 
2700         if (feat >= HEADER_LAST_FEATURE) {
2701                 pr_debug("unknown feature %d, continuing...\n", feat);
2702                 return 0;
2703         }
2704 
2705         if (!feat_ops[feat].process)
2706                 return 0;
2707 
2708         return feat_ops[feat].process(section, ph, fd, data);
2709 }
2710 
2711 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
2712                                        struct perf_header *ph, int fd,
2713                                        bool repipe)
2714 {
2715         ssize_t ret;
2716 
2717         ret = readn(fd, header, sizeof(*header));
2718         if (ret <= 0)
2719                 return -1;
2720 
2721         if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
2722                 pr_debug("endian/magic failed\n");
2723                 return -1;
2724         }
2725 
2726         if (ph->needs_swap)
2727                 header->size = bswap_64(header->size);
2728 
2729         if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
2730                 return -1;
2731 
2732         return 0;
2733 }
2734 
2735 static int perf_header__read_pipe(struct perf_session *session)
2736 {
2737         struct perf_header *header = &session->header;
2738         struct perf_pipe_file_header f_header;
2739 
2740         if (perf_file_header__read_pipe(&f_header, header,
2741                                         perf_data_file__fd(session->file),
2742                                         session->repipe) < 0) {
2743                 pr_debug("incompatible file format\n");
2744                 return -EINVAL;
2745         }
2746 
2747         return 0;
2748 }
2749 
2750 static int read_attr(int fd, struct perf_header *ph,
2751                      struct perf_file_attr *f_attr)
2752 {
2753         struct perf_event_attr *attr = &f_attr->attr;
2754         size_t sz, left;
2755         size_t our_sz = sizeof(f_attr->attr);
2756         ssize_t ret;
2757 
2758         memset(f_attr, 0, sizeof(*f_attr));
2759 
2760         /* read minimal guaranteed structure */
2761         ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
2762         if (ret <= 0) {
2763                 pr_debug("cannot read %d bytes of header attr\n",
2764                          PERF_ATTR_SIZE_VER0);
2765                 return -1;
2766         }
2767 
2768         /* on file perf_event_attr size */
2769         sz = attr->size;
2770 
2771         if (ph->needs_swap)
2772                 sz = bswap_32(sz);
2773 
2774         if (sz == 0) {
2775                 /* assume ABI0 */
2776                 sz =  PERF_ATTR_SIZE_VER0;
2777         } else if (sz > our_sz) {
2778                 pr_debug("file uses a more recent and unsupported ABI"
2779                          " (%zu bytes extra)\n", sz - our_sz);
2780                 return -1;
2781         }
2782         /* what we have not yet read and that we know about */
2783         left = sz - PERF_ATTR_SIZE_VER0;
2784         if (left) {
2785                 void *ptr = attr;
2786                 ptr += PERF_ATTR_SIZE_VER0;
2787 
2788                 ret = readn(fd, ptr, left);
2789         }
2790         /* read perf_file_section, ids are read in caller */
2791         ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
2792 
2793         return ret <= 0 ? -1 : 0;
2794 }
2795 
2796 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
2797                                                 struct pevent *pevent)
2798 {
2799         struct event_format *event;
2800         char bf[128];
2801 
2802         /* already prepared */
2803         if (evsel->tp_format)
2804                 return 0;
2805 
2806         if (pevent == NULL) {
2807                 pr_debug("broken or missing trace data\n");
2808                 return -1;
2809         }
2810 
2811         event = pevent_find_event(pevent, evsel->attr.config);
2812         if (event == NULL)
2813                 return -1;
2814 
2815         if (!evsel->name) {
2816                 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
2817                 evsel->name = strdup(bf);
2818                 if (evsel->name == NULL)
2819                         return -1;
2820         }
2821 
2822         evsel->tp_format = event;
2823         return 0;
2824 }
2825 
2826 static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
2827                                                   struct pevent *pevent)
2828 {
2829         struct perf_evsel *pos;
2830 
2831         evlist__for_each(evlist, pos) {
2832                 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
2833                     perf_evsel__prepare_tracepoint_event(pos, pevent))
2834                         return -1;
2835         }
2836 
2837         return 0;
2838 }
2839 
2840 int perf_session__read_header(struct perf_session *session)
2841 {
2842         struct perf_data_file *file = session->file;
2843         struct perf_header *header = &session->header;
2844         struct perf_file_header f_header;
2845         struct perf_file_attr   f_attr;
2846         u64                     f_id;
2847         int nr_attrs, nr_ids, i, j;
2848         int fd = perf_data_file__fd(file);
2849 
2850         session->evlist = perf_evlist__new();
2851         if (session->evlist == NULL)
2852                 return -ENOMEM;
2853 
2854         session->evlist->env = &header->env;
2855         session->machines.host.env = &header->env;
2856         if (perf_data_file__is_pipe(file))
2857                 return perf_header__read_pipe(session);
2858 
2859         if (perf_file_header__read(&f_header, header, fd) < 0)
2860                 return -EINVAL;
2861 
2862         /*
2863          * Sanity check that perf.data was written cleanly; data size is
2864          * initialized to 0 and updated only if the on_exit function is run.
2865          * If data size is still 0 then the file contains only partial
2866          * information.  Just warn user and process it as much as it can.
2867          */
2868         if (f_header.data.size == 0) {
2869                 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
2870                            "Was the 'perf record' command properly terminated?\n",
2871                            file->path);
2872         }
2873 
2874         nr_attrs = f_header.attrs.size / f_header.attr_size;
2875         lseek(fd, f_header.attrs.offset, SEEK_SET);
2876 
2877         for (i = 0; i < nr_attrs; i++) {
2878                 struct perf_evsel *evsel;
2879                 off_t tmp;
2880 
2881                 if (read_attr(fd, header, &f_attr) < 0)
2882                         goto out_errno;
2883 
2884                 if (header->needs_swap) {
2885                         f_attr.ids.size   = bswap_64(f_attr.ids.size);
2886                         f_attr.ids.offset = bswap_64(f_attr.ids.offset);
2887                         perf_event__attr_swap(&f_attr.attr);
2888                 }
2889 
2890                 tmp = lseek(fd, 0, SEEK_CUR);
2891                 evsel = perf_evsel__new(&f_attr.attr);
2892 
2893                 if (evsel == NULL)
2894                         goto out_delete_evlist;
2895 
2896                 evsel->needs_swap = header->needs_swap;
2897                 /*
2898                  * Do it before so that if perf_evsel__alloc_id fails, this
2899                  * entry gets purged too at perf_evlist__delete().
2900                  */
2901                 perf_evlist__add(session->evlist, evsel);
2902 
2903                 nr_ids = f_attr.ids.size / sizeof(u64);
2904                 /*
2905                  * We don't have the cpu and thread maps on the header, so
2906                  * for allocating the perf_sample_id table we fake 1 cpu and
2907                  * hattr->ids threads.
2908                  */
2909                 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
2910                         goto out_delete_evlist;
2911 
2912                 lseek(fd, f_attr.ids.offset, SEEK_SET);
2913 
2914                 for (j = 0; j < nr_ids; j++) {
2915                         if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
2916                                 goto out_errno;
2917 
2918                         perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
2919                 }
2920 
2921                 lseek(fd, tmp, SEEK_SET);
2922         }
2923 
2924         symbol_conf.nr_events = nr_attrs;
2925 
2926         perf_header__process_sections(header, fd, &session->tevent,
2927                                       perf_file_section__process);
2928 
2929         if (perf_evlist__prepare_tracepoint_events(session->evlist,
2930                                                    session->tevent.pevent))
2931                 goto out_delete_evlist;
2932 
2933         return 0;
2934 out_errno:
2935         return -errno;
2936 
2937 out_delete_evlist:
2938         perf_evlist__delete(session->evlist);
2939         session->evlist = NULL;
2940         return -ENOMEM;
2941 }
2942 
2943 int perf_event__synthesize_attr(struct perf_tool *tool,
2944                                 struct perf_event_attr *attr, u32 ids, u64 *id,
2945                                 perf_event__handler_t process)
2946 {
2947         union perf_event *ev;
2948         size_t size;
2949         int err;
2950 
2951         size = sizeof(struct perf_event_attr);
2952         size = PERF_ALIGN(size, sizeof(u64));
2953         size += sizeof(struct perf_event_header);
2954         size += ids * sizeof(u64);
2955 
2956         ev = malloc(size);
2957 
2958         if (ev == NULL)
2959                 return -ENOMEM;
2960 
2961         ev->attr.attr = *attr;
2962         memcpy(ev->attr.id, id, ids * sizeof(u64));
2963 
2964         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2965         ev->attr.header.size = (u16)size;
2966 
2967         if (ev->attr.header.size == size)
2968                 err = process(tool, ev, NULL, NULL);
2969         else
2970                 err = -E2BIG;
2971 
2972         free(ev);
2973 
2974         return err;
2975 }
2976 
2977 static struct event_update_event *
2978 event_update_event__new(size_t size, u64 type, u64 id)
2979 {
2980         struct event_update_event *ev;
2981 
2982         size += sizeof(*ev);
2983         size  = PERF_ALIGN(size, sizeof(u64));
2984 
2985         ev = zalloc(size);
2986         if (ev) {
2987                 ev->header.type = PERF_RECORD_EVENT_UPDATE;
2988                 ev->header.size = (u16)size;
2989                 ev->type = type;
2990                 ev->id = id;
2991         }
2992         return ev;
2993 }
2994 
2995 int
2996 perf_event__synthesize_event_update_unit(struct perf_tool *tool,
2997                                          struct perf_evsel *evsel,
2998                                          perf_event__handler_t process)
2999 {
3000         struct event_update_event *ev;
3001         size_t size = strlen(evsel->unit);
3002         int err;
3003 
3004         ev = event_update_event__new(size + 1, PERF_EVENT_UPDATE__UNIT, evsel->id[0]);
3005         if (ev == NULL)
3006                 return -ENOMEM;
3007 
3008         strncpy(ev->data, evsel->unit, size);
3009         err = process(tool, (union perf_event *)ev, NULL, NULL);
3010         free(ev);
3011         return err;
3012 }
3013 
3014 int
3015 perf_event__synthesize_event_update_scale(struct perf_tool *tool,
3016                                           struct perf_evsel *evsel,
3017                                           perf_event__handler_t process)
3018 {
3019         struct event_update_event *ev;
3020         struct event_update_event_scale *ev_data;
3021         int err;
3022 
3023         ev = event_update_event__new(sizeof(*ev_data), PERF_EVENT_UPDATE__SCALE, evsel->id[0]);
3024         if (ev == NULL)
3025                 return -ENOMEM;
3026 
3027         ev_data = (struct event_update_event_scale *) ev->data;
3028         ev_data->scale = evsel->scale;
3029         err = process(tool, (union perf_event*) ev, NULL, NULL);
3030         free(ev);
3031         return err;
3032 }
3033 
3034 int
3035 perf_event__synthesize_event_update_name(struct perf_tool *tool,
3036                                          struct perf_evsel *evsel,
3037                                          perf_event__handler_t process)
3038 {
3039         struct event_update_event *ev;
3040         size_t len = strlen(evsel->name);
3041         int err;
3042 
3043         ev = event_update_event__new(len + 1, PERF_EVENT_UPDATE__NAME, evsel->id[0]);
3044         if (ev == NULL)
3045                 return -ENOMEM;
3046 
3047         strncpy(ev->data, evsel->name, len);
3048         err = process(tool, (union perf_event*) ev, NULL, NULL);
3049         free(ev);
3050         return err;
3051 }
3052 
3053 int
3054 perf_event__synthesize_event_update_cpus(struct perf_tool *tool,
3055                                         struct perf_evsel *evsel,
3056                                         perf_event__handler_t process)
3057 {
3058         size_t size = sizeof(struct event_update_event);
3059         struct event_update_event *ev;
3060         int max, err;
3061         u16 type;
3062 
3063         if (!evsel->own_cpus)
3064                 return 0;
3065 
3066         ev = cpu_map_data__alloc(evsel->own_cpus, &size, &type, &max);
3067         if (!ev)
3068                 return -ENOMEM;
3069 
3070         ev->header.type = PERF_RECORD_EVENT_UPDATE;
3071         ev->header.size = (u16)size;
3072         ev->type = PERF_EVENT_UPDATE__CPUS;
3073         ev->id   = evsel->id[0];
3074 
3075         cpu_map_data__synthesize((struct cpu_map_data *) ev->data,
3076                                  evsel->own_cpus,
3077                                  type, max);
3078 
3079         err = process(tool, (union perf_event*) ev, NULL, NULL);
3080         free(ev);
3081         return err;
3082 }
3083 
3084 size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
3085 {
3086         struct event_update_event *ev = &event->event_update;
3087         struct event_update_event_scale *ev_scale;
3088         struct event_update_event_cpus *ev_cpus;
3089         struct cpu_map *map;
3090         size_t ret;
3091 
3092         ret = fprintf(fp, "\n... id:    %" PRIu64 "\n", ev->id);
3093 
3094         switch (ev->type) {
3095         case PERF_EVENT_UPDATE__SCALE:
3096                 ev_scale = (struct event_update_event_scale *) ev->data;
3097                 ret += fprintf(fp, "... scale: %f\n", ev_scale->scale);
3098                 break;
3099         case PERF_EVENT_UPDATE__UNIT:
3100                 ret += fprintf(fp, "... unit:  %s\n", ev->data);
3101                 break;
3102         case PERF_EVENT_UPDATE__NAME:
3103                 ret += fprintf(fp, "... name:  %s\n", ev->data);
3104                 break;
3105         case PERF_EVENT_UPDATE__CPUS:
3106                 ev_cpus = (struct event_update_event_cpus *) ev->data;
3107                 ret += fprintf(fp, "... ");
3108 
3109                 map = cpu_map__new_data(&ev_cpus->cpus);
3110                 if (map)
3111                         ret += cpu_map__fprintf(map, fp);
3112                 else
3113                         ret += fprintf(fp, "failed to get cpus\n");
3114                 break;
3115         default:
3116                 ret += fprintf(fp, "... unknown type\n");
3117                 break;
3118         }
3119 
3120         return ret;
3121 }
3122 
3123 int perf_event__synthesize_attrs(struct perf_tool *tool,
3124                                    struct perf_session *session,
3125                                    perf_event__handler_t process)
3126 {
3127         struct perf_evsel *evsel;
3128         int err = 0;
3129 
3130         evlist__for_each(session->evlist, evsel) {
3131                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
3132                                                   evsel->id, process);
3133                 if (err) {
3134                         pr_debug("failed to create perf header attribute\n");
3135                         return err;
3136                 }
3137         }
3138 
3139         return err;
3140 }
3141 
3142 int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
3143                              union perf_event *event,
3144                              struct perf_evlist **pevlist)
3145 {
3146         u32 i, ids, n_ids;
3147         struct perf_evsel *evsel;
3148         struct perf_evlist *evlist = *pevlist;
3149 
3150         if (evlist == NULL) {
3151                 *pevlist = evlist = perf_evlist__new();
3152                 if (evlist == NULL)
3153                         return -ENOMEM;
3154         }
3155 
3156         evsel = perf_evsel__new(&event->attr.attr);
3157         if (evsel == NULL)
3158                 return -ENOMEM;
3159 
3160         perf_evlist__add(evlist, evsel);
3161 
3162         ids = event->header.size;
3163         ids -= (void *)&event->attr.id - (void *)event;
3164         n_ids = ids / sizeof(u64);
3165         /*
3166          * We don't have the cpu and thread maps on the header, so
3167          * for allocating the perf_sample_id table we fake 1 cpu and
3168          * hattr->ids threads.
3169          */
3170         if (perf_evsel__alloc_id(evsel, 1, n_ids))
3171                 return -ENOMEM;
3172 
3173         for (i = 0; i < n_ids; i++) {
3174                 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
3175         }
3176 
3177         symbol_conf.nr_events = evlist->nr_entries;
3178 
3179         return 0;
3180 }
3181 
3182 int perf_event__process_event_update(struct perf_tool *tool __maybe_unused,
3183                                      union perf_event *event,
3184                                      struct perf_evlist **pevlist)
3185 {
3186         struct event_update_event *ev = &event->event_update;
3187         struct event_update_event_scale *ev_scale;
3188         struct event_update_event_cpus *ev_cpus;
3189         struct perf_evlist *evlist;
3190         struct perf_evsel *evsel;
3191         struct cpu_map *map;
3192 
3193         if (!pevlist || *pevlist == NULL)
3194                 return -EINVAL;
3195 
3196         evlist = *pevlist;
3197 
3198         evsel = perf_evlist__id2evsel(evlist, ev->id);
3199         if (evsel == NULL)
3200                 return -EINVAL;
3201 
3202         switch (ev->type) {
3203         case PERF_EVENT_UPDATE__UNIT:
3204                 evsel->unit = strdup(ev->data);
3205                 break;
3206         case PERF_EVENT_UPDATE__NAME:
3207                 evsel->name = strdup(ev->data);
3208                 break;
3209         case PERF_EVENT_UPDATE__SCALE:
3210                 ev_scale = (struct event_update_event_scale *) ev->data;
3211                 evsel->scale = ev_scale->scale;
3212         case PERF_EVENT_UPDATE__CPUS:
3213                 ev_cpus = (struct event_update_event_cpus *) ev->data;
3214 
3215                 map = cpu_map__new_data(&ev_cpus->cpus);
3216                 if (map)
3217                         evsel->own_cpus = map;
3218                 else
3219                         pr_err("failed to get event_update cpus\n");
3220         default:
3221                 break;
3222         }
3223 
3224         return 0;
3225 }
3226 
3227 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
3228                                         struct perf_evlist *evlist,
3229                                         perf_event__handler_t process)
3230 {
3231         union perf_event ev;
3232         struct tracing_data *tdata;
3233         ssize_t size = 0, aligned_size = 0, padding;
3234         int err __maybe_unused = 0;
3235 
3236         /*
3237          * We are going to store the size of the data followed
3238          * by the data contents. Since the fd descriptor is a pipe,
3239          * we cannot seek back to store the size of the data once
3240          * we know it. Instead we:
3241          *
3242          * - write the tracing data to the temp file
3243          * - get/write the data size to pipe
3244          * - write the tracing data from the temp file
3245          *   to the pipe
3246          */
3247         tdata = tracing_data_get(&evlist->entries, fd, true);
3248         if (!tdata)
3249                 return -1;
3250 
3251         memset(&ev, 0, sizeof(ev));
3252 
3253         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
3254         size = tdata->size;
3255         aligned_size = PERF_ALIGN(size, sizeof(u64));
3256         padding = aligned_size - size;
3257         ev.tracing_data.header.size = sizeof(ev.tracing_data);
3258         ev.tracing_data.size = aligned_size;
3259 
3260         process(tool, &ev, NULL, NULL);
3261 
3262         /*
3263          * The put function will copy all the tracing data
3264          * stored in temp file to the pipe.
3265          */
3266         tracing_data_put(tdata);
3267 
3268         write_padded(fd, NULL, 0, padding);
3269 
3270         return aligned_size;
3271 }
3272 
3273 int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
3274                                      union perf_event *event,
3275                                      struct perf_session *session)
3276 {
3277         ssize_t size_read, padding, size = event->tracing_data.size;
3278         int fd = perf_data_file__fd(session->file);
3279         off_t offset = lseek(fd, 0, SEEK_CUR);
3280         char buf[BUFSIZ];
3281 
3282         /* setup for reading amidst mmap */
3283         lseek(fd, offset + sizeof(struct tracing_data_event),
3284               SEEK_SET);
3285 
3286         size_read = trace_report(fd, &session->tevent,
3287                                  session->repipe);
3288         padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
3289 
3290         if (readn(fd, buf, padding) < 0) {
3291                 pr_err("%s: reading input file", __func__);
3292                 return -1;
3293         }
3294         if (session->repipe) {
3295                 int retw = write(STDOUT_FILENO, buf, padding);
3296                 if (retw <= 0 || retw != padding) {
3297                         pr_err("%s: repiping tracing data padding", __func__);
3298                         return -1;
3299                 }
3300         }
3301 
3302         if (size_read + padding != size) {
3303                 pr_err("%s: tracing data size mismatch", __func__);
3304                 return -1;
3305         }
3306 
3307         perf_evlist__prepare_tracepoint_events(session->evlist,
3308                                                session->tevent.pevent);
3309 
3310         return size_read + padding;
3311 }
3312 
3313 int perf_event__synthesize_build_id(struct perf_tool *tool,
3314                                     struct dso *pos, u16 misc,
3315                                     perf_event__handler_t process,
3316                                     struct machine *machine)
3317 {
3318         union perf_event ev;
3319         size_t len;
3320         int err = 0;
3321 
3322         if (!pos->hit)
3323                 return err;
3324 
3325         memset(&ev, 0, sizeof(ev));
3326 
3327         len = pos->long_name_len + 1;
3328         len = PERF_ALIGN(len, NAME_ALIGN);
3329         memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
3330         ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
3331         ev.build_id.header.misc = misc;
3332         ev.build_id.pid = machine->pid;
3333         ev.build_id.header.size = sizeof(ev.build_id) + len;
3334         memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
3335 
3336         err = process(tool, &ev, NULL, machine);
3337 
3338         return err;
3339 }
3340 
3341 int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
3342                                  union perf_event *event,
3343                                  struct perf_session *session)
3344 {
3345         __event_process_build_id(&event->build_id,
3346                                  event->build_id.filename,
3347                                  session);
3348         return 0;
3349 }
3350 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp