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