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#include <unistd.h>
   9#include <regex.h>
  10#include <stdio.h>
  11#include <stdlib.h>
  12#include <linux/compiler.h>
  13#include <linux/list.h>
  14#include <linux/kernel.h>
  15#include <linux/bitops.h>
  16#include <linux/string.h>
  17#include <linux/stringify.h>
  18#include <linux/zalloc.h>
  19#include <sys/stat.h>
  20#include <sys/utsname.h>
  21#include <linux/time64.h>
  22#include <dirent.h>
  23#ifdef HAVE_LIBBPF_SUPPORT
  24#include <bpf/libbpf.h>
  25#endif
  26#include <perf/cpumap.h>
  27#include <tools/libc_compat.h> // reallocarray
  28
  29#include "dso.h"
  30#include "evlist.h"
  31#include "evsel.h"
  32#include "util/evsel_fprintf.h"
  33#include "header.h"
  34#include "memswap.h"
  35#include "trace-event.h"
  36#include "session.h"
  37#include "symbol.h"
  38#include "debug.h"
  39#include "cpumap.h"
  40#include "pmu.h"
  41#include "pmus.h"
  42#include "vdso.h"
  43#include "strbuf.h"
  44#include "build-id.h"
  45#include "data.h"
  46#include <api/fs/fs.h>
  47#include "asm/bug.h"
  48#include "tool.h"
  49#include "time-utils.h"
  50#include "units.h"
  51#include "util/util.h" // perf_exe()
  52#include "cputopo.h"
  53#include "bpf-event.h"
  54#include "bpf-utils.h"
  55#include "clockid.h"
  56
  57#include <linux/ctype.h>
  58#include <internal/lib.h>
  59
  60#ifdef HAVE_LIBTRACEEVENT
  61#include <traceevent/event-parse.h>
  62#endif
  63
  64/*
  65 * magic2 = "PERFILE2"
  66 * must be a numerical value to let the endianness
  67 * determine the memory layout. That way we are able
  68 * to detect endianness when reading the perf.data file
  69 * back.
  70 *
  71 * we check for legacy (PERFFILE) format.
  72 */
  73static const char *__perf_magic1 = "PERFFILE";
  74static const u64 __perf_magic2    = 0x32454c4946524550ULL;
  75static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
  76
  77#define PERF_MAGIC	__perf_magic2
  78
  79const char perf_version_string[] = PERF_VERSION;
  80
  81struct perf_file_attr {
  82	struct perf_event_attr	attr;
  83	struct perf_file_section	ids;
  84};
  85
  86void perf_header__set_feat(struct perf_header *header, int feat)
  87{
  88	__set_bit(feat, header->adds_features);
  89}
  90
  91void perf_header__clear_feat(struct perf_header *header, int feat)
  92{
  93	__clear_bit(feat, header->adds_features);
  94}
  95
  96bool perf_header__has_feat(const struct perf_header *header, int feat)
  97{
  98	return test_bit(feat, header->adds_features);
  99}
 100
 101static int __do_write_fd(struct feat_fd *ff, const void *buf, size_t size)
 102{
 103	ssize_t ret = writen(ff->fd, buf, size);
 104
 105	if (ret != (ssize_t)size)
 106		return ret < 0 ? (int)ret : -1;
 107	return 0;
 108}
 109
 110static int __do_write_buf(struct feat_fd *ff,  const void *buf, size_t size)
 111{
 112	/* struct perf_event_header::size is u16 */
 113	const size_t max_size = 0xffff - sizeof(struct perf_event_header);
 114	size_t new_size = ff->size;
 115	void *addr;
 116
 117	if (size + ff->offset > max_size)
 118		return -E2BIG;
 119
 120	while (size > (new_size - ff->offset))
 121		new_size <<= 1;
 122	new_size = min(max_size, new_size);
 123
 124	if (ff->size < new_size) {
 125		addr = realloc(ff->buf, new_size);
 126		if (!addr)
 127			return -ENOMEM;
 128		ff->buf = addr;
 129		ff->size = new_size;
 130	}
 131
 132	memcpy(ff->buf + ff->offset, buf, size);
 133	ff->offset += size;
 134
 135	return 0;
 136}
 137
 138/* Return: 0 if succeeded, -ERR if failed. */
 139int do_write(struct feat_fd *ff, const void *buf, size_t size)
 140{
 141	if (!ff->buf)
 142		return __do_write_fd(ff, buf, size);
 143	return __do_write_buf(ff, buf, size);
 144}
 145
 146/* Return: 0 if succeeded, -ERR if failed. */
 147static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 size)
 148{
 149	u64 *p = (u64 *) set;
 150	int i, ret;
 151
 152	ret = do_write(ff, &size, sizeof(size));
 153	if (ret < 0)
 154		return ret;
 155
 156	for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
 157		ret = do_write(ff, p + i, sizeof(*p));
 158		if (ret < 0)
 159			return ret;
 160	}
 161
 162	return 0;
 163}
 164
 165/* Return: 0 if succeeded, -ERR if failed. */
 166int write_padded(struct feat_fd *ff, const void *bf,
 167		 size_t count, size_t count_aligned)
 168{
 169	static const char zero_buf[NAME_ALIGN];
 170	int err = do_write(ff, bf, count);
 171
 172	if (!err)
 173		err = do_write(ff, zero_buf, count_aligned - count);
 174
 175	return err;
 176}
 177
 178#define string_size(str)						\
 179	(PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))
 180
 181/* Return: 0 if succeeded, -ERR if failed. */
 182static int do_write_string(struct feat_fd *ff, const char *str)
 183{
 184	u32 len, olen;
 185	int ret;
 186
 187	olen = strlen(str) + 1;
 188	len = PERF_ALIGN(olen, NAME_ALIGN);
 189
 190	/* write len, incl. \0 */
 191	ret = do_write(ff, &len, sizeof(len));
 192	if (ret < 0)
 193		return ret;
 194
 195	return write_padded(ff, str, olen, len);
 196}
 197
 198static int __do_read_fd(struct feat_fd *ff, void *addr, ssize_t size)
 199{
 200	ssize_t ret = readn(ff->fd, addr, size);
 201
 202	if (ret != size)
 203		return ret < 0 ? (int)ret : -1;
 204	return 0;
 205}
 206
 207static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size)
 208{
 209	if (size > (ssize_t)ff->size - ff->offset)
 210		return -1;
 211
 212	memcpy(addr, ff->buf + ff->offset, size);
 213	ff->offset += size;
 214
 215	return 0;
 216
 217}
 218
 219static int __do_read(struct feat_fd *ff, void *addr, ssize_t size)
 220{
 221	if (!ff->buf)
 222		return __do_read_fd(ff, addr, size);
 223	return __do_read_buf(ff, addr, size);
 224}
 225
 226static int do_read_u32(struct feat_fd *ff, u32 *addr)
 227{
 228	int ret;
 229
 230	ret = __do_read(ff, addr, sizeof(*addr));
 231	if (ret)
 232		return ret;
 233
 234	if (ff->ph->needs_swap)
 235		*addr = bswap_32(*addr);
 236	return 0;
 237}
 238
 239static int do_read_u64(struct feat_fd *ff, u64 *addr)
 240{
 241	int ret;
 242
 243	ret = __do_read(ff, addr, sizeof(*addr));
 244	if (ret)
 245		return ret;
 246
 247	if (ff->ph->needs_swap)
 248		*addr = bswap_64(*addr);
 249	return 0;
 250}
 251
 252static char *do_read_string(struct feat_fd *ff)
 253{
 254	u32 len;
 255	char *buf;
 256
 257	if (do_read_u32(ff, &len))
 258		return NULL;
 259
 260	buf = malloc(len);
 261	if (!buf)
 262		return NULL;
 263
 264	if (!__do_read(ff, buf, len)) {
 265		/*
 266		 * strings are padded by zeroes
 267		 * thus the actual strlen of buf
 268		 * may be less than len
 269		 */
 270		return buf;
 271	}
 272
 273	free(buf);
 274	return NULL;
 275}
 276
 277/* Return: 0 if succeeded, -ERR if failed. */
 278static int do_read_bitmap(struct feat_fd *ff, unsigned long **pset, u64 *psize)
 279{
 280	unsigned long *set;
 281	u64 size, *p;
 282	int i, ret;
 283
 284	ret = do_read_u64(ff, &size);
 285	if (ret)
 286		return ret;
 287
 288	set = bitmap_zalloc(size);
 289	if (!set)
 290		return -ENOMEM;
 291
 292	p = (u64 *) set;
 293
 294	for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
 295		ret = do_read_u64(ff, p + i);
 296		if (ret < 0) {
 297			free(set);
 298			return ret;
 299		}
 300	}
 301
 302	*pset  = set;
 303	*psize = size;
 304	return 0;
 305}
 306
 307#ifdef HAVE_LIBTRACEEVENT
 308static int write_tracing_data(struct feat_fd *ff,
 309			      struct evlist *evlist)
 310{
 311	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
 312		return -1;
 313
 314	return read_tracing_data(ff->fd, &evlist->core.entries);
 315}
 316#endif
 317
 318static int write_build_id(struct feat_fd *ff,
 319			  struct evlist *evlist __maybe_unused)
 320{
 321	struct perf_session *session;
 322	int err;
 323
 324	session = container_of(ff->ph, struct perf_session, header);
 325
 326	if (!perf_session__read_build_ids(session, true))
 327		return -1;
 328
 329	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
 330		return -1;
 331
 332	err = perf_session__write_buildid_table(session, ff);
 333	if (err < 0) {
 334		pr_debug("failed to write buildid table\n");
 335		return err;
 336	}
 337	perf_session__cache_build_ids(session);
 338
 339	return 0;
 340}
 341
 342static int write_hostname(struct feat_fd *ff,
 343			  struct evlist *evlist __maybe_unused)
 344{
 345	struct utsname uts;
 346	int ret;
 347
 348	ret = uname(&uts);
 349	if (ret < 0)
 350		return -1;
 351
 352	return do_write_string(ff, uts.nodename);
 353}
 354
 355static int write_osrelease(struct feat_fd *ff,
 356			   struct evlist *evlist __maybe_unused)
 357{
 358	struct utsname uts;
 359	int ret;
 360
 361	ret = uname(&uts);
 362	if (ret < 0)
 363		return -1;
 364
 365	return do_write_string(ff, uts.release);
 366}
 367
 368static int write_arch(struct feat_fd *ff,
 369		      struct evlist *evlist __maybe_unused)
 370{
 371	struct utsname uts;
 372	int ret;
 373
 374	ret = uname(&uts);
 375	if (ret < 0)
 376		return -1;
 377
 378	return do_write_string(ff, uts.machine);
 379}
 380
 381static int write_version(struct feat_fd *ff,
 382			 struct evlist *evlist __maybe_unused)
 383{
 384	return do_write_string(ff, perf_version_string);
 385}
 386
 387static int __write_cpudesc(struct feat_fd *ff, const char *cpuinfo_proc)
 388{
 389	FILE *file;
 390	char *buf = NULL;
 391	char *s, *p;
 392	const char *search = cpuinfo_proc;
 393	size_t len = 0;
 394	int ret = -1;
 395
 396	if (!search)
 397		return -1;
 398
 399	file = fopen("/proc/cpuinfo", "r");
 400	if (!file)
 401		return -1;
 402
 403	while (getline(&buf, &len, file) > 0) {
 404		ret = strncmp(buf, search, strlen(search));
 405		if (!ret)
 406			break;
 407	}
 408
 409	if (ret) {
 410		ret = -1;
 411		goto done;
 412	}
 413
 414	s = buf;
 415
 416	p = strchr(buf, ':');
 417	if (p && *(p+1) == ' ' && *(p+2))
 418		s = p + 2;
 419	p = strchr(s, '\n');
 420	if (p)
 421		*p = '\0';
 422
 423	/* squash extra space characters (branding string) */
 424	p = s;
 425	while (*p) {
 426		if (isspace(*p)) {
 427			char *r = p + 1;
 428			char *q = skip_spaces(r);
 429			*p = ' ';
 430			if (q != (p+1))
 431				while ((*r++ = *q++));
 432		}
 433		p++;
 434	}
 435	ret = do_write_string(ff, s);
 436done:
 437	free(buf);
 438	fclose(file);
 439	return ret;
 440}
 441
 442static int write_cpudesc(struct feat_fd *ff,
 443		       struct evlist *evlist __maybe_unused)
 444{
 445#if defined(__powerpc__) || defined(__hppa__) || defined(__sparc__)
 446#define CPUINFO_PROC	{ "cpu", }
 447#elif defined(__s390__)
 448#define CPUINFO_PROC	{ "vendor_id", }
 449#elif defined(__sh__)
 450#define CPUINFO_PROC	{ "cpu type", }
 451#elif defined(__alpha__) || defined(__mips__)
 452#define CPUINFO_PROC	{ "cpu model", }
 453#elif defined(__arm__)
 454#define CPUINFO_PROC	{ "model name", "Processor", }
 455#elif defined(__arc__)
 456#define CPUINFO_PROC	{ "Processor", }
 457#elif defined(__xtensa__)
 458#define CPUINFO_PROC	{ "core ID", }
 459#elif defined(__loongarch__)
 460#define CPUINFO_PROC	{ "Model Name", }
 461#else
 462#define CPUINFO_PROC	{ "model name", }
 463#endif
 464	const char *cpuinfo_procs[] = CPUINFO_PROC;
 465#undef CPUINFO_PROC
 466	unsigned int i;
 467
 468	for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
 469		int ret;
 470		ret = __write_cpudesc(ff, cpuinfo_procs[i]);
 471		if (ret >= 0)
 472			return ret;
 473	}
 474	return -1;
 475}
 476
 477
 478static int write_nrcpus(struct feat_fd *ff,
 479			struct evlist *evlist __maybe_unused)
 480{
 481	long nr;
 482	u32 nrc, nra;
 483	int ret;
 484
 485	nrc = cpu__max_present_cpu().cpu;
 486
 487	nr = sysconf(_SC_NPROCESSORS_ONLN);
 488	if (nr < 0)
 489		return -1;
 490
 491	nra = (u32)(nr & UINT_MAX);
 492
 493	ret = do_write(ff, &nrc, sizeof(nrc));
 494	if (ret < 0)
 495		return ret;
 496
 497	return do_write(ff, &nra, sizeof(nra));
 498}
 499
 500static int write_event_desc(struct feat_fd *ff,
 501			    struct evlist *evlist)
 502{
 503	struct evsel *evsel;
 504	u32 nre, nri, sz;
 505	int ret;
 506
 507	nre = evlist->core.nr_entries;
 508
 509	/*
 510	 * write number of events
 511	 */
 512	ret = do_write(ff, &nre, sizeof(nre));
 513	if (ret < 0)
 514		return ret;
 515
 516	/*
 517	 * size of perf_event_attr struct
 518	 */
 519	sz = (u32)sizeof(evsel->core.attr);
 520	ret = do_write(ff, &sz, sizeof(sz));
 521	if (ret < 0)
 522		return ret;
 523
 524	evlist__for_each_entry(evlist, evsel) {
 525		ret = do_write(ff, &evsel->core.attr, sz);
 526		if (ret < 0)
 527			return ret;
 528		/*
 529		 * write number of unique id per event
 530		 * there is one id per instance of an event
 531		 *
 532		 * copy into an nri to be independent of the
 533		 * type of ids,
 534		 */
 535		nri = evsel->core.ids;
 536		ret = do_write(ff, &nri, sizeof(nri));
 537		if (ret < 0)
 538			return ret;
 539
 540		/*
 541		 * write event string as passed on cmdline
 542		 */
 543		ret = do_write_string(ff, evsel__name(evsel));
 544		if (ret < 0)
 545			return ret;
 546		/*
 547		 * write unique ids for this event
 548		 */
 549		ret = do_write(ff, evsel->core.id, evsel->core.ids * sizeof(u64));
 550		if (ret < 0)
 551			return ret;
 552	}
 553	return 0;
 554}
 555
 556static int write_cmdline(struct feat_fd *ff,
 557			 struct evlist *evlist __maybe_unused)
 558{
 559	char pbuf[MAXPATHLEN], *buf;
 560	int i, ret, n;
 561
 562	/* actual path to perf binary */
 563	buf = perf_exe(pbuf, MAXPATHLEN);
 564
 565	/* account for binary path */
 566	n = perf_env.nr_cmdline + 1;
 567
 568	ret = do_write(ff, &n, sizeof(n));
 569	if (ret < 0)
 570		return ret;
 571
 572	ret = do_write_string(ff, buf);
 573	if (ret < 0)
 574		return ret;
 575
 576	for (i = 0 ; i < perf_env.nr_cmdline; i++) {
 577		ret = do_write_string(ff, perf_env.cmdline_argv[i]);
 578		if (ret < 0)
 579			return ret;
 580	}
 581	return 0;
 582}
 583
 584
 585static int write_cpu_topology(struct feat_fd *ff,
 586			      struct evlist *evlist __maybe_unused)
 587{
 588	struct cpu_topology *tp;
 589	u32 i;
 590	int ret, j;
 591
 592	tp = cpu_topology__new();
 593	if (!tp)
 594		return -1;
 595
 596	ret = do_write(ff, &tp->package_cpus_lists, sizeof(tp->package_cpus_lists));
 597	if (ret < 0)
 598		goto done;
 599
 600	for (i = 0; i < tp->package_cpus_lists; i++) {
 601		ret = do_write_string(ff, tp->package_cpus_list[i]);
 602		if (ret < 0)
 603			goto done;
 604	}
 605	ret = do_write(ff, &tp->core_cpus_lists, sizeof(tp->core_cpus_lists));
 606	if (ret < 0)
 607		goto done;
 608
 609	for (i = 0; i < tp->core_cpus_lists; i++) {
 610		ret = do_write_string(ff, tp->core_cpus_list[i]);
 611		if (ret < 0)
 612			break;
 613	}
 614
 615	ret = perf_env__read_cpu_topology_map(&perf_env);
 616	if (ret < 0)
 617		goto done;
 618
 619	for (j = 0; j < perf_env.nr_cpus_avail; j++) {
 620		ret = do_write(ff, &perf_env.cpu[j].core_id,
 621			       sizeof(perf_env.cpu[j].core_id));
 622		if (ret < 0)
 623			return ret;
 624		ret = do_write(ff, &perf_env.cpu[j].socket_id,
 625			       sizeof(perf_env.cpu[j].socket_id));
 626		if (ret < 0)
 627			return ret;
 628	}
 629
 630	if (!tp->die_cpus_lists)
 631		goto done;
 632
 633	ret = do_write(ff, &tp->die_cpus_lists, sizeof(tp->die_cpus_lists));
 634	if (ret < 0)
 635		goto done;
 636
 637	for (i = 0; i < tp->die_cpus_lists; i++) {
 638		ret = do_write_string(ff, tp->die_cpus_list[i]);
 639		if (ret < 0)
 640			goto done;
 641	}
 642
 643	for (j = 0; j < perf_env.nr_cpus_avail; j++) {
 644		ret = do_write(ff, &perf_env.cpu[j].die_id,
 645			       sizeof(perf_env.cpu[j].die_id));
 646		if (ret < 0)
 647			return ret;
 648	}
 649
 650done:
 651	cpu_topology__delete(tp);
 652	return ret;
 653}
 654
 655
 656
 657static int write_total_mem(struct feat_fd *ff,
 658			   struct evlist *evlist __maybe_unused)
 659{
 660	char *buf = NULL;
 661	FILE *fp;
 662	size_t len = 0;
 663	int ret = -1, n;
 664	uint64_t mem;
 665
 666	fp = fopen("/proc/meminfo", "r");
 667	if (!fp)
 668		return -1;
 669
 670	while (getline(&buf, &len, fp) > 0) {
 671		ret = strncmp(buf, "MemTotal:", 9);
 672		if (!ret)
 673			break;
 674	}
 675	if (!ret) {
 676		n = sscanf(buf, "%*s %"PRIu64, &mem);
 677		if (n == 1)
 678			ret = do_write(ff, &mem, sizeof(mem));
 679	} else
 680		ret = -1;
 681	free(buf);
 682	fclose(fp);
 683	return ret;
 684}
 685
 686static int write_numa_topology(struct feat_fd *ff,
 687			       struct evlist *evlist __maybe_unused)
 688{
 689	struct numa_topology *tp;
 690	int ret = -1;
 691	u32 i;
 692
 693	tp = numa_topology__new();
 694	if (!tp)
 695		return -ENOMEM;
 696
 697	ret = do_write(ff, &tp->nr, sizeof(u32));
 698	if (ret < 0)
 699		goto err;
 700
 701	for (i = 0; i < tp->nr; i++) {
 702		struct numa_topology_node *n = &tp->nodes[i];
 703
 704		ret = do_write(ff, &n->node, sizeof(u32));
 705		if (ret < 0)
 706			goto err;
 707
 708		ret = do_write(ff, &n->mem_total, sizeof(u64));
 709		if (ret)
 710			goto err;
 711
 712		ret = do_write(ff, &n->mem_free, sizeof(u64));
 713		if (ret)
 714			goto err;
 715
 716		ret = do_write_string(ff, n->cpus);
 717		if (ret < 0)
 718			goto err;
 719	}
 720
 721	ret = 0;
 722
 723err:
 724	numa_topology__delete(tp);
 725	return ret;
 726}
 727
 728/*
 729 * File format:
 730 *
 731 * struct pmu_mappings {
 732 *	u32	pmu_num;
 733 *	struct pmu_map {
 734 *		u32	type;
 735 *		char	name[];
 736 *	}[pmu_num];
 737 * };
 738 */
 739
 740static int write_pmu_mappings(struct feat_fd *ff,
 741			      struct evlist *evlist __maybe_unused)
 742{
 743	struct perf_pmu *pmu = NULL;
 744	u32 pmu_num = 0;
 745	int ret;
 746
 747	/*
 748	 * Do a first pass to count number of pmu to avoid lseek so this
 749	 * works in pipe mode as well.
 750	 */
 751	while ((pmu = perf_pmus__scan(pmu)))
 
 
 752		pmu_num++;
 
 753
 754	ret = do_write(ff, &pmu_num, sizeof(pmu_num));
 755	if (ret < 0)
 756		return ret;
 757
 758	while ((pmu = perf_pmus__scan(pmu))) {
 
 
 
 759		ret = do_write(ff, &pmu->type, sizeof(pmu->type));
 760		if (ret < 0)
 761			return ret;
 762
 763		ret = do_write_string(ff, pmu->name);
 764		if (ret < 0)
 765			return ret;
 766	}
 767
 768	return 0;
 769}
 770
 771/*
 772 * File format:
 773 *
 774 * struct group_descs {
 775 *	u32	nr_groups;
 776 *	struct group_desc {
 777 *		char	name[];
 778 *		u32	leader_idx;
 779 *		u32	nr_members;
 780 *	}[nr_groups];
 781 * };
 782 */
 783static int write_group_desc(struct feat_fd *ff,
 784			    struct evlist *evlist)
 785{
 786	u32 nr_groups = evlist__nr_groups(evlist);
 787	struct evsel *evsel;
 788	int ret;
 789
 790	ret = do_write(ff, &nr_groups, sizeof(nr_groups));
 791	if (ret < 0)
 792		return ret;
 793
 794	evlist__for_each_entry(evlist, evsel) {
 795		if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
 796			const char *name = evsel->group_name ?: "{anon_group}";
 797			u32 leader_idx = evsel->core.idx;
 798			u32 nr_members = evsel->core.nr_members;
 799
 800			ret = do_write_string(ff, name);
 801			if (ret < 0)
 802				return ret;
 803
 804			ret = do_write(ff, &leader_idx, sizeof(leader_idx));
 805			if (ret < 0)
 806				return ret;
 807
 808			ret = do_write(ff, &nr_members, sizeof(nr_members));
 809			if (ret < 0)
 810				return ret;
 811		}
 812	}
 813	return 0;
 814}
 815
 816/*
 817 * Return the CPU id as a raw string.
 818 *
 819 * Each architecture should provide a more precise id string that
 820 * can be use to match the architecture's "mapfile".
 821 */
 822char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused)
 823{
 824	return NULL;
 825}
 826
 827/* Return zero when the cpuid from the mapfile.csv matches the
 828 * cpuid string generated on this platform.
 829 * Otherwise return non-zero.
 830 */
 831int __weak strcmp_cpuid_str(const char *mapcpuid, const char *cpuid)
 832{
 833	regex_t re;
 834	regmatch_t pmatch[1];
 835	int match;
 836
 837	if (regcomp(&re, mapcpuid, REG_EXTENDED) != 0) {
 838		/* Warn unable to generate match particular string. */
 839		pr_info("Invalid regular expression %s\n", mapcpuid);
 840		return 1;
 841	}
 842
 843	match = !regexec(&re, cpuid, 1, pmatch, 0);
 844	regfree(&re);
 845	if (match) {
 846		size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);
 847
 848		/* Verify the entire string matched. */
 849		if (match_len == strlen(cpuid))
 850			return 0;
 851	}
 852	return 1;
 853}
 854
 855/*
 856 * default get_cpuid(): nothing gets recorded
 857 * actual implementation must be in arch/$(SRCARCH)/util/header.c
 858 */
 859int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)
 860{
 861	return ENOSYS; /* Not implemented */
 862}
 863
 864static int write_cpuid(struct feat_fd *ff,
 865		       struct evlist *evlist __maybe_unused)
 866{
 867	char buffer[64];
 868	int ret;
 869
 870	ret = get_cpuid(buffer, sizeof(buffer));
 871	if (ret)
 872		return -1;
 873
 874	return do_write_string(ff, buffer);
 875}
 876
 877static int write_branch_stack(struct feat_fd *ff __maybe_unused,
 878			      struct evlist *evlist __maybe_unused)
 879{
 880	return 0;
 881}
 882
 883static int write_auxtrace(struct feat_fd *ff,
 884			  struct evlist *evlist __maybe_unused)
 885{
 886	struct perf_session *session;
 887	int err;
 888
 889	if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
 890		return -1;
 891
 892	session = container_of(ff->ph, struct perf_session, header);
 893
 894	err = auxtrace_index__write(ff->fd, &session->auxtrace_index);
 895	if (err < 0)
 896		pr_err("Failed to write auxtrace index\n");
 897	return err;
 898}
 899
 900static int write_clockid(struct feat_fd *ff,
 901			 struct evlist *evlist __maybe_unused)
 902{
 903	return do_write(ff, &ff->ph->env.clock.clockid_res_ns,
 904			sizeof(ff->ph->env.clock.clockid_res_ns));
 905}
 906
 907static int write_clock_data(struct feat_fd *ff,
 908			    struct evlist *evlist __maybe_unused)
 909{
 910	u64 *data64;
 911	u32 data32;
 912	int ret;
 913
 914	/* version */
 915	data32 = 1;
 916
 917	ret = do_write(ff, &data32, sizeof(data32));
 918	if (ret < 0)
 919		return ret;
 920
 921	/* clockid */
 922	data32 = ff->ph->env.clock.clockid;
 923
 924	ret = do_write(ff, &data32, sizeof(data32));
 925	if (ret < 0)
 926		return ret;
 927
 928	/* TOD ref time */
 929	data64 = &ff->ph->env.clock.tod_ns;
 930
 931	ret = do_write(ff, data64, sizeof(*data64));
 932	if (ret < 0)
 933		return ret;
 934
 935	/* clockid ref time */
 936	data64 = &ff->ph->env.clock.clockid_ns;
 937
 938	return do_write(ff, data64, sizeof(*data64));
 939}
 940
 941static int write_hybrid_topology(struct feat_fd *ff,
 942				 struct evlist *evlist __maybe_unused)
 943{
 944	struct hybrid_topology *tp;
 945	int ret;
 946	u32 i;
 947
 948	tp = hybrid_topology__new();
 949	if (!tp)
 950		return -ENOENT;
 951
 952	ret = do_write(ff, &tp->nr, sizeof(u32));
 953	if (ret < 0)
 954		goto err;
 955
 956	for (i = 0; i < tp->nr; i++) {
 957		struct hybrid_topology_node *n = &tp->nodes[i];
 958
 959		ret = do_write_string(ff, n->pmu_name);
 960		if (ret < 0)
 961			goto err;
 962
 963		ret = do_write_string(ff, n->cpus);
 964		if (ret < 0)
 965			goto err;
 966	}
 967
 968	ret = 0;
 969
 970err:
 971	hybrid_topology__delete(tp);
 972	return ret;
 973}
 974
 975static int write_dir_format(struct feat_fd *ff,
 976			    struct evlist *evlist __maybe_unused)
 977{
 978	struct perf_session *session;
 979	struct perf_data *data;
 980
 981	session = container_of(ff->ph, struct perf_session, header);
 982	data = session->data;
 983
 984	if (WARN_ON(!perf_data__is_dir(data)))
 985		return -1;
 986
 987	return do_write(ff, &data->dir.version, sizeof(data->dir.version));
 988}
 989
 990/*
 991 * Check whether a CPU is online
 992 *
 993 * Returns:
 994 *     1 -> if CPU is online
 995 *     0 -> if CPU is offline
 996 *    -1 -> error case
 997 */
 998int is_cpu_online(unsigned int cpu)
 999{
1000	char *str;
1001	size_t strlen;
1002	char buf[256];
1003	int status = -1;
1004	struct stat statbuf;
1005
1006	snprintf(buf, sizeof(buf),
1007		"/sys/devices/system/cpu/cpu%d", cpu);
1008	if (stat(buf, &statbuf) != 0)
1009		return 0;
1010
1011	/*
1012	 * Check if /sys/devices/system/cpu/cpux/online file
1013	 * exists. Some cases cpu0 won't have online file since
1014	 * it is not expected to be turned off generally.
1015	 * In kernels without CONFIG_HOTPLUG_CPU, this
1016	 * file won't exist
1017	 */
1018	snprintf(buf, sizeof(buf),
1019		"/sys/devices/system/cpu/cpu%d/online", cpu);
1020	if (stat(buf, &statbuf) != 0)
1021		return 1;
1022
1023	/*
1024	 * Read online file using sysfs__read_str.
1025	 * If read or open fails, return -1.
1026	 * If read succeeds, return value from file
1027	 * which gets stored in "str"
1028	 */
1029	snprintf(buf, sizeof(buf),
1030		"devices/system/cpu/cpu%d/online", cpu);
1031
1032	if (sysfs__read_str(buf, &str, &strlen) < 0)
1033		return status;
1034
1035	status = atoi(str);
1036
1037	free(str);
1038	return status;
1039}
1040
1041#ifdef HAVE_LIBBPF_SUPPORT
1042static int write_bpf_prog_info(struct feat_fd *ff,
1043			       struct evlist *evlist __maybe_unused)
1044{
1045	struct perf_env *env = &ff->ph->env;
1046	struct rb_root *root;
1047	struct rb_node *next;
1048	int ret;
1049
1050	down_read(&env->bpf_progs.lock);
1051
1052	ret = do_write(ff, &env->bpf_progs.infos_cnt,
1053		       sizeof(env->bpf_progs.infos_cnt));
1054	if (ret < 0)
1055		goto out;
1056
1057	root = &env->bpf_progs.infos;
1058	next = rb_first(root);
1059	while (next) {
1060		struct bpf_prog_info_node *node;
1061		size_t len;
1062
1063		node = rb_entry(next, struct bpf_prog_info_node, rb_node);
1064		next = rb_next(&node->rb_node);
1065		len = sizeof(struct perf_bpil) +
1066			node->info_linear->data_len;
1067
1068		/* before writing to file, translate address to offset */
1069		bpil_addr_to_offs(node->info_linear);
1070		ret = do_write(ff, node->info_linear, len);
1071		/*
1072		 * translate back to address even when do_write() fails,
1073		 * so that this function never changes the data.
1074		 */
1075		bpil_offs_to_addr(node->info_linear);
1076		if (ret < 0)
1077			goto out;
1078	}
1079out:
1080	up_read(&env->bpf_progs.lock);
1081	return ret;
1082}
 
 
 
 
 
 
 
1083
1084static int write_bpf_btf(struct feat_fd *ff,
1085			 struct evlist *evlist __maybe_unused)
1086{
1087	struct perf_env *env = &ff->ph->env;
1088	struct rb_root *root;
1089	struct rb_node *next;
1090	int ret;
1091
1092	down_read(&env->bpf_progs.lock);
1093
1094	ret = do_write(ff, &env->bpf_progs.btfs_cnt,
1095		       sizeof(env->bpf_progs.btfs_cnt));
1096
1097	if (ret < 0)
1098		goto out;
1099
1100	root = &env->bpf_progs.btfs;
1101	next = rb_first(root);
1102	while (next) {
1103		struct btf_node *node;
1104
1105		node = rb_entry(next, struct btf_node, rb_node);
1106		next = rb_next(&node->rb_node);
1107		ret = do_write(ff, &node->id,
1108			       sizeof(u32) * 2 + node->data_size);
1109		if (ret < 0)
1110			goto out;
1111	}
1112out:
1113	up_read(&env->bpf_progs.lock);
1114	return ret;
1115}
1116#endif // HAVE_LIBBPF_SUPPORT
1117
1118static int cpu_cache_level__sort(const void *a, const void *b)
1119{
1120	struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
1121	struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b;
1122
1123	return cache_a->level - cache_b->level;
1124}
1125
1126static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b)
1127{
1128	if (a->level != b->level)
1129		return false;
1130
1131	if (a->line_size != b->line_size)
1132		return false;
1133
1134	if (a->sets != b->sets)
1135		return false;
1136
1137	if (a->ways != b->ways)
1138		return false;
1139
1140	if (strcmp(a->type, b->type))
1141		return false;
1142
1143	if (strcmp(a->size, b->size))
1144		return false;
1145
1146	if (strcmp(a->map, b->map))
1147		return false;
1148
1149	return true;
1150}
1151
1152static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level)
1153{
1154	char path[PATH_MAX], file[PATH_MAX];
1155	struct stat st;
1156	size_t len;
1157
1158	scnprintf(path, PATH_MAX, "devices/system/cpu/cpu%d/cache/index%d/", cpu, level);
1159	scnprintf(file, PATH_MAX, "%s/%s", sysfs__mountpoint(), path);
1160
1161	if (stat(file, &st))
1162		return 1;
1163
1164	scnprintf(file, PATH_MAX, "%s/level", path);
1165	if (sysfs__read_int(file, (int *) &cache->level))
1166		return -1;
1167
1168	scnprintf(file, PATH_MAX, "%s/coherency_line_size", path);
1169	if (sysfs__read_int(file, (int *) &cache->line_size))
1170		return -1;
1171
1172	scnprintf(file, PATH_MAX, "%s/number_of_sets", path);
1173	if (sysfs__read_int(file, (int *) &cache->sets))
1174		return -1;
1175
1176	scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path);
1177	if (sysfs__read_int(file, (int *) &cache->ways))
1178		return -1;
1179
1180	scnprintf(file, PATH_MAX, "%s/type", path);
1181	if (sysfs__read_str(file, &cache->type, &len))
1182		return -1;
1183
1184	cache->type[len] = 0;
1185	cache->type = strim(cache->type);
1186
1187	scnprintf(file, PATH_MAX, "%s/size", path);
1188	if (sysfs__read_str(file, &cache->size, &len)) {
1189		zfree(&cache->type);
1190		return -1;
1191	}
1192
1193	cache->size[len] = 0;
1194	cache->size = strim(cache->size);
1195
1196	scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path);
1197	if (sysfs__read_str(file, &cache->map, &len)) {
1198		zfree(&cache->size);
1199		zfree(&cache->type);
1200		return -1;
1201	}
1202
1203	cache->map[len] = 0;
1204	cache->map = strim(cache->map);
1205	return 0;
1206}
1207
1208static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c)
1209{
1210	fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map);
1211}
1212
1213/*
1214 * Build caches levels for a particular CPU from the data in
1215 * /sys/devices/system/cpu/cpu<cpu>/cache/
1216 * The cache level data is stored in caches[] from index at
1217 * *cntp.
1218 */
1219int build_caches_for_cpu(u32 cpu, struct cpu_cache_level caches[], u32 *cntp)
1220{
 
 
1221	u16 level;
1222
1223	for (level = 0; level < MAX_CACHE_LVL; level++) {
1224		struct cpu_cache_level c;
1225		int err;
1226		u32 i;
1227
1228		err = cpu_cache_level__read(&c, cpu, level);
1229		if (err < 0)
1230			return err;
1231
1232		if (err == 1)
1233			break;
 
 
 
 
 
 
1234
1235		for (i = 0; i < *cntp; i++) {
1236			if (cpu_cache_level__cmp(&c, &caches[i]))
1237				break;
1238		}
1239
1240		if (i == *cntp) {
1241			caches[*cntp] = c;
1242			*cntp = *cntp + 1;
1243		} else
1244			cpu_cache_level__free(&c);
1245	}
1246
1247	return 0;
1248}
1249
1250static int build_caches(struct cpu_cache_level caches[], u32 *cntp)
1251{
1252	u32 nr, cpu, cnt = 0;
1253
1254	nr = cpu__max_cpu().cpu;
1255
1256	for (cpu = 0; cpu < nr; cpu++) {
1257		int ret = build_caches_for_cpu(cpu, caches, &cnt);
 
 
1258
1259		if (ret)
1260			return ret;
 
 
 
1261	}
1262	*cntp = cnt;
1263	return 0;
1264}
1265
1266static int write_cache(struct feat_fd *ff,
1267		       struct evlist *evlist __maybe_unused)
1268{
1269	u32 max_caches = cpu__max_cpu().cpu * MAX_CACHE_LVL;
1270	struct cpu_cache_level caches[max_caches];
1271	u32 cnt = 0, i, version = 1;
1272	int ret;
1273
1274	ret = build_caches(caches, &cnt);
1275	if (ret)
1276		goto out;
1277
1278	qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort);
1279
1280	ret = do_write(ff, &version, sizeof(u32));
1281	if (ret < 0)
1282		goto out;
1283
1284	ret = do_write(ff, &cnt, sizeof(u32));
1285	if (ret < 0)
1286		goto out;
1287
1288	for (i = 0; i < cnt; i++) {
1289		struct cpu_cache_level *c = &caches[i];
1290
1291		#define _W(v)					\
1292			ret = do_write(ff, &c->v, sizeof(u32));	\
1293			if (ret < 0)				\
1294				goto out;
1295
1296		_W(level)
1297		_W(line_size)
1298		_W(sets)
1299		_W(ways)
1300		#undef _W
1301
1302		#define _W(v)						\
1303			ret = do_write_string(ff, (const char *) c->v);	\
1304			if (ret < 0)					\
1305				goto out;
1306
1307		_W(type)
1308		_W(size)
1309		_W(map)
1310		#undef _W
1311	}
1312
1313out:
1314	for (i = 0; i < cnt; i++)
1315		cpu_cache_level__free(&caches[i]);
1316	return ret;
1317}
1318
1319static int write_stat(struct feat_fd *ff __maybe_unused,
1320		      struct evlist *evlist __maybe_unused)
1321{
1322	return 0;
1323}
1324
1325static int write_sample_time(struct feat_fd *ff,
1326			     struct evlist *evlist)
1327{
1328	int ret;
1329
1330	ret = do_write(ff, &evlist->first_sample_time,
1331		       sizeof(evlist->first_sample_time));
1332	if (ret < 0)
1333		return ret;
1334
1335	return do_write(ff, &evlist->last_sample_time,
1336			sizeof(evlist->last_sample_time));
1337}
1338
1339
1340static int memory_node__read(struct memory_node *n, unsigned long idx)
1341{
1342	unsigned int phys, size = 0;
1343	char path[PATH_MAX];
1344	struct dirent *ent;
1345	DIR *dir;
1346
1347#define for_each_memory(mem, dir)					\
1348	while ((ent = readdir(dir)))					\
1349		if (strcmp(ent->d_name, ".") &&				\
1350		    strcmp(ent->d_name, "..") &&			\
1351		    sscanf(ent->d_name, "memory%u", &mem) == 1)
1352
1353	scnprintf(path, PATH_MAX,
1354		  "%s/devices/system/node/node%lu",
1355		  sysfs__mountpoint(), idx);
1356
1357	dir = opendir(path);
1358	if (!dir) {
1359		pr_warning("failed: can't open memory sysfs data\n");
1360		return -1;
1361	}
1362
1363	for_each_memory(phys, dir) {
1364		size = max(phys, size);
1365	}
1366
1367	size++;
1368
1369	n->set = bitmap_zalloc(size);
1370	if (!n->set) {
1371		closedir(dir);
1372		return -ENOMEM;
1373	}
1374
1375	n->node = idx;
1376	n->size = size;
1377
1378	rewinddir(dir);
1379
1380	for_each_memory(phys, dir) {
1381		__set_bit(phys, n->set);
1382	}
1383
1384	closedir(dir);
1385	return 0;
1386}
1387
1388static void memory_node__delete_nodes(struct memory_node *nodesp, u64 cnt)
1389{
1390	for (u64 i = 0; i < cnt; i++)
1391		bitmap_free(nodesp[i].set);
1392
1393	free(nodesp);
1394}
1395
1396static int memory_node__sort(const void *a, const void *b)
1397{
1398	const struct memory_node *na = a;
1399	const struct memory_node *nb = b;
1400
1401	return na->node - nb->node;
1402}
1403
1404static int build_mem_topology(struct memory_node **nodesp, u64 *cntp)
1405{
1406	char path[PATH_MAX];
1407	struct dirent *ent;
1408	DIR *dir;
 
1409	int ret = 0;
1410	size_t cnt = 0, size = 0;
1411	struct memory_node *nodes = NULL;
1412
1413	scnprintf(path, PATH_MAX, "%s/devices/system/node/",
1414		  sysfs__mountpoint());
1415
1416	dir = opendir(path);
1417	if (!dir) {
1418		pr_debug2("%s: couldn't read %s, does this arch have topology information?\n",
1419			  __func__, path);
1420		return -1;
1421	}
1422
1423	while (!ret && (ent = readdir(dir))) {
1424		unsigned int idx;
1425		int r;
1426
1427		if (!strcmp(ent->d_name, ".") ||
1428		    !strcmp(ent->d_name, ".."))
1429			continue;
1430
1431		r = sscanf(ent->d_name, "node%u", &idx);
1432		if (r != 1)
1433			continue;
1434
1435		if (cnt >= size) {
1436			struct memory_node *new_nodes =
1437				reallocarray(nodes, cnt + 4, sizeof(*nodes));
1438
1439			if (!new_nodes) {
1440				pr_err("Failed to write MEM_TOPOLOGY, size %zd nodes\n", size);
1441				ret = -ENOMEM;
1442				goto out;
1443			}
1444			nodes = new_nodes;
1445			size += 4;
1446		}
1447		ret = memory_node__read(&nodes[cnt], idx);
1448		if (!ret)
1449			cnt += 1;
1450	}
1451out:
 
1452	closedir(dir);
1453	if (!ret) {
1454		*cntp = cnt;
1455		*nodesp = nodes;
1456		qsort(nodes, cnt, sizeof(nodes[0]), memory_node__sort);
1457	} else
1458		memory_node__delete_nodes(nodes, cnt);
1459
1460	return ret;
1461}
1462
 
 
1463/*
1464 * The MEM_TOPOLOGY holds physical memory map for every
1465 * node in system. The format of data is as follows:
1466 *
1467 *  0 - version          | for future changes
1468 *  8 - block_size_bytes | /sys/devices/system/memory/block_size_bytes
1469 * 16 - count            | number of nodes
1470 *
1471 * For each node we store map of physical indexes for
1472 * each node:
1473 *
1474 * 32 - node id          | node index
1475 * 40 - size             | size of bitmap
1476 * 48 - bitmap           | bitmap of memory indexes that belongs to node
1477 */
1478static int write_mem_topology(struct feat_fd *ff __maybe_unused,
1479			      struct evlist *evlist __maybe_unused)
1480{
1481	struct memory_node *nodes = NULL;
1482	u64 bsize, version = 1, i, nr = 0;
1483	int ret;
1484
1485	ret = sysfs__read_xll("devices/system/memory/block_size_bytes",
1486			      (unsigned long long *) &bsize);
1487	if (ret)
1488		return ret;
1489
1490	ret = build_mem_topology(&nodes, &nr);
1491	if (ret)
1492		return ret;
1493
1494	ret = do_write(ff, &version, sizeof(version));
1495	if (ret < 0)
1496		goto out;
1497
1498	ret = do_write(ff, &bsize, sizeof(bsize));
1499	if (ret < 0)
1500		goto out;
1501
1502	ret = do_write(ff, &nr, sizeof(nr));
1503	if (ret < 0)
1504		goto out;
1505
1506	for (i = 0; i < nr; i++) {
1507		struct memory_node *n = &nodes[i];
1508
1509		#define _W(v)						\
1510			ret = do_write(ff, &n->v, sizeof(n->v));	\
1511			if (ret < 0)					\
1512				goto out;
1513
1514		_W(node)
1515		_W(size)
1516
1517		#undef _W
1518
1519		ret = do_write_bitmap(ff, n->set, n->size);
1520		if (ret < 0)
1521			goto out;
1522	}
1523
1524out:
1525	memory_node__delete_nodes(nodes, nr);
1526	return ret;
1527}
1528
1529static int write_compressed(struct feat_fd *ff __maybe_unused,
1530			    struct evlist *evlist __maybe_unused)
1531{
1532	int ret;
1533
1534	ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver));
1535	if (ret)
1536		return ret;
1537
1538	ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type));
1539	if (ret)
1540		return ret;
1541
1542	ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level));
1543	if (ret)
1544		return ret;
1545
1546	ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio));
1547	if (ret)
1548		return ret;
1549
1550	return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len));
1551}
1552
1553static int __write_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu,
1554			    bool write_pmu)
1555{
 
1556	struct perf_pmu_caps *caps = NULL;
 
1557	int ret;
1558
1559	ret = do_write(ff, &pmu->nr_caps, sizeof(pmu->nr_caps));
 
 
 
 
 
 
 
1560	if (ret < 0)
1561		return ret;
1562
1563	list_for_each_entry(caps, &pmu->caps, list) {
1564		ret = do_write_string(ff, caps->name);
1565		if (ret < 0)
1566			return ret;
1567
1568		ret = do_write_string(ff, caps->value);
1569		if (ret < 0)
1570			return ret;
1571	}
1572
1573	if (write_pmu) {
1574		ret = do_write_string(ff, pmu->name);
1575		if (ret < 0)
1576			return ret;
1577	}
1578
1579	return ret;
1580}
1581
1582static int write_cpu_pmu_caps(struct feat_fd *ff,
1583			      struct evlist *evlist __maybe_unused)
1584{
1585	struct perf_pmu *cpu_pmu = perf_pmus__find("cpu");
1586	int ret;
1587
1588	if (!cpu_pmu)
1589		return -ENOENT;
1590
1591	ret = perf_pmu__caps_parse(cpu_pmu);
1592	if (ret < 0)
1593		return ret;
1594
1595	return __write_pmu_caps(ff, cpu_pmu, false);
1596}
1597
1598static int write_pmu_caps(struct feat_fd *ff,
1599			  struct evlist *evlist __maybe_unused)
1600{
1601	struct perf_pmu *pmu = NULL;
1602	int nr_pmu = 0;
1603	int ret;
1604
1605	while ((pmu = perf_pmus__scan(pmu))) {
1606		if (!strcmp(pmu->name, "cpu")) {
1607			/*
1608			 * The "cpu" PMU is special and covered by
1609			 * HEADER_CPU_PMU_CAPS. Note, core PMUs are
1610			 * counted/written here for ARM, s390 and Intel hybrid.
1611			 */
1612			continue;
1613		}
1614		if (perf_pmu__caps_parse(pmu) <= 0)
1615			continue;
1616		nr_pmu++;
1617	}
1618
1619	ret = do_write(ff, &nr_pmu, sizeof(nr_pmu));
1620	if (ret < 0)
1621		return ret;
1622
1623	if (!nr_pmu)
1624		return 0;
1625
1626	/*
1627	 * Note older perf tools assume core PMUs come first, this is a property
1628	 * of perf_pmus__scan.
1629	 */
1630	pmu = NULL;
1631	while ((pmu = perf_pmus__scan(pmu))) {
1632		if (!strcmp(pmu->name, "cpu")) {
1633			/* Skip as above. */
1634			continue;
1635		}
1636		if (perf_pmu__caps_parse(pmu) <= 0)
1637			continue;
1638		ret = __write_pmu_caps(ff, pmu, true);
1639		if (ret < 0)
1640			return ret;
1641	}
1642	return 0;
1643}
1644
1645static void print_hostname(struct feat_fd *ff, FILE *fp)
1646{
1647	fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname);
1648}
1649
1650static void print_osrelease(struct feat_fd *ff, FILE *fp)
1651{
1652	fprintf(fp, "# os release : %s\n", ff->ph->env.os_release);
1653}
1654
1655static void print_arch(struct feat_fd *ff, FILE *fp)
1656{
1657	fprintf(fp, "# arch : %s\n", ff->ph->env.arch);
1658}
1659
1660static void print_cpudesc(struct feat_fd *ff, FILE *fp)
1661{
1662	fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc);
1663}
1664
1665static void print_nrcpus(struct feat_fd *ff, FILE *fp)
1666{
1667	fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online);
1668	fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail);
1669}
1670
1671static void print_version(struct feat_fd *ff, FILE *fp)
1672{
1673	fprintf(fp, "# perf version : %s\n", ff->ph->env.version);
1674}
1675
1676static void print_cmdline(struct feat_fd *ff, FILE *fp)
1677{
1678	int nr, i;
1679
1680	nr = ff->ph->env.nr_cmdline;
1681
1682	fprintf(fp, "# cmdline : ");
1683
1684	for (i = 0; i < nr; i++) {
1685		char *argv_i = strdup(ff->ph->env.cmdline_argv[i]);
1686		if (!argv_i) {
1687			fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]);
1688		} else {
1689			char *mem = argv_i;
1690			do {
1691				char *quote = strchr(argv_i, '\'');
1692				if (!quote)
1693					break;
1694				*quote++ = '\0';
1695				fprintf(fp, "%s\\\'", argv_i);
1696				argv_i = quote;
1697			} while (1);
1698			fprintf(fp, "%s ", argv_i);
1699			free(mem);
1700		}
1701	}
1702	fputc('\n', fp);
1703}
1704
1705static void print_cpu_topology(struct feat_fd *ff, FILE *fp)
1706{
1707	struct perf_header *ph = ff->ph;
1708	int cpu_nr = ph->env.nr_cpus_avail;
1709	int nr, i;
1710	char *str;
1711
1712	nr = ph->env.nr_sibling_cores;
1713	str = ph->env.sibling_cores;
1714
1715	for (i = 0; i < nr; i++) {
1716		fprintf(fp, "# sibling sockets : %s\n", str);
1717		str += strlen(str) + 1;
1718	}
1719
1720	if (ph->env.nr_sibling_dies) {
1721		nr = ph->env.nr_sibling_dies;
1722		str = ph->env.sibling_dies;
1723
1724		for (i = 0; i < nr; i++) {
1725			fprintf(fp, "# sibling dies    : %s\n", str);
1726			str += strlen(str) + 1;
1727		}
1728	}
1729
1730	nr = ph->env.nr_sibling_threads;
1731	str = ph->env.sibling_threads;
1732
1733	for (i = 0; i < nr; i++) {
1734		fprintf(fp, "# sibling threads : %s\n", str);
1735		str += strlen(str) + 1;
1736	}
1737
1738	if (ph->env.nr_sibling_dies) {
1739		if (ph->env.cpu != NULL) {
1740			for (i = 0; i < cpu_nr; i++)
1741				fprintf(fp, "# CPU %d: Core ID %d, "
1742					    "Die ID %d, Socket ID %d\n",
1743					    i, ph->env.cpu[i].core_id,
1744					    ph->env.cpu[i].die_id,
1745					    ph->env.cpu[i].socket_id);
1746		} else
1747			fprintf(fp, "# Core ID, Die ID and Socket ID "
1748				    "information is not available\n");
1749	} else {
1750		if (ph->env.cpu != NULL) {
1751			for (i = 0; i < cpu_nr; i++)
1752				fprintf(fp, "# CPU %d: Core ID %d, "
1753					    "Socket ID %d\n",
1754					    i, ph->env.cpu[i].core_id,
1755					    ph->env.cpu[i].socket_id);
1756		} else
1757			fprintf(fp, "# Core ID and Socket ID "
1758				    "information is not available\n");
1759	}
1760}
1761
1762static void print_clockid(struct feat_fd *ff, FILE *fp)
1763{
1764	fprintf(fp, "# clockid frequency: %"PRIu64" MHz\n",
1765		ff->ph->env.clock.clockid_res_ns * 1000);
1766}
1767
1768static void print_clock_data(struct feat_fd *ff, FILE *fp)
1769{
1770	struct timespec clockid_ns;
1771	char tstr[64], date[64];
1772	struct timeval tod_ns;
1773	clockid_t clockid;
1774	struct tm ltime;
1775	u64 ref;
1776
1777	if (!ff->ph->env.clock.enabled) {
1778		fprintf(fp, "# reference time disabled\n");
1779		return;
1780	}
1781
1782	/* Compute TOD time. */
1783	ref = ff->ph->env.clock.tod_ns;
1784	tod_ns.tv_sec = ref / NSEC_PER_SEC;
1785	ref -= tod_ns.tv_sec * NSEC_PER_SEC;
1786	tod_ns.tv_usec = ref / NSEC_PER_USEC;
1787
1788	/* Compute clockid time. */
1789	ref = ff->ph->env.clock.clockid_ns;
1790	clockid_ns.tv_sec = ref / NSEC_PER_SEC;
1791	ref -= clockid_ns.tv_sec * NSEC_PER_SEC;
1792	clockid_ns.tv_nsec = ref;
1793
1794	clockid = ff->ph->env.clock.clockid;
1795
1796	if (localtime_r(&tod_ns.tv_sec, &ltime) == NULL)
1797		snprintf(tstr, sizeof(tstr), "<error>");
1798	else {
1799		strftime(date, sizeof(date), "%F %T", &ltime);
1800		scnprintf(tstr, sizeof(tstr), "%s.%06d",
1801			  date, (int) tod_ns.tv_usec);
1802	}
1803
1804	fprintf(fp, "# clockid: %s (%u)\n", clockid_name(clockid), clockid);
1805	fprintf(fp, "# reference time: %s = %ld.%06d (TOD) = %ld.%09ld (%s)\n",
1806		    tstr, (long) tod_ns.tv_sec, (int) tod_ns.tv_usec,
1807		    (long) clockid_ns.tv_sec, clockid_ns.tv_nsec,
1808		    clockid_name(clockid));
1809}
1810
1811static void print_hybrid_topology(struct feat_fd *ff, FILE *fp)
1812{
1813	int i;
1814	struct hybrid_node *n;
1815
1816	fprintf(fp, "# hybrid cpu system:\n");
1817	for (i = 0; i < ff->ph->env.nr_hybrid_nodes; i++) {
1818		n = &ff->ph->env.hybrid_nodes[i];
1819		fprintf(fp, "# %s cpu list : %s\n", n->pmu_name, n->cpus);
1820	}
1821}
1822
1823static void print_dir_format(struct feat_fd *ff, FILE *fp)
1824{
1825	struct perf_session *session;
1826	struct perf_data *data;
1827
1828	session = container_of(ff->ph, struct perf_session, header);
1829	data = session->data;
1830
1831	fprintf(fp, "# directory data version : %"PRIu64"\n", data->dir.version);
1832}
1833
1834#ifdef HAVE_LIBBPF_SUPPORT
1835static void print_bpf_prog_info(struct feat_fd *ff, FILE *fp)
1836{
1837	struct perf_env *env = &ff->ph->env;
1838	struct rb_root *root;
1839	struct rb_node *next;
1840
1841	down_read(&env->bpf_progs.lock);
1842
1843	root = &env->bpf_progs.infos;
1844	next = rb_first(root);
1845
1846	while (next) {
1847		struct bpf_prog_info_node *node;
1848
1849		node = rb_entry(next, struct bpf_prog_info_node, rb_node);
1850		next = rb_next(&node->rb_node);
1851
1852		__bpf_event__print_bpf_prog_info(&node->info_linear->info,
1853						 env, fp);
1854	}
1855
1856	up_read(&env->bpf_progs.lock);
1857}
1858
1859static void print_bpf_btf(struct feat_fd *ff, FILE *fp)
1860{
1861	struct perf_env *env = &ff->ph->env;
1862	struct rb_root *root;
1863	struct rb_node *next;
1864
1865	down_read(&env->bpf_progs.lock);
1866
1867	root = &env->bpf_progs.btfs;
1868	next = rb_first(root);
1869
1870	while (next) {
1871		struct btf_node *node;
1872
1873		node = rb_entry(next, struct btf_node, rb_node);
1874		next = rb_next(&node->rb_node);
1875		fprintf(fp, "# btf info of id %u\n", node->id);
1876	}
1877
1878	up_read(&env->bpf_progs.lock);
1879}
1880#endif // HAVE_LIBBPF_SUPPORT
1881
1882static void free_event_desc(struct evsel *events)
1883{
1884	struct evsel *evsel;
1885
1886	if (!events)
1887		return;
1888
1889	for (evsel = events; evsel->core.attr.size; evsel++) {
1890		zfree(&evsel->name);
1891		zfree(&evsel->core.id);
1892	}
1893
1894	free(events);
1895}
1896
1897static bool perf_attr_check(struct perf_event_attr *attr)
1898{
1899	if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3) {
1900		pr_warning("Reserved bits are set unexpectedly. "
1901			   "Please update perf tool.\n");
1902		return false;
1903	}
1904
1905	if (attr->sample_type & ~(PERF_SAMPLE_MAX-1)) {
1906		pr_warning("Unknown sample type (0x%llx) is detected. "
1907			   "Please update perf tool.\n",
1908			   attr->sample_type);
1909		return false;
1910	}
1911
1912	if (attr->read_format & ~(PERF_FORMAT_MAX-1)) {
1913		pr_warning("Unknown read format (0x%llx) is detected. "
1914			   "Please update perf tool.\n",
1915			   attr->read_format);
1916		return false;
1917	}
1918
1919	if ((attr->sample_type & PERF_SAMPLE_BRANCH_STACK) &&
1920	    (attr->branch_sample_type & ~(PERF_SAMPLE_BRANCH_MAX-1))) {
1921		pr_warning("Unknown branch sample type (0x%llx) is detected. "
1922			   "Please update perf tool.\n",
1923			   attr->branch_sample_type);
1924
1925		return false;
1926	}
1927
1928	return true;
1929}
1930
1931static struct evsel *read_event_desc(struct feat_fd *ff)
1932{
1933	struct evsel *evsel, *events = NULL;
1934	u64 *id;
1935	void *buf = NULL;
1936	u32 nre, sz, nr, i, j;
1937	size_t msz;
1938
1939	/* number of events */
1940	if (do_read_u32(ff, &nre))
1941		goto error;
1942
1943	if (do_read_u32(ff, &sz))
1944		goto error;
1945
1946	/* buffer to hold on file attr struct */
1947	buf = malloc(sz);
1948	if (!buf)
1949		goto error;
1950
1951	/* the last event terminates with evsel->core.attr.size == 0: */
1952	events = calloc(nre + 1, sizeof(*events));
1953	if (!events)
1954		goto error;
1955
1956	msz = sizeof(evsel->core.attr);
1957	if (sz < msz)
1958		msz = sz;
1959
1960	for (i = 0, evsel = events; i < nre; evsel++, i++) {
1961		evsel->core.idx = i;
1962
1963		/*
1964		 * must read entire on-file attr struct to
1965		 * sync up with layout.
1966		 */
1967		if (__do_read(ff, buf, sz))
1968			goto error;
1969
1970		if (ff->ph->needs_swap)
1971			perf_event__attr_swap(buf);
1972
1973		memcpy(&evsel->core.attr, buf, msz);
1974
1975		if (!perf_attr_check(&evsel->core.attr))
1976			goto error;
1977
1978		if (do_read_u32(ff, &nr))
1979			goto error;
1980
1981		if (ff->ph->needs_swap)
1982			evsel->needs_swap = true;
1983
1984		evsel->name = do_read_string(ff);
1985		if (!evsel->name)
1986			goto error;
1987
1988		if (!nr)
1989			continue;
1990
1991		id = calloc(nr, sizeof(*id));
1992		if (!id)
1993			goto error;
1994		evsel->core.ids = nr;
1995		evsel->core.id = id;
1996
1997		for (j = 0 ; j < nr; j++) {
1998			if (do_read_u64(ff, id))
1999				goto error;
2000			id++;
2001		}
2002	}
2003out:
2004	free(buf);
2005	return events;
2006error:
2007	free_event_desc(events);
2008	events = NULL;
2009	goto out;
2010}
2011
2012static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
2013				void *priv __maybe_unused)
2014{
2015	return fprintf(fp, ", %s = %s", name, val);
2016}
2017
2018static void print_event_desc(struct feat_fd *ff, FILE *fp)
2019{
2020	struct evsel *evsel, *events;
2021	u32 j;
2022	u64 *id;
2023
2024	if (ff->events)
2025		events = ff->events;
2026	else
2027		events = read_event_desc(ff);
2028
2029	if (!events) {
2030		fprintf(fp, "# event desc: not available or unable to read\n");
2031		return;
2032	}
2033
2034	for (evsel = events; evsel->core.attr.size; evsel++) {
2035		fprintf(fp, "# event : name = %s, ", evsel->name);
2036
2037		if (evsel->core.ids) {
2038			fprintf(fp, ", id = {");
2039			for (j = 0, id = evsel->core.id; j < evsel->core.ids; j++, id++) {
2040				if (j)
2041					fputc(',', fp);
2042				fprintf(fp, " %"PRIu64, *id);
2043			}
2044			fprintf(fp, " }");
2045		}
2046
2047		perf_event_attr__fprintf(fp, &evsel->core.attr, __desc_attr__fprintf, NULL);
2048
2049		fputc('\n', fp);
2050	}
2051
2052	free_event_desc(events);
2053	ff->events = NULL;
2054}
2055
2056static void print_total_mem(struct feat_fd *ff, FILE *fp)
2057{
2058	fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem);
2059}
2060
2061static void print_numa_topology(struct feat_fd *ff, FILE *fp)
2062{
2063	int i;
2064	struct numa_node *n;
2065
2066	for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) {
2067		n = &ff->ph->env.numa_nodes[i];
2068
2069		fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
2070			    " free = %"PRIu64" kB\n",
2071			n->node, n->mem_total, n->mem_free);
2072
2073		fprintf(fp, "# node%u cpu list : ", n->node);
2074		cpu_map__fprintf(n->map, fp);
2075	}
2076}
2077
2078static void print_cpuid(struct feat_fd *ff, FILE *fp)
2079{
2080	fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid);
2081}
2082
2083static void print_branch_stack(struct feat_fd *ff __maybe_unused, FILE *fp)
2084{
2085	fprintf(fp, "# contains samples with branch stack\n");
2086}
2087
2088static void print_auxtrace(struct feat_fd *ff __maybe_unused, FILE *fp)
2089{
2090	fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
2091}
2092
2093static void print_stat(struct feat_fd *ff __maybe_unused, FILE *fp)
2094{
2095	fprintf(fp, "# contains stat data\n");
2096}
2097
2098static void print_cache(struct feat_fd *ff, FILE *fp __maybe_unused)
2099{
2100	int i;
2101
2102	fprintf(fp, "# CPU cache info:\n");
2103	for (i = 0; i < ff->ph->env.caches_cnt; i++) {
2104		fprintf(fp, "#  ");
2105		cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]);
2106	}
2107}
2108
2109static void print_compressed(struct feat_fd *ff, FILE *fp)
2110{
2111	fprintf(fp, "# compressed : %s, level = %d, ratio = %d\n",
2112		ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown",
2113		ff->ph->env.comp_level, ff->ph->env.comp_ratio);
2114}
2115
2116static void __print_pmu_caps(FILE *fp, int nr_caps, char **caps, char *pmu_name)
2117{
2118	const char *delimiter = "";
2119	int i;
 
2120
2121	if (!nr_caps) {
2122		fprintf(fp, "# %s pmu capabilities: not available\n", pmu_name);
2123		return;
2124	}
2125
2126	fprintf(fp, "# %s pmu capabilities: ", pmu_name);
2127	for (i = 0; i < nr_caps; i++) {
2128		fprintf(fp, "%s%s", delimiter, caps[i]);
2129		delimiter = ", ";
 
2130	}
2131
2132	fprintf(fp, "\n");
2133}
2134
2135static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
2136{
2137	__print_pmu_caps(fp, ff->ph->env.nr_cpu_pmu_caps,
2138			 ff->ph->env.cpu_pmu_caps, (char *)"cpu");
2139}
2140
2141static void print_pmu_caps(struct feat_fd *ff, FILE *fp)
2142{
2143	struct pmu_caps *pmu_caps;
2144
2145	for (int i = 0; i < ff->ph->env.nr_pmus_with_caps; i++) {
2146		pmu_caps = &ff->ph->env.pmu_caps[i];
2147		__print_pmu_caps(fp, pmu_caps->nr_caps, pmu_caps->caps,
2148				 pmu_caps->pmu_name);
2149	}
2150
2151	if (strcmp(perf_env__arch(&ff->ph->env), "x86") == 0 &&
2152	    perf_env__has_pmu_mapping(&ff->ph->env, "ibs_op")) {
2153		char *max_precise = perf_env__find_pmu_cap(&ff->ph->env, "cpu", "max_precise");
2154
2155		if (max_precise != NULL && atoi(max_precise) == 0)
2156			fprintf(fp, "# AMD systems uses ibs_op// PMU for some precise events, e.g.: cycles:p, see the 'perf list' man page for further details.\n");
2157	}
2158}
2159
2160static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
2161{
2162	const char *delimiter = "# pmu mappings: ";
2163	char *str, *tmp;
2164	u32 pmu_num;
2165	u32 type;
2166
2167	pmu_num = ff->ph->env.nr_pmu_mappings;
2168	if (!pmu_num) {
2169		fprintf(fp, "# pmu mappings: not available\n");
2170		return;
2171	}
2172
2173	str = ff->ph->env.pmu_mappings;
2174
2175	while (pmu_num) {
2176		type = strtoul(str, &tmp, 0);
2177		if (*tmp != ':')
2178			goto error;
2179
2180		str = tmp + 1;
2181		fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
2182
2183		delimiter = ", ";
2184		str += strlen(str) + 1;
2185		pmu_num--;
2186	}
2187
2188	fprintf(fp, "\n");
2189
2190	if (!pmu_num)
2191		return;
2192error:
2193	fprintf(fp, "# pmu mappings: unable to read\n");
2194}
2195
2196static void print_group_desc(struct feat_fd *ff, FILE *fp)
2197{
2198	struct perf_session *session;
2199	struct evsel *evsel;
2200	u32 nr = 0;
2201
2202	session = container_of(ff->ph, struct perf_session, header);
2203
2204	evlist__for_each_entry(session->evlist, evsel) {
2205		if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
2206			fprintf(fp, "# group: %s{%s", evsel->group_name ?: "", evsel__name(evsel));
2207
2208			nr = evsel->core.nr_members - 1;
2209		} else if (nr) {
2210			fprintf(fp, ",%s", evsel__name(evsel));
2211
2212			if (--nr == 0)
2213				fprintf(fp, "}\n");
2214		}
2215	}
2216}
2217
2218static void print_sample_time(struct feat_fd *ff, FILE *fp)
2219{
2220	struct perf_session *session;
2221	char time_buf[32];
2222	double d;
2223
2224	session = container_of(ff->ph, struct perf_session, header);
2225
2226	timestamp__scnprintf_usec(session->evlist->first_sample_time,
2227				  time_buf, sizeof(time_buf));
2228	fprintf(fp, "# time of first sample : %s\n", time_buf);
2229
2230	timestamp__scnprintf_usec(session->evlist->last_sample_time,
2231				  time_buf, sizeof(time_buf));
2232	fprintf(fp, "# time of last sample : %s\n", time_buf);
2233
2234	d = (double)(session->evlist->last_sample_time -
2235		session->evlist->first_sample_time) / NSEC_PER_MSEC;
2236
2237	fprintf(fp, "# sample duration : %10.3f ms\n", d);
2238}
2239
2240static void memory_node__fprintf(struct memory_node *n,
2241				 unsigned long long bsize, FILE *fp)
2242{
2243	char buf_map[100], buf_size[50];
2244	unsigned long long size;
2245
2246	size = bsize * bitmap_weight(n->set, n->size);
2247	unit_number__scnprintf(buf_size, 50, size);
2248
2249	bitmap_scnprintf(n->set, n->size, buf_map, 100);
2250	fprintf(fp, "#  %3" PRIu64 " [%s]: %s\n", n->node, buf_size, buf_map);
2251}
2252
2253static void print_mem_topology(struct feat_fd *ff, FILE *fp)
2254{
2255	struct memory_node *nodes;
2256	int i, nr;
2257
2258	nodes = ff->ph->env.memory_nodes;
2259	nr    = ff->ph->env.nr_memory_nodes;
2260
2261	fprintf(fp, "# memory nodes (nr %d, block size 0x%llx):\n",
2262		nr, ff->ph->env.memory_bsize);
2263
2264	for (i = 0; i < nr; i++) {
2265		memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp);
2266	}
2267}
2268
2269static int __event_process_build_id(struct perf_record_header_build_id *bev,
2270				    char *filename,
2271				    struct perf_session *session)
2272{
2273	int err = -1;
2274	struct machine *machine;
2275	u16 cpumode;
2276	struct dso *dso;
2277	enum dso_space_type dso_space;
2278
2279	machine = perf_session__findnew_machine(session, bev->pid);
2280	if (!machine)
2281		goto out;
2282
2283	cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2284
2285	switch (cpumode) {
2286	case PERF_RECORD_MISC_KERNEL:
2287		dso_space = DSO_SPACE__KERNEL;
2288		break;
2289	case PERF_RECORD_MISC_GUEST_KERNEL:
2290		dso_space = DSO_SPACE__KERNEL_GUEST;
2291		break;
2292	case PERF_RECORD_MISC_USER:
2293	case PERF_RECORD_MISC_GUEST_USER:
2294		dso_space = DSO_SPACE__USER;
2295		break;
2296	default:
2297		goto out;
2298	}
2299
2300	dso = machine__findnew_dso(machine, filename);
2301	if (dso != NULL) {
2302		char sbuild_id[SBUILD_ID_SIZE];
2303		struct build_id bid;
2304		size_t size = BUILD_ID_SIZE;
2305
2306		if (bev->header.misc & PERF_RECORD_MISC_BUILD_ID_SIZE)
2307			size = bev->size;
2308
2309		build_id__init(&bid, bev->data, size);
2310		dso__set_build_id(dso, &bid);
2311		dso->header_build_id = 1;
2312
2313		if (dso_space != DSO_SPACE__USER) {
2314			struct kmod_path m = { .name = NULL, };
2315
2316			if (!kmod_path__parse_name(&m, filename) && m.kmod)
2317				dso__set_module_info(dso, &m, machine);
2318
2319			dso->kernel = dso_space;
2320			free(m.name);
2321		}
2322
2323		build_id__sprintf(&dso->bid, sbuild_id);
2324		pr_debug("build id event received for %s: %s [%zu]\n",
2325			 dso->long_name, sbuild_id, size);
 
2326		dso__put(dso);
2327	}
2328
2329	err = 0;
2330out:
2331	return err;
2332}
2333
2334static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
2335						 int input, u64 offset, u64 size)
2336{
2337	struct perf_session *session = container_of(header, struct perf_session, header);
2338	struct {
2339		struct perf_event_header   header;
2340		u8			   build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
2341		char			   filename[0];
2342	} old_bev;
2343	struct perf_record_header_build_id bev;
2344	char filename[PATH_MAX];
2345	u64 limit = offset + size;
2346
2347	while (offset < limit) {
2348		ssize_t len;
2349
2350		if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
2351			return -1;
2352
2353		if (header->needs_swap)
2354			perf_event_header__bswap(&old_bev.header);
2355
2356		len = old_bev.header.size - sizeof(old_bev);
2357		if (readn(input, filename, len) != len)
2358			return -1;
2359
2360		bev.header = old_bev.header;
2361
2362		/*
2363		 * As the pid is the missing value, we need to fill
2364		 * it properly. The header.misc value give us nice hint.
2365		 */
2366		bev.pid	= HOST_KERNEL_ID;
2367		if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
2368		    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
2369			bev.pid	= DEFAULT_GUEST_KERNEL_ID;
2370
2371		memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
2372		__event_process_build_id(&bev, filename, session);
2373
2374		offset += bev.header.size;
2375	}
2376
2377	return 0;
2378}
2379
2380static int perf_header__read_build_ids(struct perf_header *header,
2381				       int input, u64 offset, u64 size)
2382{
2383	struct perf_session *session = container_of(header, struct perf_session, header);
2384	struct perf_record_header_build_id bev;
2385	char filename[PATH_MAX];
2386	u64 limit = offset + size, orig_offset = offset;
2387	int err = -1;
2388
2389	while (offset < limit) {
2390		ssize_t len;
2391
2392		if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
2393			goto out;
2394
2395		if (header->needs_swap)
2396			perf_event_header__bswap(&bev.header);
2397
2398		len = bev.header.size - sizeof(bev);
2399		if (readn(input, filename, len) != len)
2400			goto out;
2401		/*
2402		 * The a1645ce1 changeset:
2403		 *
2404		 * "perf: 'perf kvm' tool for monitoring guest performance from host"
2405		 *
2406		 * Added a field to struct perf_record_header_build_id that broke the file
2407		 * format.
2408		 *
2409		 * Since the kernel build-id is the first entry, process the
2410		 * table using the old format if the well known
2411		 * '[kernel.kallsyms]' string for the kernel build-id has the
2412		 * first 4 characters chopped off (where the pid_t sits).
2413		 */
2414		if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
2415			if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
2416				return -1;
2417			return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
2418		}
2419
2420		__event_process_build_id(&bev, filename, session);
2421
2422		offset += bev.header.size;
2423	}
2424	err = 0;
2425out:
2426	return err;
2427}
2428
2429/* Macro for features that simply need to read and store a string. */
2430#define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \
2431static int process_##__feat(struct feat_fd *ff, void *data __maybe_unused) \
2432{\
2433	free(ff->ph->env.__feat_env);		     \
2434	ff->ph->env.__feat_env = do_read_string(ff); \
2435	return ff->ph->env.__feat_env ? 0 : -ENOMEM; \
2436}
2437
2438FEAT_PROCESS_STR_FUN(hostname, hostname);
2439FEAT_PROCESS_STR_FUN(osrelease, os_release);
2440FEAT_PROCESS_STR_FUN(version, version);
2441FEAT_PROCESS_STR_FUN(arch, arch);
2442FEAT_PROCESS_STR_FUN(cpudesc, cpu_desc);
2443FEAT_PROCESS_STR_FUN(cpuid, cpuid);
2444
2445#ifdef HAVE_LIBTRACEEVENT
2446static int process_tracing_data(struct feat_fd *ff, void *data)
2447{
2448	ssize_t ret = trace_report(ff->fd, data, false);
2449
2450	return ret < 0 ? -1 : 0;
2451}
2452#endif
2453
2454static int process_build_id(struct feat_fd *ff, void *data __maybe_unused)
2455{
2456	if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size))
2457		pr_debug("Failed to read buildids, continuing...\n");
2458	return 0;
2459}
2460
2461static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
2462{
2463	int ret;
2464	u32 nr_cpus_avail, nr_cpus_online;
2465
2466	ret = do_read_u32(ff, &nr_cpus_avail);
2467	if (ret)
2468		return ret;
2469
2470	ret = do_read_u32(ff, &nr_cpus_online);
2471	if (ret)
2472		return ret;
2473	ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail;
2474	ff->ph->env.nr_cpus_online = (int)nr_cpus_online;
2475	return 0;
2476}
2477
2478static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused)
2479{
2480	u64 total_mem;
2481	int ret;
2482
2483	ret = do_read_u64(ff, &total_mem);
2484	if (ret)
2485		return -1;
2486	ff->ph->env.total_mem = (unsigned long long)total_mem;
2487	return 0;
2488}
2489
2490static struct evsel *evlist__find_by_index(struct evlist *evlist, int idx)
 
2491{
2492	struct evsel *evsel;
2493
2494	evlist__for_each_entry(evlist, evsel) {
2495		if (evsel->core.idx == idx)
2496			return evsel;
2497	}
2498
2499	return NULL;
2500}
2501
2502static void evlist__set_event_name(struct evlist *evlist, struct evsel *event)
 
 
2503{
2504	struct evsel *evsel;
2505
2506	if (!event->name)
2507		return;
2508
2509	evsel = evlist__find_by_index(evlist, event->core.idx);
2510	if (!evsel)
2511		return;
2512
2513	if (evsel->name)
2514		return;
2515
2516	evsel->name = strdup(event->name);
2517}
2518
2519static int
2520process_event_desc(struct feat_fd *ff, void *data __maybe_unused)
2521{
2522	struct perf_session *session;
2523	struct evsel *evsel, *events = read_event_desc(ff);
2524
2525	if (!events)
2526		return 0;
2527
2528	session = container_of(ff->ph, struct perf_session, header);
2529
2530	if (session->data->is_pipe) {
2531		/* Save events for reading later by print_event_desc,
2532		 * since they can't be read again in pipe mode. */
2533		ff->events = events;
2534	}
2535
2536	for (evsel = events; evsel->core.attr.size; evsel++)
2537		evlist__set_event_name(session->evlist, evsel);
2538
2539	if (!session->data->is_pipe)
2540		free_event_desc(events);
2541
2542	return 0;
2543}
2544
2545static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
2546{
2547	char *str, *cmdline = NULL, **argv = NULL;
2548	u32 nr, i, len = 0;
2549
2550	if (do_read_u32(ff, &nr))
2551		return -1;
2552
2553	ff->ph->env.nr_cmdline = nr;
2554
2555	cmdline = zalloc(ff->size + nr + 1);
2556	if (!cmdline)
2557		return -1;
2558
2559	argv = zalloc(sizeof(char *) * (nr + 1));
2560	if (!argv)
2561		goto error;
2562
2563	for (i = 0; i < nr; i++) {
2564		str = do_read_string(ff);
2565		if (!str)
2566			goto error;
2567
2568		argv[i] = cmdline + len;
2569		memcpy(argv[i], str, strlen(str) + 1);
2570		len += strlen(str) + 1;
2571		free(str);
2572	}
2573	ff->ph->env.cmdline = cmdline;
2574	ff->ph->env.cmdline_argv = (const char **) argv;
2575	return 0;
2576
2577error:
2578	free(argv);
2579	free(cmdline);
2580	return -1;
2581}
2582
2583static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
2584{
2585	u32 nr, i;
2586	char *str = NULL;
2587	struct strbuf sb;
2588	int cpu_nr = ff->ph->env.nr_cpus_avail;
2589	u64 size = 0;
2590	struct perf_header *ph = ff->ph;
2591	bool do_core_id_test = true;
2592
2593	ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
2594	if (!ph->env.cpu)
2595		return -1;
2596
2597	if (do_read_u32(ff, &nr))
2598		goto free_cpu;
2599
2600	ph->env.nr_sibling_cores = nr;
2601	size += sizeof(u32);
2602	if (strbuf_init(&sb, 128) < 0)
2603		goto free_cpu;
2604
2605	for (i = 0; i < nr; i++) {
2606		str = do_read_string(ff);
2607		if (!str)
2608			goto error;
2609
2610		/* include a NULL character at the end */
2611		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2612			goto error;
2613		size += string_size(str);
2614		zfree(&str);
2615	}
2616	ph->env.sibling_cores = strbuf_detach(&sb, NULL);
2617
2618	if (do_read_u32(ff, &nr))
2619		return -1;
2620
2621	ph->env.nr_sibling_threads = nr;
2622	size += sizeof(u32);
2623
2624	for (i = 0; i < nr; i++) {
2625		str = do_read_string(ff);
2626		if (!str)
2627			goto error;
2628
2629		/* include a NULL character at the end */
2630		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2631			goto error;
2632		size += string_size(str);
2633		zfree(&str);
2634	}
2635	ph->env.sibling_threads = strbuf_detach(&sb, NULL);
2636
2637	/*
2638	 * The header may be from old perf,
2639	 * which doesn't include core id and socket id information.
2640	 */
2641	if (ff->size <= size) {
2642		zfree(&ph->env.cpu);
2643		return 0;
2644	}
2645
2646	/* On s390 the socket_id number is not related to the numbers of cpus.
2647	 * The socket_id number might be higher than the numbers of cpus.
2648	 * This depends on the configuration.
2649	 * AArch64 is the same.
2650	 */
2651	if (ph->env.arch && (!strncmp(ph->env.arch, "s390", 4)
2652			  || !strncmp(ph->env.arch, "aarch64", 7)))
2653		do_core_id_test = false;
2654
2655	for (i = 0; i < (u32)cpu_nr; i++) {
2656		if (do_read_u32(ff, &nr))
2657			goto free_cpu;
2658
2659		ph->env.cpu[i].core_id = nr;
2660		size += sizeof(u32);
2661
2662		if (do_read_u32(ff, &nr))
2663			goto free_cpu;
2664
2665		if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) {
2666			pr_debug("socket_id number is too big."
2667				 "You may need to upgrade the perf tool.\n");
2668			goto free_cpu;
2669		}
2670
2671		ph->env.cpu[i].socket_id = nr;
2672		size += sizeof(u32);
2673	}
2674
2675	/*
2676	 * The header may be from old perf,
2677	 * which doesn't include die information.
2678	 */
2679	if (ff->size <= size)
2680		return 0;
2681
2682	if (do_read_u32(ff, &nr))
2683		return -1;
2684
2685	ph->env.nr_sibling_dies = nr;
2686	size += sizeof(u32);
2687
2688	for (i = 0; i < nr; i++) {
2689		str = do_read_string(ff);
2690		if (!str)
2691			goto error;
2692
2693		/* include a NULL character at the end */
2694		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2695			goto error;
2696		size += string_size(str);
2697		zfree(&str);
2698	}
2699	ph->env.sibling_dies = strbuf_detach(&sb, NULL);
2700
2701	for (i = 0; i < (u32)cpu_nr; i++) {
2702		if (do_read_u32(ff, &nr))
2703			goto free_cpu;
2704
2705		ph->env.cpu[i].die_id = nr;
2706	}
2707
2708	return 0;
2709
2710error:
2711	strbuf_release(&sb);
2712	zfree(&str);
2713free_cpu:
2714	zfree(&ph->env.cpu);
2715	return -1;
2716}
2717
2718static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
2719{
2720	struct numa_node *nodes, *n;
2721	u32 nr, i;
2722	char *str;
2723
2724	/* nr nodes */
2725	if (do_read_u32(ff, &nr))
2726		return -1;
2727
2728	nodes = zalloc(sizeof(*nodes) * nr);
2729	if (!nodes)
2730		return -ENOMEM;
2731
2732	for (i = 0; i < nr; i++) {
2733		n = &nodes[i];
2734
2735		/* node number */
2736		if (do_read_u32(ff, &n->node))
2737			goto error;
2738
2739		if (do_read_u64(ff, &n->mem_total))
2740			goto error;
2741
2742		if (do_read_u64(ff, &n->mem_free))
2743			goto error;
2744
2745		str = do_read_string(ff);
2746		if (!str)
2747			goto error;
2748
2749		n->map = perf_cpu_map__new(str);
2750		free(str);
2751		if (!n->map)
2752			goto error;
 
 
2753	}
2754	ff->ph->env.nr_numa_nodes = nr;
2755	ff->ph->env.numa_nodes = nodes;
2756	return 0;
2757
2758error:
2759	free(nodes);
2760	return -1;
2761}
2762
2763static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
2764{
2765	char *name;
2766	u32 pmu_num;
2767	u32 type;
2768	struct strbuf sb;
2769
2770	if (do_read_u32(ff, &pmu_num))
2771		return -1;
2772
2773	if (!pmu_num) {
2774		pr_debug("pmu mappings not available\n");
2775		return 0;
2776	}
2777
2778	ff->ph->env.nr_pmu_mappings = pmu_num;
2779	if (strbuf_init(&sb, 128) < 0)
2780		return -1;
2781
2782	while (pmu_num) {
2783		if (do_read_u32(ff, &type))
2784			goto error;
2785
2786		name = do_read_string(ff);
2787		if (!name)
2788			goto error;
2789
2790		if (strbuf_addf(&sb, "%u:%s", type, name) < 0)
2791			goto error;
2792		/* include a NULL character at the end */
2793		if (strbuf_add(&sb, "", 1) < 0)
2794			goto error;
2795
2796		if (!strcmp(name, "msr"))
2797			ff->ph->env.msr_pmu_type = type;
2798
2799		free(name);
2800		pmu_num--;
2801	}
2802	ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2803	return 0;
2804
2805error:
2806	strbuf_release(&sb);
2807	return -1;
2808}
2809
2810static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
2811{
2812	size_t ret = -1;
2813	u32 i, nr, nr_groups;
2814	struct perf_session *session;
2815	struct evsel *evsel, *leader = NULL;
2816	struct group_desc {
2817		char *name;
2818		u32 leader_idx;
2819		u32 nr_members;
2820	} *desc;
2821
2822	if (do_read_u32(ff, &nr_groups))
2823		return -1;
2824
2825	ff->ph->env.nr_groups = nr_groups;
2826	if (!nr_groups) {
2827		pr_debug("group desc not available\n");
2828		return 0;
2829	}
2830
2831	desc = calloc(nr_groups, sizeof(*desc));
2832	if (!desc)
2833		return -1;
2834
2835	for (i = 0; i < nr_groups; i++) {
2836		desc[i].name = do_read_string(ff);
2837		if (!desc[i].name)
2838			goto out_free;
2839
2840		if (do_read_u32(ff, &desc[i].leader_idx))
2841			goto out_free;
2842
2843		if (do_read_u32(ff, &desc[i].nr_members))
2844			goto out_free;
2845	}
2846
2847	/*
2848	 * Rebuild group relationship based on the group_desc
2849	 */
2850	session = container_of(ff->ph, struct perf_session, header);
 
2851
2852	i = nr = 0;
2853	evlist__for_each_entry(session->evlist, evsel) {
2854		if (i < nr_groups && evsel->core.idx == (int) desc[i].leader_idx) {
2855			evsel__set_leader(evsel, evsel);
2856			/* {anon_group} is a dummy name */
2857			if (strcmp(desc[i].name, "{anon_group}")) {
2858				evsel->group_name = desc[i].name;
2859				desc[i].name = NULL;
2860			}
2861			evsel->core.nr_members = desc[i].nr_members;
2862
2863			if (i >= nr_groups || nr > 0) {
2864				pr_debug("invalid group desc\n");
2865				goto out_free;
2866			}
2867
2868			leader = evsel;
2869			nr = evsel->core.nr_members - 1;
2870			i++;
2871		} else if (nr) {
2872			/* This is a group member */
2873			evsel__set_leader(evsel, leader);
2874
2875			nr--;
2876		}
2877	}
2878
2879	if (i != nr_groups || nr != 0) {
2880		pr_debug("invalid group desc\n");
2881		goto out_free;
2882	}
2883
2884	ret = 0;
2885out_free:
2886	for (i = 0; i < nr_groups; i++)
2887		zfree(&desc[i].name);
2888	free(desc);
2889
2890	return ret;
2891}
2892
2893static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused)
2894{
2895	struct perf_session *session;
2896	int err;
2897
2898	session = container_of(ff->ph, struct perf_session, header);
2899
2900	err = auxtrace_index__process(ff->fd, ff->size, session,
2901				      ff->ph->needs_swap);
2902	if (err < 0)
2903		pr_err("Failed to process auxtrace index\n");
2904	return err;
2905}
2906
2907static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
2908{
2909	struct cpu_cache_level *caches;
2910	u32 cnt, i, version;
2911
2912	if (do_read_u32(ff, &version))
2913		return -1;
2914
2915	if (version != 1)
2916		return -1;
2917
2918	if (do_read_u32(ff, &cnt))
2919		return -1;
2920
2921	caches = zalloc(sizeof(*caches) * cnt);
2922	if (!caches)
2923		return -1;
2924
2925	for (i = 0; i < cnt; i++) {
2926		struct cpu_cache_level *c = &caches[i];
2927
2928		#define _R(v)						\
2929			if (do_read_u32(ff, &c->v))			\
2930				goto out_free_caches;			\
2931
2932		_R(level)
2933		_R(line_size)
2934		_R(sets)
2935		_R(ways)
2936		#undef _R
2937
2938		#define _R(v)					\
2939			c->v = do_read_string(ff);		\
2940			if (!c->v)				\
2941				goto out_free_caches;		\
2942
2943		_R(type)
2944		_R(size)
2945		_R(map)
2946		#undef _R
 
 
2947	}
2948
2949	ff->ph->env.caches = caches;
2950	ff->ph->env.caches_cnt = cnt;
2951	return 0;
2952out_free_caches:
2953	for (i = 0; i < cnt; i++) {
2954		free(caches[i].type);
2955		free(caches[i].size);
2956		free(caches[i].map);
2957	}
2958	free(caches);
2959	return -1;
2960}
2961
2962static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused)
2963{
2964	struct perf_session *session;
2965	u64 first_sample_time, last_sample_time;
2966	int ret;
2967
2968	session = container_of(ff->ph, struct perf_session, header);
2969
2970	ret = do_read_u64(ff, &first_sample_time);
2971	if (ret)
2972		return -1;
2973
2974	ret = do_read_u64(ff, &last_sample_time);
2975	if (ret)
2976		return -1;
2977
2978	session->evlist->first_sample_time = first_sample_time;
2979	session->evlist->last_sample_time = last_sample_time;
2980	return 0;
2981}
2982
2983static int process_mem_topology(struct feat_fd *ff,
2984				void *data __maybe_unused)
2985{
2986	struct memory_node *nodes;
2987	u64 version, i, nr, bsize;
2988	int ret = -1;
2989
2990	if (do_read_u64(ff, &version))
2991		return -1;
2992
2993	if (version != 1)
2994		return -1;
2995
2996	if (do_read_u64(ff, &bsize))
2997		return -1;
2998
2999	if (do_read_u64(ff, &nr))
3000		return -1;
3001
3002	nodes = zalloc(sizeof(*nodes) * nr);
3003	if (!nodes)
3004		return -1;
3005
3006	for (i = 0; i < nr; i++) {
3007		struct memory_node n;
3008
3009		#define _R(v)				\
3010			if (do_read_u64(ff, &n.v))	\
3011				goto out;		\
3012
3013		_R(node)
3014		_R(size)
3015
3016		#undef _R
3017
3018		if (do_read_bitmap(ff, &n.set, &n.size))
3019			goto out;
3020
3021		nodes[i] = n;
3022	}
3023
3024	ff->ph->env.memory_bsize    = bsize;
3025	ff->ph->env.memory_nodes    = nodes;
3026	ff->ph->env.nr_memory_nodes = nr;
3027	ret = 0;
3028
3029out:
3030	if (ret)
3031		free(nodes);
3032	return ret;
3033}
3034
3035static int process_clockid(struct feat_fd *ff,
3036			   void *data __maybe_unused)
3037{
3038	if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns))
3039		return -1;
3040
3041	return 0;
3042}
3043
3044static int process_clock_data(struct feat_fd *ff,
3045			      void *_data __maybe_unused)
3046{
3047	u32 data32;
3048	u64 data64;
3049
3050	/* version */
3051	if (do_read_u32(ff, &data32))
3052		return -1;
3053
3054	if (data32 != 1)
3055		return -1;
3056
3057	/* clockid */
3058	if (do_read_u32(ff, &data32))
3059		return -1;
3060
3061	ff->ph->env.clock.clockid = data32;
3062
3063	/* TOD ref time */
3064	if (do_read_u64(ff, &data64))
3065		return -1;
3066
3067	ff->ph->env.clock.tod_ns = data64;
3068
3069	/* clockid ref time */
3070	if (do_read_u64(ff, &data64))
3071		return -1;
3072
3073	ff->ph->env.clock.clockid_ns = data64;
3074	ff->ph->env.clock.enabled = true;
3075	return 0;
3076}
3077
3078static int process_hybrid_topology(struct feat_fd *ff,
3079				   void *data __maybe_unused)
3080{
3081	struct hybrid_node *nodes, *n;
3082	u32 nr, i;
3083
3084	/* nr nodes */
3085	if (do_read_u32(ff, &nr))
3086		return -1;
3087
3088	nodes = zalloc(sizeof(*nodes) * nr);
3089	if (!nodes)
3090		return -ENOMEM;
3091
3092	for (i = 0; i < nr; i++) {
3093		n = &nodes[i];
3094
3095		n->pmu_name = do_read_string(ff);
3096		if (!n->pmu_name)
3097			goto error;
3098
3099		n->cpus = do_read_string(ff);
3100		if (!n->cpus)
3101			goto error;
3102	}
3103
3104	ff->ph->env.nr_hybrid_nodes = nr;
3105	ff->ph->env.hybrid_nodes = nodes;
3106	return 0;
3107
3108error:
3109	for (i = 0; i < nr; i++) {
3110		free(nodes[i].pmu_name);
3111		free(nodes[i].cpus);
3112	}
3113
3114	free(nodes);
3115	return -1;
3116}
3117
3118static int process_dir_format(struct feat_fd *ff,
3119			      void *_data __maybe_unused)
3120{
3121	struct perf_session *session;
3122	struct perf_data *data;
3123
3124	session = container_of(ff->ph, struct perf_session, header);
3125	data = session->data;
3126
3127	if (WARN_ON(!perf_data__is_dir(data)))
3128		return -1;
3129
3130	return do_read_u64(ff, &data->dir.version);
3131}
3132
3133#ifdef HAVE_LIBBPF_SUPPORT
3134static int process_bpf_prog_info(struct feat_fd *ff, void *data __maybe_unused)
3135{
 
3136	struct bpf_prog_info_node *info_node;
3137	struct perf_env *env = &ff->ph->env;
3138	struct perf_bpil *info_linear;
3139	u32 count, i;
3140	int err = -1;
3141
3142	if (ff->ph->needs_swap) {
3143		pr_warning("interpreting bpf_prog_info from systems with endianness is not yet supported\n");
3144		return 0;
3145	}
3146
3147	if (do_read_u32(ff, &count))
3148		return -1;
3149
3150	down_write(&env->bpf_progs.lock);
3151
3152	for (i = 0; i < count; ++i) {
3153		u32 info_len, data_len;
3154
3155		info_linear = NULL;
3156		info_node = NULL;
3157		if (do_read_u32(ff, &info_len))
3158			goto out;
3159		if (do_read_u32(ff, &data_len))
3160			goto out;
3161
3162		if (info_len > sizeof(struct bpf_prog_info)) {
3163			pr_warning("detected invalid bpf_prog_info\n");
3164			goto out;
3165		}
3166
3167		info_linear = malloc(sizeof(struct perf_bpil) +
3168				     data_len);
3169		if (!info_linear)
3170			goto out;
3171		info_linear->info_len = sizeof(struct bpf_prog_info);
3172		info_linear->data_len = data_len;
3173		if (do_read_u64(ff, (u64 *)(&info_linear->arrays)))
3174			goto out;
3175		if (__do_read(ff, &info_linear->info, info_len))
3176			goto out;
3177		if (info_len < sizeof(struct bpf_prog_info))
3178			memset(((void *)(&info_linear->info)) + info_len, 0,
3179			       sizeof(struct bpf_prog_info) - info_len);
3180
3181		if (__do_read(ff, info_linear->data, data_len))
3182			goto out;
3183
3184		info_node = malloc(sizeof(struct bpf_prog_info_node));
3185		if (!info_node)
3186			goto out;
3187
3188		/* after reading from file, translate offset to address */
3189		bpil_offs_to_addr(info_linear);
3190		info_node->info_linear = info_linear;
3191		__perf_env__insert_bpf_prog_info(env, info_node);
3192	}
3193
3194	up_write(&env->bpf_progs.lock);
3195	return 0;
3196out:
3197	free(info_linear);
3198	free(info_node);
3199	up_write(&env->bpf_progs.lock);
3200	return err;
3201}
 
 
 
 
 
 
3202
3203static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
3204{
3205	struct perf_env *env = &ff->ph->env;
3206	struct btf_node *node = NULL;
3207	u32 count, i;
3208	int err = -1;
3209
3210	if (ff->ph->needs_swap) {
3211		pr_warning("interpreting btf from systems with endianness is not yet supported\n");
3212		return 0;
3213	}
3214
3215	if (do_read_u32(ff, &count))
3216		return -1;
3217
3218	down_write(&env->bpf_progs.lock);
3219
3220	for (i = 0; i < count; ++i) {
3221		u32 id, data_size;
3222
3223		if (do_read_u32(ff, &id))
3224			goto out;
3225		if (do_read_u32(ff, &data_size))
3226			goto out;
3227
3228		node = malloc(sizeof(struct btf_node) + data_size);
3229		if (!node)
3230			goto out;
3231
3232		node->id = id;
3233		node->data_size = data_size;
3234
3235		if (__do_read(ff, node->data, data_size))
3236			goto out;
3237
3238		__perf_env__insert_btf(env, node);
3239		node = NULL;
3240	}
3241
3242	err = 0;
3243out:
3244	up_write(&env->bpf_progs.lock);
3245	free(node);
3246	return err;
3247}
3248#endif // HAVE_LIBBPF_SUPPORT
3249
3250static int process_compressed(struct feat_fd *ff,
3251			      void *data __maybe_unused)
3252{
3253	if (do_read_u32(ff, &(ff->ph->env.comp_ver)))
3254		return -1;
3255
3256	if (do_read_u32(ff, &(ff->ph->env.comp_type)))
3257		return -1;
3258
3259	if (do_read_u32(ff, &(ff->ph->env.comp_level)))
3260		return -1;
3261
3262	if (do_read_u32(ff, &(ff->ph->env.comp_ratio)))
3263		return -1;
3264
3265	if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len)))
3266		return -1;
3267
3268	return 0;
3269}
3270
3271static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps,
3272			      char ***caps, unsigned int *max_branches,
3273			      unsigned int *br_cntr_nr,
3274			      unsigned int *br_cntr_width)
3275{
3276	char *name, *value, *ptr;
3277	u32 nr_pmu_caps, i;
3278
3279	*nr_caps = 0;
3280	*caps = NULL;
3281
3282	if (do_read_u32(ff, &nr_pmu_caps))
3283		return -1;
3284
3285	if (!nr_pmu_caps)
 
3286		return 0;
 
3287
3288	*caps = zalloc(sizeof(char *) * nr_pmu_caps);
3289	if (!*caps)
 
3290		return -1;
3291
3292	for (i = 0; i < nr_pmu_caps; i++) {
3293		name = do_read_string(ff);
3294		if (!name)
3295			goto error;
3296
3297		value = do_read_string(ff);
3298		if (!value)
3299			goto free_name;
3300
3301		if (asprintf(&ptr, "%s=%s", name, value) < 0)
3302			goto free_value;
3303
3304		(*caps)[i] = ptr;
 
 
3305
3306		if (!strcmp(name, "branches"))
3307			*max_branches = atoi(value);
3308
3309		if (!strcmp(name, "branch_counter_nr"))
3310			*br_cntr_nr = atoi(value);
3311
3312		if (!strcmp(name, "branch_counter_width"))
3313			*br_cntr_width = atoi(value);
3314
3315		free(value);
3316		free(name);
3317	}
3318	*nr_caps = nr_pmu_caps;
3319	return 0;
3320
3321free_value:
3322	free(value);
3323free_name:
3324	free(name);
3325error:
3326	for (; i > 0; i--)
3327		free((*caps)[i - 1]);
3328	free(*caps);
3329	*caps = NULL;
3330	*nr_caps = 0;
3331	return -1;
3332}
3333
3334static int process_cpu_pmu_caps(struct feat_fd *ff,
3335				void *data __maybe_unused)
3336{
3337	int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
3338				     &ff->ph->env.cpu_pmu_caps,
3339				     &ff->ph->env.max_branches,
3340				     &ff->ph->env.br_cntr_nr,
3341				     &ff->ph->env.br_cntr_width);
3342
3343	if (!ret && !ff->ph->env.cpu_pmu_caps)
3344		pr_debug("cpu pmu capabilities not available\n");
3345	return ret;
3346}
3347
3348static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused)
3349{
3350	struct pmu_caps *pmu_caps;
3351	u32 nr_pmu, i;
3352	int ret;
3353	int j;
3354
3355	if (do_read_u32(ff, &nr_pmu))
3356		return -1;
3357
3358	if (!nr_pmu) {
3359		pr_debug("pmu capabilities not available\n");
3360		return 0;
3361	}
3362
3363	pmu_caps = zalloc(sizeof(*pmu_caps) * nr_pmu);
3364	if (!pmu_caps)
3365		return -ENOMEM;
3366
3367	for (i = 0; i < nr_pmu; i++) {
3368		ret = __process_pmu_caps(ff, &pmu_caps[i].nr_caps,
3369					 &pmu_caps[i].caps,
3370					 &pmu_caps[i].max_branches,
3371					 &pmu_caps[i].br_cntr_nr,
3372					 &pmu_caps[i].br_cntr_width);
3373		if (ret)
3374			goto err;
3375
3376		pmu_caps[i].pmu_name = do_read_string(ff);
3377		if (!pmu_caps[i].pmu_name) {
3378			ret = -1;
3379			goto err;
3380		}
3381		if (!pmu_caps[i].nr_caps) {
3382			pr_debug("%s pmu capabilities not available\n",
3383				 pmu_caps[i].pmu_name);
3384		}
3385	}
3386
3387	ff->ph->env.nr_pmus_with_caps = nr_pmu;
3388	ff->ph->env.pmu_caps = pmu_caps;
3389	return 0;
3390
3391err:
3392	for (i = 0; i < nr_pmu; i++) {
3393		for (j = 0; j < pmu_caps[i].nr_caps; j++)
3394			free(pmu_caps[i].caps[j]);
3395		free(pmu_caps[i].caps);
3396		free(pmu_caps[i].pmu_name);
3397	}
3398
3399	free(pmu_caps);
3400	return ret;
3401}
3402
3403#define FEAT_OPR(n, func, __full_only) \
3404	[HEADER_##n] = {					\
3405		.name	    = __stringify(n),			\
3406		.write	    = write_##func,			\
3407		.print	    = print_##func,			\
3408		.full_only  = __full_only,			\
3409		.process    = process_##func,			\
3410		.synthesize = true				\
3411	}
3412
3413#define FEAT_OPN(n, func, __full_only) \
3414	[HEADER_##n] = {					\
3415		.name	    = __stringify(n),			\
3416		.write	    = write_##func,			\
3417		.print	    = print_##func,			\
3418		.full_only  = __full_only,			\
3419		.process    = process_##func			\
3420	}
3421
3422/* feature_ops not implemented: */
3423#define print_tracing_data	NULL
3424#define print_build_id		NULL
3425
3426#define process_branch_stack	NULL
3427#define process_stat		NULL
3428
3429// Only used in util/synthetic-events.c
3430const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE];
3431
3432const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE] = {
3433#ifdef HAVE_LIBTRACEEVENT
3434	FEAT_OPN(TRACING_DATA,	tracing_data,	false),
3435#endif
3436	FEAT_OPN(BUILD_ID,	build_id,	false),
3437	FEAT_OPR(HOSTNAME,	hostname,	false),
3438	FEAT_OPR(OSRELEASE,	osrelease,	false),
3439	FEAT_OPR(VERSION,	version,	false),
3440	FEAT_OPR(ARCH,		arch,		false),
3441	FEAT_OPR(NRCPUS,	nrcpus,		false),
3442	FEAT_OPR(CPUDESC,	cpudesc,	false),
3443	FEAT_OPR(CPUID,		cpuid,		false),
3444	FEAT_OPR(TOTAL_MEM,	total_mem,	false),
3445	FEAT_OPR(EVENT_DESC,	event_desc,	false),
3446	FEAT_OPR(CMDLINE,	cmdline,	false),
3447	FEAT_OPR(CPU_TOPOLOGY,	cpu_topology,	true),
3448	FEAT_OPR(NUMA_TOPOLOGY,	numa_topology,	true),
3449	FEAT_OPN(BRANCH_STACK,	branch_stack,	false),
3450	FEAT_OPR(PMU_MAPPINGS,	pmu_mappings,	false),
3451	FEAT_OPR(GROUP_DESC,	group_desc,	false),
3452	FEAT_OPN(AUXTRACE,	auxtrace,	false),
3453	FEAT_OPN(STAT,		stat,		false),
3454	FEAT_OPN(CACHE,		cache,		true),
3455	FEAT_OPR(SAMPLE_TIME,	sample_time,	false),
3456	FEAT_OPR(MEM_TOPOLOGY,	mem_topology,	true),
3457	FEAT_OPR(CLOCKID,	clockid,	false),
3458	FEAT_OPN(DIR_FORMAT,	dir_format,	false),
3459#ifdef HAVE_LIBBPF_SUPPORT
3460	FEAT_OPR(BPF_PROG_INFO, bpf_prog_info,  false),
3461	FEAT_OPR(BPF_BTF,       bpf_btf,        false),
3462#endif
3463	FEAT_OPR(COMPRESSED,	compressed,	false),
3464	FEAT_OPR(CPU_PMU_CAPS,	cpu_pmu_caps,	false),
3465	FEAT_OPR(CLOCK_DATA,	clock_data,	false),
3466	FEAT_OPN(HYBRID_TOPOLOGY,	hybrid_topology,	true),
3467	FEAT_OPR(PMU_CAPS,	pmu_caps,	false),
3468};
3469
3470struct header_print_data {
3471	FILE *fp;
3472	bool full; /* extended list of headers */
3473};
3474
3475static int perf_file_section__fprintf_info(struct perf_file_section *section,
3476					   struct perf_header *ph,
3477					   int feat, int fd, void *data)
3478{
3479	struct header_print_data *hd = data;
3480	struct feat_fd ff;
3481
3482	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
3483		pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
3484				"%d, continuing...\n", section->offset, feat);
3485		return 0;
3486	}
3487	if (feat >= HEADER_LAST_FEATURE) {
3488		pr_warning("unknown feature %d\n", feat);
3489		return 0;
3490	}
3491	if (!feat_ops[feat].print)
3492		return 0;
3493
3494	ff = (struct  feat_fd) {
3495		.fd = fd,
3496		.ph = ph,
3497	};
3498
3499	if (!feat_ops[feat].full_only || hd->full)
3500		feat_ops[feat].print(&ff, hd->fp);
3501	else
3502		fprintf(hd->fp, "# %s info available, use -I to display\n",
3503			feat_ops[feat].name);
3504
3505	return 0;
3506}
3507
3508int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
3509{
3510	struct header_print_data hd;
3511	struct perf_header *header = &session->header;
3512	int fd = perf_data__fd(session->data);
3513	struct stat st;
3514	time_t stctime;
3515	int ret, bit;
3516
3517	hd.fp = fp;
3518	hd.full = full;
3519
3520	ret = fstat(fd, &st);
3521	if (ret == -1)
3522		return -1;
3523
3524	stctime = st.st_mtime;
3525	fprintf(fp, "# captured on    : %s", ctime(&stctime));
3526
3527	fprintf(fp, "# header version : %u\n", header->version);
3528	fprintf(fp, "# data offset    : %" PRIu64 "\n", header->data_offset);
3529	fprintf(fp, "# data size      : %" PRIu64 "\n", header->data_size);
3530	fprintf(fp, "# feat offset    : %" PRIu64 "\n", header->feat_offset);
3531
3532	perf_header__process_sections(header, fd, &hd,
3533				      perf_file_section__fprintf_info);
3534
3535	if (session->data->is_pipe)
3536		return 0;
3537
3538	fprintf(fp, "# missing features: ");
3539	for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) {
3540		if (bit)
3541			fprintf(fp, "%s ", feat_ops[bit].name);
3542	}
3543
3544	fprintf(fp, "\n");
3545	return 0;
3546}
3547
3548struct header_fw {
3549	struct feat_writer	fw;
3550	struct feat_fd		*ff;
3551};
3552
3553static int feat_writer_cb(struct feat_writer *fw, void *buf, size_t sz)
3554{
3555	struct header_fw *h = container_of(fw, struct header_fw, fw);
3556
3557	return do_write(h->ff, buf, sz);
3558}
3559
3560static int do_write_feat(struct feat_fd *ff, int type,
3561			 struct perf_file_section **p,
3562			 struct evlist *evlist,
3563			 struct feat_copier *fc)
3564{
3565	int err;
3566	int ret = 0;
3567
3568	if (perf_header__has_feat(ff->ph, type)) {
3569		if (!feat_ops[type].write)
3570			return -1;
3571
3572		if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
3573			return -1;
3574
3575		(*p)->offset = lseek(ff->fd, 0, SEEK_CUR);
3576
3577		/*
3578		 * Hook to let perf inject copy features sections from the input
3579		 * file.
3580		 */
3581		if (fc && fc->copy) {
3582			struct header_fw h = {
3583				.fw.write = feat_writer_cb,
3584				.ff = ff,
3585			};
3586
3587			/* ->copy() returns 0 if the feature was not copied */
3588			err = fc->copy(fc, type, &h.fw);
3589		} else {
3590			err = 0;
3591		}
3592		if (!err)
3593			err = feat_ops[type].write(ff, evlist);
3594		if (err < 0) {
3595			pr_debug("failed to write feature %s\n", feat_ops[type].name);
3596
3597			/* undo anything written */
3598			lseek(ff->fd, (*p)->offset, SEEK_SET);
3599
3600			return -1;
3601		}
3602		(*p)->size = lseek(ff->fd, 0, SEEK_CUR) - (*p)->offset;
3603		(*p)++;
3604	}
3605	return ret;
3606}
3607
3608static int perf_header__adds_write(struct perf_header *header,
3609				   struct evlist *evlist, int fd,
3610				   struct feat_copier *fc)
3611{
3612	int nr_sections;
3613	struct feat_fd ff = {
3614		.fd  = fd,
3615		.ph = header,
3616	};
3617	struct perf_file_section *feat_sec, *p;
3618	int sec_size;
3619	u64 sec_start;
3620	int feat;
3621	int err;
3622
 
 
 
 
 
3623	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3624	if (!nr_sections)
3625		return 0;
3626
3627	feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
3628	if (feat_sec == NULL)
3629		return -ENOMEM;
3630
3631	sec_size = sizeof(*feat_sec) * nr_sections;
3632
3633	sec_start = header->feat_offset;
3634	lseek(fd, sec_start + sec_size, SEEK_SET);
3635
3636	for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
3637		if (do_write_feat(&ff, feat, &p, evlist, fc))
3638			perf_header__clear_feat(header, feat);
3639	}
3640
3641	lseek(fd, sec_start, SEEK_SET);
3642	/*
3643	 * may write more than needed due to dropped feature, but
3644	 * this is okay, reader will skip the missing entries
3645	 */
3646	err = do_write(&ff, feat_sec, sec_size);
3647	if (err < 0)
3648		pr_debug("failed to write feature section\n");
3649	free(ff.buf); /* TODO: added to silence clang-tidy. */
3650	free(feat_sec);
3651	return err;
3652}
3653
3654int perf_header__write_pipe(int fd)
3655{
3656	struct perf_pipe_file_header f_header;
3657	struct feat_fd ff = {
3658		.fd = fd,
3659	};
3660	int err;
3661
 
 
3662	f_header = (struct perf_pipe_file_header){
3663		.magic	   = PERF_MAGIC,
3664		.size	   = sizeof(f_header),
3665	};
3666
3667	err = do_write(&ff, &f_header, sizeof(f_header));
3668	if (err < 0) {
3669		pr_debug("failed to write perf pipe header\n");
3670		return err;
3671	}
3672	free(ff.buf);
3673	return 0;
3674}
3675
3676static int perf_session__do_write_header(struct perf_session *session,
3677					 struct evlist *evlist,
3678					 int fd, bool at_exit,
3679					 struct feat_copier *fc)
3680{
3681	struct perf_file_header f_header;
3682	struct perf_file_attr   f_attr;
3683	struct perf_header *header = &session->header;
3684	struct evsel *evsel;
3685	struct feat_fd ff = {
3686		.fd = fd,
3687	};
3688	u64 attr_offset;
3689	int err;
3690
 
3691	lseek(fd, sizeof(f_header), SEEK_SET);
3692
3693	evlist__for_each_entry(session->evlist, evsel) {
3694		evsel->id_offset = lseek(fd, 0, SEEK_CUR);
3695		err = do_write(&ff, evsel->core.id, evsel->core.ids * sizeof(u64));
3696		if (err < 0) {
3697			pr_debug("failed to write perf header\n");
3698			free(ff.buf);
3699			return err;
3700		}
3701	}
3702
3703	attr_offset = lseek(ff.fd, 0, SEEK_CUR);
3704
3705	evlist__for_each_entry(evlist, evsel) {
3706		if (evsel->core.attr.size < sizeof(evsel->core.attr)) {
3707			/*
3708			 * We are likely in "perf inject" and have read
3709			 * from an older file. Update attr size so that
3710			 * reader gets the right offset to the ids.
3711			 */
3712			evsel->core.attr.size = sizeof(evsel->core.attr);
3713		}
3714		f_attr = (struct perf_file_attr){
3715			.attr = evsel->core.attr,
3716			.ids  = {
3717				.offset = evsel->id_offset,
3718				.size   = evsel->core.ids * sizeof(u64),
3719			}
3720		};
3721		err = do_write(&ff, &f_attr, sizeof(f_attr));
3722		if (err < 0) {
3723			pr_debug("failed to write perf header attribute\n");
3724			free(ff.buf);
3725			return err;
3726		}
3727	}
3728
3729	if (!header->data_offset)
3730		header->data_offset = lseek(fd, 0, SEEK_CUR);
3731	header->feat_offset = header->data_offset + header->data_size;
3732
3733	if (at_exit) {
3734		err = perf_header__adds_write(header, evlist, fd, fc);
3735		if (err < 0) {
3736			free(ff.buf);
3737			return err;
3738		}
3739	}
3740
3741	f_header = (struct perf_file_header){
3742		.magic	   = PERF_MAGIC,
3743		.size	   = sizeof(f_header),
3744		.attr_size = sizeof(f_attr),
3745		.attrs = {
3746			.offset = attr_offset,
3747			.size   = evlist->core.nr_entries * sizeof(f_attr),
3748		},
3749		.data = {
3750			.offset = header->data_offset,
3751			.size	= header->data_size,
3752		},
3753		/* event_types is ignored, store zeros */
3754	};
3755
3756	memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
3757
3758	lseek(fd, 0, SEEK_SET);
3759	err = do_write(&ff, &f_header, sizeof(f_header));
3760	free(ff.buf);
3761	if (err < 0) {
3762		pr_debug("failed to write perf header\n");
3763		return err;
3764	}
3765	lseek(fd, header->data_offset + header->data_size, SEEK_SET);
3766
3767	return 0;
3768}
3769
3770int perf_session__write_header(struct perf_session *session,
3771			       struct evlist *evlist,
3772			       int fd, bool at_exit)
3773{
3774	return perf_session__do_write_header(session, evlist, fd, at_exit, NULL);
3775}
3776
3777size_t perf_session__data_offset(const struct evlist *evlist)
3778{
3779	struct evsel *evsel;
3780	size_t data_offset;
3781
3782	data_offset = sizeof(struct perf_file_header);
3783	evlist__for_each_entry(evlist, evsel) {
3784		data_offset += evsel->core.ids * sizeof(u64);
3785	}
3786	data_offset += evlist->core.nr_entries * sizeof(struct perf_file_attr);
3787
3788	return data_offset;
3789}
3790
3791int perf_session__inject_header(struct perf_session *session,
3792				struct evlist *evlist,
3793				int fd,
3794				struct feat_copier *fc)
3795{
3796	return perf_session__do_write_header(session, evlist, fd, true, fc);
3797}
3798
3799static int perf_header__getbuffer64(struct perf_header *header,
3800				    int fd, void *buf, size_t size)
3801{
3802	if (readn(fd, buf, size) <= 0)
3803		return -1;
3804
3805	if (header->needs_swap)
3806		mem_bswap_64(buf, size);
3807
3808	return 0;
3809}
3810
3811int perf_header__process_sections(struct perf_header *header, int fd,
3812				  void *data,
3813				  int (*process)(struct perf_file_section *section,
3814						 struct perf_header *ph,
3815						 int feat, int fd, void *data))
3816{
3817	struct perf_file_section *feat_sec, *sec;
3818	int nr_sections;
3819	int sec_size;
3820	int feat;
3821	int err;
3822
3823	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3824	if (!nr_sections)
3825		return 0;
3826
3827	feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
3828	if (!feat_sec)
3829		return -1;
3830
3831	sec_size = sizeof(*feat_sec) * nr_sections;
3832
3833	lseek(fd, header->feat_offset, SEEK_SET);
3834
3835	err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
3836	if (err < 0)
3837		goto out_free;
3838
3839	for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
3840		err = process(sec++, header, feat, fd, data);
3841		if (err < 0)
3842			goto out_free;
3843	}
3844	err = 0;
3845out_free:
3846	free(feat_sec);
3847	return err;
3848}
3849
3850static const int attr_file_abi_sizes[] = {
3851	[0] = PERF_ATTR_SIZE_VER0,
3852	[1] = PERF_ATTR_SIZE_VER1,
3853	[2] = PERF_ATTR_SIZE_VER2,
3854	[3] = PERF_ATTR_SIZE_VER3,
3855	[4] = PERF_ATTR_SIZE_VER4,
3856	0,
3857};
3858
3859/*
3860 * In the legacy file format, the magic number is not used to encode endianness.
3861 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
3862 * on ABI revisions, we need to try all combinations for all endianness to
3863 * detect the endianness.
3864 */
3865static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
3866{
3867	uint64_t ref_size, attr_size;
3868	int i;
3869
3870	for (i = 0 ; attr_file_abi_sizes[i]; i++) {
3871		ref_size = attr_file_abi_sizes[i]
3872			 + sizeof(struct perf_file_section);
3873		if (hdr_sz != ref_size) {
3874			attr_size = bswap_64(hdr_sz);
3875			if (attr_size != ref_size)
3876				continue;
3877
3878			ph->needs_swap = true;
3879		}
3880		pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
3881			 i,
3882			 ph->needs_swap);
3883		return 0;
3884	}
3885	/* could not determine endianness */
3886	return -1;
3887}
3888
3889#define PERF_PIPE_HDR_VER0	16
3890
3891static const size_t attr_pipe_abi_sizes[] = {
3892	[0] = PERF_PIPE_HDR_VER0,
3893	0,
3894};
3895
3896/*
3897 * In the legacy pipe format, there is an implicit assumption that endianness
3898 * between host recording the samples, and host parsing the samples is the
3899 * same. This is not always the case given that the pipe output may always be
3900 * redirected into a file and analyzed on a different machine with possibly a
3901 * different endianness and perf_event ABI revisions in the perf tool itself.
3902 */
3903static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
3904{
3905	u64 attr_size;
3906	int i;
3907
3908	for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
3909		if (hdr_sz != attr_pipe_abi_sizes[i]) {
3910			attr_size = bswap_64(hdr_sz);
3911			if (attr_size != hdr_sz)
3912				continue;
3913
3914			ph->needs_swap = true;
3915		}
3916		pr_debug("Pipe ABI%d perf.data file detected\n", i);
3917		return 0;
3918	}
3919	return -1;
3920}
3921
3922bool is_perf_magic(u64 magic)
3923{
3924	if (!memcmp(&magic, __perf_magic1, sizeof(magic))
3925		|| magic == __perf_magic2
3926		|| magic == __perf_magic2_sw)
3927		return true;
3928
3929	return false;
3930}
3931
3932static int check_magic_endian(u64 magic, uint64_t hdr_sz,
3933			      bool is_pipe, struct perf_header *ph)
3934{
3935	int ret;
3936
3937	/* check for legacy format */
3938	ret = memcmp(&magic, __perf_magic1, sizeof(magic));
3939	if (ret == 0) {
3940		ph->version = PERF_HEADER_VERSION_1;
3941		pr_debug("legacy perf.data format\n");
3942		if (is_pipe)
3943			return try_all_pipe_abis(hdr_sz, ph);
3944
3945		return try_all_file_abis(hdr_sz, ph);
3946	}
3947	/*
3948	 * the new magic number serves two purposes:
3949	 * - unique number to identify actual perf.data files
3950	 * - encode endianness of file
3951	 */
3952	ph->version = PERF_HEADER_VERSION_2;
3953
3954	/* check magic number with one endianness */
3955	if (magic == __perf_magic2)
3956		return 0;
3957
3958	/* check magic number with opposite endianness */
3959	if (magic != __perf_magic2_sw)
3960		return -1;
3961
3962	ph->needs_swap = true;
3963
3964	return 0;
3965}
3966
3967int perf_file_header__read(struct perf_file_header *header,
3968			   struct perf_header *ph, int fd)
3969{
3970	ssize_t ret;
3971
3972	lseek(fd, 0, SEEK_SET);
3973
3974	ret = readn(fd, header, sizeof(*header));
3975	if (ret <= 0)
3976		return -1;
3977
3978	if (check_magic_endian(header->magic,
3979			       header->attr_size, false, ph) < 0) {
3980		pr_debug("magic/endian check failed\n");
3981		return -1;
3982	}
3983
3984	if (ph->needs_swap) {
3985		mem_bswap_64(header, offsetof(struct perf_file_header,
3986			     adds_features));
3987	}
3988
3989	if (header->size != sizeof(*header)) {
3990		/* Support the previous format */
3991		if (header->size == offsetof(typeof(*header), adds_features))
3992			bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
3993		else
3994			return -1;
3995	} else if (ph->needs_swap) {
3996		/*
3997		 * feature bitmap is declared as an array of unsigned longs --
3998		 * not good since its size can differ between the host that
3999		 * generated the data file and the host analyzing the file.
4000		 *
4001		 * We need to handle endianness, but we don't know the size of
4002		 * the unsigned long where the file was generated. Take a best
4003		 * guess at determining it: try 64-bit swap first (ie., file
4004		 * created on a 64-bit host), and check if the hostname feature
4005		 * bit is set (this feature bit is forced on as of fbe96f2).
4006		 * If the bit is not, undo the 64-bit swap and try a 32-bit
4007		 * swap. If the hostname bit is still not set (e.g., older data
4008		 * file), punt and fallback to the original behavior --
4009		 * clearing all feature bits and setting buildid.
4010		 */
4011		mem_bswap_64(&header->adds_features,
4012			    BITS_TO_U64(HEADER_FEAT_BITS));
4013
4014		if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
4015			/* unswap as u64 */
4016			mem_bswap_64(&header->adds_features,
4017				    BITS_TO_U64(HEADER_FEAT_BITS));
4018
4019			/* unswap as u32 */
4020			mem_bswap_32(&header->adds_features,
4021				    BITS_TO_U32(HEADER_FEAT_BITS));
4022		}
4023
4024		if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
4025			bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
4026			__set_bit(HEADER_BUILD_ID, header->adds_features);
4027		}
4028	}
4029
4030	memcpy(&ph->adds_features, &header->adds_features,
4031	       sizeof(ph->adds_features));
4032
4033	ph->data_offset  = header->data.offset;
4034	ph->data_size	 = header->data.size;
4035	ph->feat_offset  = header->data.offset + header->data.size;
4036	return 0;
4037}
4038
4039static int perf_file_section__process(struct perf_file_section *section,
4040				      struct perf_header *ph,
4041				      int feat, int fd, void *data)
4042{
4043	struct feat_fd fdd = {
4044		.fd	= fd,
4045		.ph	= ph,
4046		.size	= section->size,
4047		.offset	= section->offset,
4048	};
4049
4050	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
4051		pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
4052			  "%d, continuing...\n", section->offset, feat);
4053		return 0;
4054	}
4055
4056	if (feat >= HEADER_LAST_FEATURE) {
4057		pr_debug("unknown feature %d, continuing...\n", feat);
4058		return 0;
4059	}
4060
4061	if (!feat_ops[feat].process)
4062		return 0;
4063
4064	return feat_ops[feat].process(&fdd, data);
4065}
4066
4067static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
4068				       struct perf_header *ph,
4069				       struct perf_data* data,
4070				       bool repipe, int repipe_fd)
4071{
4072	struct feat_fd ff = {
4073		.fd = repipe_fd,
4074		.ph = ph,
4075	};
4076	ssize_t ret;
4077
4078	ret = perf_data__read(data, header, sizeof(*header));
4079	if (ret <= 0)
4080		return -1;
4081
4082	if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
4083		pr_debug("endian/magic failed\n");
4084		return -1;
4085	}
4086
4087	if (ph->needs_swap)
4088		header->size = bswap_64(header->size);
4089
4090	if (repipe && do_write(&ff, header, sizeof(*header)) < 0)
4091		return -1;
4092
4093	return 0;
4094}
4095
4096static int perf_header__read_pipe(struct perf_session *session, int repipe_fd)
4097{
4098	struct perf_header *header = &session->header;
4099	struct perf_pipe_file_header f_header;
4100
4101	if (perf_file_header__read_pipe(&f_header, header, session->data,
4102					session->repipe, repipe_fd) < 0) {
 
4103		pr_debug("incompatible file format\n");
4104		return -EINVAL;
4105	}
4106
4107	return f_header.size == sizeof(f_header) ? 0 : -1;
4108}
4109
4110static int read_attr(int fd, struct perf_header *ph,
4111		     struct perf_file_attr *f_attr)
4112{
4113	struct perf_event_attr *attr = &f_attr->attr;
4114	size_t sz, left;
4115	size_t our_sz = sizeof(f_attr->attr);
4116	ssize_t ret;
4117
4118	memset(f_attr, 0, sizeof(*f_attr));
4119
4120	/* read minimal guaranteed structure */
4121	ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
4122	if (ret <= 0) {
4123		pr_debug("cannot read %d bytes of header attr\n",
4124			 PERF_ATTR_SIZE_VER0);
4125		return -1;
4126	}
4127
4128	/* on file perf_event_attr size */
4129	sz = attr->size;
4130
4131	if (ph->needs_swap)
4132		sz = bswap_32(sz);
4133
4134	if (sz == 0) {
4135		/* assume ABI0 */
4136		sz =  PERF_ATTR_SIZE_VER0;
4137	} else if (sz > our_sz) {
4138		pr_debug("file uses a more recent and unsupported ABI"
4139			 " (%zu bytes extra)\n", sz - our_sz);
4140		return -1;
4141	}
4142	/* what we have not yet read and that we know about */
4143	left = sz - PERF_ATTR_SIZE_VER0;
4144	if (left) {
4145		void *ptr = attr;
4146		ptr += PERF_ATTR_SIZE_VER0;
4147
4148		ret = readn(fd, ptr, left);
4149	}
4150	/* read perf_file_section, ids are read in caller */
4151	ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
4152
4153	return ret <= 0 ? -1 : 0;
4154}
4155
4156#ifdef HAVE_LIBTRACEEVENT
4157static int evsel__prepare_tracepoint_event(struct evsel *evsel, struct tep_handle *pevent)
4158{
4159	struct tep_event *event;
4160	char bf[128];
4161
4162	/* already prepared */
4163	if (evsel->tp_format)
4164		return 0;
4165
4166	if (pevent == NULL) {
4167		pr_debug("broken or missing trace data\n");
4168		return -1;
4169	}
4170
4171	event = tep_find_event(pevent, evsel->core.attr.config);
4172	if (event == NULL) {
4173		pr_debug("cannot find event format for %d\n", (int)evsel->core.attr.config);
4174		return -1;
4175	}
4176
4177	if (!evsel->name) {
4178		snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
4179		evsel->name = strdup(bf);
4180		if (evsel->name == NULL)
4181			return -1;
4182	}
4183
4184	evsel->tp_format = event;
4185	return 0;
4186}
4187
4188static int evlist__prepare_tracepoint_events(struct evlist *evlist, struct tep_handle *pevent)
 
4189{
4190	struct evsel *pos;
4191
4192	evlist__for_each_entry(evlist, pos) {
4193		if (pos->core.attr.type == PERF_TYPE_TRACEPOINT &&
4194		    evsel__prepare_tracepoint_event(pos, pevent))
4195			return -1;
4196	}
4197
4198	return 0;
4199}
4200#endif
4201
4202int perf_session__read_header(struct perf_session *session, int repipe_fd)
4203{
4204	struct perf_data *data = session->data;
4205	struct perf_header *header = &session->header;
4206	struct perf_file_header	f_header;
4207	struct perf_file_attr	f_attr;
4208	u64			f_id;
4209	int nr_attrs, nr_ids, i, j, err;
4210	int fd = perf_data__fd(data);
4211
4212	session->evlist = evlist__new();
4213	if (session->evlist == NULL)
4214		return -ENOMEM;
4215
4216	session->evlist->env = &header->env;
4217	session->machines.host.env = &header->env;
4218
4219	/*
4220	 * We can read 'pipe' data event from regular file,
4221	 * check for the pipe header regardless of source.
4222	 */
4223	err = perf_header__read_pipe(session, repipe_fd);
4224	if (!err || perf_data__is_pipe(data)) {
4225		data->is_pipe = true;
4226		return err;
4227	}
4228
4229	if (perf_file_header__read(&f_header, header, fd) < 0)
4230		return -EINVAL;
4231
4232	if (header->needs_swap && data->in_place_update) {
4233		pr_err("In-place update not supported when byte-swapping is required\n");
4234		return -EINVAL;
4235	}
4236
4237	/*
4238	 * Sanity check that perf.data was written cleanly; data size is
4239	 * initialized to 0 and updated only if the on_exit function is run.
4240	 * If data size is still 0 then the file contains only partial
4241	 * information.  Just warn user and process it as much as it can.
4242	 */
4243	if (f_header.data.size == 0) {
4244		pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
4245			   "Was the 'perf record' command properly terminated?\n",
4246			   data->file.path);
4247	}
4248
4249	if (f_header.attr_size == 0) {
4250		pr_err("ERROR: The %s file's attr size field is 0 which is unexpected.\n"
4251		       "Was the 'perf record' command properly terminated?\n",
4252		       data->file.path);
4253		return -EINVAL;
4254	}
4255
4256	nr_attrs = f_header.attrs.size / f_header.attr_size;
4257	lseek(fd, f_header.attrs.offset, SEEK_SET);
4258
4259	for (i = 0; i < nr_attrs; i++) {
4260		struct evsel *evsel;
4261		off_t tmp;
4262
4263		if (read_attr(fd, header, &f_attr) < 0)
4264			goto out_errno;
4265
4266		if (header->needs_swap) {
4267			f_attr.ids.size   = bswap_64(f_attr.ids.size);
4268			f_attr.ids.offset = bswap_64(f_attr.ids.offset);
4269			perf_event__attr_swap(&f_attr.attr);
4270		}
4271
4272		tmp = lseek(fd, 0, SEEK_CUR);
4273		evsel = evsel__new(&f_attr.attr);
4274
4275		if (evsel == NULL)
4276			goto out_delete_evlist;
4277
4278		evsel->needs_swap = header->needs_swap;
4279		/*
4280		 * Do it before so that if perf_evsel__alloc_id fails, this
4281		 * entry gets purged too at evlist__delete().
4282		 */
4283		evlist__add(session->evlist, evsel);
4284
4285		nr_ids = f_attr.ids.size / sizeof(u64);
4286		/*
4287		 * We don't have the cpu and thread maps on the header, so
4288		 * for allocating the perf_sample_id table we fake 1 cpu and
4289		 * hattr->ids threads.
4290		 */
4291		if (perf_evsel__alloc_id(&evsel->core, 1, nr_ids))
4292			goto out_delete_evlist;
4293
4294		lseek(fd, f_attr.ids.offset, SEEK_SET);
4295
4296		for (j = 0; j < nr_ids; j++) {
4297			if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
4298				goto out_errno;
4299
4300			perf_evlist__id_add(&session->evlist->core, &evsel->core, 0, j, f_id);
4301		}
4302
4303		lseek(fd, tmp, SEEK_SET);
4304	}
4305
4306#ifdef HAVE_LIBTRACEEVENT
4307	perf_header__process_sections(header, fd, &session->tevent,
4308				      perf_file_section__process);
4309
4310	if (evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent))
 
4311		goto out_delete_evlist;
4312#else
4313	perf_header__process_sections(header, fd, NULL, perf_file_section__process);
4314#endif
4315
4316	return 0;
4317out_errno:
4318	return -errno;
4319
4320out_delete_evlist:
4321	evlist__delete(session->evlist);
4322	session->evlist = NULL;
4323	return -ENOMEM;
4324}
4325
4326int perf_event__process_feature(struct perf_session *session,
4327				union perf_event *event)
4328{
4329	struct perf_tool *tool = session->tool;
4330	struct feat_fd ff = { .fd = 0 };
4331	struct perf_record_header_feature *fe = (struct perf_record_header_feature *)event;
4332	int type = fe->header.type;
4333	u64 feat = fe->feat_id;
4334	int ret = 0;
4335
4336	if (type < 0 || type >= PERF_RECORD_HEADER_MAX) {
4337		pr_warning("invalid record type %d in pipe-mode\n", type);
4338		return 0;
4339	}
4340	if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) {
4341		pr_warning("invalid record type %d in pipe-mode\n", type);
4342		return -1;
4343	}
4344
4345	if (!feat_ops[feat].process)
4346		return 0;
4347
4348	ff.buf  = (void *)fe->data;
4349	ff.size = event->header.size - sizeof(*fe);
4350	ff.ph = &session->header;
4351
4352	if (feat_ops[feat].process(&ff, NULL)) {
4353		ret = -1;
4354		goto out;
4355	}
4356
4357	if (!feat_ops[feat].print || !tool->show_feat_hdr)
4358		goto out;
4359
4360	if (!feat_ops[feat].full_only ||
4361	    tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {
4362		feat_ops[feat].print(&ff, stdout);
4363	} else {
4364		fprintf(stdout, "# %s info available, use -I to display\n",
4365			feat_ops[feat].name);
4366	}
4367out:
4368	free_event_desc(ff.events);
4369	return ret;
4370}
4371
4372size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
4373{
4374	struct perf_record_event_update *ev = &event->event_update;
 
 
4375	struct perf_cpu_map *map;
4376	size_t ret;
4377
4378	ret = fprintf(fp, "\n... id:    %" PRI_lu64 "\n", ev->id);
4379
4380	switch (ev->type) {
4381	case PERF_EVENT_UPDATE__SCALE:
4382		ret += fprintf(fp, "... scale: %f\n", ev->scale.scale);
 
4383		break;
4384	case PERF_EVENT_UPDATE__UNIT:
4385		ret += fprintf(fp, "... unit:  %s\n", ev->unit);
4386		break;
4387	case PERF_EVENT_UPDATE__NAME:
4388		ret += fprintf(fp, "... name:  %s\n", ev->name);
4389		break;
4390	case PERF_EVENT_UPDATE__CPUS:
 
4391		ret += fprintf(fp, "... ");
4392
4393		map = cpu_map__new_data(&ev->cpus.cpus);
4394		if (map) {
4395			ret += cpu_map__fprintf(map, fp);
4396			perf_cpu_map__put(map);
4397		} else
4398			ret += fprintf(fp, "failed to get cpus\n");
4399		break;
4400	default:
4401		ret += fprintf(fp, "... unknown type\n");
4402		break;
4403	}
4404
4405	return ret;
4406}
4407
4408int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
4409			     union perf_event *event,
4410			     struct evlist **pevlist)
4411{
4412	u32 i, n_ids;
4413	u64 *ids;
4414	struct evsel *evsel;
4415	struct evlist *evlist = *pevlist;
4416
4417	if (evlist == NULL) {
4418		*pevlist = evlist = evlist__new();
4419		if (evlist == NULL)
4420			return -ENOMEM;
4421	}
4422
4423	evsel = evsel__new(&event->attr.attr);
4424	if (evsel == NULL)
4425		return -ENOMEM;
4426
4427	evlist__add(evlist, evsel);
4428
4429	n_ids = event->header.size - sizeof(event->header) - event->attr.attr.size;
4430	n_ids = n_ids / sizeof(u64);
 
4431	/*
4432	 * We don't have the cpu and thread maps on the header, so
4433	 * for allocating the perf_sample_id table we fake 1 cpu and
4434	 * hattr->ids threads.
4435	 */
4436	if (perf_evsel__alloc_id(&evsel->core, 1, n_ids))
4437		return -ENOMEM;
4438
4439	ids = perf_record_header_attr_id(event);
4440	for (i = 0; i < n_ids; i++) {
4441		perf_evlist__id_add(&evlist->core, &evsel->core, 0, i, ids[i]);
4442	}
4443
4444	return 0;
4445}
4446
4447int perf_event__process_event_update(struct perf_tool *tool __maybe_unused,
4448				     union perf_event *event,
4449				     struct evlist **pevlist)
4450{
4451	struct perf_record_event_update *ev = &event->event_update;
 
 
4452	struct evlist *evlist;
4453	struct evsel *evsel;
4454	struct perf_cpu_map *map;
4455
4456	if (dump_trace)
4457		perf_event__fprintf_event_update(event, stdout);
4458
4459	if (!pevlist || *pevlist == NULL)
4460		return -EINVAL;
4461
4462	evlist = *pevlist;
4463
4464	evsel = evlist__id2evsel(evlist, ev->id);
4465	if (evsel == NULL)
4466		return -EINVAL;
4467
4468	switch (ev->type) {
4469	case PERF_EVENT_UPDATE__UNIT:
4470		free((char *)evsel->unit);
4471		evsel->unit = strdup(ev->unit);
4472		break;
4473	case PERF_EVENT_UPDATE__NAME:
4474		free(evsel->name);
4475		evsel->name = strdup(ev->name);
4476		break;
4477	case PERF_EVENT_UPDATE__SCALE:
4478		evsel->scale = ev->scale.scale;
 
4479		break;
4480	case PERF_EVENT_UPDATE__CPUS:
4481		map = cpu_map__new_data(&ev->cpus.cpus);
4482		if (map) {
4483			perf_cpu_map__put(evsel->core.own_cpus);
 
4484			evsel->core.own_cpus = map;
4485		} else
4486			pr_err("failed to get event_update cpus\n");
4487	default:
4488		break;
4489	}
4490
4491	return 0;
4492}
4493
4494#ifdef HAVE_LIBTRACEEVENT
4495int perf_event__process_tracing_data(struct perf_session *session,
4496				     union perf_event *event)
4497{
4498	ssize_t size_read, padding, size = event->tracing_data.size;
4499	int fd = perf_data__fd(session->data);
4500	char buf[BUFSIZ];
4501
4502	/*
4503	 * The pipe fd is already in proper place and in any case
4504	 * we can't move it, and we'd screw the case where we read
4505	 * 'pipe' data from regular file. The trace_report reads
4506	 * data from 'fd' so we need to set it directly behind the
4507	 * event, where the tracing data starts.
4508	 */
4509	if (!perf_data__is_pipe(session->data)) {
4510		off_t offset = lseek(fd, 0, SEEK_CUR);
4511
4512		/* setup for reading amidst mmap */
4513		lseek(fd, offset + sizeof(struct perf_record_header_tracing_data),
4514		      SEEK_SET);
4515	}
4516
4517	size_read = trace_report(fd, &session->tevent,
4518				 session->repipe);
4519	padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
4520
4521	if (readn(fd, buf, padding) < 0) {
4522		pr_err("%s: reading input file", __func__);
4523		return -1;
4524	}
4525	if (session->repipe) {
4526		int retw = write(STDOUT_FILENO, buf, padding);
4527		if (retw <= 0 || retw != padding) {
4528			pr_err("%s: repiping tracing data padding", __func__);
4529			return -1;
4530		}
4531	}
4532
4533	if (size_read + padding != size) {
4534		pr_err("%s: tracing data size mismatch", __func__);
4535		return -1;
4536	}
4537
4538	evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent);
 
4539
4540	return size_read + padding;
4541}
4542#endif
4543
4544int perf_event__process_build_id(struct perf_session *session,
4545				 union perf_event *event)
4546{
4547	__event_process_build_id(&event->build_id,
4548				 event->build_id.filename,
4549				 session);
4550	return 0;
4551}