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