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