[deliverable/linux.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__delete(struct perf_header_attr *self)
{
	free(self->id);
	free(self);
}

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

	self->ids++;
	if (self->ids > self->size) {
		int nsize = self->size * 2;
		u64 *nid = realloc(self->id, nsize * sizeof(u64));

		if (nid == NULL)
			return -1;

		self->size = nsize;
		self->id = nid;
	}
	self->id[pos] = id;
	return 0;
}

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

	if (self != NULL) {
		self->size = 1;
		self->attr = malloc(sizeof(void *));

		if (self->attr == NULL) {
			free(self);
			self = NULL;
		}
	}

	return self;
}

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

	if (self->frozen)
		return -1;

	self->attrs++;
	if (self->attrs > self->size) {
		int nsize = self->size * 2;
		struct perf_header_attr **nattr;

		nattr = realloc(self->attr, nsize * sizeof(void *));
		if (nattr == NULL)
			return -1;

		self->size = nsize;
		self->attr = nattr;
	}
	self->attr[pos] = attr;
	return 0;
}

#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 (self == NULL)
		die("nomem");

	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));

			if (perf_header_attr__add_id(attr, f_id) < 0)
				die("nomem");
		}
		if (perf_header__add_attr(self, attr) < 0)
			 die("nomem");

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