header.c 93.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
#include <errno.h>
3
#include <inttypes.h>
4
#include "string2.h"
5
#include <sys/param.h>
6
#include <sys/types.h>
7
#include <byteswap.h>
8 9 10
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
11
#include <linux/compiler.h>
12
#include <linux/list.h>
13
#include <linux/kernel.h>
14
#include <linux/bitops.h>
15
#include <linux/string.h>
16
#include <linux/stringify.h>
17
#include <linux/zalloc.h>
18
#include <sys/stat.h>
19
#include <sys/utsname.h>
20
#include <linux/time64.h>
21
#include <dirent.h>
22
#ifdef HAVE_LIBBPF_SUPPORT
23
#include <bpf/libbpf.h>
24
#endif
25
#include <perf/cpumap.h>
26

27
#include "dso.h"
28
#include "evlist.h"
29
#include "evsel.h"
30
#include "util/evsel_fprintf.h"
31
#include "header.h"
32
#include "memswap.h"
33
#include "trace-event.h"
34
#include "session.h"
35
#include "symbol.h"
36
#include "debug.h"
37
#include "cpumap.h"
38
#include "pmu.h"
39
#include "vdso.h"
40
#include "strbuf.h"
41
#include "build-id.h"
42
#include "data.h"
43 44
#include <api/fs/fs.h>
#include "asm/bug.h"
45
#include "tool.h"
46
#include "time-utils.h"
47
#include "units.h"
48
#include "util/util.h" // perf_exe()
J
Jiri Olsa 已提交
49
#include "cputopo.h"
50
#include "bpf-event.h"
51
#include "clockid.h"
52
#include "pmu-hybrid.h"
53

54
#include <linux/ctype.h>
55
#include <internal/lib.h>
56

57 58 59 60 61 62 63 64 65 66 67 68
/*
 * magic2 = "PERFILE2"
 * must be a numerical value to let the endianness
 * determine the memory layout. That way we are able
 * to detect endianness when reading the perf.data file
 * back.
 *
 * we check for legacy (PERFFILE) format.
 */
static const char *__perf_magic1 = "PERFFILE";
static const u64 __perf_magic2    = 0x32454c4946524550ULL;
static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
69

70
#define PERF_MAGIC	__perf_magic2
71

72 73
const char perf_version_string[] = PERF_VERSION;

74
struct perf_file_attr {
75
	struct perf_event_attr	attr;
76 77 78
	struct perf_file_section	ids;
};

79
void perf_header__set_feat(struct perf_header *header, int feat)
80
{
81
	set_bit(feat, header->adds_features);
82 83
}

84
void perf_header__clear_feat(struct perf_header *header, int feat)
85
{
86
	clear_bit(feat, header->adds_features);
87 88
}

89
bool perf_header__has_feat(const struct perf_header *header, int feat)
90
{
91
	return test_bit(feat, header->adds_features);
92 93
}

94
static int __do_write_fd(struct feat_fd *ff, const void *buf, size_t size)
95
{
96
	ssize_t ret = writen(ff->fd, buf, size);
97

98 99
	if (ret != (ssize_t)size)
		return ret < 0 ? (int)ret : -1;
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	return 0;
}

static int __do_write_buf(struct feat_fd *ff,  const void *buf, size_t size)
{
	/* struct perf_event_header::size is u16 */
	const size_t max_size = 0xffff - sizeof(struct perf_event_header);
	size_t new_size = ff->size;
	void *addr;

	if (size + ff->offset > max_size)
		return -E2BIG;

	while (size > (new_size - ff->offset))
		new_size <<= 1;
	new_size = min(max_size, new_size);

	if (ff->size < new_size) {
		addr = realloc(ff->buf, new_size);
		if (!addr)
			return -ENOMEM;
		ff->buf = addr;
		ff->size = new_size;
	}

	memcpy(ff->buf + ff->offset, buf, size);
	ff->offset += size;
127 128

	return 0;
129 130
}

131
/* Return: 0 if succeeded, -ERR if failed. */
132 133 134 135 136 137 138
int do_write(struct feat_fd *ff, const void *buf, size_t size)
{
	if (!ff->buf)
		return __do_write_fd(ff, buf, size);
	return __do_write_buf(ff, buf, size);
}

139
/* Return: 0 if succeeded, -ERR if failed. */
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 size)
{
	u64 *p = (u64 *) set;
	int i, ret;

	ret = do_write(ff, &size, sizeof(size));
	if (ret < 0)
		return ret;

	for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
		ret = do_write(ff, p + i, sizeof(*p));
		if (ret < 0)
			return ret;
	}

	return 0;
}

158
/* Return: 0 if succeeded, -ERR if failed. */
159 160
int write_padded(struct feat_fd *ff, const void *bf,
		 size_t count, size_t count_aligned)
161 162
{
	static const char zero_buf[NAME_ALIGN];
163
	int err = do_write(ff, bf, count);
164 165

	if (!err)
166
		err = do_write(ff, zero_buf, count_aligned - count);
167 168 169 170

	return err;
}

171 172 173
#define string_size(str)						\
	(PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))

174
/* Return: 0 if succeeded, -ERR if failed. */
175
static int do_write_string(struct feat_fd *ff, const char *str)
176 177 178 179 180
{
	u32 len, olen;
	int ret;

	olen = strlen(str) + 1;
181
	len = PERF_ALIGN(olen, NAME_ALIGN);
182 183

	/* write len, incl. \0 */
184
	ret = do_write(ff, &len, sizeof(len));
185 186 187
	if (ret < 0)
		return ret;

188
	return write_padded(ff, str, olen, len);
189 190
}

191
static int __do_read_fd(struct feat_fd *ff, void *addr, ssize_t size)
192
{
193
	ssize_t ret = readn(ff->fd, addr, size);
194 195 196 197 198 199

	if (ret != size)
		return ret < 0 ? (int)ret : -1;
	return 0;
}

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size)
{
	if (size > (ssize_t)ff->size - ff->offset)
		return -1;

	memcpy(addr, ff->buf + ff->offset, size);
	ff->offset += size;

	return 0;

}

static int __do_read(struct feat_fd *ff, void *addr, ssize_t size)
{
	if (!ff->buf)
		return __do_read_fd(ff, addr, size);
	return __do_read_buf(ff, addr, size);
}

219
static int do_read_u32(struct feat_fd *ff, u32 *addr)
220 221 222
{
	int ret;

223
	ret = __do_read(ff, addr, sizeof(*addr));
224 225 226
	if (ret)
		return ret;

227
	if (ff->ph->needs_swap)
228 229 230 231
		*addr = bswap_32(*addr);
	return 0;
}

232
static int do_read_u64(struct feat_fd *ff, u64 *addr)
233 234 235
{
	int ret;

236
	ret = __do_read(ff, addr, sizeof(*addr));
237 238 239
	if (ret)
		return ret;

240
	if (ff->ph->needs_swap)
241 242 243 244
		*addr = bswap_64(*addr);
	return 0;
}

245
static char *do_read_string(struct feat_fd *ff)
246 247 248 249
{
	u32 len;
	char *buf;

250
	if (do_read_u32(ff, &len))
251 252 253 254 255 256
		return NULL;

	buf = malloc(len);
	if (!buf)
		return NULL;

257
	if (!__do_read(ff, buf, len)) {
258 259 260 261 262 263 264 265 266 267 268 269
		/*
		 * strings are padded by zeroes
		 * thus the actual strlen of buf
		 * may be less than len
		 */
		return buf;
	}

	free(buf);
	return NULL;
}

270
/* Return: 0 if succeeded, -ERR if failed. */
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
static int do_read_bitmap(struct feat_fd *ff, unsigned long **pset, u64 *psize)
{
	unsigned long *set;
	u64 size, *p;
	int i, ret;

	ret = do_read_u64(ff, &size);
	if (ret)
		return ret;

	set = bitmap_alloc(size);
	if (!set)
		return -ENOMEM;

	p = (u64 *) set;

	for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
		ret = do_read_u64(ff, p + i);
		if (ret < 0) {
			free(set);
			return ret;
		}
	}

	*pset  = set;
	*psize = size;
	return 0;
}

300
static int write_tracing_data(struct feat_fd *ff,
301
			      struct evlist *evlist)
302
{
303 304 305
	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
		return -1;

306
	return read_tracing_data(ff->fd, &evlist->core.entries);
307 308
}

309
static int write_build_id(struct feat_fd *ff,
310
			  struct evlist *evlist __maybe_unused)
311 312 313 314
{
	struct perf_session *session;
	int err;

315
	session = container_of(ff->ph, struct perf_session, header);
316

317 318 319
	if (!perf_session__read_build_ids(session, true))
		return -1;

320 321 322
	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
		return -1;

323
	err = perf_session__write_buildid_table(session, ff);
324 325 326 327
	if (err < 0) {
		pr_debug("failed to write buildid table\n");
		return err;
	}
328
	perf_session__cache_build_ids(session);
329 330 331 332

	return 0;
}

333
static int write_hostname(struct feat_fd *ff,
334
			  struct evlist *evlist __maybe_unused)
335 336 337 338 339 340 341 342
{
	struct utsname uts;
	int ret;

	ret = uname(&uts);
	if (ret < 0)
		return -1;

343
	return do_write_string(ff, uts.nodename);
344 345
}

346
static int write_osrelease(struct feat_fd *ff,
347
			   struct evlist *evlist __maybe_unused)
348 349 350 351 352 353 354 355
{
	struct utsname uts;
	int ret;

	ret = uname(&uts);
	if (ret < 0)
		return -1;

356
	return do_write_string(ff, uts.release);
357 358
}

359
static int write_arch(struct feat_fd *ff,
360
		      struct evlist *evlist __maybe_unused)
361 362 363 364 365 366 367 368
{
	struct utsname uts;
	int ret;

	ret = uname(&uts);
	if (ret < 0)
		return -1;

369
	return do_write_string(ff, uts.machine);
370 371
}

372
static int write_version(struct feat_fd *ff,
373
			 struct evlist *evlist __maybe_unused)
374
{
375
	return do_write_string(ff, perf_version_string);
376 377
}

378
static int __write_cpudesc(struct feat_fd *ff, const char *cpuinfo_proc)
379 380 381 382
{
	FILE *file;
	char *buf = NULL;
	char *s, *p;
383
	const char *search = cpuinfo_proc;
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
	size_t len = 0;
	int ret = -1;

	if (!search)
		return -1;

	file = fopen("/proc/cpuinfo", "r");
	if (!file)
		return -1;

	while (getline(&buf, &len, file) > 0) {
		ret = strncmp(buf, search, strlen(search));
		if (!ret)
			break;
	}

400 401
	if (ret) {
		ret = -1;
402
		goto done;
403
	}
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418

	s = buf;

	p = strchr(buf, ':');
	if (p && *(p+1) == ' ' && *(p+2))
		s = p + 2;
	p = strchr(s, '\n');
	if (p)
		*p = '\0';

	/* squash extra space characters (branding string) */
	p = s;
	while (*p) {
		if (isspace(*p)) {
			char *r = p + 1;
419
			char *q = skip_spaces(r);
420 421 422 423 424 425
			*p = ' ';
			if (q != (p+1))
				while ((*r++ = *q++));
		}
		p++;
	}
426
	ret = do_write_string(ff, s);
427 428 429 430 431 432
done:
	free(buf);
	fclose(file);
	return ret;
}

433
static int write_cpudesc(struct feat_fd *ff,
434
		       struct evlist *evlist __maybe_unused)
435
{
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
#if defined(__powerpc__) || defined(__hppa__) || defined(__sparc__)
#define CPUINFO_PROC	{ "cpu", }
#elif defined(__s390__)
#define CPUINFO_PROC	{ "vendor_id", }
#elif defined(__sh__)
#define CPUINFO_PROC	{ "cpu type", }
#elif defined(__alpha__) || defined(__mips__)
#define CPUINFO_PROC	{ "cpu model", }
#elif defined(__arm__)
#define CPUINFO_PROC	{ "model name", "Processor", }
#elif defined(__arc__)
#define CPUINFO_PROC	{ "Processor", }
#elif defined(__xtensa__)
#define CPUINFO_PROC	{ "core ID", }
#else
#define CPUINFO_PROC	{ "model name", }
#endif
453
	const char *cpuinfo_procs[] = CPUINFO_PROC;
454
#undef CPUINFO_PROC
455 456 457 458
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
		int ret;
459
		ret = __write_cpudesc(ff, cpuinfo_procs[i]);
460 461 462 463 464 465 466
		if (ret >= 0)
			return ret;
	}
	return -1;
}


467
static int write_nrcpus(struct feat_fd *ff,
468
			struct evlist *evlist __maybe_unused)
469 470 471 472 473
{
	long nr;
	u32 nrc, nra;
	int ret;

474
	nrc = cpu__max_present_cpu();
475 476 477 478 479 480 481

	nr = sysconf(_SC_NPROCESSORS_ONLN);
	if (nr < 0)
		return -1;

	nra = (u32)(nr & UINT_MAX);

482
	ret = do_write(ff, &nrc, sizeof(nrc));
483 484 485
	if (ret < 0)
		return ret;

486
	return do_write(ff, &nra, sizeof(nra));
487 488
}

489
static int write_event_desc(struct feat_fd *ff,
490
			    struct evlist *evlist)
491
{
492
	struct evsel *evsel;
493
	u32 nre, nri, sz;
494 495
	int ret;

496
	nre = evlist->core.nr_entries;
497 498 499 500

	/*
	 * write number of events
	 */
501
	ret = do_write(ff, &nre, sizeof(nre));
502 503 504 505 506 507
	if (ret < 0)
		return ret;

	/*
	 * size of perf_event_attr struct
	 */
508
	sz = (u32)sizeof(evsel->core.attr);
509
	ret = do_write(ff, &sz, sizeof(sz));
510 511 512
	if (ret < 0)
		return ret;

513
	evlist__for_each_entry(evlist, evsel) {
514
		ret = do_write(ff, &evsel->core.attr, sz);
515 516 517 518 519 520 521 522 523
		if (ret < 0)
			return ret;
		/*
		 * write number of unique id per event
		 * there is one id per instance of an event
		 *
		 * copy into an nri to be independent of the
		 * type of ids,
		 */
524
		nri = evsel->core.ids;
525
		ret = do_write(ff, &nri, sizeof(nri));
526 527 528 529 530 531
		if (ret < 0)
			return ret;

		/*
		 * write event string as passed on cmdline
		 */
532
		ret = do_write_string(ff, evsel__name(evsel));
533 534 535 536 537
		if (ret < 0)
			return ret;
		/*
		 * write unique ids for this event
		 */
538
		ret = do_write(ff, evsel->core.id, evsel->core.ids * sizeof(u64));
539 540 541 542 543 544
		if (ret < 0)
			return ret;
	}
	return 0;
}

545
static int write_cmdline(struct feat_fd *ff,
546
			 struct evlist *evlist __maybe_unused)
547
{
548 549
	char pbuf[MAXPATHLEN], *buf;
	int i, ret, n;
550

551
	/* actual path to perf binary */
552
	buf = perf_exe(pbuf, MAXPATHLEN);
553 554

	/* account for binary path */
555
	n = perf_env.nr_cmdline + 1;
556

557
	ret = do_write(ff, &n, sizeof(n));
558 559 560
	if (ret < 0)
		return ret;

561
	ret = do_write_string(ff, buf);
562 563 564
	if (ret < 0)
		return ret;

565
	for (i = 0 ; i < perf_env.nr_cmdline; i++) {
566
		ret = do_write_string(ff, perf_env.cmdline_argv[i]);
567 568 569 570 571 572 573
		if (ret < 0)
			return ret;
	}
	return 0;
}


574
static int write_cpu_topology(struct feat_fd *ff,
575
			      struct evlist *evlist __maybe_unused)
576
{
J
Jiri Olsa 已提交
577
	struct cpu_topology *tp;
578
	u32 i;
579
	int ret, j;
580

J
Jiri Olsa 已提交
581
	tp = cpu_topology__new();
582 583 584
	if (!tp)
		return -1;

585
	ret = do_write(ff, &tp->core_sib, sizeof(tp->core_sib));
586 587 588 589
	if (ret < 0)
		goto done;

	for (i = 0; i < tp->core_sib; i++) {
590
		ret = do_write_string(ff, tp->core_siblings[i]);
591 592 593
		if (ret < 0)
			goto done;
	}
594
	ret = do_write(ff, &tp->thread_sib, sizeof(tp->thread_sib));
595 596 597 598
	if (ret < 0)
		goto done;

	for (i = 0; i < tp->thread_sib; i++) {
599
		ret = do_write_string(ff, tp->thread_siblings[i]);
600 601 602
		if (ret < 0)
			break;
	}
603

604 605 606 607 608
	ret = perf_env__read_cpu_topology_map(&perf_env);
	if (ret < 0)
		goto done;

	for (j = 0; j < perf_env.nr_cpus_avail; j++) {
609
		ret = do_write(ff, &perf_env.cpu[j].core_id,
610
			       sizeof(perf_env.cpu[j].core_id));
611 612
		if (ret < 0)
			return ret;
613
		ret = do_write(ff, &perf_env.cpu[j].socket_id,
614
			       sizeof(perf_env.cpu[j].socket_id));
615 616 617
		if (ret < 0)
			return ret;
	}
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638

	if (!tp->die_sib)
		goto done;

	ret = do_write(ff, &tp->die_sib, sizeof(tp->die_sib));
	if (ret < 0)
		goto done;

	for (i = 0; i < tp->die_sib; i++) {
		ret = do_write_string(ff, tp->die_siblings[i]);
		if (ret < 0)
			goto done;
	}

	for (j = 0; j < perf_env.nr_cpus_avail; j++) {
		ret = do_write(ff, &perf_env.cpu[j].die_id,
			       sizeof(perf_env.cpu[j].die_id));
		if (ret < 0)
			return ret;
	}

639
done:
J
Jiri Olsa 已提交
640
	cpu_topology__delete(tp);
641 642 643 644 645
	return ret;
}



646
static int write_total_mem(struct feat_fd *ff,
647
			   struct evlist *evlist __maybe_unused)
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
{
	char *buf = NULL;
	FILE *fp;
	size_t len = 0;
	int ret = -1, n;
	uint64_t mem;

	fp = fopen("/proc/meminfo", "r");
	if (!fp)
		return -1;

	while (getline(&buf, &len, fp) > 0) {
		ret = strncmp(buf, "MemTotal:", 9);
		if (!ret)
			break;
	}
	if (!ret) {
		n = sscanf(buf, "%*s %"PRIu64, &mem);
		if (n == 1)
667
			ret = do_write(ff, &mem, sizeof(mem));
668 669
	} else
		ret = -1;
670 671 672 673 674
	free(buf);
	fclose(fp);
	return ret;
}

675
static int write_numa_topology(struct feat_fd *ff,
676
			       struct evlist *evlist __maybe_unused)
677
{
J
Jiri Olsa 已提交
678
	struct numa_topology *tp;
679
	int ret = -1;
J
Jiri Olsa 已提交
680
	u32 i;
681

J
Jiri Olsa 已提交
682 683 684
	tp = numa_topology__new();
	if (!tp)
		return -ENOMEM;
685

J
Jiri Olsa 已提交
686 687 688
	ret = do_write(ff, &tp->nr, sizeof(u32));
	if (ret < 0)
		goto err;
689

J
Jiri Olsa 已提交
690 691
	for (i = 0; i < tp->nr; i++) {
		struct numa_topology_node *n = &tp->nodes[i];
692

J
Jiri Olsa 已提交
693 694 695
		ret = do_write(ff, &n->node, sizeof(u32));
		if (ret < 0)
			goto err;
696

J
Jiri Olsa 已提交
697 698 699
		ret = do_write(ff, &n->mem_total, sizeof(u64));
		if (ret)
			goto err;
700

J
Jiri Olsa 已提交
701 702 703
		ret = do_write(ff, &n->mem_free, sizeof(u64));
		if (ret)
			goto err;
704

J
Jiri Olsa 已提交
705
		ret = do_write_string(ff, n->cpus);
706
		if (ret < 0)
J
Jiri Olsa 已提交
707
			goto err;
708
	}
J
Jiri Olsa 已提交
709 710 711 712 713

	ret = 0;

err:
	numa_topology__delete(tp);
714 715 716
	return ret;
}

717 718 719 720 721 722 723 724 725 726 727 728
/*
 * File format:
 *
 * struct pmu_mappings {
 *	u32	pmu_num;
 *	struct pmu_map {
 *		u32	type;
 *		char	name[];
 *	}[pmu_num];
 * };
 */

729
static int write_pmu_mappings(struct feat_fd *ff,
730
			      struct evlist *evlist __maybe_unused)
731 732
{
	struct perf_pmu *pmu = NULL;
733
	u32 pmu_num = 0;
734
	int ret;
735

736 737 738 739 740 741 742 743 744 745
	/*
	 * Do a first pass to count number of pmu to avoid lseek so this
	 * works in pipe mode as well.
	 */
	while ((pmu = perf_pmu__scan(pmu))) {
		if (!pmu->name)
			continue;
		pmu_num++;
	}

746
	ret = do_write(ff, &pmu_num, sizeof(pmu_num));
747 748
	if (ret < 0)
		return ret;
749 750 751 752

	while ((pmu = perf_pmu__scan(pmu))) {
		if (!pmu->name)
			continue;
753

754
		ret = do_write(ff, &pmu->type, sizeof(pmu->type));
755 756 757
		if (ret < 0)
			return ret;

758
		ret = do_write_string(ff, pmu->name);
759 760
		if (ret < 0)
			return ret;
761 762 763 764 765
	}

	return 0;
}

766 767 768 769 770 771 772 773 774 775 776 777
/*
 * File format:
 *
 * struct group_descs {
 *	u32	nr_groups;
 *	struct group_desc {
 *		char	name[];
 *		u32	leader_idx;
 *		u32	nr_members;
 *	}[nr_groups];
 * };
 */
778
static int write_group_desc(struct feat_fd *ff,
779
			    struct evlist *evlist)
780
{
781
	u32 nr_groups = evlist->core.nr_groups;
782
	struct evsel *evsel;
783 784
	int ret;

785
	ret = do_write(ff, &nr_groups, sizeof(nr_groups));
786 787 788
	if (ret < 0)
		return ret;

789
	evlist__for_each_entry(evlist, evsel) {
790
		if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
791
			const char *name = evsel->group_name ?: "{anon_group}";
792
			u32 leader_idx = evsel->core.idx;
793
			u32 nr_members = evsel->core.nr_members;
794

795
			ret = do_write_string(ff, name);
796 797 798
			if (ret < 0)
				return ret;

799
			ret = do_write(ff, &leader_idx, sizeof(leader_idx));
800 801 802
			if (ret < 0)
				return ret;

803
			ret = do_write(ff, &nr_members, sizeof(nr_members));
804 805 806 807 808 809 810
			if (ret < 0)
				return ret;
		}
	}
	return 0;
}

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
/*
 * Return the CPU id as a raw string.
 *
 * Each architecture should provide a more precise id string that
 * can be use to match the architecture's "mapfile".
 */
char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused)
{
	return NULL;
}

/* Return zero when the cpuid from the mapfile.csv matches the
 * cpuid string generated on this platform.
 * Otherwise return non-zero.
 */
int __weak strcmp_cpuid_str(const char *mapcpuid, const char *cpuid)
{
	regex_t re;
	regmatch_t pmatch[1];
	int match;

	if (regcomp(&re, mapcpuid, REG_EXTENDED) != 0) {
		/* Warn unable to generate match particular string. */
		pr_info("Invalid regular expression %s\n", mapcpuid);
		return 1;
	}

	match = !regexec(&re, cpuid, 1, pmatch, 0);
	regfree(&re);
	if (match) {
		size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);

		/* Verify the entire string matched. */
		if (match_len == strlen(cpuid))
			return 0;
	}
	return 1;
}

850 851
/*
 * default get_cpuid(): nothing gets recorded
852
 * actual implementation must be in arch/$(SRCARCH)/util/header.c
853
 */
854
int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)
855
{
856
	return ENOSYS; /* Not implemented */
857 858
}

859
static int write_cpuid(struct feat_fd *ff,
860
		       struct evlist *evlist __maybe_unused)
861 862 863 864 865
{
	char buffer[64];
	int ret;

	ret = get_cpuid(buffer, sizeof(buffer));
866 867
	if (ret)
		return -1;
868

869
	return do_write_string(ff, buffer);
870 871
}

872
static int write_branch_stack(struct feat_fd *ff __maybe_unused,
873
			      struct evlist *evlist __maybe_unused)
874 875 876 877
{
	return 0;
}

878
static int write_auxtrace(struct feat_fd *ff,
879
			  struct evlist *evlist __maybe_unused)
880
{
881 882 883
	struct perf_session *session;
	int err;

884 885 886
	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
		return -1;

887
	session = container_of(ff->ph, struct perf_session, header);
888

889
	err = auxtrace_index__write(ff->fd, &session->auxtrace_index);
890 891 892
	if (err < 0)
		pr_err("Failed to write auxtrace index\n");
	return err;
893 894
}

895
static int write_clockid(struct feat_fd *ff,
896
			 struct evlist *evlist __maybe_unused)
897
{
898 899
	return do_write(ff, &ff->ph->env.clock.clockid_res_ns,
			sizeof(ff->ph->env.clock.clockid_res_ns));
900 901
}

902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
static int write_clock_data(struct feat_fd *ff,
			    struct evlist *evlist __maybe_unused)
{
	u64 *data64;
	u32 data32;
	int ret;

	/* version */
	data32 = 1;

	ret = do_write(ff, &data32, sizeof(data32));
	if (ret < 0)
		return ret;

	/* clockid */
	data32 = ff->ph->env.clock.clockid;

	ret = do_write(ff, &data32, sizeof(data32));
	if (ret < 0)
		return ret;

	/* TOD ref time */
	data64 = &ff->ph->env.clock.tod_ns;

	ret = do_write(ff, data64, sizeof(*data64));
	if (ret < 0)
		return ret;

	/* clockid ref time */
	data64 = &ff->ph->env.clock.clockid_ns;

	return do_write(ff, data64, sizeof(*data64));
}

936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
static int write_hybrid_topology(struct feat_fd *ff,
				 struct evlist *evlist __maybe_unused)
{
	struct hybrid_topology *tp;
	int ret;
	u32 i;

	tp = hybrid_topology__new();
	if (!tp)
		return -ENOENT;

	ret = do_write(ff, &tp->nr, sizeof(u32));
	if (ret < 0)
		goto err;

	for (i = 0; i < tp->nr; i++) {
		struct hybrid_topology_node *n = &tp->nodes[i];

		ret = do_write_string(ff, n->pmu_name);
		if (ret < 0)
			goto err;

		ret = do_write_string(ff, n->cpus);
		if (ret < 0)
			goto err;
	}

	ret = 0;

err:
	hybrid_topology__delete(tp);
	return ret;
}

970
static int write_dir_format(struct feat_fd *ff,
971
			    struct evlist *evlist __maybe_unused)
972 973 974 975 976 977 978 979 980 981 982 983 984
{
	struct perf_session *session;
	struct perf_data *data;

	session = container_of(ff->ph, struct perf_session, header);
	data = session->data;

	if (WARN_ON(!perf_data__is_dir(data)))
		return -1;

	return do_write(ff, &data->dir.version, sizeof(data->dir.version));
}

985 986
#ifdef HAVE_LIBBPF_SUPPORT
static int write_bpf_prog_info(struct feat_fd *ff,
987
			       struct evlist *evlist __maybe_unused)
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
{
	struct perf_env *env = &ff->ph->env;
	struct rb_root *root;
	struct rb_node *next;
	int ret;

	down_read(&env->bpf_progs.lock);

	ret = do_write(ff, &env->bpf_progs.infos_cnt,
		       sizeof(env->bpf_progs.infos_cnt));
	if (ret < 0)
		goto out;

	root = &env->bpf_progs.infos;
	next = rb_first(root);
	while (next) {
		struct bpf_prog_info_node *node;
		size_t len;

		node = rb_entry(next, struct bpf_prog_info_node, rb_node);
		next = rb_next(&node->rb_node);
		len = sizeof(struct bpf_prog_info_linear) +
			node->info_linear->data_len;

		/* before writing to file, translate address to offset */
		bpf_program__bpil_addr_to_offs(node->info_linear);
		ret = do_write(ff, node->info_linear, len);
		/*
		 * translate back to address even when do_write() fails,
		 * so that this function never changes the data.
		 */
		bpf_program__bpil_offs_to_addr(node->info_linear);
		if (ret < 0)
			goto out;
	}
out:
	up_read(&env->bpf_progs.lock);
	return ret;
}

1028
static int write_bpf_btf(struct feat_fd *ff,
1029
			 struct evlist *evlist __maybe_unused)
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
{
	struct perf_env *env = &ff->ph->env;
	struct rb_root *root;
	struct rb_node *next;
	int ret;

	down_read(&env->bpf_progs.lock);

	ret = do_write(ff, &env->bpf_progs.btfs_cnt,
		       sizeof(env->bpf_progs.btfs_cnt));

	if (ret < 0)
		goto out;

	root = &env->bpf_progs.btfs;
	next = rb_first(root);
	while (next) {
		struct btf_node *node;

		node = rb_entry(next, struct btf_node, rb_node);
		next = rb_next(&node->rb_node);
		ret = do_write(ff, &node->id,
			       sizeof(u32) * 2 + node->data_size);
		if (ret < 0)
			goto out;
	}
out:
	up_read(&env->bpf_progs.lock);
	return ret;
}
1060
#endif // HAVE_LIBBPF_SUPPORT
1061

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
static int cpu_cache_level__sort(const void *a, const void *b)
{
	struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
	struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b;

	return cache_a->level - cache_b->level;
}

static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b)
{
	if (a->level != b->level)
		return false;

	if (a->line_size != b->line_size)
		return false;

	if (a->sets != b->sets)
		return false;

	if (a->ways != b->ways)
		return false;

	if (strcmp(a->type, b->type))
		return false;

	if (strcmp(a->size, b->size))
		return false;

	if (strcmp(a->map, b->map))
		return false;

	return true;
}

static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level)
{
	char path[PATH_MAX], file[PATH_MAX];
	struct stat st;
	size_t len;

	scnprintf(path, PATH_MAX, "devices/system/cpu/cpu%d/cache/index%d/", cpu, level);
	scnprintf(file, PATH_MAX, "%s/%s", sysfs__mountpoint(), path);

	if (stat(file, &st))
		return 1;

	scnprintf(file, PATH_MAX, "%s/level", path);
	if (sysfs__read_int(file, (int *) &cache->level))
		return -1;

	scnprintf(file, PATH_MAX, "%s/coherency_line_size", path);
	if (sysfs__read_int(file, (int *) &cache->line_size))
		return -1;

	scnprintf(file, PATH_MAX, "%s/number_of_sets", path);
	if (sysfs__read_int(file, (int *) &cache->sets))
		return -1;

	scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path);
	if (sysfs__read_int(file, (int *) &cache->ways))
		return -1;

	scnprintf(file, PATH_MAX, "%s/type", path);
	if (sysfs__read_str(file, &cache->type, &len))
		return -1;

	cache->type[len] = 0;
1129
	cache->type = strim(cache->type);
1130 1131 1132

	scnprintf(file, PATH_MAX, "%s/size", path);
	if (sysfs__read_str(file, &cache->size, &len)) {
1133
		zfree(&cache->type);
1134 1135 1136 1137
		return -1;
	}

	cache->size[len] = 0;
1138
	cache->size = strim(cache->size);
1139 1140 1141

	scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path);
	if (sysfs__read_str(file, &cache->map, &len)) {
1142
		zfree(&cache->size);
1143
		zfree(&cache->type);
1144 1145 1146 1147
		return -1;
	}

	cache->map[len] = 0;
1148
	cache->map = strim(cache->map);
1149 1150 1151 1152 1153 1154 1155 1156
	return 0;
}

static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c)
{
	fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map);
}

1157 1158 1159
#define MAX_CACHE_LVL 4

static int build_caches(struct cpu_cache_level caches[], u32 *cntp)
1160 1161 1162 1163 1164
{
	u32 i, cnt = 0;
	u32 nr, cpu;
	u16 level;

1165
	nr = cpu__max_cpu();
1166 1167

	for (cpu = 0; cpu < nr; cpu++) {
1168
		for (level = 0; level < MAX_CACHE_LVL; level++) {
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
			struct cpu_cache_level c;
			int err;

			err = cpu_cache_level__read(&c, cpu, level);
			if (err < 0)
				return err;

			if (err == 1)
				break;

			for (i = 0; i < cnt; i++) {
				if (cpu_cache_level__cmp(&c, &caches[i]))
					break;
			}

			if (i == cnt)
				caches[cnt++] = c;
			else
				cpu_cache_level__free(&c);
		}
	}
	*cntp = cnt;
	return 0;
}

1194
static int write_cache(struct feat_fd *ff,
1195
		       struct evlist *evlist __maybe_unused)
1196
{
1197 1198
	u32 max_caches = cpu__max_cpu() * MAX_CACHE_LVL;
	struct cpu_cache_level caches[max_caches];
1199 1200 1201
	u32 cnt = 0, i, version = 1;
	int ret;

1202
	ret = build_caches(caches, &cnt);
1203 1204 1205 1206 1207
	if (ret)
		goto out;

	qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort);

1208
	ret = do_write(ff, &version, sizeof(u32));
1209 1210 1211
	if (ret < 0)
		goto out;

1212
	ret = do_write(ff, &cnt, sizeof(u32));
1213 1214 1215 1216 1217 1218 1219
	if (ret < 0)
		goto out;

	for (i = 0; i < cnt; i++) {
		struct cpu_cache_level *c = &caches[i];

		#define _W(v)					\
1220
			ret = do_write(ff, &c->v, sizeof(u32));	\
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
			if (ret < 0)				\
				goto out;

		_W(level)
		_W(line_size)
		_W(sets)
		_W(ways)
		#undef _W

		#define _W(v)						\
1231
			ret = do_write_string(ff, (const char *) c->v);	\
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
			if (ret < 0)					\
				goto out;

		_W(type)
		_W(size)
		_W(map)
		#undef _W
	}

out:
	for (i = 0; i < cnt; i++)
		cpu_cache_level__free(&caches[i]);
	return ret;
}

1247
static int write_stat(struct feat_fd *ff __maybe_unused,
1248
		      struct evlist *evlist __maybe_unused)
1249 1250 1251 1252
{
	return 0;
}

1253
static int write_sample_time(struct feat_fd *ff,
1254
			     struct evlist *evlist)
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
{
	int ret;

	ret = do_write(ff, &evlist->first_sample_time,
		       sizeof(evlist->first_sample_time));
	if (ret < 0)
		return ret;

	return do_write(ff, &evlist->last_sample_time,
			sizeof(evlist->last_sample_time));
}

1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336

static int memory_node__read(struct memory_node *n, unsigned long idx)
{
	unsigned int phys, size = 0;
	char path[PATH_MAX];
	struct dirent *ent;
	DIR *dir;

#define for_each_memory(mem, dir)					\
	while ((ent = readdir(dir)))					\
		if (strcmp(ent->d_name, ".") &&				\
		    strcmp(ent->d_name, "..") &&			\
		    sscanf(ent->d_name, "memory%u", &mem) == 1)

	scnprintf(path, PATH_MAX,
		  "%s/devices/system/node/node%lu",
		  sysfs__mountpoint(), idx);

	dir = opendir(path);
	if (!dir) {
		pr_warning("failed: cant' open memory sysfs data\n");
		return -1;
	}

	for_each_memory(phys, dir) {
		size = max(phys, size);
	}

	size++;

	n->set = bitmap_alloc(size);
	if (!n->set) {
		closedir(dir);
		return -ENOMEM;
	}

	n->node = idx;
	n->size = size;

	rewinddir(dir);

	for_each_memory(phys, dir) {
		set_bit(phys, n->set);
	}

	closedir(dir);
	return 0;
}

static int memory_node__sort(const void *a, const void *b)
{
	const struct memory_node *na = a;
	const struct memory_node *nb = b;

	return na->node - nb->node;
}

static int build_mem_topology(struct memory_node *nodes, u64 size, u64 *cntp)
{
	char path[PATH_MAX];
	struct dirent *ent;
	DIR *dir;
	u64 cnt = 0;
	int ret = 0;

	scnprintf(path, PATH_MAX, "%s/devices/system/node/",
		  sysfs__mountpoint());

	dir = opendir(path);
	if (!dir) {
1337 1338
		pr_debug2("%s: could't read %s, does this arch have topology information?\n",
			  __func__, path);
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
		return -1;
	}

	while (!ret && (ent = readdir(dir))) {
		unsigned int idx;
		int r;

		if (!strcmp(ent->d_name, ".") ||
		    !strcmp(ent->d_name, ".."))
			continue;

		r = sscanf(ent->d_name, "node%u", &idx);
		if (r != 1)
			continue;

		if (WARN_ONCE(cnt >= size,
1355 1356
			"failed to write MEM_TOPOLOGY, way too many nodes\n")) {
			closedir(dir);
1357
			return -1;
1358
		}
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389

		ret = memory_node__read(&nodes[cnt++], idx);
	}

	*cntp = cnt;
	closedir(dir);

	if (!ret)
		qsort(nodes, cnt, sizeof(nodes[0]), memory_node__sort);

	return ret;
}

#define MAX_MEMORY_NODES 2000

/*
 * The MEM_TOPOLOGY holds physical memory map for every
 * node in system. The format of data is as follows:
 *
 *  0 - version          | for future changes
 *  8 - block_size_bytes | /sys/devices/system/memory/block_size_bytes
 * 16 - count            | number of nodes
 *
 * For each node we store map of physical indexes for
 * each node:
 *
 * 32 - node id          | node index
 * 40 - size             | size of bitmap
 * 48 - bitmap           | bitmap of memory indexes that belongs to node
 */
static int write_mem_topology(struct feat_fd *ff __maybe_unused,
1390
			      struct evlist *evlist __maybe_unused)
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
{
	static struct memory_node nodes[MAX_MEMORY_NODES];
	u64 bsize, version = 1, i, nr;
	int ret;

	ret = sysfs__read_xll("devices/system/memory/block_size_bytes",
			      (unsigned long long *) &bsize);
	if (ret)
		return ret;

	ret = build_mem_topology(&nodes[0], MAX_MEMORY_NODES, &nr);
	if (ret)
		return ret;

	ret = do_write(ff, &version, sizeof(version));
	if (ret < 0)
		goto out;

	ret = do_write(ff, &bsize, sizeof(bsize));
	if (ret < 0)
		goto out;

	ret = do_write(ff, &nr, sizeof(nr));
	if (ret < 0)
		goto out;

	for (i = 0; i < nr; i++) {
		struct memory_node *n = &nodes[i];

		#define _W(v)						\
			ret = do_write(ff, &n->v, sizeof(n->v));	\
			if (ret < 0)					\
				goto out;

		_W(node)
		_W(size)

		#undef _W

		ret = do_write_bitmap(ff, n->set, n->size);
		if (ret < 0)
			goto out;
	}

out:
	return ret;
}

1439
static int write_compressed(struct feat_fd *ff __maybe_unused,
1440
			    struct evlist *evlist __maybe_unused)
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
{
	int ret;

	ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver));
	if (ret)
		return ret;

	ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type));
	if (ret)
		return ret;

	ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level));
	if (ret)
		return ret;

	ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio));
	if (ret)
		return ret;

	return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len));
}

1463 1464
static int write_per_cpu_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu,
				  bool write_pmu)
1465 1466 1467 1468 1469
{
	struct perf_pmu_caps *caps = NULL;
	int nr_caps;
	int ret;

1470
	nr_caps = perf_pmu__caps_parse(pmu);
1471 1472 1473 1474 1475 1476 1477
	if (nr_caps < 0)
		return nr_caps;

	ret = do_write(ff, &nr_caps, sizeof(nr_caps));
	if (ret < 0)
		return ret;

1478
	list_for_each_entry(caps, &pmu->caps, list) {
1479 1480 1481 1482 1483 1484 1485 1486 1487
		ret = do_write_string(ff, caps->name);
		if (ret < 0)
			return ret;

		ret = do_write_string(ff, caps->value);
		if (ret < 0)
			return ret;
	}

1488 1489 1490 1491 1492 1493
	if (write_pmu) {
		ret = do_write_string(ff, pmu->name);
		if (ret < 0)
			return ret;
	}

1494 1495 1496
	return ret;
}

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
static int write_cpu_pmu_caps(struct feat_fd *ff,
			      struct evlist *evlist __maybe_unused)
{
	struct perf_pmu *cpu_pmu = perf_pmu__find("cpu");

	if (!cpu_pmu)
		return -ENOENT;

	return write_per_cpu_pmu_caps(ff, cpu_pmu, false);
}

static int write_hybrid_cpu_pmu_caps(struct feat_fd *ff,
				     struct evlist *evlist __maybe_unused)
{
	struct perf_pmu *pmu;
	u32 nr_pmu = perf_pmu__hybrid_pmu_num();
	int ret;

	if (nr_pmu == 0)
		return -ENOENT;

	ret = do_write(ff, &nr_pmu, sizeof(nr_pmu));
	if (ret < 0)
		return ret;

	perf_pmu__for_each_hybrid_pmu(pmu) {
		ret = write_per_cpu_pmu_caps(ff, pmu, true);
		if (ret < 0)
			return ret;
	}

	return 0;
}

1531
static void print_hostname(struct feat_fd *ff, FILE *fp)
1532
{
1533
	fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname);
1534 1535
}

1536
static void print_osrelease(struct feat_fd *ff, FILE *fp)
1537
{
1538
	fprintf(fp, "# os release : %s\n", ff->ph->env.os_release);
1539 1540
}

1541
static void print_arch(struct feat_fd *ff, FILE *fp)
1542
{
1543
	fprintf(fp, "# arch : %s\n", ff->ph->env.arch);
1544 1545
}

1546
static void print_cpudesc(struct feat_fd *ff, FILE *fp)
1547
{
1548
	fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc);
1549 1550
}

1551
static void print_nrcpus(struct feat_fd *ff, FILE *fp)
1552
{
1553 1554
	fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online);
	fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail);
1555 1556
}

1557
static void print_version(struct feat_fd *ff, FILE *fp)
1558
{
1559
	fprintf(fp, "# perf version : %s\n", ff->ph->env.version);
1560 1561
}

1562
static void print_cmdline(struct feat_fd *ff, FILE *fp)
1563
{
1564
	int nr, i;
1565

1566
	nr = ff->ph->env.nr_cmdline;
1567 1568 1569

	fprintf(fp, "# cmdline : ");

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
	for (i = 0; i < nr; i++) {
		char *argv_i = strdup(ff->ph->env.cmdline_argv[i]);
		if (!argv_i) {
			fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]);
		} else {
			char *mem = argv_i;
			do {
				char *quote = strchr(argv_i, '\'');
				if (!quote)
					break;
				*quote++ = '\0';
				fprintf(fp, "%s\\\'", argv_i);
				argv_i = quote;
			} while (1);
			fprintf(fp, "%s ", argv_i);
			free(mem);
		}
	}
1588 1589 1590
	fputc('\n', fp);
}

1591
static void print_cpu_topology(struct feat_fd *ff, FILE *fp)
1592
{
1593 1594
	struct perf_header *ph = ff->ph;
	int cpu_nr = ph->env.nr_cpus_avail;
1595
	int nr, i;
1596 1597
	char *str;

1598 1599
	nr = ph->env.nr_sibling_cores;
	str = ph->env.sibling_cores;
1600 1601

	for (i = 0; i < nr; i++) {
1602
		fprintf(fp, "# sibling sockets : %s\n", str);
1603
		str += strlen(str) + 1;
1604 1605
	}

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
	if (ph->env.nr_sibling_dies) {
		nr = ph->env.nr_sibling_dies;
		str = ph->env.sibling_dies;

		for (i = 0; i < nr; i++) {
			fprintf(fp, "# sibling dies    : %s\n", str);
			str += strlen(str) + 1;
		}
	}

1616 1617
	nr = ph->env.nr_sibling_threads;
	str = ph->env.sibling_threads;
1618 1619 1620

	for (i = 0; i < nr; i++) {
		fprintf(fp, "# sibling threads : %s\n", str);
1621
		str += strlen(str) + 1;
1622
	}
1623

1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
	if (ph->env.nr_sibling_dies) {
		if (ph->env.cpu != NULL) {
			for (i = 0; i < cpu_nr; i++)
				fprintf(fp, "# CPU %d: Core ID %d, "
					    "Die ID %d, Socket ID %d\n",
					    i, ph->env.cpu[i].core_id,
					    ph->env.cpu[i].die_id,
					    ph->env.cpu[i].socket_id);
		} else
			fprintf(fp, "# Core ID, Die ID and Socket ID "
				    "information is not available\n");
	} else {
		if (ph->env.cpu != NULL) {
			for (i = 0; i < cpu_nr; i++)
				fprintf(fp, "# CPU %d: Core ID %d, "
					    "Socket ID %d\n",
					    i, ph->env.cpu[i].core_id,
					    ph->env.cpu[i].socket_id);
		} else
			fprintf(fp, "# Core ID and Socket ID "
				    "information is not available\n");
	}
1646 1647
}

1648 1649 1650
static void print_clockid(struct feat_fd *ff, FILE *fp)
{
	fprintf(fp, "# clockid frequency: %"PRIu64" MHz\n",
1651
		ff->ph->env.clock.clockid_res_ns * 1000);
1652 1653
}

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
static void print_clock_data(struct feat_fd *ff, FILE *fp)
{
	struct timespec clockid_ns;
	char tstr[64], date[64];
	struct timeval tod_ns;
	clockid_t clockid;
	struct tm ltime;
	u64 ref;

	if (!ff->ph->env.clock.enabled) {
		fprintf(fp, "# reference time disabled\n");
		return;
	}

	/* Compute TOD time. */
	ref = ff->ph->env.clock.tod_ns;
	tod_ns.tv_sec = ref / NSEC_PER_SEC;
	ref -= tod_ns.tv_sec * NSEC_PER_SEC;
	tod_ns.tv_usec = ref / NSEC_PER_USEC;

	/* Compute clockid time. */
	ref = ff->ph->env.clock.clockid_ns;
	clockid_ns.tv_sec = ref / NSEC_PER_SEC;
	ref -= clockid_ns.tv_sec * NSEC_PER_SEC;
	clockid_ns.tv_nsec = ref;

	clockid = ff->ph->env.clock.clockid;

	if (localtime_r(&tod_ns.tv_sec, &ltime) == NULL)
		snprintf(tstr, sizeof(tstr), "<error>");
	else {
		strftime(date, sizeof(date), "%F %T", &ltime);
		scnprintf(tstr, sizeof(tstr), "%s.%06d",
			  date, (int) tod_ns.tv_usec);
	}

	fprintf(fp, "# clockid: %s (%u)\n", clockid_name(clockid), clockid);
	fprintf(fp, "# reference time: %s = %ld.%06d (TOD) = %ld.%09ld (%s)\n",
1692 1693
		    tstr, (long) tod_ns.tv_sec, (int) tod_ns.tv_usec,
		    (long) clockid_ns.tv_sec, clockid_ns.tv_nsec,
1694 1695 1696
		    clockid_name(clockid));
}

1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
static void print_hybrid_topology(struct feat_fd *ff, FILE *fp)
{
	int i;
	struct hybrid_node *n;

	fprintf(fp, "# hybrid cpu system:\n");
	for (i = 0; i < ff->ph->env.nr_hybrid_nodes; i++) {
		n = &ff->ph->env.hybrid_nodes[i];
		fprintf(fp, "# %s cpu list : %s\n", n->pmu_name, n->cpus);
	}
}

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
static void print_dir_format(struct feat_fd *ff, FILE *fp)
{
	struct perf_session *session;
	struct perf_data *data;

	session = container_of(ff->ph, struct perf_session, header);
	data = session->data;

	fprintf(fp, "# directory data version : %"PRIu64"\n", data->dir.version);
}

1720
#ifdef HAVE_LIBBPF_SUPPORT
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
static void print_bpf_prog_info(struct feat_fd *ff, FILE *fp)
{
	struct perf_env *env = &ff->ph->env;
	struct rb_root *root;
	struct rb_node *next;

	down_read(&env->bpf_progs.lock);

	root = &env->bpf_progs.infos;
	next = rb_first(root);

	while (next) {
		struct bpf_prog_info_node *node;

		node = rb_entry(next, struct bpf_prog_info_node, rb_node);
		next = rb_next(&node->rb_node);
1737 1738 1739

		bpf_event__print_bpf_prog_info(&node->info_linear->info,
					       env, fp);
1740 1741 1742 1743 1744
	}

	up_read(&env->bpf_progs.lock);
}

1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
static void print_bpf_btf(struct feat_fd *ff, FILE *fp)
{
	struct perf_env *env = &ff->ph->env;
	struct rb_root *root;
	struct rb_node *next;

	down_read(&env->bpf_progs.lock);

	root = &env->bpf_progs.btfs;
	next = rb_first(root);

	while (next) {
		struct btf_node *node;

		node = rb_entry(next, struct btf_node, rb_node);
		next = rb_next(&node->rb_node);
		fprintf(fp, "# btf info of id %u\n", node->id);
	}

	up_read(&env->bpf_progs.lock);
}
1766
#endif // HAVE_LIBBPF_SUPPORT
1767

1768
static void free_event_desc(struct evsel *events)
1769
{
1770
	struct evsel *evsel;
1771 1772 1773 1774

	if (!events)
		return;

1775
	for (evsel = events; evsel->core.attr.size; evsel++) {
1776
		zfree(&evsel->name);
1777
		zfree(&evsel->core.id);
1778 1779 1780 1781 1782
	}

	free(events);
}

1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
static bool perf_attr_check(struct perf_event_attr *attr)
{
	if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3) {
		pr_warning("Reserved bits are set unexpectedly. "
			   "Please update perf tool.\n");
		return false;
	}

	if (attr->sample_type & ~(PERF_SAMPLE_MAX-1)) {
		pr_warning("Unknown sample type (0x%llx) is detected. "
			   "Please update perf tool.\n",
			   attr->sample_type);
		return false;
	}

	if (attr->read_format & ~(PERF_FORMAT_MAX-1)) {
		pr_warning("Unknown read format (0x%llx) is detected. "
			   "Please update perf tool.\n",
			   attr->read_format);
		return false;
	}

	if ((attr->sample_type & PERF_SAMPLE_BRANCH_STACK) &&
	    (attr->branch_sample_type & ~(PERF_SAMPLE_BRANCH_MAX-1))) {
		pr_warning("Unknown branch sample type (0x%llx) is detected. "
			   "Please update perf tool.\n",
			   attr->branch_sample_type);

		return false;
	}

	return true;
}

1817
static struct evsel *read_event_desc(struct feat_fd *ff)
1818
{
1819
	struct evsel *evsel, *events = NULL;
1820
	u64 *id;
1821
	void *buf = NULL;
1822 1823
	u32 nre, sz, nr, i, j;
	size_t msz;
1824 1825

	/* number of events */
1826
	if (do_read_u32(ff, &nre))
1827 1828
		goto error;

1829
	if (do_read_u32(ff, &sz))
1830 1831
		goto error;

1832
	/* buffer to hold on file attr struct */
1833 1834 1835 1836
	buf = malloc(sz);
	if (!buf)
		goto error;

1837
	/* the last event terminates with evsel->core.attr.size == 0: */
1838 1839 1840 1841
	events = calloc(nre + 1, sizeof(*events));
	if (!events)
		goto error;

1842
	msz = sizeof(evsel->core.attr);
1843
	if (sz < msz)
1844 1845
		msz = sz;

1846
	for (i = 0, evsel = events; i < nre; evsel++, i++) {
1847
		evsel->core.idx = i;
1848

1849 1850 1851 1852
		/*
		 * must read entire on-file attr struct to
		 * sync up with layout.
		 */
1853
		if (__do_read(ff, buf, sz))
1854 1855
			goto error;

1856
		if (ff->ph->needs_swap)
1857 1858
			perf_event__attr_swap(buf);

1859
		memcpy(&evsel->core.attr, buf, msz);
1860

1861 1862 1863
		if (!perf_attr_check(&evsel->core.attr))
			goto error;

1864
		if (do_read_u32(ff, &nr))
1865 1866
			goto error;

1867
		if (ff->ph->needs_swap)
1868
			evsel->needs_swap = true;
1869

1870
		evsel->name = do_read_string(ff);
1871 1872
		if (!evsel->name)
			goto error;
1873 1874 1875 1876 1877 1878 1879

		if (!nr)
			continue;

		id = calloc(nr, sizeof(*id));
		if (!id)
			goto error;
1880
		evsel->core.ids = nr;
1881
		evsel->core.id = id;
1882 1883

		for (j = 0 ; j < nr; j++) {
1884
			if (do_read_u64(ff, id))
1885 1886 1887 1888 1889
				goto error;
			id++;
		}
	}
out:
1890
	free(buf);
1891 1892
	return events;
error:
1893
	free_event_desc(events);
1894 1895 1896 1897
	events = NULL;
	goto out;
}

1898
static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
1899
				void *priv __maybe_unused)
1900 1901 1902 1903
{
	return fprintf(fp, ", %s = %s", name, val);
}

1904
static void print_event_desc(struct feat_fd *ff, FILE *fp)
1905
{
1906
	struct evsel *evsel, *events;
1907 1908 1909
	u32 j;
	u64 *id;

1910 1911 1912 1913 1914
	if (ff->events)
		events = ff->events;
	else
		events = read_event_desc(ff);

1915 1916 1917 1918 1919
	if (!events) {
		fprintf(fp, "# event desc: not available or unable to read\n");
		return;
	}

1920
	for (evsel = events; evsel->core.attr.size; evsel++) {
1921
		fprintf(fp, "# event : name = %s, ", evsel->name);
1922

1923
		if (evsel->core.ids) {
1924
			fprintf(fp, ", id = {");
1925
			for (j = 0, id = evsel->core.id; j < evsel->core.ids; j++, id++) {
1926 1927 1928 1929
				if (j)
					fputc(',', fp);
				fprintf(fp, " %"PRIu64, *id);
			}
1930
			fprintf(fp, " }");
1931
		}
1932

1933
		perf_event_attr__fprintf(fp, &evsel->core.attr, __desc_attr__fprintf, NULL);
1934

1935 1936
		fputc('\n', fp);
	}
1937 1938

	free_event_desc(events);
1939
	ff->events = NULL;
1940 1941
}

1942
static void print_total_mem(struct feat_fd *ff, FILE *fp)
1943
{
1944
	fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem);
1945 1946
}

1947
static void print_numa_topology(struct feat_fd *ff, FILE *fp)
1948
{
1949 1950
	int i;
	struct numa_node *n;
1951

1952 1953
	for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) {
		n = &ff->ph->env.numa_nodes[i];
1954 1955 1956

		fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
			    " free = %"PRIu64" kB\n",
1957
			n->node, n->mem_total, n->mem_free);
1958

1959 1960
		fprintf(fp, "# node%u cpu list : ", n->node);
		cpu_map__fprintf(n->map, fp);
1961 1962 1963
	}
}

1964
static void print_cpuid(struct feat_fd *ff, FILE *fp)
1965
{
1966
	fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid);
1967 1968
}

1969
static void print_branch_stack(struct feat_fd *ff __maybe_unused, FILE *fp)
1970 1971 1972 1973
{
	fprintf(fp, "# contains samples with branch stack\n");
}

1974
static void print_auxtrace(struct feat_fd *ff __maybe_unused, FILE *fp)
1975 1976 1977 1978
{
	fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
}

1979
static void print_stat(struct feat_fd *ff __maybe_unused, FILE *fp)
1980 1981 1982 1983
{
	fprintf(fp, "# contains stat data\n");
}

1984
static void print_cache(struct feat_fd *ff, FILE *fp __maybe_unused)
1985 1986 1987 1988
{
	int i;

	fprintf(fp, "# CPU cache info:\n");
1989
	for (i = 0; i < ff->ph->env.caches_cnt; i++) {
1990
		fprintf(fp, "#  ");
1991
		cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]);
1992 1993 1994
	}
}

1995 1996 1997 1998 1999 2000 2001
static void print_compressed(struct feat_fd *ff, FILE *fp)
{
	fprintf(fp, "# compressed : %s, level = %d, ratio = %d\n",
		ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown",
		ff->ph->env.comp_level, ff->ph->env.comp_ratio);
}

2002 2003
static void print_per_cpu_pmu_caps(FILE *fp, int nr_caps, char *cpu_pmu_caps,
				   char *pmu_name)
2004
{
2005 2006
	const char *delimiter;
	char *str, buf[128];
2007 2008

	if (!nr_caps) {
2009 2010 2011 2012
		if (!pmu_name)
			fprintf(fp, "# cpu pmu capabilities: not available\n");
		else
			fprintf(fp, "# %s pmu capabilities: not available\n", pmu_name);
2013 2014 2015
		return;
	}

2016 2017 2018 2019 2020 2021 2022 2023
	if (!pmu_name)
		scnprintf(buf, sizeof(buf), "# cpu pmu capabilities: ");
	else
		scnprintf(buf, sizeof(buf), "# %s pmu capabilities: ", pmu_name);

	delimiter = buf;

	str = cpu_pmu_caps;
2024 2025 2026 2027 2028 2029 2030 2031 2032
	while (nr_caps--) {
		fprintf(fp, "%s%s", delimiter, str);
		delimiter = ", ";
		str += strlen(str) + 1;
	}

	fprintf(fp, "\n");
}

2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
{
	print_per_cpu_pmu_caps(fp, ff->ph->env.nr_cpu_pmu_caps,
			       ff->ph->env.cpu_pmu_caps, NULL);
}

static void print_hybrid_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
{
	struct hybrid_cpc_node *n;

	for (int i = 0; i < ff->ph->env.nr_hybrid_cpc_nodes; i++) {
		n = &ff->ph->env.hybrid_cpc_nodes[i];
		print_per_cpu_pmu_caps(fp, n->nr_cpu_pmu_caps,
				       n->cpu_pmu_caps,
				       n->pmu_name);
	}
}

2051
static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
2052 2053
{
	const char *delimiter = "# pmu mappings: ";
2054
	char *str, *tmp;
2055 2056 2057
	u32 pmu_num;
	u32 type;

2058
	pmu_num = ff->ph->env.nr_pmu_mappings;
2059 2060 2061 2062 2063
	if (!pmu_num) {
		fprintf(fp, "# pmu mappings: not available\n");
		return;
	}

2064
	str = ff->ph->env.pmu_mappings;
2065

2066
	while (pmu_num) {
2067 2068 2069 2070 2071 2072
		type = strtoul(str, &tmp, 0);
		if (*tmp != ':')
			goto error;

		str = tmp + 1;
		fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
2073

2074
		delimiter = ", ";
2075 2076
		str += strlen(str) + 1;
		pmu_num--;
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
	}

	fprintf(fp, "\n");

	if (!pmu_num)
		return;
error:
	fprintf(fp, "# pmu mappings: unable to read\n");
}

2087
static void print_group_desc(struct feat_fd *ff, FILE *fp)
2088 2089
{
	struct perf_session *session;
2090
	struct evsel *evsel;
2091 2092
	u32 nr = 0;

2093
	session = container_of(ff->ph, struct perf_session, header);
2094

2095
	evlist__for_each_entry(session->evlist, evsel) {
2096
		if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
2097
			fprintf(fp, "# group: %s{%s", evsel->group_name ?: "", evsel__name(evsel));
2098

2099
			nr = evsel->core.nr_members - 1;
2100
		} else if (nr) {
2101
			fprintf(fp, ",%s", evsel__name(evsel));
2102 2103 2104 2105 2106 2107 2108

			if (--nr == 0)
				fprintf(fp, "}\n");
		}
	}
}

2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130
static void print_sample_time(struct feat_fd *ff, FILE *fp)
{
	struct perf_session *session;
	char time_buf[32];
	double d;

	session = container_of(ff->ph, struct perf_session, header);

	timestamp__scnprintf_usec(session->evlist->first_sample_time,
				  time_buf, sizeof(time_buf));
	fprintf(fp, "# time of first sample : %s\n", time_buf);

	timestamp__scnprintf_usec(session->evlist->last_sample_time,
				  time_buf, sizeof(time_buf));
	fprintf(fp, "# time of last sample : %s\n", time_buf);

	d = (double)(session->evlist->last_sample_time -
		session->evlist->first_sample_time) / NSEC_PER_MSEC;

	fprintf(fp, "# sample duration : %10.3f ms\n", d);
}

2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
static void memory_node__fprintf(struct memory_node *n,
				 unsigned long long bsize, FILE *fp)
{
	char buf_map[100], buf_size[50];
	unsigned long long size;

	size = bsize * bitmap_weight(n->set, n->size);
	unit_number__scnprintf(buf_size, 50, size);

	bitmap_scnprintf(n->set, n->size, buf_map, 100);
	fprintf(fp, "#  %3" PRIu64 " [%s]: %s\n", n->node, buf_size, buf_map);
}

static void print_mem_topology(struct feat_fd *ff, FILE *fp)
{
	struct memory_node *nodes;
	int i, nr;

	nodes = ff->ph->env.memory_nodes;
	nr    = ff->ph->env.nr_memory_nodes;

	fprintf(fp, "# memory nodes (nr %d, block size 0x%llx):\n",
		nr, ff->ph->env.memory_bsize);

	for (i = 0; i < nr; i++) {
		memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp);
	}
}

2160
static int __event_process_build_id(struct perf_record_header_build_id *bev,
2161 2162 2163 2164 2165
				    char *filename,
				    struct perf_session *session)
{
	int err = -1;
	struct machine *machine;
2166
	u16 cpumode;
2167
	struct dso *dso;
2168
	enum dso_space_type dso_space;
2169 2170 2171 2172 2173

	machine = perf_session__findnew_machine(session, bev->pid);
	if (!machine)
		goto out;

2174
	cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2175

2176
	switch (cpumode) {
2177
	case PERF_RECORD_MISC_KERNEL:
2178
		dso_space = DSO_SPACE__KERNEL;
2179 2180
		break;
	case PERF_RECORD_MISC_GUEST_KERNEL:
2181
		dso_space = DSO_SPACE__KERNEL_GUEST;
2182 2183 2184
		break;
	case PERF_RECORD_MISC_USER:
	case PERF_RECORD_MISC_GUEST_USER:
2185
		dso_space = DSO_SPACE__USER;
2186 2187 2188 2189 2190
		break;
	default:
		goto out;
	}

2191
	dso = machine__findnew_dso(machine, filename);
2192
	if (dso != NULL) {
2193
		char sbuild_id[SBUILD_ID_SIZE];
2194
		struct build_id bid;
2195
		size_t size = BUILD_ID_SIZE;
2196

2197 2198 2199 2200
		if (bev->header.misc & PERF_RECORD_MISC_BUILD_ID_SIZE)
			size = bev->size;

		build_id__init(&bid, bev->data, size);
2201
		dso__set_build_id(dso, &bid);
2202

2203
		if (dso_space != DSO_SPACE__USER) {
2204 2205 2206
			struct kmod_path m = { .name = NULL, };

			if (!kmod_path__parse_name(&m, filename) && m.kmod)
2207
				dso__set_module_info(dso, &m, machine);
2208

2209
			dso->kernel = dso_space;
2210 2211
			free(m.name);
		}
2212

2213
		build_id__sprintf(&dso->bid, sbuild_id);
2214 2215
		pr_debug("build id event received for %s: %s [%zu]\n",
			 dso->long_name, sbuild_id, size);
2216
		dso__put(dso);
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
	}

	err = 0;
out:
	return err;
}

static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
						 int input, u64 offset, u64 size)
{
	struct perf_session *session = container_of(header, struct perf_session, header);
	struct {
		struct perf_event_header   header;
2230
		u8			   build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
2231 2232
		char			   filename[0];
	} old_bev;
2233
	struct perf_record_header_build_id bev;
2234 2235 2236 2237 2238 2239
	char filename[PATH_MAX];
	u64 limit = offset + size;

	while (offset < limit) {
		ssize_t len;

2240
		if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
2241 2242 2243 2244 2245 2246
			return -1;

		if (header->needs_swap)
			perf_event_header__bswap(&old_bev.header);

		len = old_bev.header.size - sizeof(old_bev);
2247
		if (readn(input, filename, len) != len)
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
			return -1;

		bev.header = old_bev.header;

		/*
		 * As the pid is the missing value, we need to fill
		 * it properly. The header.misc value give us nice hint.
		 */
		bev.pid	= HOST_KERNEL_ID;
		if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
		    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
			bev.pid	= DEFAULT_GUEST_KERNEL_ID;

		memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
		__event_process_build_id(&bev, filename, session);

		offset += bev.header.size;
	}

	return 0;
}

static int perf_header__read_build_ids(struct perf_header *header,
				       int input, u64 offset, u64 size)
{
	struct perf_session *session = container_of(header, struct perf_session, header);
2274
	struct perf_record_header_build_id bev;
2275 2276 2277 2278 2279 2280 2281
	char filename[PATH_MAX];
	u64 limit = offset + size, orig_offset = offset;
	int err = -1;

	while (offset < limit) {
		ssize_t len;

2282
		if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
2283 2284 2285 2286 2287 2288
			goto out;

		if (header->needs_swap)
			perf_event_header__bswap(&bev.header);

		len = bev.header.size - sizeof(bev);
2289
		if (readn(input, filename, len) != len)
2290 2291 2292 2293 2294 2295
			goto out;
		/*
		 * The a1645ce1 changeset:
		 *
		 * "perf: 'perf kvm' tool for monitoring guest performance from host"
		 *
2296
		 * Added a field to struct perf_record_header_build_id that broke the file
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
		 * format.
		 *
		 * Since the kernel build-id is the first entry, process the
		 * table using the old format if the well known
		 * '[kernel.kallsyms]' string for the kernel build-id has the
		 * first 4 characters chopped off (where the pid_t sits).
		 */
		if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
			if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
				return -1;
			return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
		}

		__event_process_build_id(&bev, filename, session);

		offset += bev.header.size;
	}
	err = 0;
out:
	return err;
}

2319 2320
/* Macro for features that simply need to read and store a string. */
#define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \
2321
static int process_##__feat(struct feat_fd *ff, void *data __maybe_unused) \
2322
{\
2323
	ff->ph->env.__feat_env = do_read_string(ff); \
2324
	return ff->ph->env.__feat_env ? 0 : -ENOMEM; \
2325 2326 2327 2328 2329 2330 2331 2332 2333
}

FEAT_PROCESS_STR_FUN(hostname, hostname);
FEAT_PROCESS_STR_FUN(osrelease, os_release);
FEAT_PROCESS_STR_FUN(version, version);
FEAT_PROCESS_STR_FUN(arch, arch);
FEAT_PROCESS_STR_FUN(cpudesc, cpu_desc);
FEAT_PROCESS_STR_FUN(cpuid, cpuid);

2334
static int process_tracing_data(struct feat_fd *ff, void *data)
2335
{
2336 2337
	ssize_t ret = trace_report(ff->fd, data, false);

2338
	return ret < 0 ? -1 : 0;
2339 2340
}

2341
static int process_build_id(struct feat_fd *ff, void *data __maybe_unused)
2342
{
2343
	if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size))
2344 2345 2346 2347
		pr_debug("Failed to read buildids, continuing...\n");
	return 0;
}

2348
static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
2349
{
2350 2351
	int ret;
	u32 nr_cpus_avail, nr_cpus_online;
2352

2353
	ret = do_read_u32(ff, &nr_cpus_avail);
2354 2355
	if (ret)
		return ret;
2356

2357
	ret = do_read_u32(ff, &nr_cpus_online);
2358 2359
	if (ret)
		return ret;
2360 2361
	ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail;
	ff->ph->env.nr_cpus_online = (int)nr_cpus_online;
2362 2363 2364
	return 0;
}

2365
static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused)
2366
{
2367 2368
	u64 total_mem;
	int ret;
2369

2370
	ret = do_read_u64(ff, &total_mem);
2371
	if (ret)
2372
		return -1;
2373
	ff->ph->env.total_mem = (unsigned long long)total_mem;
2374 2375 2376
	return 0;
}

2377
static struct evsel *evlist__find_by_index(struct evlist *evlist, int idx)
2378
{
2379
	struct evsel *evsel;
2380

2381
	evlist__for_each_entry(evlist, evsel) {
2382
		if (evsel->core.idx == idx)
2383 2384 2385 2386 2387 2388
			return evsel;
	}

	return NULL;
}

2389
static void evlist__set_event_name(struct evlist *evlist, struct evsel *event)
2390
{
2391
	struct evsel *evsel;
2392 2393 2394 2395

	if (!event->name)
		return;

2396
	evsel = evlist__find_by_index(evlist, event->core.idx);
2397 2398 2399 2400 2401 2402 2403 2404 2405 2406
	if (!evsel)
		return;

	if (evsel->name)
		return;

	evsel->name = strdup(event->name);
}

static int
2407
process_event_desc(struct feat_fd *ff, void *data __maybe_unused)
2408
{
2409
	struct perf_session *session;
2410
	struct evsel *evsel, *events = read_event_desc(ff);
2411 2412 2413 2414

	if (!events)
		return 0;

2415
	session = container_of(ff->ph, struct perf_session, header);
2416

2417
	if (session->data->is_pipe) {
2418 2419 2420 2421 2422
		/* Save events for reading later by print_event_desc,
		 * since they can't be read again in pipe mode. */
		ff->events = events;
	}

2423
	for (evsel = events; evsel->core.attr.size; evsel++)
2424
		evlist__set_event_name(session->evlist, evsel);
2425

2426
	if (!session->data->is_pipe)
2427
		free_event_desc(events);
2428 2429 2430 2431

	return 0;
}

2432
static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
2433
{
2434 2435
	char *str, *cmdline = NULL, **argv = NULL;
	u32 nr, i, len = 0;
2436

2437
	if (do_read_u32(ff, &nr))
2438 2439
		return -1;

2440
	ff->ph->env.nr_cmdline = nr;
2441

2442
	cmdline = zalloc(ff->size + nr + 1);
2443 2444 2445 2446 2447 2448
	if (!cmdline)
		return -1;

	argv = zalloc(sizeof(char *) * (nr + 1));
	if (!argv)
		goto error;
2449 2450

	for (i = 0; i < nr; i++) {
2451
		str = do_read_string(ff);
2452 2453 2454
		if (!str)
			goto error;

2455 2456 2457
		argv[i] = cmdline + len;
		memcpy(argv[i], str, strlen(str) + 1);
		len += strlen(str) + 1;
2458 2459
		free(str);
	}
2460 2461
	ff->ph->env.cmdline = cmdline;
	ff->ph->env.cmdline_argv = (const char **) argv;
2462 2463 2464
	return 0;

error:
2465 2466
	free(argv);
	free(cmdline);
2467 2468 2469
	return -1;
}

2470
static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
2471 2472 2473 2474
{
	u32 nr, i;
	char *str;
	struct strbuf sb;
2475
	int cpu_nr = ff->ph->env.nr_cpus_avail;
2476
	u64 size = 0;
2477
	struct perf_header *ph = ff->ph;
2478
	bool do_core_id_test = true;
2479 2480 2481 2482

	ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
	if (!ph->env.cpu)
		return -1;
2483

2484
	if (do_read_u32(ff, &nr))
2485
		goto free_cpu;
2486 2487

	ph->env.nr_sibling_cores = nr;
2488
	size += sizeof(u32);
2489 2490
	if (strbuf_init(&sb, 128) < 0)
		goto free_cpu;
2491 2492

	for (i = 0; i < nr; i++) {
2493
		str = do_read_string(ff);
2494 2495 2496 2497
		if (!str)
			goto error;

		/* include a NULL character at the end */
2498 2499
		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
			goto error;
2500
		size += string_size(str);
2501 2502 2503 2504
		free(str);
	}
	ph->env.sibling_cores = strbuf_detach(&sb, NULL);

2505
	if (do_read_u32(ff, &nr))
2506 2507 2508
		return -1;

	ph->env.nr_sibling_threads = nr;
2509
	size += sizeof(u32);
2510 2511

	for (i = 0; i < nr; i++) {
2512
		str = do_read_string(ff);
2513 2514 2515 2516
		if (!str)
			goto error;

		/* include a NULL character at the end */
2517 2518
		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
			goto error;
2519
		size += string_size(str);
2520 2521 2522
		free(str);
	}
	ph->env.sibling_threads = strbuf_detach(&sb, NULL);
2523 2524 2525 2526 2527

	/*
	 * The header may be from old perf,
	 * which doesn't include core id and socket id information.
	 */
2528
	if (ff->size <= size) {
2529 2530 2531 2532
		zfree(&ph->env.cpu);
		return 0;
	}

2533 2534 2535
	/* On s390 the socket_id number is not related to the numbers of cpus.
	 * The socket_id number might be higher than the numbers of cpus.
	 * This depends on the configuration.
2536
	 * AArch64 is the same.
2537
	 */
2538 2539
	if (ph->env.arch && (!strncmp(ph->env.arch, "s390", 4)
			  || !strncmp(ph->env.arch, "aarch64", 7)))
2540 2541
		do_core_id_test = false;

2542
	for (i = 0; i < (u32)cpu_nr; i++) {
2543
		if (do_read_u32(ff, &nr))
2544 2545 2546
			goto free_cpu;

		ph->env.cpu[i].core_id = nr;
2547
		size += sizeof(u32);
2548

2549
		if (do_read_u32(ff, &nr))
2550 2551
			goto free_cpu;

2552
		if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) {
2553 2554 2555 2556 2557 2558
			pr_debug("socket_id number is too big."
				 "You may need to upgrade the perf tool.\n");
			goto free_cpu;
		}

		ph->env.cpu[i].socket_id = nr;
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
		size += sizeof(u32);
	}

	/*
	 * The header may be from old perf,
	 * which doesn't include die information.
	 */
	if (ff->size <= size)
		return 0;

	if (do_read_u32(ff, &nr))
		return -1;

	ph->env.nr_sibling_dies = nr;
	size += sizeof(u32);

	for (i = 0; i < nr; i++) {
		str = do_read_string(ff);
		if (!str)
			goto error;

		/* include a NULL character at the end */
		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
			goto error;
		size += string_size(str);
		free(str);
	}
	ph->env.sibling_dies = strbuf_detach(&sb, NULL);

	for (i = 0; i < (u32)cpu_nr; i++) {
		if (do_read_u32(ff, &nr))
			goto free_cpu;

		ph->env.cpu[i].die_id = nr;
2593 2594
	}

2595 2596 2597 2598
	return 0;

error:
	strbuf_release(&sb);
2599 2600
free_cpu:
	zfree(&ph->env.cpu);
2601 2602 2603
	return -1;
}

2604
static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
2605
{
2606 2607
	struct numa_node *nodes, *n;
	u32 nr, i;
2608 2609 2610
	char *str;

	/* nr nodes */
2611
	if (do_read_u32(ff, &nr))
2612
		return -1;
2613

2614 2615 2616
	nodes = zalloc(sizeof(*nodes) * nr);
	if (!nodes)
		return -ENOMEM;
2617 2618

	for (i = 0; i < nr; i++) {
2619 2620
		n = &nodes[i];

2621
		/* node number */
2622
		if (do_read_u32(ff, &n->node))
2623 2624
			goto error;

2625
		if (do_read_u64(ff, &n->mem_total))
2626 2627
			goto error;

2628
		if (do_read_u64(ff, &n->mem_free))
2629 2630
			goto error;

2631
		str = do_read_string(ff);
2632 2633 2634
		if (!str)
			goto error;

2635
		n->map = perf_cpu_map__new(str);
2636
		if (!n->map)
2637
			goto error;
2638

2639 2640
		free(str);
	}
2641 2642
	ff->ph->env.nr_numa_nodes = nr;
	ff->ph->env.numa_nodes = nodes;
2643 2644 2645
	return 0;

error:
2646
	free(nodes);
2647 2648 2649
	return -1;
}

2650
static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
2651 2652 2653 2654 2655 2656
{
	char *name;
	u32 pmu_num;
	u32 type;
	struct strbuf sb;

2657
	if (do_read_u32(ff, &pmu_num))
2658 2659 2660 2661 2662 2663 2664
		return -1;

	if (!pmu_num) {
		pr_debug("pmu mappings not available\n");
		return 0;
	}

2665
	ff->ph->env.nr_pmu_mappings = pmu_num;
2666 2667
	if (strbuf_init(&sb, 128) < 0)
		return -1;
2668 2669

	while (pmu_num) {
2670
		if (do_read_u32(ff, &type))
2671 2672
			goto error;

2673
		name = do_read_string(ff);
2674 2675 2676
		if (!name)
			goto error;

2677 2678
		if (strbuf_addf(&sb, "%u:%s", type, name) < 0)
			goto error;
2679
		/* include a NULL character at the end */
2680 2681
		if (strbuf_add(&sb, "", 1) < 0)
			goto error;
2682

2683
		if (!strcmp(name, "msr"))
2684
			ff->ph->env.msr_pmu_type = type;
2685

2686 2687 2688
		free(name);
		pmu_num--;
	}
2689
	ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2690 2691 2692 2693 2694 2695 2696
	return 0;

error:
	strbuf_release(&sb);
	return -1;
}

2697
static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
2698 2699 2700 2701
{
	size_t ret = -1;
	u32 i, nr, nr_groups;
	struct perf_session *session;
2702
	struct evsel *evsel, *leader = NULL;
2703 2704 2705 2706 2707 2708
	struct group_desc {
		char *name;
		u32 leader_idx;
		u32 nr_members;
	} *desc;

2709
	if (do_read_u32(ff, &nr_groups))
2710 2711
		return -1;

2712
	ff->ph->env.nr_groups = nr_groups;
2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
	if (!nr_groups) {
		pr_debug("group desc not available\n");
		return 0;
	}

	desc = calloc(nr_groups, sizeof(*desc));
	if (!desc)
		return -1;

	for (i = 0; i < nr_groups; i++) {
2723
		desc[i].name = do_read_string(ff);
2724 2725 2726
		if (!desc[i].name)
			goto out_free;

2727
		if (do_read_u32(ff, &desc[i].leader_idx))
2728 2729
			goto out_free;

2730
		if (do_read_u32(ff, &desc[i].nr_members))
2731 2732 2733 2734 2735 2736
			goto out_free;
	}

	/*
	 * Rebuild group relationship based on the group_desc
	 */
2737
	session = container_of(ff->ph, struct perf_session, header);
2738
	session->evlist->core.nr_groups = nr_groups;
2739 2740

	i = nr = 0;
2741
	evlist__for_each_entry(session->evlist, evsel) {
2742
		if (evsel->core.idx == (int) desc[i].leader_idx) {
2743
			evsel__set_leader(evsel, evsel);
2744
			/* {anon_group} is a dummy name */
N
Namhyung Kim 已提交
2745
			if (strcmp(desc[i].name, "{anon_group}")) {
2746
				evsel->group_name = desc[i].name;
N
Namhyung Kim 已提交
2747 2748
				desc[i].name = NULL;
			}
2749
			evsel->core.nr_members = desc[i].nr_members;
2750 2751 2752 2753 2754 2755 2756

			if (i >= nr_groups || nr > 0) {
				pr_debug("invalid group desc\n");
				goto out_free;
			}

			leader = evsel;
2757
			nr = evsel->core.nr_members - 1;
2758 2759 2760
			i++;
		} else if (nr) {
			/* This is a group member */
2761
			evsel__set_leader(evsel, leader);
2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773

			nr--;
		}
	}

	if (i != nr_groups || nr != 0) {
		pr_debug("invalid group desc\n");
		goto out_free;
	}

	ret = 0;
out_free:
2774
	for (i = 0; i < nr_groups; i++)
2775
		zfree(&desc[i].name);
2776 2777 2778 2779 2780
	free(desc);

	return ret;
}

2781
static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused)
2782 2783 2784 2785
{
	struct perf_session *session;
	int err;

2786
	session = container_of(ff->ph, struct perf_session, header);
2787

2788
	err = auxtrace_index__process(ff->fd, ff->size, session,
2789
				      ff->ph->needs_swap);
2790 2791 2792 2793 2794
	if (err < 0)
		pr_err("Failed to process auxtrace index\n");
	return err;
}

2795
static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
2796 2797 2798 2799
{
	struct cpu_cache_level *caches;
	u32 cnt, i, version;

2800
	if (do_read_u32(ff, &version))
2801 2802 2803 2804 2805
		return -1;

	if (version != 1)
		return -1;

2806
	if (do_read_u32(ff, &cnt))
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
		return -1;

	caches = zalloc(sizeof(*caches) * cnt);
	if (!caches)
		return -1;

	for (i = 0; i < cnt; i++) {
		struct cpu_cache_level c;

		#define _R(v)						\
2817
			if (do_read_u32(ff, &c.v))\
2818 2819 2820 2821 2822 2823 2824 2825
				goto out_free_caches;			\

		_R(level)
		_R(line_size)
		_R(sets)
		_R(ways)
		#undef _R

2826
		#define _R(v)					\
2827
			c.v = do_read_string(ff);		\
2828
			if (!c.v)				\
2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
				goto out_free_caches;

		_R(type)
		_R(size)
		_R(map)
		#undef _R

		caches[i] = c;
	}

2839 2840
	ff->ph->env.caches = caches;
	ff->ph->env.caches_cnt = cnt;
2841 2842 2843 2844 2845 2846
	return 0;
out_free_caches:
	free(caches);
	return -1;
}

2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused)
{
	struct perf_session *session;
	u64 first_sample_time, last_sample_time;
	int ret;

	session = container_of(ff->ph, struct perf_session, header);

	ret = do_read_u64(ff, &first_sample_time);
	if (ret)
		return -1;

	ret = do_read_u64(ff, &last_sample_time);
	if (ret)
		return -1;

	session->evlist->first_sample_time = first_sample_time;
	session->evlist->last_sample_time = last_sample_time;
	return 0;
}

2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
static int process_mem_topology(struct feat_fd *ff,
				void *data __maybe_unused)
{
	struct memory_node *nodes;
	u64 version, i, nr, bsize;
	int ret = -1;

	if (do_read_u64(ff, &version))
		return -1;

	if (version != 1)
		return -1;

	if (do_read_u64(ff, &bsize))
		return -1;

	if (do_read_u64(ff, &nr))
		return -1;

	nodes = zalloc(sizeof(*nodes) * nr);
	if (!nodes)
		return -1;

	for (i = 0; i < nr; i++) {
		struct memory_node n;

		#define _R(v)				\
			if (do_read_u64(ff, &n.v))	\
				goto out;		\

		_R(node)
		_R(size)

		#undef _R

		if (do_read_bitmap(ff, &n.set, &n.size))
			goto out;

		nodes[i] = n;
	}

	ff->ph->env.memory_bsize    = bsize;
	ff->ph->env.memory_nodes    = nodes;
	ff->ph->env.nr_memory_nodes = nr;
	ret = 0;

out:
	if (ret)
		free(nodes);
	return ret;
}

2920 2921 2922
static int process_clockid(struct feat_fd *ff,
			   void *data __maybe_unused)
{
2923
	if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns))
2924 2925 2926 2927 2928
		return -1;

	return 0;
}

2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
static int process_clock_data(struct feat_fd *ff,
			      void *_data __maybe_unused)
{
	u32 data32;
	u64 data64;

	/* version */
	if (do_read_u32(ff, &data32))
		return -1;

	if (data32 != 1)
		return -1;

	/* clockid */
	if (do_read_u32(ff, &data32))
		return -1;

	ff->ph->env.clock.clockid = data32;

	/* TOD ref time */
	if (do_read_u64(ff, &data64))
		return -1;

	ff->ph->env.clock.tod_ns = data64;

	/* clockid ref time */
	if (do_read_u64(ff, &data64))
		return -1;

	ff->ph->env.clock.clockid_ns = data64;
	ff->ph->env.clock.enabled = true;
	return 0;
}

2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002
static int process_hybrid_topology(struct feat_fd *ff,
				   void *data __maybe_unused)
{
	struct hybrid_node *nodes, *n;
	u32 nr, i;

	/* nr nodes */
	if (do_read_u32(ff, &nr))
		return -1;

	nodes = zalloc(sizeof(*nodes) * nr);
	if (!nodes)
		return -ENOMEM;

	for (i = 0; i < nr; i++) {
		n = &nodes[i];

		n->pmu_name = do_read_string(ff);
		if (!n->pmu_name)
			goto error;

		n->cpus = do_read_string(ff);
		if (!n->cpus)
			goto error;
	}

	ff->ph->env.nr_hybrid_nodes = nr;
	ff->ph->env.hybrid_nodes = nodes;
	return 0;

error:
	for (i = 0; i < nr; i++) {
		free(nodes[i].pmu_name);
		free(nodes[i].cpus);
	}

	free(nodes);
	return -1;
}

3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017
static int process_dir_format(struct feat_fd *ff,
			      void *_data __maybe_unused)
{
	struct perf_session *session;
	struct perf_data *data;

	session = container_of(ff->ph, struct perf_session, header);
	data = session->data;

	if (WARN_ON(!perf_data__is_dir(data)))
		return -1;

	return do_read_u64(ff, &data->dir.version);
}

3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
#ifdef HAVE_LIBBPF_SUPPORT
static int process_bpf_prog_info(struct feat_fd *ff, void *data __maybe_unused)
{
	struct bpf_prog_info_linear *info_linear;
	struct bpf_prog_info_node *info_node;
	struct perf_env *env = &ff->ph->env;
	u32 count, i;
	int err = -1;

	if (ff->ph->needs_swap) {
3028
		pr_warning("interpreting bpf_prog_info from systems with endianness is not yet supported\n");
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
		return 0;
	}

	if (do_read_u32(ff, &count))
		return -1;

	down_write(&env->bpf_progs.lock);

	for (i = 0; i < count; ++i) {
		u32 info_len, data_len;

		info_linear = NULL;
		info_node = NULL;
		if (do_read_u32(ff, &info_len))
			goto out;
		if (do_read_u32(ff, &data_len))
			goto out;

		if (info_len > sizeof(struct bpf_prog_info)) {
			pr_warning("detected invalid bpf_prog_info\n");
			goto out;
		}

		info_linear = malloc(sizeof(struct bpf_prog_info_linear) +
				     data_len);
		if (!info_linear)
			goto out;
		info_linear->info_len = sizeof(struct bpf_prog_info);
		info_linear->data_len = data_len;
		if (do_read_u64(ff, (u64 *)(&info_linear->arrays)))
			goto out;
		if (__do_read(ff, &info_linear->info, info_len))
			goto out;
		if (info_len < sizeof(struct bpf_prog_info))
			memset(((void *)(&info_linear->info)) + info_len, 0,
			       sizeof(struct bpf_prog_info) - info_len);

		if (__do_read(ff, info_linear->data, data_len))
			goto out;

		info_node = malloc(sizeof(struct bpf_prog_info_node));
		if (!info_node)
			goto out;

		/* after reading from file, translate offset to address */
		bpf_program__bpil_offs_to_addr(info_linear);
		info_node->info_linear = info_linear;
		perf_env__insert_bpf_prog_info(env, info_node);
	}

3079
	up_write(&env->bpf_progs.lock);
3080 3081 3082 3083 3084 3085 3086 3087
	return 0;
out:
	free(info_linear);
	free(info_node);
	up_write(&env->bpf_progs.lock);
	return err;
}

3088 3089 3090
static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
{
	struct perf_env *env = &ff->ph->env;
3091
	struct btf_node *node = NULL;
3092
	u32 count, i;
3093
	int err = -1;
3094 3095

	if (ff->ph->needs_swap) {
3096
		pr_warning("interpreting btf from systems with endianness is not yet supported\n");
3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108
		return 0;
	}

	if (do_read_u32(ff, &count))
		return -1;

	down_write(&env->bpf_progs.lock);

	for (i = 0; i < count; ++i) {
		u32 id, data_size;

		if (do_read_u32(ff, &id))
3109
			goto out;
3110
		if (do_read_u32(ff, &data_size))
3111
			goto out;
3112 3113 3114

		node = malloc(sizeof(struct btf_node) + data_size);
		if (!node)
3115
			goto out;
3116 3117 3118 3119

		node->id = id;
		node->data_size = data_size;

3120 3121
		if (__do_read(ff, node->data, data_size))
			goto out;
3122 3123

		perf_env__insert_btf(env, node);
3124
		node = NULL;
3125 3126
	}

3127 3128
	err = 0;
out:
3129
	up_write(&env->bpf_progs.lock);
3130 3131
	free(node);
	return err;
3132
}
3133
#endif // HAVE_LIBBPF_SUPPORT
3134

3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155
static int process_compressed(struct feat_fd *ff,
			      void *data __maybe_unused)
{
	if (do_read_u32(ff, &(ff->ph->env.comp_ver)))
		return -1;

	if (do_read_u32(ff, &(ff->ph->env.comp_type)))
		return -1;

	if (do_read_u32(ff, &(ff->ph->env.comp_level)))
		return -1;

	if (do_read_u32(ff, &(ff->ph->env.comp_ratio)))
		return -1;

	if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len)))
		return -1;

	return 0;
}

3156 3157 3158
static int process_per_cpu_pmu_caps(struct feat_fd *ff, int *nr_cpu_pmu_caps,
				    char **cpu_pmu_caps,
				    unsigned int *max_branches)
3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171
{
	char *name, *value;
	struct strbuf sb;
	u32 nr_caps;

	if (do_read_u32(ff, &nr_caps))
		return -1;

	if (!nr_caps) {
		pr_debug("cpu pmu capabilities not available\n");
		return 0;
	}

3172
	*nr_cpu_pmu_caps = nr_caps;
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193

	if (strbuf_init(&sb, 128) < 0)
		return -1;

	while (nr_caps--) {
		name = do_read_string(ff);
		if (!name)
			goto error;

		value = do_read_string(ff);
		if (!value)
			goto free_name;

		if (strbuf_addf(&sb, "%s=%s", name, value) < 0)
			goto free_value;

		/* include a NULL character at the end */
		if (strbuf_add(&sb, "", 1) < 0)
			goto free_value;

		if (!strcmp(name, "branches"))
3194
			*max_branches = atoi(value);
3195 3196 3197 3198

		free(value);
		free(name);
	}
3199
	*cpu_pmu_caps = strbuf_detach(&sb, NULL);
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210
	return 0;

free_value:
	free(value);
free_name:
	free(name);
error:
	strbuf_release(&sb);
	return -1;
}

3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267
static int process_cpu_pmu_caps(struct feat_fd *ff,
				void *data __maybe_unused)
{
	return process_per_cpu_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
					&ff->ph->env.cpu_pmu_caps,
					&ff->ph->env.max_branches);
}

static int process_hybrid_cpu_pmu_caps(struct feat_fd *ff,
				       void *data __maybe_unused)
{
	struct hybrid_cpc_node *nodes;
	u32 nr_pmu, i;
	int ret;

	if (do_read_u32(ff, &nr_pmu))
		return -1;

	if (!nr_pmu) {
		pr_debug("hybrid cpu pmu capabilities not available\n");
		return 0;
	}

	nodes = zalloc(sizeof(*nodes) * nr_pmu);
	if (!nodes)
		return -ENOMEM;

	for (i = 0; i < nr_pmu; i++) {
		struct hybrid_cpc_node *n = &nodes[i];

		ret = process_per_cpu_pmu_caps(ff, &n->nr_cpu_pmu_caps,
					       &n->cpu_pmu_caps,
					       &n->max_branches);
		if (ret)
			goto err;

		n->pmu_name = do_read_string(ff);
		if (!n->pmu_name) {
			ret = -1;
			goto err;
		}
	}

	ff->ph->env.nr_hybrid_cpc_nodes = nr_pmu;
	ff->ph->env.hybrid_cpc_nodes = nodes;
	return 0;

err:
	for (i = 0; i < nr_pmu; i++) {
		free(nodes[i].cpu_pmu_caps);
		free(nodes[i].pmu_name);
	}

	free(nodes);
	return ret;
}

3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285
#define FEAT_OPR(n, func, __full_only) \
	[HEADER_##n] = {					\
		.name	    = __stringify(n),			\
		.write	    = write_##func,			\
		.print	    = print_##func,			\
		.full_only  = __full_only,			\
		.process    = process_##func,			\
		.synthesize = true				\
	}

#define FEAT_OPN(n, func, __full_only) \
	[HEADER_##n] = {					\
		.name	    = __stringify(n),			\
		.write	    = write_##func,			\
		.print	    = print_##func,			\
		.full_only  = __full_only,			\
		.process    = process_##func			\
	}
3286 3287

/* feature_ops not implemented: */
3288 3289
#define print_tracing_data	NULL
#define print_build_id		NULL
3290

3291 3292 3293
#define process_branch_stack	NULL
#define process_stat		NULL

3294 3295
// Only used in util/synthetic-events.c
const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE];
3296

3297
const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE] = {
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
	FEAT_OPN(TRACING_DATA,	tracing_data,	false),
	FEAT_OPN(BUILD_ID,	build_id,	false),
	FEAT_OPR(HOSTNAME,	hostname,	false),
	FEAT_OPR(OSRELEASE,	osrelease,	false),
	FEAT_OPR(VERSION,	version,	false),
	FEAT_OPR(ARCH,		arch,		false),
	FEAT_OPR(NRCPUS,	nrcpus,		false),
	FEAT_OPR(CPUDESC,	cpudesc,	false),
	FEAT_OPR(CPUID,		cpuid,		false),
	FEAT_OPR(TOTAL_MEM,	total_mem,	false),
	FEAT_OPR(EVENT_DESC,	event_desc,	false),
	FEAT_OPR(CMDLINE,	cmdline,	false),
	FEAT_OPR(CPU_TOPOLOGY,	cpu_topology,	true),
	FEAT_OPR(NUMA_TOPOLOGY,	numa_topology,	true),
	FEAT_OPN(BRANCH_STACK,	branch_stack,	false),
	FEAT_OPR(PMU_MAPPINGS,	pmu_mappings,	false),
3314
	FEAT_OPR(GROUP_DESC,	group_desc,	false),
3315 3316 3317
	FEAT_OPN(AUXTRACE,	auxtrace,	false),
	FEAT_OPN(STAT,		stat,		false),
	FEAT_OPN(CACHE,		cache,		true),
3318
	FEAT_OPR(SAMPLE_TIME,	sample_time,	false),
3319
	FEAT_OPR(MEM_TOPOLOGY,	mem_topology,	true),
3320
	FEAT_OPR(CLOCKID,	clockid,	false),
3321
	FEAT_OPN(DIR_FORMAT,	dir_format,	false),
3322
#ifdef HAVE_LIBBPF_SUPPORT
3323 3324
	FEAT_OPR(BPF_PROG_INFO, bpf_prog_info,  false),
	FEAT_OPR(BPF_BTF,       bpf_btf,        false),
3325
#endif
3326
	FEAT_OPR(COMPRESSED,	compressed,	false),
3327
	FEAT_OPR(CPU_PMU_CAPS,	cpu_pmu_caps,	false),
3328
	FEAT_OPR(CLOCK_DATA,	clock_data,	false),
3329
	FEAT_OPN(HYBRID_TOPOLOGY,	hybrid_topology,	true),
3330
	FEAT_OPR(HYBRID_CPU_PMU_CAPS,	hybrid_cpu_pmu_caps,	false),
3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342
};

struct header_print_data {
	FILE *fp;
	bool full; /* extended list of headers */
};

static int perf_file_section__fprintf_info(struct perf_file_section *section,
					   struct perf_header *ph,
					   int feat, int fd, void *data)
{
	struct header_print_data *hd = data;
3343
	struct feat_fd ff;
3344 3345 3346 3347 3348 3349

	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
		pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
				"%d, continuing...\n", section->offset, feat);
		return 0;
	}
3350
	if (feat >= HEADER_LAST_FEATURE) {
3351
		pr_warning("unknown feature %d\n", feat);
3352
		return 0;
3353 3354 3355 3356
	}
	if (!feat_ops[feat].print)
		return 0;

3357 3358 3359 3360 3361
	ff = (struct  feat_fd) {
		.fd = fd,
		.ph = ph,
	};

3362
	if (!feat_ops[feat].full_only || hd->full)
3363
		feat_ops[feat].print(&ff, hd->fp);
3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
	else
		fprintf(hd->fp, "# %s info available, use -I to display\n",
			feat_ops[feat].name);

	return 0;
}

int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
{
	struct header_print_data hd;
	struct perf_header *header = &session->header;
3375
	int fd = perf_data__fd(session->data);
3376
	struct stat st;
3377
	time_t stctime;
J
Jiri Olsa 已提交
3378
	int ret, bit;
3379

3380 3381 3382
	hd.fp = fp;
	hd.full = full;

3383 3384 3385 3386
	ret = fstat(fd, &st);
	if (ret == -1)
		return -1;

3387
	stctime = st.st_mtime;
3388
	fprintf(fp, "# captured on    : %s", ctime(&stctime));
3389 3390 3391 3392 3393

	fprintf(fp, "# header version : %u\n", header->version);
	fprintf(fp, "# data offset    : %" PRIu64 "\n", header->data_offset);
	fprintf(fp, "# data size      : %" PRIu64 "\n", header->data_size);
	fprintf(fp, "# feat offset    : %" PRIu64 "\n", header->feat_offset);
3394

3395 3396
	perf_header__process_sections(header, fd, &hd,
				      perf_file_section__fprintf_info);
J
Jiri Olsa 已提交
3397

3398
	if (session->data->is_pipe)
3399 3400
		return 0;

J
Jiri Olsa 已提交
3401 3402 3403 3404 3405 3406 3407
	fprintf(fp, "# missing features: ");
	for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) {
		if (bit)
			fprintf(fp, "%s ", feat_ops[bit].name);
	}

	fprintf(fp, "\n");
3408 3409 3410
	return 0;
}

3411
static int do_write_feat(struct feat_fd *ff, int type,
3412
			 struct perf_file_section **p,
3413
			 struct evlist *evlist)
3414 3415 3416 3417
{
	int err;
	int ret = 0;

3418
	if (perf_header__has_feat(ff->ph, type)) {
3419 3420
		if (!feat_ops[type].write)
			return -1;
3421

3422 3423 3424
		if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
			return -1;

3425
		(*p)->offset = lseek(ff->fd, 0, SEEK_CUR);
3426

3427
		err = feat_ops[type].write(ff, evlist);
3428
		if (err < 0) {
3429
			pr_debug("failed to write feature %s\n", feat_ops[type].name);
3430 3431

			/* undo anything written */
3432
			lseek(ff->fd, (*p)->offset, SEEK_SET);
3433 3434 3435

			return -1;
		}
3436
		(*p)->size = lseek(ff->fd, 0, SEEK_CUR) - (*p)->offset;
3437 3438 3439 3440 3441
		(*p)++;
	}
	return ret;
}

3442
static int perf_header__adds_write(struct perf_header *header,
3443
				   struct evlist *evlist, int fd)
3444
{
3445
	int nr_sections;
3446
	struct feat_fd ff;
3447
	struct perf_file_section *feat_sec, *p;
3448 3449
	int sec_size;
	u64 sec_start;
3450
	int feat;
3451
	int err;
3452

3453 3454 3455 3456 3457
	ff = (struct feat_fd){
		.fd  = fd,
		.ph = header,
	};

3458
	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3459
	if (!nr_sections)
3460
		return 0;
3461

3462
	feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
3463 3464
	if (feat_sec == NULL)
		return -ENOMEM;
3465 3466 3467

	sec_size = sizeof(*feat_sec) * nr_sections;

3468
	sec_start = header->feat_offset;
3469
	lseek(fd, sec_start + sec_size, SEEK_SET);
3470

3471
	for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
3472
		if (do_write_feat(&ff, feat, &p, evlist))
3473 3474
			perf_header__clear_feat(header, feat);
	}
3475

3476
	lseek(fd, sec_start, SEEK_SET);
3477 3478
	/*
	 * may write more than needed due to dropped feature, but
3479
	 * this is okay, reader will skip the missing entries
3480
	 */
3481
	err = do_write(&ff, feat_sec, sec_size);
3482 3483
	if (err < 0)
		pr_debug("failed to write feature section\n");
3484
	free(feat_sec);
3485
	return err;
3486
}
3487

3488 3489 3490
int perf_header__write_pipe(int fd)
{
	struct perf_pipe_file_header f_header;
3491
	struct feat_fd ff;
3492 3493
	int err;

3494 3495
	ff = (struct feat_fd){ .fd = fd };

3496 3497 3498 3499 3500
	f_header = (struct perf_pipe_file_header){
		.magic	   = PERF_MAGIC,
		.size	   = sizeof(f_header),
	};

3501
	err = do_write(&ff, &f_header, sizeof(f_header));
3502 3503 3504 3505 3506 3507 3508 3509
	if (err < 0) {
		pr_debug("failed to write perf pipe header\n");
		return err;
	}

	return 0;
}

3510
int perf_session__write_header(struct perf_session *session,
3511
			       struct evlist *evlist,
3512
			       int fd, bool at_exit)
3513 3514 3515
{
	struct perf_file_header f_header;
	struct perf_file_attr   f_attr;
3516
	struct perf_header *header = &session->header;
3517
	struct evsel *evsel;
3518
	struct feat_fd ff;
3519
	u64 attr_offset;
3520
	int err;
3521

3522
	ff = (struct feat_fd){ .fd = fd};
3523 3524
	lseek(fd, sizeof(f_header), SEEK_SET);

3525
	evlist__for_each_entry(session->evlist, evsel) {
3526
		evsel->id_offset = lseek(fd, 0, SEEK_CUR);
3527
		err = do_write(&ff, evsel->core.id, evsel->core.ids * sizeof(u64));
3528 3529 3530 3531
		if (err < 0) {
			pr_debug("failed to write perf header\n");
			return err;
		}
3532 3533
	}

3534
	attr_offset = lseek(ff.fd, 0, SEEK_CUR);
3535

3536
	evlist__for_each_entry(evlist, evsel) {
3537 3538 3539 3540 3541 3542 3543 3544
		if (evsel->core.attr.size < sizeof(evsel->core.attr)) {
			/*
			 * We are likely in "perf inject" and have read
			 * from an older file. Update attr size so that
			 * reader gets the right offset to the ids.
			 */
			evsel->core.attr.size = sizeof(evsel->core.attr);
		}
3545
		f_attr = (struct perf_file_attr){
3546
			.attr = evsel->core.attr,
3547
			.ids  = {
3548
				.offset = evsel->id_offset,
3549
				.size   = evsel->core.ids * sizeof(u64),
3550 3551
			}
		};
3552
		err = do_write(&ff, &f_attr, sizeof(f_attr));
3553 3554 3555 3556
		if (err < 0) {
			pr_debug("failed to write perf header attribute\n");
			return err;
		}
3557 3558
	}

3559 3560
	if (!header->data_offset)
		header->data_offset = lseek(fd, 0, SEEK_CUR);
3561
	header->feat_offset = header->data_offset + header->data_size;
3562

3563
	if (at_exit) {
3564
		err = perf_header__adds_write(header, evlist, fd);
3565 3566 3567
		if (err < 0)
			return err;
	}
3568

3569 3570 3571 3572 3573
	f_header = (struct perf_file_header){
		.magic	   = PERF_MAGIC,
		.size	   = sizeof(f_header),
		.attr_size = sizeof(f_attr),
		.attrs = {
3574
			.offset = attr_offset,
3575
			.size   = evlist->core.nr_entries * sizeof(f_attr),
3576 3577
		},
		.data = {
3578 3579
			.offset = header->data_offset,
			.size	= header->data_size,
3580
		},
3581
		/* event_types is ignored, store zeros */
3582 3583
	};

3584
	memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
3585

3586
	lseek(fd, 0, SEEK_SET);
3587
	err = do_write(&ff, &f_header, sizeof(f_header));
3588 3589 3590 3591
	if (err < 0) {
		pr_debug("failed to write perf header\n");
		return err;
	}
3592
	lseek(fd, header->data_offset + header->data_size, SEEK_SET);
3593

3594
	return 0;
3595 3596
}

3597
static int perf_header__getbuffer64(struct perf_header *header,
3598 3599
				    int fd, void *buf, size_t size)
{
3600
	if (readn(fd, buf, size) <= 0)
3601 3602
		return -1;

3603
	if (header->needs_swap)
3604 3605 3606 3607 3608
		mem_bswap_64(buf, size);

	return 0;
}

3609
int perf_header__process_sections(struct perf_header *header, int fd,
3610
				  void *data,
3611
				  int (*process)(struct perf_file_section *section,
3612 3613
						 struct perf_header *ph,
						 int feat, int fd, void *data))
3614
{
3615
	struct perf_file_section *feat_sec, *sec;
3616 3617
	int nr_sections;
	int sec_size;
3618 3619
	int feat;
	int err;
3620

3621
	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3622
	if (!nr_sections)
3623
		return 0;
3624

3625
	feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
3626
	if (!feat_sec)
3627
		return -1;
3628 3629 3630

	sec_size = sizeof(*feat_sec) * nr_sections;

3631
	lseek(fd, header->feat_offset, SEEK_SET);
3632

3633 3634
	err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
	if (err < 0)
3635
		goto out_free;
3636

3637 3638 3639 3640
	for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
		err = process(sec++, header, feat, fd, data);
		if (err < 0)
			goto out_free;
3641
	}
3642
	err = 0;
3643
out_free:
3644 3645
	free(feat_sec);
	return err;
3646
}
3647

3648 3649 3650
static const int attr_file_abi_sizes[] = {
	[0] = PERF_ATTR_SIZE_VER0,
	[1] = PERF_ATTR_SIZE_VER1,
3651
	[2] = PERF_ATTR_SIZE_VER2,
3652
	[3] = PERF_ATTR_SIZE_VER3,
3653
	[4] = PERF_ATTR_SIZE_VER4,
3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
	0,
};

/*
 * In the legacy file format, the magic number is not used to encode endianness.
 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
 * on ABI revisions, we need to try all combinations for all endianness to
 * detect the endianness.
 */
static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
3664
{
3665 3666
	uint64_t ref_size, attr_size;
	int i;
3667

3668 3669 3670 3671 3672 3673 3674
	for (i = 0 ; attr_file_abi_sizes[i]; i++) {
		ref_size = attr_file_abi_sizes[i]
			 + sizeof(struct perf_file_section);
		if (hdr_sz != ref_size) {
			attr_size = bswap_64(hdr_sz);
			if (attr_size != ref_size)
				continue;
3675

3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
			ph->needs_swap = true;
		}
		pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
			 i,
			 ph->needs_swap);
		return 0;
	}
	/* could not determine endianness */
	return -1;
}
3686

3687 3688 3689 3690 3691 3692 3693 3694
#define PERF_PIPE_HDR_VER0	16

static const size_t attr_pipe_abi_sizes[] = {
	[0] = PERF_PIPE_HDR_VER0,
	0,
};

/*
3695
 * In the legacy pipe format, there is an implicit assumption that endianness
3696 3697 3698
 * between host recording the samples, and host parsing the samples is the
 * same. This is not always the case given that the pipe output may always be
 * redirected into a file and analyzed on a different machine with possibly a
3699
 * different endianness and perf_event ABI revisions in the perf tool itself.
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
 */
static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
{
	u64 attr_size;
	int i;

	for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
		if (hdr_sz != attr_pipe_abi_sizes[i]) {
			attr_size = bswap_64(hdr_sz);
			if (attr_size != hdr_sz)
				continue;
3711 3712 3713

			ph->needs_swap = true;
		}
3714
		pr_debug("Pipe ABI%d perf.data file detected\n", i);
3715 3716
		return 0;
	}
3717 3718 3719
	return -1;
}

F
Feng Tang 已提交
3720 3721 3722 3723 3724 3725 3726 3727 3728 3729
bool is_perf_magic(u64 magic)
{
	if (!memcmp(&magic, __perf_magic1, sizeof(magic))
		|| magic == __perf_magic2
		|| magic == __perf_magic2_sw)
		return true;

	return false;
}

3730 3731 3732 3733 3734 3735 3736 3737
static int check_magic_endian(u64 magic, uint64_t hdr_sz,
			      bool is_pipe, struct perf_header *ph)
{
	int ret;

	/* check for legacy format */
	ret = memcmp(&magic, __perf_magic1, sizeof(magic));
	if (ret == 0) {
3738
		ph->version = PERF_HEADER_VERSION_1;
3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749
		pr_debug("legacy perf.data format\n");
		if (is_pipe)
			return try_all_pipe_abis(hdr_sz, ph);

		return try_all_file_abis(hdr_sz, ph);
	}
	/*
	 * the new magic number serves two purposes:
	 * - unique number to identify actual perf.data files
	 * - encode endianness of file
	 */
3750
	ph->version = PERF_HEADER_VERSION_2;
3751

3752 3753
	/* check magic number with one endianness */
	if (magic == __perf_magic2)
3754 3755
		return 0;

3756 3757
	/* check magic number with opposite endianness */
	if (magic != __perf_magic2_sw)
3758 3759 3760 3761 3762 3763 3764
		return -1;

	ph->needs_swap = true;

	return 0;
}

3765
int perf_file_header__read(struct perf_file_header *header,
3766 3767
			   struct perf_header *ph, int fd)
{
3768
	ssize_t ret;
3769

3770 3771
	lseek(fd, 0, SEEK_SET);

3772 3773
	ret = readn(fd, header, sizeof(*header));
	if (ret <= 0)
3774 3775
		return -1;

3776 3777 3778
	if (check_magic_endian(header->magic,
			       header->attr_size, false, ph) < 0) {
		pr_debug("magic/endian check failed\n");
3779
		return -1;
3780
	}
3781

3782
	if (ph->needs_swap) {
3783
		mem_bswap_64(header, offsetof(struct perf_file_header,
3784
			     adds_features));
3785 3786
	}

3787
	if (header->size != sizeof(*header)) {
3788
		/* Support the previous format */
3789 3790
		if (header->size == offsetof(typeof(*header), adds_features))
			bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
3791 3792
		else
			return -1;
3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
	} else if (ph->needs_swap) {
		/*
		 * feature bitmap is declared as an array of unsigned longs --
		 * not good since its size can differ between the host that
		 * generated the data file and the host analyzing the file.
		 *
		 * We need to handle endianness, but we don't know the size of
		 * the unsigned long where the file was generated. Take a best
		 * guess at determining it: try 64-bit swap first (ie., file
		 * created on a 64-bit host), and check if the hostname feature
		 * bit is set (this feature bit is forced on as of fbe96f2).
		 * If the bit is not, undo the 64-bit swap and try a 32-bit
		 * swap. If the hostname bit is still not set (e.g., older data
		 * file), punt and fallback to the original behavior --
		 * clearing all feature bits and setting buildid.
		 */
3809 3810
		mem_bswap_64(&header->adds_features,
			    BITS_TO_U64(HEADER_FEAT_BITS));
3811 3812

		if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
3813 3814 3815 3816 3817 3818 3819
			/* unswap as u64 */
			mem_bswap_64(&header->adds_features,
				    BITS_TO_U64(HEADER_FEAT_BITS));

			/* unswap as u32 */
			mem_bswap_32(&header->adds_features,
				    BITS_TO_U32(HEADER_FEAT_BITS));
3820 3821 3822 3823 3824 3825
		}

		if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
			bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
			set_bit(HEADER_BUILD_ID, header->adds_features);
		}
3826
	}
3827

3828
	memcpy(&ph->adds_features, &header->adds_features,
3829
	       sizeof(ph->adds_features));
3830

3831 3832
	ph->data_offset  = header->data.offset;
	ph->data_size	 = header->data.size;
3833
	ph->feat_offset  = header->data.offset + header->data.size;
3834 3835 3836
	return 0;
}

3837
static int perf_file_section__process(struct perf_file_section *section,
3838
				      struct perf_header *ph,
3839
				      int feat, int fd, void *data)
3840
{
3841
	struct feat_fd fdd = {
3842 3843
		.fd	= fd,
		.ph	= ph,
3844 3845
		.size	= section->size,
		.offset	= section->offset,
3846 3847
	};

3848
	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
3849
		pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
3850
			  "%d, continuing...\n", section->offset, feat);
3851 3852 3853
		return 0;
	}

3854 3855 3856 3857 3858
	if (feat >= HEADER_LAST_FEATURE) {
		pr_debug("unknown feature %d, continuing...\n", feat);
		return 0;
	}

3859 3860
	if (!feat_ops[feat].process)
		return 0;
3861

3862
	return feat_ops[feat].process(&fdd, data);
3863
}
3864

3865
static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
3866 3867
				       struct perf_header *ph,
				       struct perf_data* data,
3868
				       bool repipe, int repipe_fd)
3869
{
3870
	struct feat_fd ff = {
3871
		.fd = repipe_fd,
3872 3873
		.ph = ph,
	};
3874
	ssize_t ret;
3875

3876
	ret = perf_data__read(data, header, sizeof(*header));
3877 3878 3879
	if (ret <= 0)
		return -1;

3880 3881
	if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
		pr_debug("endian/magic failed\n");
3882
		return -1;
3883 3884 3885 3886
	}

	if (ph->needs_swap)
		header->size = bswap_64(header->size);
3887

3888
	if (repipe && do_write(&ff, header, sizeof(*header)) < 0)
T
Tom Zanussi 已提交
3889 3890
		return -1;

3891 3892 3893
	return 0;
}

3894
static int perf_header__read_pipe(struct perf_session *session, int repipe_fd)
3895
{
3896
	struct perf_header *header = &session->header;
3897 3898
	struct perf_pipe_file_header f_header;

3899
	if (perf_file_header__read_pipe(&f_header, header, session->data,
3900
					session->repipe, repipe_fd) < 0) {
3901 3902 3903 3904
		pr_debug("incompatible file format\n");
		return -EINVAL;
	}

3905
	return f_header.size == sizeof(f_header) ? 0 : -1;
3906 3907
}

3908 3909 3910 3911 3912 3913
static int read_attr(int fd, struct perf_header *ph,
		     struct perf_file_attr *f_attr)
{
	struct perf_event_attr *attr = &f_attr->attr;
	size_t sz, left;
	size_t our_sz = sizeof(f_attr->attr);
3914
	ssize_t ret;
3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927

	memset(f_attr, 0, sizeof(*f_attr));

	/* read minimal guaranteed structure */
	ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
	if (ret <= 0) {
		pr_debug("cannot read %d bytes of header attr\n",
			 PERF_ATTR_SIZE_VER0);
		return -1;
	}

	/* on file perf_event_attr size */
	sz = attr->size;
3928

3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
	if (ph->needs_swap)
		sz = bswap_32(sz);

	if (sz == 0) {
		/* assume ABI0 */
		sz =  PERF_ATTR_SIZE_VER0;
	} else if (sz > our_sz) {
		pr_debug("file uses a more recent and unsupported ABI"
			 " (%zu bytes extra)\n", sz - our_sz);
		return -1;
	}
	/* what we have not yet read and that we know about */
	left = sz - PERF_ATTR_SIZE_VER0;
	if (left) {
		void *ptr = attr;
		ptr += PERF_ATTR_SIZE_VER0;

		ret = readn(fd, ptr, left);
	}
	/* read perf_file_section, ids are read in caller */
	ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));

	return ret <= 0 ? -1 : 0;
}

3954
static int evsel__prepare_tracepoint_event(struct evsel *evsel, struct tep_handle *pevent)
3955
{
3956
	struct tep_event *event;
3957 3958
	char bf[128];

3959 3960 3961 3962
	/* already prepared */
	if (evsel->tp_format)
		return 0;

3963 3964 3965 3966 3967
	if (pevent == NULL) {
		pr_debug("broken or missing trace data\n");
		return -1;
	}

3968
	event = tep_find_event(pevent, evsel->core.attr.config);
3969
	if (event == NULL) {
3970
		pr_debug("cannot find event format for %d\n", (int)evsel->core.attr.config);
3971
		return -1;
3972
	}
3973

3974 3975 3976 3977 3978 3979
	if (!evsel->name) {
		snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
		evsel->name = strdup(bf);
		if (evsel->name == NULL)
			return -1;
	}
3980

3981
	evsel->tp_format = event;
3982 3983 3984
	return 0;
}

3985
static int evlist__prepare_tracepoint_events(struct evlist *evlist, struct tep_handle *pevent)
3986
{
3987
	struct evsel *pos;
3988

3989
	evlist__for_each_entry(evlist, pos) {
3990
		if (pos->core.attr.type == PERF_TYPE_TRACEPOINT &&
3991
		    evsel__prepare_tracepoint_event(pos, pevent))
3992 3993 3994 3995 3996 3997
			return -1;
	}

	return 0;
}

3998
int perf_session__read_header(struct perf_session *session, int repipe_fd)
3999
{
4000
	struct perf_data *data = session->data;
4001
	struct perf_header *header = &session->header;
4002
	struct perf_file_header	f_header;
4003 4004
	struct perf_file_attr	f_attr;
	u64			f_id;
4005
	int nr_attrs, nr_ids, i, j, err;
4006
	int fd = perf_data__fd(data);
4007

4008
	session->evlist = evlist__new();
4009 4010 4011
	if (session->evlist == NULL)
		return -ENOMEM;

4012
	session->evlist->env = &header->env;
4013
	session->machines.host.env = &header->env;
4014 4015 4016 4017 4018

	/*
	 * We can read 'pipe' data event from regular file,
	 * check for the pipe header regardless of source.
	 */
4019
	err = perf_header__read_pipe(session, repipe_fd);
4020
	if (!err || perf_data__is_pipe(data)) {
4021 4022 4023
		data->is_pipe = true;
		return err;
	}
4024

4025
	if (perf_file_header__read(&f_header, header, fd) < 0)
4026
		return -EINVAL;
4027

4028 4029 4030 4031 4032
	if (header->needs_swap && data->in_place_update) {
		pr_err("In-place update not supported when byte-swapping is required\n");
		return -EINVAL;
	}

4033 4034 4035 4036 4037 4038 4039 4040 4041
	/*
	 * Sanity check that perf.data was written cleanly; data size is
	 * initialized to 0 and updated only if the on_exit function is run.
	 * If data size is still 0 then the file contains only partial
	 * information.  Just warn user and process it as much as it can.
	 */
	if (f_header.data.size == 0) {
		pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
			   "Was the 'perf record' command properly terminated?\n",
J
Jiri Olsa 已提交
4042
			   data->file.path);
4043 4044
	}

4045 4046 4047 4048 4049 4050 4051
	if (f_header.attr_size == 0) {
		pr_err("ERROR: The %s file's attr size field is 0 which is unexpected.\n"
		       "Was the 'perf record' command properly terminated?\n",
		       data->file.path);
		return -EINVAL;
	}

4052
	nr_attrs = f_header.attrs.size / f_header.attr_size;
4053 4054 4055
	lseek(fd, f_header.attrs.offset, SEEK_SET);

	for (i = 0; i < nr_attrs; i++) {
4056
		struct evsel *evsel;
4057
		off_t tmp;
4058

4059
		if (read_attr(fd, header, &f_attr) < 0)
4060
			goto out_errno;
4061

4062 4063 4064
		if (header->needs_swap) {
			f_attr.ids.size   = bswap_64(f_attr.ids.size);
			f_attr.ids.offset = bswap_64(f_attr.ids.offset);
4065
			perf_event__attr_swap(&f_attr.attr);
4066
		}
4067

4068
		tmp = lseek(fd, 0, SEEK_CUR);
4069
		evsel = evsel__new(&f_attr.attr);
4070

4071 4072
		if (evsel == NULL)
			goto out_delete_evlist;
4073 4074

		evsel->needs_swap = header->needs_swap;
4075 4076
		/*
		 * Do it before so that if perf_evsel__alloc_id fails, this
4077
		 * entry gets purged too at evlist__delete().
4078
		 */
4079
		evlist__add(session->evlist, evsel);
4080 4081

		nr_ids = f_attr.ids.size / sizeof(u64);
4082 4083 4084 4085 4086
		/*
		 * We don't have the cpu and thread maps on the header, so
		 * for allocating the perf_sample_id table we fake 1 cpu and
		 * hattr->ids threads.
		 */
4087
		if (perf_evsel__alloc_id(&evsel->core, 1, nr_ids))
4088 4089
			goto out_delete_evlist;

4090 4091 4092
		lseek(fd, f_attr.ids.offset, SEEK_SET);

		for (j = 0; j < nr_ids; j++) {
4093
			if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
4094
				goto out_errno;
4095

4096
			perf_evlist__id_add(&session->evlist->core, &evsel->core, 0, j, f_id);
4097
		}
4098

4099 4100 4101
		lseek(fd, tmp, SEEK_SET);
	}

J
Jiri Olsa 已提交
4102
	perf_header__process_sections(header, fd, &session->tevent,
4103
				      perf_file_section__process);
4104

4105
	if (evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent))
4106 4107
		goto out_delete_evlist;

4108
	return 0;
4109 4110
out_errno:
	return -errno;
4111 4112

out_delete_evlist:
4113
	evlist__delete(session->evlist);
4114 4115
	session->evlist = NULL;
	return -ENOMEM;
4116
}
4117

4118 4119
int perf_event__process_feature(struct perf_session *session,
				union perf_event *event)
4120
{
4121
	struct perf_tool *tool = session->tool;
4122
	struct feat_fd ff = { .fd = 0 };
4123
	struct perf_record_header_feature *fe = (struct perf_record_header_feature *)event;
4124 4125 4126 4127 4128 4129 4130
	int type = fe->header.type;
	u64 feat = fe->feat_id;

	if (type < 0 || type >= PERF_RECORD_HEADER_MAX) {
		pr_warning("invalid record type %d in pipe-mode\n", type);
		return 0;
	}
4131
	if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) {
4132 4133 4134 4135 4136 4137 4138 4139
		pr_warning("invalid record type %d in pipe-mode\n", type);
		return -1;
	}

	if (!feat_ops[feat].process)
		return 0;

	ff.buf  = (void *)fe->data;
4140
	ff.size = event->header.size - sizeof(*fe);
4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159
	ff.ph = &session->header;

	if (feat_ops[feat].process(&ff, NULL))
		return -1;

	if (!feat_ops[feat].print || !tool->show_feat_hdr)
		return 0;

	if (!feat_ops[feat].full_only ||
	    tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {
		feat_ops[feat].print(&ff, stdout);
	} else {
		fprintf(stdout, "# %s info available, use -I to display\n",
			feat_ops[feat].name);
	}

	return 0;
}

4160 4161
size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
{
4162 4163 4164
	struct perf_record_event_update *ev = &event->event_update;
	struct perf_record_event_update_scale *ev_scale;
	struct perf_record_event_update_cpus *ev_cpus;
4165
	struct perf_cpu_map *map;
4166 4167
	size_t ret;

4168
	ret = fprintf(fp, "\n... id:    %" PRI_lu64 "\n", ev->id);
4169 4170 4171

	switch (ev->type) {
	case PERF_EVENT_UPDATE__SCALE:
4172
		ev_scale = (struct perf_record_event_update_scale *)ev->data;
4173 4174 4175 4176 4177 4178 4179 4180 4181
		ret += fprintf(fp, "... scale: %f\n", ev_scale->scale);
		break;
	case PERF_EVENT_UPDATE__UNIT:
		ret += fprintf(fp, "... unit:  %s\n", ev->data);
		break;
	case PERF_EVENT_UPDATE__NAME:
		ret += fprintf(fp, "... name:  %s\n", ev->data);
		break;
	case PERF_EVENT_UPDATE__CPUS:
4182
		ev_cpus = (struct perf_record_event_update_cpus *)ev->data;
4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
		ret += fprintf(fp, "... ");

		map = cpu_map__new_data(&ev_cpus->cpus);
		if (map)
			ret += cpu_map__fprintf(map, fp);
		else
			ret += fprintf(fp, "failed to get cpus\n");
		break;
	default:
		ret += fprintf(fp, "... unknown type\n");
		break;
	}

	return ret;
}
4198

4199 4200
int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
			     union perf_event *event,
4201
			     struct evlist **pevlist)
4202
{
4203
	u32 i, ids, n_ids;
4204
	struct evsel *evsel;
4205
	struct evlist *evlist = *pevlist;
4206

4207
	if (evlist == NULL) {
4208
		*pevlist = evlist = evlist__new();
4209
		if (evlist == NULL)
4210 4211 4212
			return -ENOMEM;
	}

4213
	evsel = evsel__new(&event->attr.attr);
4214
	if (evsel == NULL)
4215 4216
		return -ENOMEM;

4217
	evlist__add(evlist, evsel);
4218

4219 4220
	ids = event->header.size;
	ids -= (void *)&event->attr.id - (void *)event;
4221
	n_ids = ids / sizeof(u64);
4222 4223 4224 4225 4226
	/*
	 * We don't have the cpu and thread maps on the header, so
	 * for allocating the perf_sample_id table we fake 1 cpu and
	 * hattr->ids threads.
	 */
4227
	if (perf_evsel__alloc_id(&evsel->core, 1, n_ids))
4228
		return -ENOMEM;
4229 4230

	for (i = 0; i < n_ids; i++) {
4231
		perf_evlist__id_add(&evlist->core, &evsel->core, 0, i, event->attr.id[i]);
4232 4233 4234 4235
	}

	return 0;
}
4236

4237 4238
int perf_event__process_event_update(struct perf_tool *tool __maybe_unused,
				     union perf_event *event,
4239
				     struct evlist **pevlist)
4240
{
4241 4242 4243
	struct perf_record_event_update *ev = &event->event_update;
	struct perf_record_event_update_scale *ev_scale;
	struct perf_record_event_update_cpus *ev_cpus;
4244
	struct evlist *evlist;
4245
	struct evsel *evsel;
4246
	struct perf_cpu_map *map;
4247 4248 4249 4250 4251 4252

	if (!pevlist || *pevlist == NULL)
		return -EINVAL;

	evlist = *pevlist;

4253
	evsel = evlist__id2evsel(evlist, ev->id);
4254 4255 4256
	if (evsel == NULL)
		return -EINVAL;

4257 4258 4259
	switch (ev->type) {
	case PERF_EVENT_UPDATE__UNIT:
		evsel->unit = strdup(ev->data);
4260
		break;
4261 4262 4263
	case PERF_EVENT_UPDATE__NAME:
		evsel->name = strdup(ev->data);
		break;
4264
	case PERF_EVENT_UPDATE__SCALE:
4265
		ev_scale = (struct perf_record_event_update_scale *)ev->data;
4266
		evsel->scale = ev_scale->scale;
4267
		break;
4268
	case PERF_EVENT_UPDATE__CPUS:
4269
		ev_cpus = (struct perf_record_event_update_cpus *)ev->data;
4270 4271 4272

		map = cpu_map__new_data(&ev_cpus->cpus);
		if (map)
4273
			evsel->core.own_cpus = map;
4274 4275
		else
			pr_err("failed to get event_update cpus\n");
4276 4277 4278 4279
	default:
		break;
	}

4280 4281 4282
	return 0;
}

4283 4284
int perf_event__process_tracing_data(struct perf_session *session,
				     union perf_event *event)
4285
{
4286
	ssize_t size_read, padding, size = event->tracing_data.size;
4287
	int fd = perf_data__fd(session->data);
4288 4289
	char buf[BUFSIZ];

4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303
	/*
	 * The pipe fd is already in proper place and in any case
	 * we can't move it, and we'd screw the case where we read
	 * 'pipe' data from regular file. The trace_report reads
	 * data from 'fd' so we need to set it directly behind the
	 * event, where the tracing data starts.
	 */
	if (!perf_data__is_pipe(session->data)) {
		off_t offset = lseek(fd, 0, SEEK_CUR);

		/* setup for reading amidst mmap */
		lseek(fd, offset + sizeof(struct perf_record_header_tracing_data),
		      SEEK_SET);
	}
4304

J
Jiri Olsa 已提交
4305
	size_read = trace_report(fd, &session->tevent,
4306
				 session->repipe);
4307
	padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
4308

4309
	if (readn(fd, buf, padding) < 0) {
4310 4311 4312
		pr_err("%s: reading input file", __func__);
		return -1;
	}
T
Tom Zanussi 已提交
4313 4314
	if (session->repipe) {
		int retw = write(STDOUT_FILENO, buf, padding);
4315 4316 4317 4318
		if (retw <= 0 || retw != padding) {
			pr_err("%s: repiping tracing data padding", __func__);
			return -1;
		}
T
Tom Zanussi 已提交
4319
	}
4320

4321 4322 4323 4324
	if (size_read + padding != size) {
		pr_err("%s: tracing data size mismatch", __func__);
		return -1;
	}
4325

4326
	evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent);
4327

4328 4329
	return size_read + padding;
}
4330

4331 4332
int perf_event__process_build_id(struct perf_session *session,
				 union perf_event *event)
4333
{
4334 4335
	__event_process_build_id(&event->build_id,
				 event->build_id.filename,
4336
				 session);
4337 4338
	return 0;
}