[GitHub/moto-9609/android_kernel_motorola_exynos9610.git] / tools / perf / util / header.c

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/list.h>

#include "util.h"
#include "header.h"
#include "../perf.h"
#include "trace-event.h"
#include "symbol.h"
#include "data_map.h"
#include "debug.h"

/*
 * Create new perf.data header attribute:
 */
struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
{
	struct perf_header_attr *self = malloc(sizeof(*self));

	if (self != NULL) {
		self->attr = *attr;
		self->ids  = 0;
		self->size = 1;
		self->id   = malloc(sizeof(u64));
		if (self->id == NULL) {
			free(self);
			self = NULL;
		}
	}

	return self;
}

void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
{
	int pos = self->ids;

	self->ids++;
	if (self->ids > self->size) {
		self->size *= 2;
		self->id = realloc(self->id, self->size * sizeof(u64));
		if (!self->id)
			die("nomem");
	}
	self->id[pos] = id;
}

/*
 * Create new perf.data header:
 */
struct perf_header *perf_header__new(void)
{
	struct perf_header *self = calloc(sizeof(*self), 1);

	if (!self)
		die("nomem");

	self->size = 1;
	self->attr = malloc(sizeof(void *));

	if (!self->attr)
		die("nomem");

	return self;
}

void perf_header__add_attr(struct perf_header *self,
			   struct perf_header_attr *attr)
{
	int pos = self->attrs;

	if (self->frozen)
		die("frozen");

	self->attrs++;
	if (self->attrs > self->size) {
		self->size *= 2;
		self->attr = realloc(self->attr, self->size * sizeof(void *));
		if (!self->attr)
			die("nomem");
	}
	self->attr[pos] = attr;
}

#define MAX_EVENT_NAME 64

struct perf_trace_event_type {
	u64	event_id;
	char	name[MAX_EVENT_NAME];
};

static int event_count;
static struct perf_trace_event_type *events;

void perf_header__push_event(u64 id, const char *name)
{
	if (strlen(name) > MAX_EVENT_NAME)
		pr_warning("Event %s will be truncated\n", name);

	if (!events) {
		events = malloc(sizeof(struct perf_trace_event_type));
		if (!events)
			die("nomem");
	} else {
		events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
		if (!events)
			die("nomem");
	}
	memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
	events[event_count].event_id = id;
	strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
	event_count++;
}

char *perf_header__find_event(u64 id)
{
	int i;
	for (i = 0 ; i < event_count; i++) {
		if (events[i].event_id == id)
			return events[i].name;
	}
	return NULL;
}

static const char *__perf_magic = "PERFFILE";

#define PERF_MAGIC	(*(u64 *)__perf_magic)

struct perf_file_attr {
	struct perf_event_attr	attr;
	struct perf_file_section	ids;
};

void perf_header__set_feat(struct perf_header *self, int feat)
{
	set_bit(feat, self->adds_features);
}

bool perf_header__has_feat(const struct perf_header *self, int feat)
{
	return test_bit(feat, self->adds_features);
}

static void do_write(int fd, void *buf, size_t size)
{
	while (size) {
		int ret = write(fd, buf, size);

		if (ret < 0)
			die("failed to write");

		size -= ret;
		buf += ret;
	}
}

static void write_buildid_table(int fd, struct list_head *id_head)
{
	struct build_id_list *iter, *next;

	list_for_each_entry_safe(iter, next, id_head, list) {
		struct build_id_event *b = &iter->event;

		do_write(fd, b, sizeof(*b));
		do_write(fd, (void *)iter->dso_name, iter->len);
		list_del(&iter->list);
		free(iter);
	}
}

static void
perf_header__adds_write(struct perf_header *self, int fd)
{
	LIST_HEAD(id_list);
	int nr_sections;
	struct perf_file_section *feat_sec;
	int sec_size;
	u64 sec_start;
	int idx = 0;

	if (fetch_build_id_table(&id_list))
		perf_header__set_feat(self, HEADER_BUILD_ID);

	nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
	if (!nr_sections)
		return;

	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
	if (!feat_sec)
		die("No memory");

	sec_size = sizeof(*feat_sec) * nr_sections;

	sec_start = self->data_offset + self->data_size;
	lseek(fd, sec_start + sec_size, SEEK_SET);

	if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
		struct perf_file_section *trace_sec;

		trace_sec = &feat_sec[idx++];

		/* Write trace info */
		trace_sec->offset = lseek(fd, 0, SEEK_CUR);
		read_tracing_data(fd, attrs, nr_counters);
		trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
	}


	if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
		struct perf_file_section *buildid_sec;

		buildid_sec = &feat_sec[idx++];

		/* Write build-ids */
		buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
		write_buildid_table(fd, &id_list);
		buildid_sec->size = lseek(fd, 0, SEEK_CUR) - buildid_sec->offset;
	}

	lseek(fd, sec_start, SEEK_SET);
	do_write(fd, feat_sec, sec_size);
	free(feat_sec);
}

void perf_header__write(struct perf_header *self, int fd, bool at_exit)
{
	struct perf_file_header f_header;
	struct perf_file_attr   f_attr;
	struct perf_header_attr	*attr;
	int i;

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


	for (i = 0; i < self->attrs; i++) {
		attr = self->attr[i];

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


	self->attr_offset = lseek(fd, 0, SEEK_CUR);

	for (i = 0; i < self->attrs; i++) {
		attr = self->attr[i];

		f_attr = (struct perf_file_attr){
			.attr = attr->attr,
			.ids  = {
				.offset = attr->id_offset,
				.size   = attr->ids * sizeof(u64),
			}
		};
		do_write(fd, &f_attr, sizeof(f_attr));
	}

	self->event_offset = lseek(fd, 0, SEEK_CUR);
	self->event_size = event_count * sizeof(struct perf_trace_event_type);
	if (events)
		do_write(fd, events, self->event_size);

	self->data_offset = lseek(fd, 0, SEEK_CUR);

	if (at_exit)
		perf_header__adds_write(self, fd);

	f_header = (struct perf_file_header){
		.magic	   = PERF_MAGIC,
		.size	   = sizeof(f_header),
		.attr_size = sizeof(f_attr),
		.attrs = {
			.offset = self->attr_offset,
			.size   = self->attrs * sizeof(f_attr),
		},
		.data = {
			.offset = self->data_offset,
			.size	= self->data_size,
		},
		.event_types = {
			.offset = self->event_offset,
			.size	= self->event_size,
		},
	};

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

	lseek(fd, 0, SEEK_SET);
	do_write(fd, &f_header, sizeof(f_header));
	lseek(fd, self->data_offset + self->data_size, SEEK_SET);

	self->frozen = 1;
}

static void do_read(int fd, void *buf, size_t size)
{
	while (size) {
		int ret = read(fd, buf, size);

		if (ret < 0)
			die("failed to read");
		if (ret == 0)
			die("failed to read: missing data");

		size -= ret;
		buf += ret;
	}
}

int perf_header__process_sections(struct perf_header *self, int fd,
				  int (*process)(struct perf_file_section *self,
						 int feat, int fd))
{
	struct perf_file_section *feat_sec;
	int nr_sections;
	int sec_size;
	int idx = 0;
	int err = 0, feat = 1;

	nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
	if (!nr_sections)
		return 0;

	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
	if (!feat_sec)
		return -1;

	sec_size = sizeof(*feat_sec) * nr_sections;

	lseek(fd, self->data_offset + self->data_size, SEEK_SET);

	do_read(fd, feat_sec, sec_size);

	while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
		if (perf_header__has_feat(self, feat)) {
			struct perf_file_section *sec = &feat_sec[idx++];

			err = process(sec, feat, fd);
			if (err < 0)
				break;
		}
		++feat;
	}

	free(feat_sec);
	return err;
};

int perf_file_header__read(struct perf_file_header *self,
			   struct perf_header *ph, int fd)
{
	lseek(fd, 0, SEEK_SET);
	do_read(fd, self, sizeof(*self));

	if (self->magic     != PERF_MAGIC ||
	    self->attr_size != sizeof(struct perf_file_attr))
		return -1;

	if (self->size != sizeof(*self)) {
		/* Support the previous format */
		if (self->size == offsetof(typeof(*self), adds_features))
			bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
		else
			return -1;
	}

	memcpy(&ph->adds_features, &self->adds_features,
	       sizeof(self->adds_features));

	ph->event_offset = self->event_types.offset;
	ph->event_size	 = self->event_types.size;
	ph->data_offset	 = self->data.offset;
	ph->data_size	 = self->data.size;
	return 0;
}

static int perf_file_section__process(struct perf_file_section *self,
				      int feat, int fd)
{
	if (lseek(fd, self->offset, SEEK_SET) < 0) {
		pr_debug("Failed to lseek to %Ld offset for feature %d, "
			 "continuing...\n", self->offset, feat);
		return 0;
	}

	switch (feat) {
	case HEADER_TRACE_INFO:
		trace_report(fd);
		break;

	case HEADER_BUILD_ID:
		if (perf_header__read_build_ids(fd, self->offset, self->size))
			pr_debug("Failed to read buildids, continuing...\n");
		break;
	default:
		pr_debug("unknown feature %d, continuing...\n", feat);
	}

	return 0;
}

struct perf_header *perf_header__read(int fd)
{
	struct perf_header	*self = perf_header__new();
	struct perf_file_header f_header;
	struct perf_file_attr	f_attr;
	u64			f_id;
	int nr_attrs, nr_ids, i, j;

	if (perf_file_header__read(&f_header, self, fd) < 0)
		die("incompatible file format");

	nr_attrs = f_header.attrs.size / sizeof(f_attr);
	lseek(fd, f_header.attrs.offset, SEEK_SET);

	for (i = 0; i < nr_attrs; i++) {
		struct perf_header_attr *attr;
		off_t tmp;

		do_read(fd, &f_attr, sizeof(f_attr));
		tmp = lseek(fd, 0, SEEK_CUR);

		attr = perf_header_attr__new(&f_attr.attr);
		if (attr == NULL)
			 die("nomem");

		nr_ids = f_attr.ids.size / sizeof(u64);
		lseek(fd, f_attr.ids.offset, SEEK_SET);

		for (j = 0; j < nr_ids; j++) {
			do_read(fd, &f_id, sizeof(f_id));

			perf_header_attr__add_id(attr, f_id);
		}
		perf_header__add_attr(self, attr);
		lseek(fd, tmp, SEEK_SET);
	}

	if (f_header.event_types.size) {
		lseek(fd, f_header.event_types.offset, SEEK_SET);
		events = malloc(f_header.event_types.size);
		if (!events)
			die("nomem");
		do_read(fd, events, f_header.event_types.size);
		event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
	}

	perf_header__process_sections(self, fd, perf_file_section__process);

	lseek(fd, self->data_offset, SEEK_SET);

	self->frozen = 1;

	return self;
}

u64 perf_header__sample_type(struct perf_header *header)
{
	u64 type = 0;
	int i;

	for (i = 0; i < header->attrs; i++) {
		struct perf_header_attr *attr = header->attr[i];

		if (!type)
			type = attr->attr.sample_type;
		else if (type != attr->attr.sample_type)
			die("non matching sample_type");
	}

	return type;
}

struct perf_event_attr *
perf_header__find_attr(u64 id, struct perf_header *header)
{
	int i;

	for (i = 0; i < header->attrs; i++) {
		struct perf_header_attr *attr = header->attr[i];
		int j;

		for (j = 0; j < attr->ids; j++) {
			if (attr->id[j] == id)
				return &attr->attr;
		}
	}

	return NULL;
}
Commit	Line	Data
7c6a1c65 PZ	1	#include <sys/types.h>
	2	#include <unistd.h>
	3	#include <stdio.h>
	4	#include <stdlib.h>
8671dab9	5	#include <linux/list.h>
7c6a1c65 PZ	6
	7	#include "util.h"
	8	#include "header.h"
03456a15 FW	9	#include "../perf.h"
03456a15 FW	10	#include "trace-event.h"
8671dab9	11	#include "symbol.h"
4778d2e4 FW	12	#include "data_map.h"
4778d2e4 FW	13	#include "debug.h"
7c6a1c65 PZ	14
7c6a1c65 PZ	15	/*
ec60a3fe	16	* Create new perf.data header attribute:
7c6a1c65	17	*/
cdd6c482	18	struct perf_header_attr perf_header_attr__new(struct perf_event_attr attr)
7c6a1c65 PZ	19	{
	20	struct perf_header_attr self = malloc(sizeof(self));
	21
dc79c0fc ACM	22	if (self != NULL) {
	23	self->attr = *attr;
	24	self->ids = 0;
	25	self->size = 1;
	26	self->id = malloc(sizeof(u64));
	27	if (self->id == NULL) {
	28	free(self);
	29	self = NULL;
	30	}
	31	}
7c6a1c65 PZ	32
	33	return self;
	34	}
	35
	36	void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
	37	{
	38	int pos = self->ids;
	39
	40	self->ids++;
	41	if (self->ids > self->size) {
	42	self->size *= 2;
	43	self->id = realloc(self->id, self->size * sizeof(u64));
	44	if (!self->id)
	45	die("nomem");
	46	}
	47	self->id[pos] = id;
	48	}
	49
	50	/*
ec60a3fe	51	* Create new perf.data header:
7c6a1c65	52	*/
7c6a1c65 PZ	53	struct perf_header *perf_header__new(void)
7c6a1c65 PZ	54	{
2ba08250	55	struct perf_header self = calloc(sizeof(self), 1);
7c6a1c65 PZ	56
	57	if (!self)
	58	die("nomem");
	59
7c6a1c65 PZ	60	self->size = 1;
	61	self->attr = malloc(sizeof(void *));
	62
	63	if (!self->attr)
	64	die("nomem");
	65
7c6a1c65 PZ	66	return self;
	67	}
	68
	69	void perf_header__add_attr(struct perf_header *self,
	70	struct perf_header_attr *attr)
	71	{
	72	int pos = self->attrs;
	73
	74	if (self->frozen)
	75	die("frozen");
	76
	77	self->attrs++;
	78	if (self->attrs > self->size) {
	79	self->size *= 2;
	80	self->attr = realloc(self->attr, self->size * sizeof(void *));
	81	if (!self->attr)
	82	die("nomem");
	83	}
	84	self->attr[pos] = attr;
	85	}
	86
ec60a3fe AV	87	#define MAX_EVENT_NAME 64
ec60a3fe AV	88
8755a8f2 AV	89	struct perf_trace_event_type {
8755a8f2 AV	90	u64 event_id;
ec60a3fe	91	char name[MAX_EVENT_NAME];
8755a8f2 AV	92	};
	93
	94	static int event_count;
	95	static struct perf_trace_event_type *events;
	96
	97	void perf_header__push_event(u64 id, const char *name)
	98	{
ec60a3fe	99	if (strlen(name) > MAX_EVENT_NAME)
6beba7ad	100	pr_warning("Event %s will be truncated\n", name);
8755a8f2 AV	101
	102	if (!events) {
	103	events = malloc(sizeof(struct perf_trace_event_type));
	104	if (!events)
	105	die("nomem");
	106	} else {
	107	events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
	108	if (!events)
	109	die("nomem");
	110	}
	111	memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
	112	events[event_count].event_id = id;
ec60a3fe	113	strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
8755a8f2 AV	114	event_count++;
	115	}
	116
	117	char *perf_header__find_event(u64 id)
	118	{
	119	int i;
	120	for (i = 0 ; i < event_count; i++) {
	121	if (events[i].event_id == id)
	122	return events[i].name;
	123	}
	124	return NULL;
	125	}
	126
7c6a1c65 PZ	127	static const char *__perf_magic = "PERFFILE";
	128
	129	#define PERF_MAGIC ((u64 )__perf_magic)
	130
7c6a1c65	131	struct perf_file_attr {
cdd6c482	132	struct perf_event_attr attr;
7c6a1c65 PZ	133	struct perf_file_section ids;
	134	};
	135
8d06367f ACM	136	void perf_header__set_feat(struct perf_header *self, int feat)
	137	{
	138	set_bit(feat, self->adds_features);
	139	}
	140
	141	bool perf_header__has_feat(const struct perf_header *self, int feat)
	142	{
	143	return test_bit(feat, self->adds_features);
	144	}
	145
7c6a1c65 PZ	146	static void do_write(int fd, void *buf, size_t size)
	147	{
	148	while (size) {
	149	int ret = write(fd, buf, size);
	150
	151	if (ret < 0)
	152	die("failed to write");
	153
	154	size -= ret;
	155	buf += ret;
	156	}
	157	}
	158
57f395a7	159	static void write_buildid_table(int fd, struct list_head *id_head)
8671dab9	160	{
57f395a7 FW	161	struct build_id_list iter, next;
	162
	163	list_for_each_entry_safe(iter, next, id_head, list) {
	164	struct build_id_event *b = &iter->event;
8671dab9	165
57f395a7 FW	166	do_write(fd, b, sizeof(*b));
	167	do_write(fd, (void *)iter->dso_name, iter->len);
	168	list_del(&iter->list);
	169	free(iter);
	170	}
8671dab9 FW	171	}
	172
	173	static void
9e827dd0	174	perf_header__adds_write(struct perf_header *self, int fd)
2ba08250	175	{
9e827dd0 FW	176	LIST_HEAD(id_list);
	177	int nr_sections;
	178	struct perf_file_section *feat_sec;
	179	int sec_size;
	180	u64 sec_start;
	181	int idx = 0;
	182
	183	if (fetch_build_id_table(&id_list))
	184	perf_header__set_feat(self, HEADER_BUILD_ID);
	185
	186	nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
	187	if (!nr_sections)
	188	return;
	189
	190	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
	191	if (!feat_sec)
	192	die("No memory");
	193
	194	sec_size = sizeof(feat_sec) nr_sections;
	195
	196	sec_start = self->data_offset + self->data_size;
	197	lseek(fd, sec_start + sec_size, SEEK_SET);
2ba08250	198
3e13ab2d	199	if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
9e827dd0 FW	200	struct perf_file_section *trace_sec;
	201
	202	trace_sec = &feat_sec[idx++];
	203
2ba08250	204	/* Write trace info */
9e827dd0	205	trace_sec->offset = lseek(fd, 0, SEEK_CUR);
2ba08250	206	read_tracing_data(fd, attrs, nr_counters);
9e827dd0	207	trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
2ba08250	208	}
8671dab9	209
57f395a7	210
9e827dd0 FW	211	if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
	212	struct perf_file_section *buildid_sec;
	213
	214	buildid_sec = &feat_sec[idx++];
	215
	216	/* Write build-ids */
	217	buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
	218	write_buildid_table(fd, &id_list);
	219	buildid_sec->size = lseek(fd, 0, SEEK_CUR) - buildid_sec->offset;
8671dab9	220	}
9e827dd0 FW	221
	222	lseek(fd, sec_start, SEEK_SET);
	223	do_write(fd, feat_sec, sec_size);
	224	free(feat_sec);
	225	}
2ba08250	226
8671dab9	227	void perf_header__write(struct perf_header *self, int fd, bool at_exit)
7c6a1c65 PZ	228	{
	229	struct perf_file_header f_header;
	230	struct perf_file_attr f_attr;
	231	struct perf_header_attr *attr;
	232	int i;
	233
	234	lseek(fd, sizeof(f_header), SEEK_SET);
	235
	236
	237	for (i = 0; i < self->attrs; i++) {
	238	attr = self->attr[i];
	239
	240	attr->id_offset = lseek(fd, 0, SEEK_CUR);
	241	do_write(fd, attr->id, attr->ids * sizeof(u64));
	242	}
	243
	244
	245	self->attr_offset = lseek(fd, 0, SEEK_CUR);
	246
	247	for (i = 0; i < self->attrs; i++) {
	248	attr = self->attr[i];
	249
	250	f_attr = (struct perf_file_attr){
	251	.attr = attr->attr,
	252	.ids = {
	253	.offset = attr->id_offset,
	254	.size = attr->ids * sizeof(u64),
	255	}
	256	};
	257	do_write(fd, &f_attr, sizeof(f_attr));
	258	}
	259
8755a8f2 AV	260	self->event_offset = lseek(fd, 0, SEEK_CUR);
	261	self->event_size = event_count * sizeof(struct perf_trace_event_type);
	262	if (events)
	263	do_write(fd, events, self->event_size);
	264
7c6a1c65 PZ	265	self->data_offset = lseek(fd, 0, SEEK_CUR);
7c6a1c65 PZ	266
9e827dd0 FW	267	if (at_exit)
	268	perf_header__adds_write(self, fd);
	269
7c6a1c65 PZ	270	f_header = (struct perf_file_header){
	271	.magic = PERF_MAGIC,
	272	.size = sizeof(f_header),
	273	.attr_size = sizeof(f_attr),
	274	.attrs = {
	275	.offset = self->attr_offset,
	276	.size = self->attrs * sizeof(f_attr),
	277	},
	278	.data = {
	279	.offset = self->data_offset,
	280	.size = self->data_size,
	281	},
8755a8f2 AV	282	.event_types = {
	283	.offset = self->event_offset,
	284	.size = self->event_size,
	285	},
7c6a1c65 PZ	286	};
7c6a1c65 PZ	287
db9f11e3	288	memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
2ba08250	289
7c6a1c65 PZ	290	lseek(fd, 0, SEEK_SET);
	291	do_write(fd, &f_header, sizeof(f_header));
	292	lseek(fd, self->data_offset + self->data_size, SEEK_SET);
	293
	294	self->frozen = 1;
	295	}
	296
	297	static void do_read(int fd, void *buf, size_t size)
	298	{
	299	while (size) {
	300	int ret = read(fd, buf, size);
	301
	302	if (ret < 0)
	303	die("failed to read");
7eac7e9e PH	304	if (ret == 0)
7eac7e9e PH	305	die("failed to read: missing data");
7c6a1c65 PZ	306
	307	size -= ret;
	308	buf += ret;
	309	}
	310	}
	311
37562eac ACM	312	int perf_header__process_sections(struct perf_header *self, int fd,
	313	int (process)(struct perf_file_section self,
	314	int feat, int fd))
2ba08250	315	{
9e827dd0 FW	316	struct perf_file_section *feat_sec;
	317	int nr_sections;
	318	int sec_size;
	319	int idx = 0;
37562eac	320	int err = 0, feat = 1;
9e827dd0 FW	321
	322	nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
	323	if (!nr_sections)
37562eac	324	return 0;
9e827dd0 FW	325
	326	feat_sec = calloc(sizeof(*feat_sec), nr_sections);
	327	if (!feat_sec)
37562eac	328	return -1;
9e827dd0 FW	329
	330	sec_size = sizeof(feat_sec) nr_sections;
	331
	332	lseek(fd, self->data_offset + self->data_size, SEEK_SET);
	333
	334	do_read(fd, feat_sec, sec_size);
	335
37562eac ACM	336	while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
	337	if (perf_header__has_feat(self, feat)) {
	338	struct perf_file_section *sec = &feat_sec[idx++];
2ba08250	339
37562eac ACM	340	err = process(sec, feat, fd);
	341	if (err < 0)
	342	break;
	343	}
	344	++feat;
2ba08250	345	}
4778d2e4	346
37562eac ACM	347	free(feat_sec);
	348	return err;
	349	};
4778d2e4	350
37562eac ACM	351	int perf_file_header__read(struct perf_file_header *self,
	352	struct perf_header *ph, int fd)
	353	{
	354	lseek(fd, 0, SEEK_SET);
	355	do_read(fd, self, sizeof(*self));
	356
	357	if (self->magic != PERF_MAGIC \|\|
	358	self->attr_size != sizeof(struct perf_file_attr))
	359	return -1;
	360
	361	if (self->size != sizeof(*self)) {
	362	/* Support the previous format */
	363	if (self->size == offsetof(typeof(*self), adds_features))
	364	bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
	365	else
	366	return -1;
4778d2e4	367	}
9e827dd0	368
37562eac ACM	369	memcpy(&ph->adds_features, &self->adds_features,
	370	sizeof(self->adds_features));
	371
	372	ph->event_offset = self->event_types.offset;
	373	ph->event_size = self->event_types.size;
	374	ph->data_offset = self->data.offset;
	375	ph->data_size = self->data.size;
	376	return 0;
	377	}
	378
	379	static int perf_file_section__process(struct perf_file_section *self,
	380	int feat, int fd)
	381	{
	382	if (lseek(fd, self->offset, SEEK_SET) < 0) {
	383	pr_debug("Failed to lseek to %Ld offset for feature %d, "
	384	"continuing...\n", self->offset, feat);
	385	return 0;
	386	}
	387
	388	switch (feat) {
	389	case HEADER_TRACE_INFO:
	390	trace_report(fd);
	391	break;
	392
	393	case HEADER_BUILD_ID:
	394	if (perf_header__read_build_ids(fd, self->offset, self->size))
	395	pr_debug("Failed to read buildids, continuing...\n");
	396	break;
	397	default:
	398	pr_debug("unknown feature %d, continuing...\n", feat);
	399	}
	400
	401	return 0;
	402	}
2ba08250	403
7c6a1c65 PZ	404	struct perf_header *perf_header__read(int fd)
	405	{
	406	struct perf_header *self = perf_header__new();
	407	struct perf_file_header f_header;
	408	struct perf_file_attr f_attr;
	409	u64 f_id;
7c6a1c65 PZ	410	int nr_attrs, nr_ids, i, j;
7c6a1c65 PZ	411
37562eac	412	if (perf_file_header__read(&f_header, self, fd) < 0)
7c6a1c65 PZ	413	die("incompatible file format");
	414
	415	nr_attrs = f_header.attrs.size / sizeof(f_attr);
	416	lseek(fd, f_header.attrs.offset, SEEK_SET);
	417
	418	for (i = 0; i < nr_attrs; i++) {
	419	struct perf_header_attr *attr;
1c222bce	420	off_t tmp;
7c6a1c65 PZ	421
7c6a1c65 PZ	422	do_read(fd, &f_attr, sizeof(f_attr));
1c222bce	423	tmp = lseek(fd, 0, SEEK_CUR);
7c6a1c65 PZ	424
7c6a1c65 PZ	425	attr = perf_header_attr__new(&f_attr.attr);
dc79c0fc ACM	426	if (attr == NULL)
dc79c0fc ACM	427	die("nomem");
7c6a1c65 PZ	428
	429	nr_ids = f_attr.ids.size / sizeof(u64);
	430	lseek(fd, f_attr.ids.offset, SEEK_SET);
	431
	432	for (j = 0; j < nr_ids; j++) {
	433	do_read(fd, &f_id, sizeof(f_id));
	434
	435	perf_header_attr__add_id(attr, f_id);
	436	}
	437	perf_header__add_attr(self, attr);
	438	lseek(fd, tmp, SEEK_SET);
	439	}
	440
8755a8f2 AV	441	if (f_header.event_types.size) {
	442	lseek(fd, f_header.event_types.offset, SEEK_SET);
	443	events = malloc(f_header.event_types.size);
	444	if (!events)
	445	die("nomem");
	446	do_read(fd, events, f_header.event_types.size);
	447	event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
	448	}
03456a15	449
37562eac	450	perf_header__process_sections(self, fd, perf_file_section__process);
4778d2e4	451
2e01d179	452	lseek(fd, self->data_offset, SEEK_SET);
7c6a1c65 PZ	453
	454	self->frozen = 1;
	455
	456	return self;
	457	}
0d3a5c88 FW	458
	459	u64 perf_header__sample_type(struct perf_header *header)
	460	{
	461	u64 type = 0;
	462	int i;
	463
	464	for (i = 0; i < header->attrs; i++) {
	465	struct perf_header_attr *attr = header->attr[i];
	466
	467	if (!type)
	468	type = attr->attr.sample_type;
	469	else if (type != attr->attr.sample_type)
	470	die("non matching sample_type");
	471	}
	472
	473	return type;
	474	}
	475
cdd6c482	476	struct perf_event_attr *
0d3a5c88 FW	477	perf_header__find_attr(u64 id, struct perf_header *header)
	478	{
	479	int i;
	480
	481	for (i = 0; i < header->attrs; i++) {
	482	struct perf_header_attr *attr = header->attr[i];
	483	int j;
	484
	485	for (j = 0; j < attr->ids; j++) {
	486	if (attr->id[j] == id)
	487	return &attr->attr;
	488	}
	489	}
	490
	491	return NULL;
	492	}