#include <errno.h>

  #include <inttypes.h>

  #include "util.h"

  #include "string2.h"

  #include <sys/param.h>

  #include <sys/types.h>

  #include <byteswap.h>

  #include <unistd.h>
  #include <stdio.h>
  #include <stdlib.h>

  #include <linux/list.h>

  #include <linux/kernel.h>

  #include <linux/bitops.h>

  #include <sys/stat.h>
  #include <sys/types.h>

  #include <sys/utsname.h>

  #include <unistd.h>

  #include "evlist.h"

  #include "evsel.h"

  #include "header.h"

  #include "memswap.h"

  #include "../perf.h"
  #include "trace-event.h"

  #include "session.h"

  #include "symbol.h"

  #include "debug.h"

  #include "cpumap.h"

  #include "pmu.h"

  #include "vdso.h"

  #include "strbuf.h"

  #include "build-id.h"

  #include "data.h"

  #include <api/fs/fs.h>
  #include "asm/bug.h"

  #include "sane_ctype.h"

  /*
   * magic2 = "PERFILE2"
   * must be a numerical value to let the endianness
   * determine the memory layout. That way we are able
   * to detect endianness when reading the perf.data file
   * back.
   *
   * we check for legacy (PERFFILE) format.
   */
  static const char *__perf_magic1 = "PERFFILE";
  static const u64 __perf_magic2    = 0x32454c4946524550ULL;
  static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;

  #define PERF_MAGIC	__perf_magic2

  const char perf_version_string[] = PERF_VERSION;

  struct perf_file_attr {

  	struct perf_event_attr	attr;

  	struct perf_file_section	ids;
  };

  void perf_header__set_feat(struct perf_header *header, int feat)

  {

  	set_bit(feat, header->adds_features);

  }

  void perf_header__clear_feat(struct perf_header *header, int feat)

  {

  	clear_bit(feat, header->adds_features);

  }

  bool perf_header__has_feat(const struct perf_header *header, int feat)

  {

  	return test_bit(feat, header->adds_features);

  }

  static int do_write(int fd, const void *buf, size_t size)

  {
  	while (size) {
  		int ret = write(fd, buf, size);
  
  		if (ret < 0)

  			return -errno;

  
  		size -= ret;
  		buf += ret;
  	}

  
  	return 0;

  }

  int write_padded(int fd, const void *bf, size_t count, size_t count_aligned)

  {
  	static const char zero_buf[NAME_ALIGN];
  	int err = do_write(fd, bf, count);
  
  	if (!err)
  		err = do_write(fd, zero_buf, count_aligned - count);
  
  	return err;
  }

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

  static int do_write_string(int fd, const char *str)
  {
  	u32 len, olen;
  	int ret;
  
  	olen = strlen(str) + 1;

  	len = PERF_ALIGN(olen, NAME_ALIGN);

  
  	/* write len, incl. \0 */
  	ret = do_write(fd, &len, sizeof(len));
  	if (ret < 0)
  		return ret;
  
  	return write_padded(fd, str, olen, len);
  }
  
  static char *do_read_string(int fd, struct perf_header *ph)
  {
  	ssize_t sz, ret;
  	u32 len;
  	char *buf;

  	sz = readn(fd, &len, sizeof(len));

  	if (sz < (ssize_t)sizeof(len))
  		return NULL;
  
  	if (ph->needs_swap)
  		len = bswap_32(len);
  
  	buf = malloc(len);
  	if (!buf)
  		return NULL;

  	ret = readn(fd, buf, len);

  	if (ret == (ssize_t)len) {
  		/*
  		 * strings are padded by zeroes
  		 * thus the actual strlen of buf
  		 * may be less than len
  		 */
  		return buf;
  	}
  
  	free(buf);
  	return NULL;
  }

  static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,

  			    struct perf_evlist *evlist)
  {
  	return read_tracing_data(fd, &evlist->entries);
  }
  
  
  static int write_build_id(int fd, struct perf_header *h,

  			  struct perf_evlist *evlist __maybe_unused)

  {
  	struct perf_session *session;
  	int err;
  
  	session = container_of(h, struct perf_session, header);

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

  	err = perf_session__write_buildid_table(session, fd);

  	if (err < 0) {
  		pr_debug("failed to write buildid table
  ");
  		return err;
  	}

  	perf_session__cache_build_ids(session);

  
  	return 0;
  }

  static int write_hostname(int fd, struct perf_header *h __maybe_unused,
  			  struct perf_evlist *evlist __maybe_unused)

  {
  	struct utsname uts;
  	int ret;
  
  	ret = uname(&uts);
  	if (ret < 0)
  		return -1;
  
  	return do_write_string(fd, uts.nodename);
  }

  static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
  			   struct perf_evlist *evlist __maybe_unused)

  {
  	struct utsname uts;
  	int ret;
  
  	ret = uname(&uts);
  	if (ret < 0)
  		return -1;
  
  	return do_write_string(fd, uts.release);
  }

  static int write_arch(int fd, struct perf_header *h __maybe_unused,
  		      struct perf_evlist *evlist __maybe_unused)

  {
  	struct utsname uts;
  	int ret;
  
  	ret = uname(&uts);
  	if (ret < 0)
  		return -1;
  
  	return do_write_string(fd, uts.machine);
  }

  static int write_version(int fd, struct perf_header *h __maybe_unused,
  			 struct perf_evlist *evlist __maybe_unused)

  {
  	return do_write_string(fd, perf_version_string);
  }

  static int __write_cpudesc(int fd, const char *cpuinfo_proc)

  {

  	FILE *file;
  	char *buf = NULL;
  	char *s, *p;

  	const char *search = cpuinfo_proc;

  	size_t len = 0;
  	int ret = -1;
  
  	if (!search)
  		return -1;
  
  	file = fopen("/proc/cpuinfo", "r");
  	if (!file)
  		return -1;
  
  	while (getline(&buf, &len, file) > 0) {
  		ret = strncmp(buf, search, strlen(search));
  		if (!ret)
  			break;
  	}

  	if (ret) {
  		ret = -1;

  		goto done;

  	}

  
  	s = buf;
  
  	p = strchr(buf, ':');
  	if (p && *(p+1) == ' ' && *(p+2))
  		s = p + 2;
  	p = strchr(s, '
  ');
  	if (p)
  		*p = '\0';
  
  	/* squash extra space characters (branding string) */
  	p = s;
  	while (*p) {
  		if (isspace(*p)) {
  			char *r = p + 1;
  			char *q = r;
  			*p = ' ';
  			while (*q && isspace(*q))
  				q++;
  			if (q != (p+1))
  				while ((*r++ = *q++));
  		}
  		p++;
  	}
  	ret = do_write_string(fd, s);
  done:
  	free(buf);
  	fclose(file);
  	return ret;
  }

  static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
  		       struct perf_evlist *evlist __maybe_unused)
  {
  #ifndef CPUINFO_PROC
  #define CPUINFO_PROC {"model name", }
  #endif
  	const char *cpuinfo_procs[] = CPUINFO_PROC;
  	unsigned int i;
  
  	for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
  		int ret;
  		ret = __write_cpudesc(fd, cpuinfo_procs[i]);
  		if (ret >= 0)
  			return ret;
  	}
  	return -1;
  }

  static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
  			struct perf_evlist *evlist __maybe_unused)

  {
  	long nr;
  	u32 nrc, nra;
  	int ret;

  	nrc = cpu__max_present_cpu();

  
  	nr = sysconf(_SC_NPROCESSORS_ONLN);
  	if (nr < 0)
  		return -1;
  
  	nra = (u32)(nr & UINT_MAX);
  
  	ret = do_write(fd, &nrc, sizeof(nrc));
  	if (ret < 0)
  		return ret;
  
  	return do_write(fd, &nra, sizeof(nra));
  }

  static int write_event_desc(int fd, struct perf_header *h __maybe_unused,

  			    struct perf_evlist *evlist)
  {

  	struct perf_evsel *evsel;

  	u32 nre, nri, sz;

  	int ret;

  	nre = evlist->nr_entries;

  
  	/*
  	 * write number of events
  	 */
  	ret = do_write(fd, &nre, sizeof(nre));
  	if (ret < 0)
  		return ret;
  
  	/*
  	 * size of perf_event_attr struct
  	 */

  	sz = (u32)sizeof(evsel->attr);

  	ret = do_write(fd, &sz, sizeof(sz));
  	if (ret < 0)
  		return ret;

  	evlist__for_each_entry(evlist, evsel) {

  		ret = do_write(fd, &evsel->attr, sz);

  		if (ret < 0)
  			return ret;
  		/*
  		 * write number of unique id per event
  		 * there is one id per instance of an event
  		 *
  		 * copy into an nri to be independent of the
  		 * type of ids,
  		 */

  		nri = evsel->ids;

  		ret = do_write(fd, &nri, sizeof(nri));
  		if (ret < 0)
  			return ret;
  
  		/*
  		 * write event string as passed on cmdline
  		 */

  		ret = do_write_string(fd, perf_evsel__name(evsel));

  		if (ret < 0)
  			return ret;
  		/*
  		 * write unique ids for this event
  		 */

  		ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64));

  		if (ret < 0)
  			return ret;
  	}
  	return 0;
  }

  static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
  			 struct perf_evlist *evlist __maybe_unused)

  {
  	char buf[MAXPATHLEN];

  	u32 n;
  	int i, ret;

  	/* actual path to perf binary */
  	ret = readlink("/proc/self/exe", buf, sizeof(buf) - 1);

  	if (ret <= 0)
  		return -1;
  
  	/* readlink() does not add null termination */
  	buf[ret] = '\0';
  
  	/* account for binary path */

  	n = perf_env.nr_cmdline + 1;

  
  	ret = do_write(fd, &n, sizeof(n));
  	if (ret < 0)
  		return ret;
  
  	ret = do_write_string(fd, buf);
  	if (ret < 0)
  		return ret;

  	for (i = 0 ; i < perf_env.nr_cmdline; i++) {
  		ret = do_write_string(fd, perf_env.cmdline_argv[i]);

  		if (ret < 0)
  			return ret;
  	}
  	return 0;
  }
  
  #define CORE_SIB_FMT \
  	"/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
  #define THRD_SIB_FMT \
  	"/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
  
  struct cpu_topo {

  	u32 cpu_nr;

  	u32 core_sib;
  	u32 thread_sib;
  	char **core_siblings;
  	char **thread_siblings;
  };
  
  static int build_cpu_topo(struct cpu_topo *tp, int cpu)
  {
  	FILE *fp;
  	char filename[MAXPATHLEN];
  	char *buf = NULL, *p;
  	size_t len = 0;

  	ssize_t sret;

  	u32 i = 0;
  	int ret = -1;
  
  	sprintf(filename, CORE_SIB_FMT, cpu);
  	fp = fopen(filename, "r");
  	if (!fp)

  		goto try_threads;

  	sret = getline(&buf, &len, fp);

  	fclose(fp);

  	if (sret <= 0)
  		goto try_threads;

  
  	p = strchr(buf, '
  ');
  	if (p)
  		*p = '\0';
  
  	for (i = 0; i < tp->core_sib; i++) {
  		if (!strcmp(buf, tp->core_siblings[i]))
  			break;
  	}
  	if (i == tp->core_sib) {
  		tp->core_siblings[i] = buf;
  		tp->core_sib++;
  		buf = NULL;
  		len = 0;
  	}

  	ret = 0;

  try_threads:

  	sprintf(filename, THRD_SIB_FMT, cpu);
  	fp = fopen(filename, "r");
  	if (!fp)
  		goto done;
  
  	if (getline(&buf, &len, fp) <= 0)
  		goto done;
  
  	p = strchr(buf, '
  ');
  	if (p)
  		*p = '\0';
  
  	for (i = 0; i < tp->thread_sib; i++) {
  		if (!strcmp(buf, tp->thread_siblings[i]))
  			break;
  	}
  	if (i == tp->thread_sib) {
  		tp->thread_siblings[i] = buf;
  		tp->thread_sib++;
  		buf = NULL;
  	}
  	ret = 0;
  done:
  	if(fp)
  		fclose(fp);
  	free(buf);
  	return ret;
  }
  
  static void free_cpu_topo(struct cpu_topo *tp)
  {
  	u32 i;
  
  	if (!tp)
  		return;
  
  	for (i = 0 ; i < tp->core_sib; i++)

  		zfree(&tp->core_siblings[i]);

  
  	for (i = 0 ; i < tp->thread_sib; i++)

  		zfree(&tp->thread_siblings[i]);

  
  	free(tp);
  }
  
  static struct cpu_topo *build_cpu_topology(void)
  {

  	struct cpu_topo *tp = NULL;

  	void *addr;
  	u32 nr, i;

  	size_t sz;

  	long ncpus;
  	int ret = -1;

  	struct cpu_map *map;

  	ncpus = cpu__max_present_cpu();

  	/* build online CPU map */
  	map = cpu_map__new(NULL);
  	if (map == NULL) {
  		pr_debug("failed to get system cpumap
  ");
  		return NULL;
  	}

  	nr = (u32)(ncpus & UINT_MAX);
  
  	sz = nr * sizeof(char *);

  	addr = calloc(1, sizeof(*tp) + 2 * sz);

  	if (!addr)

  		goto out_free;

  
  	tp = addr;

  	tp->cpu_nr = nr;

  	addr += sizeof(*tp);
  	tp->core_siblings = addr;
  	addr += sz;
  	tp->thread_siblings = addr;
  
  	for (i = 0; i < nr; i++) {

  		if (!cpu_map__has(map, i))
  			continue;

  		ret = build_cpu_topo(tp, i);
  		if (ret < 0)
  			break;
  	}

  
  out_free:
  	cpu_map__put(map);

  	if (ret) {
  		free_cpu_topo(tp);
  		tp = NULL;
  	}
  	return tp;
  }

  static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused,
  			  struct perf_evlist *evlist __maybe_unused)

  {
  	struct cpu_topo *tp;
  	u32 i;

  	int ret, j;

  
  	tp = build_cpu_topology();
  	if (!tp)
  		return -1;
  
  	ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
  	if (ret < 0)
  		goto done;
  
  	for (i = 0; i < tp->core_sib; i++) {
  		ret = do_write_string(fd, tp->core_siblings[i]);
  		if (ret < 0)
  			goto done;
  	}
  	ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
  	if (ret < 0)
  		goto done;
  
  	for (i = 0; i < tp->thread_sib; i++) {
  		ret = do_write_string(fd, tp->thread_siblings[i]);
  		if (ret < 0)
  			break;
  	}

  	ret = perf_env__read_cpu_topology_map(&perf_env);
  	if (ret < 0)
  		goto done;
  
  	for (j = 0; j < perf_env.nr_cpus_avail; j++) {
  		ret = do_write(fd, &perf_env.cpu[j].core_id,
  			       sizeof(perf_env.cpu[j].core_id));

  		if (ret < 0)
  			return ret;

  		ret = do_write(fd, &perf_env.cpu[j].socket_id,
  			       sizeof(perf_env.cpu[j].socket_id));

  		if (ret < 0)
  			return ret;
  	}

  done:
  	free_cpu_topo(tp);
  	return ret;
  }

  static int write_total_mem(int fd, struct perf_header *h __maybe_unused,
  			  struct perf_evlist *evlist __maybe_unused)

  {
  	char *buf = NULL;
  	FILE *fp;
  	size_t len = 0;
  	int ret = -1, n;
  	uint64_t mem;
  
  	fp = fopen("/proc/meminfo", "r");
  	if (!fp)
  		return -1;
  
  	while (getline(&buf, &len, fp) > 0) {
  		ret = strncmp(buf, "MemTotal:", 9);
  		if (!ret)
  			break;
  	}
  	if (!ret) {
  		n = sscanf(buf, "%*s %"PRIu64, &mem);
  		if (n == 1)
  			ret = do_write(fd, &mem, sizeof(mem));

  	} else
  		ret = -1;

  	free(buf);
  	fclose(fp);
  	return ret;
  }
  
  static int write_topo_node(int fd, int node)
  {
  	char str[MAXPATHLEN];
  	char field[32];
  	char *buf = NULL, *p;
  	size_t len = 0;
  	FILE *fp;
  	u64 mem_total, mem_free, mem;
  	int ret = -1;
  
  	sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
  	fp = fopen(str, "r");
  	if (!fp)
  		return -1;
  
  	while (getline(&buf, &len, fp) > 0) {
  		/* skip over invalid lines */
  		if (!strchr(buf, ':'))
  			continue;

  		if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)

  			goto done;
  		if (!strcmp(field, "MemTotal:"))
  			mem_total = mem;
  		if (!strcmp(field, "MemFree:"))
  			mem_free = mem;
  	}
  
  	fclose(fp);

  	fp = NULL;

  
  	ret = do_write(fd, &mem_total, sizeof(u64));
  	if (ret)
  		goto done;
  
  	ret = do_write(fd, &mem_free, sizeof(u64));
  	if (ret)
  		goto done;
  
  	ret = -1;
  	sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
  
  	fp = fopen(str, "r");
  	if (!fp)
  		goto done;
  
  	if (getline(&buf, &len, fp) <= 0)
  		goto done;
  
  	p = strchr(buf, '
  ');
  	if (p)
  		*p = '\0';
  
  	ret = do_write_string(fd, buf);
  done:
  	free(buf);

  	if (fp)
  		fclose(fp);

  	return ret;
  }

  static int write_numa_topology(int fd, struct perf_header *h __maybe_unused,
  			  struct perf_evlist *evlist __maybe_unused)

  {
  	char *buf = NULL;
  	size_t len = 0;
  	FILE *fp;
  	struct cpu_map *node_map = NULL;
  	char *c;
  	u32 nr, i, j;
  	int ret = -1;
  
  	fp = fopen("/sys/devices/system/node/online", "r");
  	if (!fp)
  		return -1;
  
  	if (getline(&buf, &len, fp) <= 0)
  		goto done;
  
  	c = strchr(buf, '
  ');
  	if (c)
  		*c = '\0';
  
  	node_map = cpu_map__new(buf);
  	if (!node_map)
  		goto done;
  
  	nr = (u32)node_map->nr;
  
  	ret = do_write(fd, &nr, sizeof(nr));
  	if (ret < 0)
  		goto done;
  
  	for (i = 0; i < nr; i++) {
  		j = (u32)node_map->map[i];
  		ret = do_write(fd, &j, sizeof(j));
  		if (ret < 0)
  			break;
  
  		ret = write_topo_node(fd, i);
  		if (ret < 0)
  			break;
  	}
  done:
  	free(buf);
  	fclose(fp);

  	cpu_map__put(node_map);

  	return ret;
  }
  
  /*

   * File format:
   *
   * struct pmu_mappings {
   *	u32	pmu_num;
   *	struct pmu_map {
   *		u32	type;
   *		char	name[];
   *	}[pmu_num];
   * };
   */

  static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
  			      struct perf_evlist *evlist __maybe_unused)

  {
  	struct perf_pmu *pmu = NULL;
  	off_t offset = lseek(fd, 0, SEEK_CUR);
  	__u32 pmu_num = 0;

  	int ret;

  
  	/* write real pmu_num later */

  	ret = do_write(fd, &pmu_num, sizeof(pmu_num));
  	if (ret < 0)
  		return ret;

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

  
  		ret = do_write(fd, &pmu->type, sizeof(pmu->type));
  		if (ret < 0)
  			return ret;
  
  		ret = do_write_string(fd, pmu->name);
  		if (ret < 0)
  			return ret;

  	}
  
  	if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
  		/* discard all */
  		lseek(fd, offset, SEEK_SET);
  		return -1;
  	}
  
  	return 0;
  }
  
  /*

   * File format:
   *
   * struct group_descs {
   *	u32	nr_groups;
   *	struct group_desc {
   *		char	name[];
   *		u32	leader_idx;
   *		u32	nr_members;
   *	}[nr_groups];
   * };
   */
  static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
  			    struct perf_evlist *evlist)
  {
  	u32 nr_groups = evlist->nr_groups;
  	struct perf_evsel *evsel;
  	int ret;
  
  	ret = do_write(fd, &nr_groups, sizeof(nr_groups));
  	if (ret < 0)
  		return ret;

  	evlist__for_each_entry(evlist, evsel) {

  		if (perf_evsel__is_group_leader(evsel) &&
  		    evsel->nr_members > 1) {
  			const char *name = evsel->group_name ?: "{anon_group}";
  			u32 leader_idx = evsel->idx;
  			u32 nr_members = evsel->nr_members;
  
  			ret = do_write_string(fd, name);
  			if (ret < 0)
  				return ret;
  
  			ret = do_write(fd, &leader_idx, sizeof(leader_idx));
  			if (ret < 0)
  				return ret;
  
  			ret = do_write(fd, &nr_members, sizeof(nr_members));
  			if (ret < 0)
  				return ret;
  		}
  	}
  	return 0;
  }
  
  /*

   * default get_cpuid(): nothing gets recorded
   * actual implementation must be in arch/$(ARCH)/util/header.c
   */

  int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)

  {
  	return -1;
  }

  static int write_cpuid(int fd, struct perf_header *h __maybe_unused,
  		       struct perf_evlist *evlist __maybe_unused)

  {
  	char buffer[64];
  	int ret;
  
  	ret = get_cpuid(buffer, sizeof(buffer));
  	if (!ret)
  		goto write_it;
  
  	return -1;
  write_it:
  	return do_write_string(fd, buffer);
  }

  static int write_branch_stack(int fd __maybe_unused,
  			      struct perf_header *h __maybe_unused,
  		       struct perf_evlist *evlist __maybe_unused)

  {
  	return 0;
  }

  static int write_auxtrace(int fd, struct perf_header *h,

  			  struct perf_evlist *evlist __maybe_unused)
  {

  	struct perf_session *session;
  	int err;
  
  	session = container_of(h, struct perf_session, header);
  
  	err = auxtrace_index__write(fd, &session->auxtrace_index);
  	if (err < 0)
  		pr_err("Failed to write auxtrace index
  ");
  	return err;

  }

  static int cpu_cache_level__sort(const void *a, const void *b)
  {
  	struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
  	struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b;
  
  	return cache_a->level - cache_b->level;
  }
  
  static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b)
  {
  	if (a->level != b->level)
  		return false;
  
  	if (a->line_size != b->line_size)
  		return false;
  
  	if (a->sets != b->sets)
  		return false;
  
  	if (a->ways != b->ways)
  		return false;
  
  	if (strcmp(a->type, b->type))
  		return false;
  
  	if (strcmp(a->size, b->size))
  		return false;
  
  	if (strcmp(a->map, b->map))
  		return false;
  
  	return true;
  }
  
  static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level)
  {
  	char path[PATH_MAX], file[PATH_MAX];
  	struct stat st;
  	size_t len;
  
  	scnprintf(path, PATH_MAX, "devices/system/cpu/cpu%d/cache/index%d/", cpu, level);
  	scnprintf(file, PATH_MAX, "%s/%s", sysfs__mountpoint(), path);
  
  	if (stat(file, &st))
  		return 1;
  
  	scnprintf(file, PATH_MAX, "%s/level", path);
  	if (sysfs__read_int(file, (int *) &cache->level))
  		return -1;
  
  	scnprintf(file, PATH_MAX, "%s/coherency_line_size", path);
  	if (sysfs__read_int(file, (int *) &cache->line_size))
  		return -1;
  
  	scnprintf(file, PATH_MAX, "%s/number_of_sets", path);
  	if (sysfs__read_int(file, (int *) &cache->sets))
  		return -1;
  
  	scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path);
  	if (sysfs__read_int(file, (int *) &cache->ways))
  		return -1;
  
  	scnprintf(file, PATH_MAX, "%s/type", path);
  	if (sysfs__read_str(file, &cache->type, &len))
  		return -1;
  
  	cache->type[len] = 0;
  	cache->type = rtrim(cache->type);
  
  	scnprintf(file, PATH_MAX, "%s/size", path);
  	if (sysfs__read_str(file, &cache->size, &len)) {
  		free(cache->type);
  		return -1;
  	}
  
  	cache->size[len] = 0;
  	cache->size = rtrim(cache->size);
  
  	scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path);
  	if (sysfs__read_str(file, &cache->map, &len)) {
  		free(cache->map);
  		free(cache->type);
  		return -1;
  	}
  
  	cache->map[len] = 0;
  	cache->map = rtrim(cache->map);
  	return 0;
  }
  
  static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c)
  {
  	fprintf(out, "L%d %-15s %8s [%s]
  ", c->level, c->type, c->size, c->map);
  }
  
  static int build_caches(struct cpu_cache_level caches[], u32 size, u32 *cntp)
  {
  	u32 i, cnt = 0;
  	long ncpus;
  	u32 nr, cpu;
  	u16 level;
  
  	ncpus = sysconf(_SC_NPROCESSORS_CONF);
  	if (ncpus < 0)
  		return -1;
  
  	nr = (u32)(ncpus & UINT_MAX);
  
  	for (cpu = 0; cpu < nr; cpu++) {
  		for (level = 0; level < 10; level++) {
  			struct cpu_cache_level c;
  			int err;
  
  			err = cpu_cache_level__read(&c, cpu, level);
  			if (err < 0)
  				return err;
  
  			if (err == 1)
  				break;
  
  			for (i = 0; i < cnt; i++) {
  				if (cpu_cache_level__cmp(&c, &caches[i]))
  					break;
  			}
  
  			if (i == cnt)
  				caches[cnt++] = c;
  			else
  				cpu_cache_level__free(&c);
  
  			if (WARN_ONCE(cnt == size, "way too many cpu caches.."))
  				goto out;
  		}
  	}
   out:
  	*cntp = cnt;
  	return 0;
  }
  
  #define MAX_CACHES 2000
  
  static int write_cache(int fd, struct perf_header *h __maybe_unused,
  			  struct perf_evlist *evlist __maybe_unused)
  {
  	struct cpu_cache_level caches[MAX_CACHES];
  	u32 cnt = 0, i, version = 1;
  	int ret;
  
  	ret = build_caches(caches, MAX_CACHES, &cnt);
  	if (ret)
  		goto out;
  
  	qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort);
  
  	ret = do_write(fd, &version, sizeof(u32));
  	if (ret < 0)
  		goto out;
  
  	ret = do_write(fd, &cnt, sizeof(u32));
  	if (ret < 0)
  		goto out;
  
  	for (i = 0; i < cnt; i++) {
  		struct cpu_cache_level *c = &caches[i];
  
  		#define _W(v)					\
  			ret = do_write(fd, &c->v, sizeof(u32));	\
  			if (ret < 0)				\
  				goto out;
  
  		_W(level)
  		_W(line_size)
  		_W(sets)
  		_W(ways)
  		#undef _W
  
  		#define _W(v)						\
  			ret = do_write_string(fd, (const char *) c->v);	\
  			if (ret < 0)					\
  				goto out;
  
  		_W(type)
  		_W(size)
  		_W(map)
  		#undef _W
  	}
  
  out:
  	for (i = 0; i < cnt; i++)
  		cpu_cache_level__free(&caches[i]);
  	return ret;
  }

  static int write_stat(int fd __maybe_unused,
  		      struct perf_header *h __maybe_unused,
  		      struct perf_evlist *evlist __maybe_unused)
  {
  	return 0;
  }

  static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
  			   FILE *fp)

  {

  	fprintf(fp, "# hostname : %s
  ", ph->env.hostname);

  }

  static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
  			    FILE *fp)

  {

  	fprintf(fp, "# os release : %s
  ", ph->env.os_release);

  }

  static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)

  {

  	fprintf(fp, "# arch : %s
  ", ph->env.arch);

  }

  static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
  			  FILE *fp)

  {

  	fprintf(fp, "# cpudesc : %s
  ", ph->env.cpu_desc);

  }

  static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
  			 FILE *fp)

  {

  	fprintf(fp, "# nrcpus online : %u
  ", ph->env.nr_cpus_online);
  	fprintf(fp, "# nrcpus avail : %u
  ", ph->env.nr_cpus_avail);

  }

  static void print_version(struct perf_header *ph, int fd __maybe_unused,
  			  FILE *fp)

  {

  	fprintf(fp, "# perf version : %s
  ", ph->env.version);

  }

  static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
  			  FILE *fp)

  {

  	int nr, i;

  	nr = ph->env.nr_cmdline;

  
  	fprintf(fp, "# cmdline : ");

  	for (i = 0; i < nr; i++)
  		fprintf(fp, "%s ", ph->env.cmdline_argv[i]);

  	fputc('
  ', fp);
  }

  static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
  			       FILE *fp)

  {

  	int nr, i;

  	char *str;

  	int cpu_nr = ph->env.nr_cpus_avail;

  	nr = ph->env.nr_sibling_cores;
  	str = ph->env.sibling_cores;

  
  	for (i = 0; i < nr; i++) {

  		fprintf(fp, "# sibling cores   : %s
  ", str);

  		str += strlen(str) + 1;

  	}

  	nr = ph->env.nr_sibling_threads;
  	str = ph->env.sibling_threads;

  
  	for (i = 0; i < nr; i++) {

  		fprintf(fp, "# sibling threads : %s
  ", str);

  		str += strlen(str) + 1;

  	}

  
  	if (ph->env.cpu != NULL) {
  		for (i = 0; i < cpu_nr; i++)
  			fprintf(fp, "# CPU %d: Core ID %d, Socket ID %d
  ", i,
  				ph->env.cpu[i].core_id, ph->env.cpu[i].socket_id);
  	} else
  		fprintf(fp, "# Core ID and Socket ID information is not available
  ");

  }

  static void free_event_desc(struct perf_evsel *events)

  {

  	struct perf_evsel *evsel;
  
  	if (!events)
  		return;
  
  	for (evsel = events; evsel->attr.size; evsel++) {

  		zfree(&evsel->name);
  		zfree(&evsel->id);

  	}
  
  	free(events);
  }
  
  static struct perf_evsel *
  read_event_desc(struct perf_header *ph, int fd)
  {
  	struct perf_evsel *evsel, *events = NULL;
  	u64 *id;

  	void *buf = NULL;

  	u32 nre, sz, nr, i, j;
  	ssize_t ret;
  	size_t msz;

  
  	/* number of events */

  	ret = readn(fd, &nre, sizeof(nre));

  	if (ret != (ssize_t)sizeof(nre))
  		goto error;
  
  	if (ph->needs_swap)
  		nre = bswap_32(nre);

  	ret = readn(fd, &sz, sizeof(sz));

  	if (ret != (ssize_t)sizeof(sz))
  		goto error;
  
  	if (ph->needs_swap)
  		sz = bswap_32(sz);

  	/* buffer to hold on file attr struct */

  	buf = malloc(sz);
  	if (!buf)
  		goto error;

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

  	if (sz < msz)

  		msz = sz;

  	for (i = 0, evsel = events; i < nre; evsel++, i++) {
  		evsel->idx = i;

  		/*
  		 * must read entire on-file attr struct to
  		 * sync up with layout.
  		 */

  		ret = readn(fd, buf, sz);

  		if (ret != (ssize_t)sz)
  			goto error;
  
  		if (ph->needs_swap)
  			perf_event__attr_swap(buf);

  		memcpy(&evsel->attr, buf, msz);

  		ret = readn(fd, &nr, sizeof(nr));

  		if (ret != (ssize_t)sizeof(nr))
  			goto error;

  		if (ph->needs_swap) {

  			nr = bswap_32(nr);

  			evsel->needs_swap = true;
  		}

  		evsel->name = do_read_string(fd, ph);
  
  		if (!nr)
  			continue;
  
  		id = calloc(nr, sizeof(*id));
  		if (!id)
  			goto error;
  		evsel->ids = nr;
  		evsel->id = id;
  
  		for (j = 0 ; j < nr; j++) {

  			ret = readn(fd, id, sizeof(*id));

  			if (ret != (ssize_t)sizeof(*id))
  				goto error;
  			if (ph->needs_swap)
  				*id = bswap_64(*id);
  			id++;
  		}
  	}
  out:

  	free(buf);

  	return events;
  error:

  	free_event_desc(events);

  	events = NULL;
  	goto out;
  }

  static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
  				void *priv __attribute__((unused)))
  {
  	return fprintf(fp, ", %s = %s", name, val);
  }

  static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
  {
  	struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
  	u32 j;
  	u64 *id;
  
  	if (!events) {
  		fprintf(fp, "# event desc: not available or unable to read
  ");
  		return;
  	}
  
  	for (evsel = events; evsel->attr.size; evsel++) {
  		fprintf(fp, "# event : name = %s, ", evsel->name);

  		if (evsel->ids) {

  			fprintf(fp, ", id = {");

  			for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
  				if (j)
  					fputc(',', fp);
  				fprintf(fp, " %"PRIu64, *id);
  			}

  			fprintf(fp, " }");

  		}

  		perf_event_attr__fprintf(fp, &evsel->attr, __desc_attr__fprintf, NULL);

  		fputc('
  ', fp);
  	}

  
  	free_event_desc(events);

  }

  static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,

  			    FILE *fp)

  {

  	fprintf(fp, "# total memory : %Lu kB
  ", ph->env.total_mem);

  }

  static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,

  				FILE *fp)

  {

  	int i;
  	struct numa_node *n;

  	for (i = 0; i < ph->env.nr_numa_nodes; i++) {
  		n = &ph->env.numa_nodes[i];

  		fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
  			    " free = %"PRIu64" kB
  ",

  			n->node, n->mem_total, n->mem_free);

  		fprintf(fp, "# node%u cpu list : ", n->node);
  		cpu_map__fprintf(n->map, fp);

  	}

  }

  static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)

  {

  	fprintf(fp, "# cpuid : %s
  ", ph->env.cpuid);

  }

  static void print_branch_stack(struct perf_header *ph __maybe_unused,

  			       int fd __maybe_unused, FILE *fp)

  {
  	fprintf(fp, "# contains samples with branch stack
  ");
  }

  static void print_auxtrace(struct perf_header *ph __maybe_unused,
  			   int fd __maybe_unused, FILE *fp)
  {
  	fprintf(fp, "# contains AUX area data (e.g. instruction trace)
  ");
  }

  static void print_stat(struct perf_header *ph __maybe_unused,
  		       int fd __maybe_unused, FILE *fp)
  {
  	fprintf(fp, "# contains stat data
  ");
  }

  static void print_cache(struct perf_header *ph __maybe_unused,
  			int fd __maybe_unused, FILE *fp __maybe_unused)
  {
  	int i;
  
  	fprintf(fp, "# CPU cache info:
  ");
  	for (i = 0; i < ph->env.caches_cnt; i++) {
  		fprintf(fp, "#  ");
  		cpu_cache_level__fprintf(fp, &ph->env.caches[i]);
  	}
  }

  static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
  			       FILE *fp)

  {
  	const char *delimiter = "# pmu mappings: ";

  	char *str, *tmp;

  	u32 pmu_num;
  	u32 type;

  	pmu_num = ph->env.nr_pmu_mappings;

  	if (!pmu_num) {
  		fprintf(fp, "# pmu mappings: not available
  ");
  		return;
  	}

  	str = ph->env.pmu_mappings;

  	while (pmu_num) {

  		type = strtoul(str, &tmp, 0);
  		if (*tmp != ':')
  			goto error;
  
  		str = tmp + 1;
  		fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);

  		delimiter = ", ";

  		str += strlen(str) + 1;
  		pmu_num--;

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

  static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
  			     FILE *fp)
  {
  	struct perf_session *session;
  	struct perf_evsel *evsel;
  	u32 nr = 0;
  
  	session = container_of(ph, struct perf_session, header);

  	evlist__for_each_entry(session->evlist, evsel) {

  		if (perf_evsel__is_group_leader(evsel) &&
  		    evsel->nr_members > 1) {
  			fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
  				perf_evsel__name(evsel));
  
  			nr = evsel->nr_members - 1;
  		} else if (nr) {
  			fprintf(fp, ",%s", perf_evsel__name(evsel));
  
  			if (--nr == 0)
  				fprintf(fp, "}
  ");
  		}
  	}
  }

  static int __event_process_build_id(struct build_id_event *bev,
  				    char *filename,
  				    struct perf_session *session)
  {
  	int err = -1;

  	struct machine *machine;

  	u16 cpumode;

  	struct dso *dso;
  	enum dso_kernel_type dso_type;
  
  	machine = perf_session__findnew_machine(session, bev->pid);
  	if (!machine)
  		goto out;

  	cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;

  	switch (cpumode) {

  	case PERF_RECORD_MISC_KERNEL:
  		dso_type = DSO_TYPE_KERNEL;

  		break;
  	case PERF_RECORD_MISC_GUEST_KERNEL:
  		dso_type = DSO_TYPE_GUEST_KERNEL;

  		break;
  	case PERF_RECORD_MISC_USER:
  	case PERF_RECORD_MISC_GUEST_USER:
  		dso_type = DSO_TYPE_USER;

  		break;
  	default:
  		goto out;
  	}

  	dso = machine__findnew_dso(machine, filename);

  	if (dso != NULL) {

  		char sbuild_id[SBUILD_ID_SIZE];

  
  		dso__set_build_id(dso, &bev->build_id);

  		if (!is_kernel_module(filename, cpumode))

  			dso->kernel = dso_type;
  
  		build_id__sprintf(dso->build_id, sizeof(dso->build_id),
  				  sbuild_id);
  		pr_debug("build id event received for %s: %s
  ",
  			 dso->long_name, sbuild_id);

  		dso__put(dso);

  	}
  
  	err = 0;
  out:
  	return err;
  }
  
  static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
  						 int input, u64 offset, u64 size)
  {
  	struct perf_session *session = container_of(header, struct perf_session, header);
  	struct {
  		struct perf_event_header   header;

  		u8			   build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];

  		char			   filename[0];
  	} old_bev;
  	struct build_id_event bev;
  	char filename[PATH_MAX];
  	u64 limit = offset + size;
  
  	while (offset < limit) {
  		ssize_t len;

  		if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))

  			return -1;
  
  		if (header->needs_swap)
  			perf_event_header__bswap(&old_bev.header);
  
  		len = old_bev.header.size - sizeof(old_bev);

  		if (readn(input, filename, len) != len)

  			return -1;
  
  		bev.header = old_bev.header;
  
  		/*
  		 * As the pid is the missing value, we need to fill
  		 * it properly. The header.misc value give us nice hint.
  		 */
  		bev.pid	= HOST_KERNEL_ID;
  		if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
  		    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
  			bev.pid	= DEFAULT_GUEST_KERNEL_ID;
  
  		memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
  		__event_process_build_id(&bev, filename, session);
  
  		offset += bev.header.size;
  	}
  
  	return 0;
  }
  
  static int perf_header__read_build_ids(struct perf_header *header,
  				       int input, u64 offset, u64 size)
  {
  	struct perf_session *session = container_of(header, struct perf_session, header);
  	struct build_id_event bev;
  	char filename[PATH_MAX];
  	u64 limit = offset + size, orig_offset = offset;
  	int err = -1;
  
  	while (offset < limit) {
  		ssize_t len;

  		if (readn(input, &bev, sizeof(bev)) != sizeof(bev))

  			goto out;
  
  		if (header->needs_swap)
  			perf_event_header__bswap(&bev.header);
  
  		len = bev.header.size - sizeof(bev);

  		if (readn(input, filename, len) != len)

  			goto out;
  		/*
  		 * The a1645ce1 changeset:
  		 *
  		 * "perf: 'perf kvm' tool for monitoring guest performance from host"
  		 *
  		 * Added a field to struct build_id_event that broke the file
  		 * format.
  		 *
  		 * Since the kernel build-id is the first entry, process the
  		 * table using the old format if the well known
  		 * '[kernel.kallsyms]' string for the kernel build-id has the
  		 * first 4 characters chopped off (where the pid_t sits).
  		 */
  		if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
  			if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
  				return -1;
  			return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
  		}
  
  		__event_process_build_id(&bev, filename, session);
  
  		offset += bev.header.size;
  	}
  	err = 0;
  out:
  	return err;
  }

  static int process_tracing_data(struct perf_file_section *section __maybe_unused,
  				struct perf_header *ph __maybe_unused,
  				int fd, void *data)

  {

  	ssize_t ret = trace_report(fd, data, false);
  	return ret < 0 ? -1 : 0;

  }
  
  static int process_build_id(struct perf_file_section *section,

  			    struct perf_header *ph, int fd,

  			    void *data __maybe_unused)

  {
  	if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
  		pr_debug("Failed to read buildids, continuing...
  ");
  	return 0;
  }

  static int process_hostname(struct perf_file_section *section __maybe_unused,

  			    struct perf_header *ph, int fd,
  			    void *data __maybe_unused)

  {
  	ph->env.hostname = do_read_string(fd, ph);
  	return ph->env.hostname ? 0 : -ENOMEM;
  }
  
  static int process_osrelease(struct perf_file_section *section __maybe_unused,

  			     struct perf_header *ph, int fd,
  			     void *data __maybe_unused)

  {
  	ph->env.os_release = do_read_string(fd, ph);
  	return ph->env.os_release ? 0 : -ENOMEM;
  }
  
  static int process_version(struct perf_file_section *section __maybe_unused,

  			   struct perf_header *ph, int fd,
  			   void *data __maybe_unused)

  {
  	ph->env.version = do_read_string(fd, ph);
  	return ph->env.version ? 0 : -ENOMEM;
  }
  
  static int process_arch(struct perf_file_section *section __maybe_unused,

  			struct perf_header *ph,	int fd,
  			void *data __maybe_unused)

  {
  	ph->env.arch = do_read_string(fd, ph);
  	return ph->env.arch ? 0 : -ENOMEM;
  }
  
  static int process_nrcpus(struct perf_file_section *section __maybe_unused,

  			  struct perf_header *ph, int fd,
  			  void *data __maybe_unused)

  {

  	ssize_t ret;

  	u32 nr;

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))
  		return -1;
  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);

  	ph->env.nr_cpus_avail = nr;

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))
  		return -1;
  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);

  	ph->env.nr_cpus_online = nr;

  	return 0;
  }
  
  static int process_cpudesc(struct perf_file_section *section __maybe_unused,

  			   struct perf_header *ph, int fd,
  			   void *data __maybe_unused)

  {
  	ph->env.cpu_desc = do_read_string(fd, ph);
  	return ph->env.cpu_desc ? 0 : -ENOMEM;
  }
  
  static int process_cpuid(struct perf_file_section *section __maybe_unused,

  			 struct perf_header *ph,  int fd,
  			 void *data __maybe_unused)

  {
  	ph->env.cpuid = do_read_string(fd, ph);
  	return ph->env.cpuid ? 0 : -ENOMEM;
  }
  
  static int process_total_mem(struct perf_file_section *section __maybe_unused,

  			     struct perf_header *ph, int fd,
  			     void *data __maybe_unused)

  {
  	uint64_t mem;

  	ssize_t ret;

  	ret = readn(fd, &mem, sizeof(mem));

  	if (ret != sizeof(mem))
  		return -1;
  
  	if (ph->needs_swap)
  		mem = bswap_64(mem);
  
  	ph->env.total_mem = mem;
  	return 0;
  }

  static struct perf_evsel *
  perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
  {
  	struct perf_evsel *evsel;

  	evlist__for_each_entry(evlist, evsel) {

  		if (evsel->idx == idx)
  			return evsel;
  	}
  
  	return NULL;
  }
  
  static void

  perf_evlist__set_event_name(struct perf_evlist *evlist,
  			    struct perf_evsel *event)

  {
  	struct perf_evsel *evsel;
  
  	if (!event->name)
  		return;
  
  	evsel = perf_evlist__find_by_index(evlist, event->idx);
  	if (!evsel)
  		return;
  
  	if (evsel->name)
  		return;
  
  	evsel->name = strdup(event->name);
  }
  
  static int

  process_event_desc(struct perf_file_section *section __maybe_unused,

  		   struct perf_header *header, int fd,

  		   void *data __maybe_unused)

  {

  	struct perf_session *session;

  	struct perf_evsel *evsel, *events = read_event_desc(header, fd);
  
  	if (!events)
  		return 0;

  	session = container_of(header, struct perf_session, header);

  	for (evsel = events; evsel->attr.size; evsel++)
  		perf_evlist__set_event_name(session->evlist, evsel);
  
  	free_event_desc(events);
  
  	return 0;
  }

  static int process_cmdline(struct perf_file_section *section,

  			   struct perf_header *ph, int fd,
  			   void *data __maybe_unused)

  {

  	ssize_t ret;

  	char *str, *cmdline = NULL, **argv = NULL;
  	u32 nr, i, len = 0;

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))
  		return -1;
  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);
  
  	ph->env.nr_cmdline = nr;

  
  	cmdline = zalloc(section->size + nr + 1);
  	if (!cmdline)
  		return -1;
  
  	argv = zalloc(sizeof(char *) * (nr + 1));
  	if (!argv)
  		goto error;

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

  		argv[i] = cmdline + len;
  		memcpy(argv[i], str, strlen(str) + 1);
  		len += strlen(str) + 1;

  		free(str);
  	}

  	ph->env.cmdline = cmdline;
  	ph->env.cmdline_argv = (const char **) argv;

  	return 0;
  
  error:

  	free(argv);
  	free(cmdline);

  	return -1;
  }

  static int process_cpu_topology(struct perf_file_section *section,

  				struct perf_header *ph, int fd,
  				void *data __maybe_unused)

  {

  	ssize_t ret;

  	u32 nr, i;
  	char *str;
  	struct strbuf sb;

  	int cpu_nr = ph->env.nr_cpus_avail;

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

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))

  		goto free_cpu;

  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);
  
  	ph->env.nr_sibling_cores = nr;

  	size += sizeof(u32);

  	if (strbuf_init(&sb, 128) < 0)
  		goto free_cpu;

  
  	for (i = 0; i < nr; i++) {
  		str = do_read_string(fd, ph);
  		if (!str)
  			goto error;
  
  		/* include a NULL character at the end */

  		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
  			goto error;

  		size += string_size(str);

  		free(str);
  	}
  	ph->env.sibling_cores = strbuf_detach(&sb, NULL);

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))
  		return -1;
  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);
  
  	ph->env.nr_sibling_threads = nr;

  	size += sizeof(u32);

  
  	for (i = 0; i < nr; i++) {
  		str = do_read_string(fd, ph);
  		if (!str)
  			goto error;
  
  		/* include a NULL character at the end */

  		if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
  			goto error;

  		size += string_size(str);

  		free(str);
  	}
  	ph->env.sibling_threads = strbuf_detach(&sb, NULL);

  
  	/*
  	 * The header may be from old perf,
  	 * which doesn't include core id and socket id information.
  	 */
  	if (section->size <= size) {
  		zfree(&ph->env.cpu);
  		return 0;
  	}
  
  	for (i = 0; i < (u32)cpu_nr; i++) {
  		ret = readn(fd, &nr, sizeof(nr));
  		if (ret != sizeof(nr))
  			goto free_cpu;
  
  		if (ph->needs_swap)
  			nr = bswap_32(nr);

  		ph->env.cpu[i].core_id = nr;
  
  		ret = readn(fd, &nr, sizeof(nr));
  		if (ret != sizeof(nr))
  			goto free_cpu;
  
  		if (ph->needs_swap)
  			nr = bswap_32(nr);

  		if (nr != (u32)-1 && nr > (u32)cpu_nr) {

  			pr_debug("socket_id number is too big."
  				 "You may need to upgrade the perf tool.
  ");
  			goto free_cpu;
  		}
  
  		ph->env.cpu[i].socket_id = nr;
  	}

  	return 0;
  
  error:
  	strbuf_release(&sb);

  free_cpu:
  	zfree(&ph->env.cpu);

  	return -1;
  }
  
  static int process_numa_topology(struct perf_file_section *section __maybe_unused,

  				 struct perf_header *ph, int fd,
  				 void *data __maybe_unused)

  {

  	struct numa_node *nodes, *n;

  	ssize_t ret;

  	u32 nr, i;

  	char *str;

  
  	/* nr nodes */

  	ret = readn(fd, &nr, sizeof(nr));

  	if (ret != sizeof(nr))

  		return -1;

  
  	if (ph->needs_swap)
  		nr = bswap_32(nr);

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

  
  	for (i = 0; i < nr; i++) {

  		n = &nodes[i];

  		/* node number */

  		ret = readn(fd, &n->node, sizeof(u32));
  		if (ret != sizeof(n->node))

  			goto error;

  		ret = readn(fd, &n->mem_total, sizeof(u64));

  		if (ret != sizeof(u64))
  			goto error;

  		ret = readn(fd, &n->mem_free, sizeof(u64));

  		if (ret != sizeof(u64))
  			goto error;
  
  		if (ph->needs_swap) {

  			n->node      = bswap_32(n->node);
  			n->mem_total = bswap_64(n->mem_total);
  			n->mem_free  = bswap_64(n->mem_free);

  		}

  		str = do_read_string(fd, ph);
  		if (!str)
  			goto error;

  		n->map = cpu_map__new(str);
  		if (!n->map)

  			goto error;

  		free(str);
  	}

  	ph->env.nr_numa_nodes = nr;

  	ph->env.numa_nodes = nodes;

  	return 0;
  
  error:

  	free(nodes);

  	return -1;
  }
  
  static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,

  				struct perf_header *ph, int fd,
  				void *data __maybe_unused)

  {

  	ssize_t ret;

  	char *name;
  	u32 pmu_num;
  	u32 type;
  	struct strbuf sb;

  	ret = readn(fd, &pmu_num, sizeof(pmu_num));

  	if (ret != sizeof(pmu_num))
  		return -1;
  
  	if (ph->needs_swap)
  		pmu_num = bswap_32(pmu_num);
  
  	if (!pmu_num) {
  		pr_debug("pmu mappings not available
  ");
  		return 0;
  	}
  
  	ph->env.nr_pmu_mappings = pmu_num;

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

  
  	while (pmu_num) {

  		if (readn(fd, &type, sizeof(type)) != sizeof(type))

  			goto error;
  		if (ph->needs_swap)
  			type = bswap_32(type);
  
  		name = do_read_string(fd, ph);
  		if (!name)
  			goto error;

  		if (strbuf_addf(&sb, "%u:%s", type, name) < 0)
  			goto error;

  		/* include a NULL character at the end */

  		if (strbuf_add(&sb, "", 1) < 0)
  			goto error;

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

  		free(name);
  		pmu_num--;
  	}
  	ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
  	return 0;
  
  error:
  	strbuf_release(&sb);
  	return -1;
  }

  static int process_group_desc(struct perf_file_section *section __maybe_unused,
  			      struct perf_header *ph, int fd,
  			      void *data __maybe_unused)
  {
  	size_t ret = -1;
  	u32 i, nr, nr_groups;
  	struct perf_session *session;
  	struct perf_evsel *evsel, *leader = NULL;
  	struct group_desc {
  		char *name;
  		u32 leader_idx;
  		u32 nr_members;
  	} *desc;
  
  	if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
  		return -1;
  
  	if (ph->needs_swap)
  		nr_groups = bswap_32(nr_groups);
  
  	ph->env.nr_groups = nr_groups;
  	if (!nr_groups) {
  		pr_debug("group desc not available
  ");
  		return 0;
  	}
  
  	desc = calloc(nr_groups, sizeof(*desc));
  	if (!desc)
  		return -1;
  
  	for (i = 0; i < nr_groups; i++) {
  		desc[i].name = do_read_string(fd, ph);
  		if (!desc[i].name)
  			goto out_free;
  
  		if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
  			goto out_free;
  
  		if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
  			goto out_free;
  
  		if (ph->needs_swap) {
  			desc[i].leader_idx = bswap_32(desc[i].leader_idx);
  			desc[i].nr_members = bswap_32(desc[i].nr_members);
  		}
  	}
  
  	/*
  	 * Rebuild group relationship based on the group_desc
  	 */
  	session = container_of(ph, struct perf_session, header);
  	session->evlist->nr_groups = nr_groups;
  
  	i = nr = 0;

  	evlist__for_each_entry(session->evlist, evsel) {

  		if (evsel->idx == (int) desc[i].leader_idx) {
  			evsel->leader = evsel;
  			/* {anon_group} is a dummy name */

  			if (strcmp(desc[i].name, "{anon_group}")) {

  				evsel->group_name = desc[i].name;

  				desc[i].name = NULL;
  			}

  			evsel->nr_members = desc[i].nr_members;
  
  			if (i >= nr_groups || nr > 0) {
  				pr_debug("invalid group desc
  ");
  				goto out_free;
  			}
  
  			leader = evsel;
  			nr = evsel->nr_members - 1;
  			i++;
  		} else if (nr) {
  			/* This is a group member */
  			evsel->leader = leader;
  
  			nr--;
  		}
  	}
  
  	if (i != nr_groups || nr != 0) {
  		pr_debug("invalid group desc
  ");
  		goto out_free;
  	}
  
  	ret = 0;
  out_free:

  	for (i = 0; i < nr_groups; i++)

  		zfree(&desc[i].name);

  	free(desc);
  
  	return ret;
  }

  static int process_auxtrace(struct perf_file_section *section,
  			    struct perf_header *ph, int fd,
  			    void *data __maybe_unused)
  {
  	struct perf_session *session;
  	int err;
  
  	session = container_of(ph, struct perf_session, header);
  
  	err = auxtrace_index__process(fd, section->size, session,
  				      ph->needs_swap);
  	if (err < 0)
  		pr_err("Failed to process auxtrace index
  ");
  	return err;
  }

  static int process_cache(struct perf_file_section *section __maybe_unused,
  			 struct perf_header *ph __maybe_unused, int fd __maybe_unused,
  			 void *data __maybe_unused)
  {
  	struct cpu_cache_level *caches;
  	u32 cnt, i, version;
  
  	if (readn(fd, &version, sizeof(version)) != sizeof(version))
  		return -1;
  
  	if (ph->needs_swap)
  		version = bswap_32(version);
  
  	if (version != 1)
  		return -1;
  
  	if (readn(fd, &cnt, sizeof(cnt)) != sizeof(cnt))
  		return -1;
  
  	if (ph->needs_swap)
  		cnt = bswap_32(cnt);
  
  	caches = zalloc(sizeof(*caches) * cnt);
  	if (!caches)
  		return -1;
  
  	for (i = 0; i < cnt; i++) {
  		struct cpu_cache_level c;
  
  		#define _R(v)						\
  			if (readn(fd, &c.v, sizeof(u32)) != sizeof(u32))\
  				goto out_free_caches;			\
  			if (ph->needs_swap)				\
  				c.v = bswap_32(c.v);			\
  
  		_R(level)
  		_R(line_size)
  		_R(sets)
  		_R(ways)
  		#undef _R
  
  		#define _R(v)				\
  			c.v = do_read_string(fd, ph);	\
  			if (!c.v)			\
  				goto out_free_caches;
  
  		_R(type)
  		_R(size)
  		_R(map)
  		#undef _R
  
  		caches[i] = c;
  	}
  
  	ph->env.caches = caches;
  	ph->env.caches_cnt = cnt;
  	return 0;
  out_free_caches:
  	free(caches);
  	return -1;
  }

  struct feature_ops {
  	int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
  	void (*print)(struct perf_header *h, int fd, FILE *fp);

  	int (*process)(struct perf_file_section *section,

  		       struct perf_header *h, int fd, void *data);

  	const char *name;
  	bool full_only;
  };

  #define FEAT_OPA(n, func) \
  	[n] = { .name = #n, .write = write_##func, .print = print_##func }

  #define FEAT_OPP(n, func) \
  	[n] = { .name = #n, .write = write_##func, .print = print_##func, \
  		.process = process_##func }

  #define FEAT_OPF(n, func) \

  	[n] = { .name = #n, .write = write_##func, .print = print_##func, \

  		.process = process_##func, .full_only = true }

  
  /* feature_ops not implemented: */

  #define print_tracing_data	NULL
  #define print_build_id		NULL

  
  static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {

  	FEAT_OPP(HEADER_TRACING_DATA,	tracing_data),

  	FEAT_OPP(HEADER_BUILD_ID,	build_id),

  	FEAT_OPP(HEADER_HOSTNAME,	hostname),
  	FEAT_OPP(HEADER_OSRELEASE,	osrelease),
  	FEAT_OPP(HEADER_VERSION,	version),
  	FEAT_OPP(HEADER_ARCH,		arch),
  	FEAT_OPP(HEADER_NRCPUS,		nrcpus),
  	FEAT_OPP(HEADER_CPUDESC,	cpudesc),

  	FEAT_OPP(HEADER_CPUID,		cpuid),

  	FEAT_OPP(HEADER_TOTAL_MEM,	total_mem),

  	FEAT_OPP(HEADER_EVENT_DESC,	event_desc),

  	FEAT_OPP(HEADER_CMDLINE,	cmdline),

  	FEAT_OPF(HEADER_CPU_TOPOLOGY,	cpu_topology),
  	FEAT_OPF(HEADER_NUMA_TOPOLOGY,	numa_topology),

  	FEAT_OPA(HEADER_BRANCH_STACK,	branch_stack),

  	FEAT_OPP(HEADER_PMU_MAPPINGS,	pmu_mappings),

  	FEAT_OPP(HEADER_GROUP_DESC,	group_desc),

  	FEAT_OPP(HEADER_AUXTRACE,	auxtrace),

  	FEAT_OPA(HEADER_STAT,		stat),

  	FEAT_OPF(HEADER_CACHE,		cache),

  };
  
  struct header_print_data {
  	FILE *fp;
  	bool full; /* extended list of headers */
  };
  
  static int perf_file_section__fprintf_info(struct perf_file_section *section,
  					   struct perf_header *ph,
  					   int feat, int fd, void *data)
  {
  	struct header_print_data *hd = data;
  
  	if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
  		pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
  				"%d, continuing...
  ", section->offset, feat);
  		return 0;
  	}

  	if (feat >= HEADER_LAST_FEATURE) {

  		pr_warning("unknown feature %d
  ", feat);

  		return 0;

  	}
  	if (!feat_ops[feat].print)
  		return 0;
  
  	if (!feat_ops[feat].full_only || hd->full)
  		feat_ops[feat].print(ph, fd, hd->fp);
  	else
  		fprintf(hd->fp, "# %s info available, use -I to display
  ",
  			feat_ops[feat].name);
  
  	return 0;
  }
  
  int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
  {
  	struct header_print_data hd;
  	struct perf_header *header = &session->header;

  	int fd = perf_data_file__fd(session->file);

  	struct stat st;

  	int ret, bit;

  	hd.fp = fp;
  	hd.full = full;

  	ret = fstat(fd, &st);
  	if (ret == -1)
  		return -1;
  
  	fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));

  	perf_header__process_sections(header, fd, &hd,
  				      perf_file_section__fprintf_info);

  	if (session->file->is_pipe)
  		return 0;

  	fprintf(fp, "# missing features: ");
  	for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) {
  		if (bit)
  			fprintf(fp, "%s ", feat_ops[bit].name);
  	}
  
  	fprintf(fp, "
  ");

  	return 0;
  }

  static int do_write_feat(int fd, struct perf_header *h, int type,
  			 struct perf_file_section **p,
  			 struct perf_evlist *evlist)
  {
  	int err;
  	int ret = 0;
  
  	if (perf_header__has_feat(h, type)) {

  		if (!feat_ops[type].write)
  			return -1;

  
  		(*p)->offset = lseek(fd, 0, SEEK_CUR);
  
  		err = feat_ops[type].write(fd, h, evlist);
  		if (err < 0) {

  			pr_debug("failed to write feature %s
  ", feat_ops[type].name);

  
  			/* undo anything written */
  			lseek(fd, (*p)->offset, SEEK_SET);
  
  			return -1;
  		}
  		(*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
  		(*p)++;
  	}
  	return ret;
  }

  static int perf_header__adds_write(struct perf_header *header,

  				   struct perf_evlist *evlist, int fd)

  {

  	int nr_sections;

  	struct perf_file_section *feat_sec, *p;

  	int sec_size;
  	u64 sec_start;

  	int feat;

  	int err;

  	nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);

  	if (!nr_sections)

  		return 0;

  	feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));

  	if (feat_sec == NULL)
  		return -ENOMEM;

  
  	sec_size = sizeof(*feat_sec) * nr_sections;

  	sec_start = header->feat_offset;

  	lseek(fd, sec_start + sec_size, SEEK_SET);

  	for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
  		if (do_write_feat(fd, header, feat, &p, evlist))
  			perf_header__clear_feat(header, feat);
  	}

  	lseek(fd, sec_start, SEEK_SET);

  	/*
  	 * may write more than needed due to dropped feature, but
  	 * this is okay, reader will skip the mising entries
  	 */

  	err = do_write(fd, feat_sec, sec_size);
  	if (err < 0)
  		pr_debug("failed to write feature section
  ");

  	free(feat_sec);

  	return err;

  }

  int perf_header__write_pipe(int fd)
  {
  	struct perf_pipe_file_header f_header;
  	int err;
  
  	f_header = (struct perf_pipe_file_header){
  		.magic	   = PERF_MAGIC,
  		.size	   = sizeof(f_header),
  	};
  
  	err = do_write(fd, &f_header, sizeof(f_header));
  	if (err < 0) {
  		pr_debug("failed to write perf pipe header
  ");
  		return err;
  	}
  
  	return 0;
  }

  int perf_session__write_header(struct perf_session *session,
  			       struct perf_evlist *evlist,
  			       int fd, bool at_exit)

  {
  	struct perf_file_header f_header;
  	struct perf_file_attr   f_attr;

  	struct perf_header *header = &session->header;

  	struct perf_evsel *evsel;

  	u64 attr_offset;

  	int err;

  
  	lseek(fd, sizeof(f_header), SEEK_SET);

  	evlist__for_each_entry(session->evlist, evsel) {

  		evsel->id_offset = lseek(fd, 0, SEEK_CUR);
  		err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));

  		if (err < 0) {
  			pr_debug("failed to write perf header
  ");
  			return err;
  		}

  	}

  	attr_offset = lseek(fd, 0, SEEK_CUR);

  	evlist__for_each_entry(evlist, evsel) {

  		f_attr = (struct perf_file_attr){

  			.attr = evsel->attr,

  			.ids  = {

  				.offset = evsel->id_offset,
  				.size   = evsel->ids * sizeof(u64),

  			}
  		};

  		err = do_write(fd, &f_attr, sizeof(f_attr));
  		if (err < 0) {
  			pr_debug("failed to write perf header attribute
  ");
  			return err;
  		}

  	}

  	if (!header->data_offset)
  		header->data_offset = lseek(fd, 0, SEEK_CUR);

  	header->feat_offset = header->data_offset + header->data_size;

  	if (at_exit) {

  		err = perf_header__adds_write(header, evlist, fd);

  		if (err < 0)
  			return err;
  	}

  	f_header = (struct perf_file_header){
  		.magic	   = PERF_MAGIC,
  		.size	   = sizeof(f_header),
  		.attr_size = sizeof(f_attr),
  		.attrs = {

  			.offset = attr_offset,

  			.size   = evlist->nr_entries * sizeof(f_attr),

  		},
  		.data = {

  			.offset = header->data_offset,
  			.size	= header->data_size,

  		},

  		/* event_types is ignored, store zeros */

  	};

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

  	lseek(fd, 0, SEEK_SET);