[deliverable/linux.git] / tools / perf / util / evsel.c

/*
 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
 *
 * Parts came from builtin-{top,stat,record}.c, see those files for further
 * copyright notes.
 *
 * Released under the GPL v2. (and only v2, not any later version)
 */

#include "evsel.h"
#include "evlist.h"
#include "util.h"
#include "cpumap.h"
#include "thread_map.h"

#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))

void perf_evsel__init(struct perf_evsel *evsel,
		      struct perf_event_attr *attr, int idx)
{
	evsel->idx	   = idx;
	evsel->attr	   = *attr;
	INIT_LIST_HEAD(&evsel->node);
}

struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
{
	struct perf_evsel *evsel = zalloc(sizeof(*evsel));

	if (evsel != NULL)
		perf_evsel__init(evsel, attr, idx);

	return evsel;
}

int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
{
	evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
	return evsel->fd != NULL ? 0 : -ENOMEM;
}

int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
{
	evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
	if (evsel->sample_id == NULL)
		return -ENOMEM;

	evsel->id = zalloc(ncpus * nthreads * sizeof(u64));
	if (evsel->id == NULL) {
		xyarray__delete(evsel->sample_id);
		evsel->sample_id = NULL;
		return -ENOMEM;
	}

	return 0;
}

int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
{
	evsel->counts = zalloc((sizeof(*evsel->counts) +
				(ncpus * sizeof(struct perf_counts_values))));
	return evsel->counts != NULL ? 0 : -ENOMEM;
}

void perf_evsel__free_fd(struct perf_evsel *evsel)
{
	xyarray__delete(evsel->fd);
	evsel->fd = NULL;
}

void perf_evsel__free_id(struct perf_evsel *evsel)
{
	xyarray__delete(evsel->sample_id);
	evsel->sample_id = NULL;
	free(evsel->id);
	evsel->id = NULL;
}

void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
{
	int cpu, thread;

	for (cpu = 0; cpu < ncpus; cpu++)
		for (thread = 0; thread < nthreads; ++thread) {
			close(FD(evsel, cpu, thread));
			FD(evsel, cpu, thread) = -1;
		}
}

void perf_evsel__exit(struct perf_evsel *evsel)
{
	assert(list_empty(&evsel->node));
	xyarray__delete(evsel->fd);
	xyarray__delete(evsel->sample_id);
	free(evsel->id);
}

void perf_evsel__delete(struct perf_evsel *evsel)
{
	perf_evsel__exit(evsel);
	close_cgroup(evsel->cgrp);
	free(evsel->name);
	free(evsel);
}

int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
			      int cpu, int thread, bool scale)
{
	struct perf_counts_values count;
	size_t nv = scale ? 3 : 1;

	if (FD(evsel, cpu, thread) < 0)
		return -EINVAL;

	if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1) < 0)
		return -ENOMEM;

	if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
		return -errno;

	if (scale) {
		if (count.run == 0)
			count.val = 0;
		else if (count.run < count.ena)
			count.val = (u64)((double)count.val * count.ena / count.run + 0.5);
	} else
		count.ena = count.run = 0;

	evsel->counts->cpu[cpu] = count;
	return 0;
}

int __perf_evsel__read(struct perf_evsel *evsel,
		       int ncpus, int nthreads, bool scale)
{
	size_t nv = scale ? 3 : 1;
	int cpu, thread;
	struct perf_counts_values *aggr = &evsel->counts->aggr, count;

	aggr->val = aggr->ena = aggr->run = 0;

	for (cpu = 0; cpu < ncpus; cpu++) {
		for (thread = 0; thread < nthreads; thread++) {
			if (FD(evsel, cpu, thread) < 0)
				continue;

			if (readn(FD(evsel, cpu, thread),
				  &count, nv * sizeof(u64)) < 0)
				return -errno;

			aggr->val += count.val;
			if (scale) {
				aggr->ena += count.ena;
				aggr->run += count.run;
			}
		}
	}

	evsel->counts->scaled = 0;
	if (scale) {
		if (aggr->run == 0) {
			evsel->counts->scaled = -1;
			aggr->val = 0;
			return 0;
		}

		if (aggr->run < aggr->ena) {
			evsel->counts->scaled = 1;
			aggr->val = (u64)((double)aggr->val * aggr->ena / aggr->run + 0.5);
		}
	} else
		aggr->ena = aggr->run = 0;

	return 0;
}

static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
			      struct thread_map *threads, bool group)
{
	int cpu, thread;
	unsigned long flags = 0;
	int pid = -1;

	if (evsel->fd == NULL &&
	    perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
		return -1;

	if (evsel->cgrp) {
		flags = PERF_FLAG_PID_CGROUP;
		pid = evsel->cgrp->fd;
	}

	for (cpu = 0; cpu < cpus->nr; cpu++) {
		int group_fd = -1;

		for (thread = 0; thread < threads->nr; thread++) {

			if (!evsel->cgrp)
				pid = threads->map[thread];

			FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
								     pid,
								     cpus->map[cpu],
								     group_fd, flags);
			if (FD(evsel, cpu, thread) < 0)
				goto out_close;

			if (group && group_fd == -1)
				group_fd = FD(evsel, cpu, thread);
		}
	}

	return 0;

out_close:
	do {
		while (--thread >= 0) {
			close(FD(evsel, cpu, thread));
			FD(evsel, cpu, thread) = -1;
		}
		thread = threads->nr;
	} while (--cpu >= 0);
	return -1;
}

static struct {
	struct cpu_map map;
	int cpus[1];
} empty_cpu_map = {
	.map.nr	= 1,
	.cpus	= { -1, },
};

static struct {
	struct thread_map map;
	int threads[1];
} empty_thread_map = {
	.map.nr	 = 1,
	.threads = { -1, },
};

int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
		     struct thread_map *threads, bool group)
{
	if (cpus == NULL) {
		/* Work around old compiler warnings about strict aliasing */
		cpus = &empty_cpu_map.map;
	}

	if (threads == NULL)
		threads = &empty_thread_map.map;

	return __perf_evsel__open(evsel, cpus, threads, group);
}

int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
			     struct cpu_map *cpus, bool group)
{
	return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group);
}

int perf_evsel__open_per_thread(struct perf_evsel *evsel,
				struct thread_map *threads, bool group)
{
	return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group);
}

static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
				       struct perf_sample *sample)
{
	const u64 *array = event->sample.array;

	array += ((event->header.size -
		   sizeof(event->header)) / sizeof(u64)) - 1;

	if (type & PERF_SAMPLE_CPU) {
		u32 *p = (u32 *)array;
		sample->cpu = *p;
		array--;
	}

	if (type & PERF_SAMPLE_STREAM_ID) {
		sample->stream_id = *array;
		array--;
	}

	if (type & PERF_SAMPLE_ID) {
		sample->id = *array;
		array--;
	}

	if (type & PERF_SAMPLE_TIME) {
		sample->time = *array;
		array--;
	}

	if (type & PERF_SAMPLE_TID) {
		u32 *p = (u32 *)array;
		sample->pid = p[0];
		sample->tid = p[1];
	}

	return 0;
}

int perf_event__parse_sample(const union perf_event *event, u64 type,
			     bool sample_id_all, struct perf_sample *data)
{
	const u64 *array;

	data->cpu = data->pid = data->tid = -1;
	data->stream_id = data->id = data->time = -1ULL;

	if (event->header.type != PERF_RECORD_SAMPLE) {
		if (!sample_id_all)
			return 0;
		return perf_event__parse_id_sample(event, type, data);
	}

	array = event->sample.array;

	if (type & PERF_SAMPLE_IP) {
		data->ip = event->ip.ip;
		array++;
	}

	if (type & PERF_SAMPLE_TID) {
		u32 *p = (u32 *)array;
		data->pid = p[0];
		data->tid = p[1];
		array++;
	}

	if (type & PERF_SAMPLE_TIME) {
		data->time = *array;
		array++;
	}

	if (type & PERF_SAMPLE_ADDR) {
		data->addr = *array;
		array++;
	}

	data->id = -1ULL;
	if (type & PERF_SAMPLE_ID) {
		data->id = *array;
		array++;
	}

	if (type & PERF_SAMPLE_STREAM_ID) {
		data->stream_id = *array;
		array++;
	}

	if (type & PERF_SAMPLE_CPU) {
		u32 *p = (u32 *)array;
		data->cpu = *p;
		array++;
	}

	if (type & PERF_SAMPLE_PERIOD) {
		data->period = *array;
		array++;
	}

	if (type & PERF_SAMPLE_READ) {
		fprintf(stderr, "PERF_SAMPLE_READ is unsuported for now\n");
		return -1;
	}

	if (type & PERF_SAMPLE_CALLCHAIN) {
		data->callchain = (struct ip_callchain *)array;
		array += 1 + data->callchain->nr;
	}

	if (type & PERF_SAMPLE_RAW) {
		u32 *p = (u32 *)array;
		data->raw_size = *p;
		p++;
		data->raw_data = p;
	}

	return 0;
}
Commit	Line	Data
f8a95309 ACM	1	/*
	2	* Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
	3	*
	4	* Parts came from builtin-{top,stat,record}.c, see those files for further
	5	* copyright notes.
	6	*
	7	* Released under the GPL v2. (and only v2, not any later version)
	8	*/
	9
69aad6f1	10	#include "evsel.h"
70082dd9	11	#include "evlist.h"
69aad6f1	12	#include "util.h"
86bd5e86	13	#include "cpumap.h"
fd78260b	14	#include "thread_map.h"
69aad6f1	15
c52b12ed ACM	16	#define FD(e, x, y) ((int )xyarray__entry(e->fd, x, y))
c52b12ed ACM	17
ef1d1af2 ACM	18	void perf_evsel__init(struct perf_evsel *evsel,
	19	struct perf_event_attr *attr, int idx)
	20	{
	21	evsel->idx = idx;
	22	evsel->attr = *attr;
	23	INIT_LIST_HEAD(&evsel->node);
	24	}
	25
23a2f3ab	26	struct perf_evsel perf_evsel__new(struct perf_event_attr attr, int idx)
69aad6f1 ACM	27	{
	28	struct perf_evsel evsel = zalloc(sizeof(evsel));
	29
ef1d1af2 ACM	30	if (evsel != NULL)
ef1d1af2 ACM	31	perf_evsel__init(evsel, attr, idx);
69aad6f1 ACM	32
	33	return evsel;
	34	}
	35
	36	int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
	37	{
	38	evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
	39	return evsel->fd != NULL ? 0 : -ENOMEM;
	40	}
	41
70db7533 ACM	42	int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
70db7533 ACM	43	{
a91e5431 ACM	44	evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
	45	if (evsel->sample_id == NULL)
	46	return -ENOMEM;
	47
	48	evsel->id = zalloc(ncpus * nthreads * sizeof(u64));
	49	if (evsel->id == NULL) {
	50	xyarray__delete(evsel->sample_id);
	51	evsel->sample_id = NULL;
	52	return -ENOMEM;
	53	}
	54
	55	return 0;
70db7533 ACM	56	}
70db7533 ACM	57
c52b12ed ACM	58	int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
	59	{
	60	evsel->counts = zalloc((sizeof(*evsel->counts) +
	61	(ncpus * sizeof(struct perf_counts_values))));
	62	return evsel->counts != NULL ? 0 : -ENOMEM;
	63	}
	64
69aad6f1 ACM	65	void perf_evsel__free_fd(struct perf_evsel *evsel)
	66	{
	67	xyarray__delete(evsel->fd);
	68	evsel->fd = NULL;
	69	}
	70
70db7533 ACM	71	void perf_evsel__free_id(struct perf_evsel *evsel)
70db7533 ACM	72	{
a91e5431 ACM	73	xyarray__delete(evsel->sample_id);
	74	evsel->sample_id = NULL;
	75	free(evsel->id);
70db7533 ACM	76	evsel->id = NULL;
	77	}
	78
c52b12ed ACM	79	void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
	80	{
	81	int cpu, thread;
	82
	83	for (cpu = 0; cpu < ncpus; cpu++)
	84	for (thread = 0; thread < nthreads; ++thread) {
	85	close(FD(evsel, cpu, thread));
	86	FD(evsel, cpu, thread) = -1;
	87	}
	88	}
	89
ef1d1af2	90	void perf_evsel__exit(struct perf_evsel *evsel)
69aad6f1 ACM	91	{
	92	assert(list_empty(&evsel->node));
	93	xyarray__delete(evsel->fd);
a91e5431 ACM	94	xyarray__delete(evsel->sample_id);
a91e5431 ACM	95	free(evsel->id);
ef1d1af2 ACM	96	}
	97
	98	void perf_evsel__delete(struct perf_evsel *evsel)
	99	{
	100	perf_evsel__exit(evsel);
023695d9	101	close_cgroup(evsel->cgrp);
f0c55bcf	102	free(evsel->name);
69aad6f1 ACM	103	free(evsel);
69aad6f1 ACM	104	}
c52b12ed ACM	105
	106	int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
	107	int cpu, int thread, bool scale)
	108	{
	109	struct perf_counts_values count;
	110	size_t nv = scale ? 3 : 1;
	111
	112	if (FD(evsel, cpu, thread) < 0)
	113	return -EINVAL;
	114
4eed11d5 ACM	115	if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1) < 0)
	116	return -ENOMEM;
	117
c52b12ed ACM	118	if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
	119	return -errno;
	120
	121	if (scale) {
	122	if (count.run == 0)
	123	count.val = 0;
	124	else if (count.run < count.ena)
	125	count.val = (u64)((double)count.val * count.ena / count.run + 0.5);
	126	} else
	127	count.ena = count.run = 0;
	128
	129	evsel->counts->cpu[cpu] = count;
	130	return 0;
	131	}
	132
	133	int __perf_evsel__read(struct perf_evsel *evsel,
	134	int ncpus, int nthreads, bool scale)
	135	{
	136	size_t nv = scale ? 3 : 1;
	137	int cpu, thread;
	138	struct perf_counts_values *aggr = &evsel->counts->aggr, count;
	139
52bcd994	140	aggr->val = aggr->ena = aggr->run = 0;
c52b12ed ACM	141
	142	for (cpu = 0; cpu < ncpus; cpu++) {
	143	for (thread = 0; thread < nthreads; thread++) {
	144	if (FD(evsel, cpu, thread) < 0)
	145	continue;
	146
	147	if (readn(FD(evsel, cpu, thread),
	148	&count, nv * sizeof(u64)) < 0)
	149	return -errno;
	150
	151	aggr->val += count.val;
	152	if (scale) {
	153	aggr->ena += count.ena;
	154	aggr->run += count.run;
	155	}
	156	}
	157	}
	158
	159	evsel->counts->scaled = 0;
	160	if (scale) {
	161	if (aggr->run == 0) {
	162	evsel->counts->scaled = -1;
	163	aggr->val = 0;
	164	return 0;
	165	}
	166
	167	if (aggr->run < aggr->ena) {
	168	evsel->counts->scaled = 1;
	169	aggr->val = (u64)((double)aggr->val * aggr->ena / aggr->run + 0.5);
	170	}
	171	} else
	172	aggr->ena = aggr->run = 0;
	173
	174	return 0;
	175	}
48290609	176
0252208e	177	static int __perf_evsel__open(struct perf_evsel evsel, struct cpu_map cpus,
5d2cd909	178	struct thread_map *threads, bool group)
48290609	179	{
0252208e	180	int cpu, thread;
023695d9 SE	181	unsigned long flags = 0;
023695d9 SE	182	int pid = -1;
48290609	183
0252208e ACM	184	if (evsel->fd == NULL &&
0252208e ACM	185	perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
4eed11d5 ACM	186	return -1;
4eed11d5 ACM	187
023695d9 SE	188	if (evsel->cgrp) {
	189	flags = PERF_FLAG_PID_CGROUP;
	190	pid = evsel->cgrp->fd;
	191	}
	192
86bd5e86	193	for (cpu = 0; cpu < cpus->nr; cpu++) {
f08199d3	194	int group_fd = -1;
9d04f178	195
0252208e	196	for (thread = 0; thread < threads->nr; thread++) {
023695d9 SE	197
	198	if (!evsel->cgrp)
	199	pid = threads->map[thread];
	200
0252208e	201	FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
023695d9	202	pid,
f08199d3	203	cpus->map[cpu],
023695d9	204	group_fd, flags);
0252208e ACM	205	if (FD(evsel, cpu, thread) < 0)
0252208e ACM	206	goto out_close;
f08199d3 ACM	207
	208	if (group && group_fd == -1)
	209	group_fd = FD(evsel, cpu, thread);
0252208e	210	}
48290609 ACM	211	}
	212
	213	return 0;
	214
	215	out_close:
0252208e ACM	216	do {
	217	while (--thread >= 0) {
	218	close(FD(evsel, cpu, thread));
	219	FD(evsel, cpu, thread) = -1;
	220	}
	221	thread = threads->nr;
	222	} while (--cpu >= 0);
48290609 ACM	223	return -1;
	224	}
	225
0252208e ACM	226	static struct {
	227	struct cpu_map map;
	228	int cpus[1];
	229	} empty_cpu_map = {
	230	.map.nr = 1,
	231	.cpus = { -1, },
	232	};
	233
	234	static struct {
	235	struct thread_map map;
	236	int threads[1];
	237	} empty_thread_map = {
	238	.map.nr = 1,
	239	.threads = { -1, },
	240	};
	241
f08199d3	242	int perf_evsel__open(struct perf_evsel evsel, struct cpu_map cpus,
5d2cd909	243	struct thread_map *threads, bool group)
48290609	244	{
0252208e ACM	245	if (cpus == NULL) {
	246	/* Work around old compiler warnings about strict aliasing */
	247	cpus = &empty_cpu_map.map;
48290609 ACM	248	}
48290609 ACM	249
0252208e ACM	250	if (threads == NULL)
0252208e ACM	251	threads = &empty_thread_map.map;
48290609	252
5d2cd909	253	return __perf_evsel__open(evsel, cpus, threads, group);
48290609 ACM	254	}
48290609 ACM	255
f08199d3	256	int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
5d2cd909	257	struct cpu_map *cpus, bool group)
48290609	258	{
5d2cd909	259	return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group);
0252208e	260	}
48290609	261
f08199d3	262	int perf_evsel__open_per_thread(struct perf_evsel *evsel,
5d2cd909	263	struct thread_map *threads, bool group)
0252208e	264	{
5d2cd909	265	return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group);
48290609	266	}
70082dd9	267
8115d60c ACM	268	static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
8115d60c ACM	269	struct perf_sample *sample)
d0dd74e8 ACM	270	{
	271	const u64 *array = event->sample.array;
	272
	273	array += ((event->header.size -
	274	sizeof(event->header)) / sizeof(u64)) - 1;
	275
	276	if (type & PERF_SAMPLE_CPU) {
	277	u32 p = (u32 )array;
	278	sample->cpu = *p;
	279	array--;
	280	}
	281
	282	if (type & PERF_SAMPLE_STREAM_ID) {
	283	sample->stream_id = *array;
	284	array--;
	285	}
	286
	287	if (type & PERF_SAMPLE_ID) {
	288	sample->id = *array;
	289	array--;
	290	}
	291
	292	if (type & PERF_SAMPLE_TIME) {
	293	sample->time = *array;
	294	array--;
	295	}
	296
	297	if (type & PERF_SAMPLE_TID) {
	298	u32 p = (u32 )array;
	299	sample->pid = p[0];
	300	sample->tid = p[1];
	301	}
	302
	303	return 0;
	304	}
	305
8115d60c ACM	306	int perf_event__parse_sample(const union perf_event *event, u64 type,
8115d60c ACM	307	bool sample_id_all, struct perf_sample *data)
d0dd74e8 ACM	308	{
	309	const u64 *array;
	310
	311	data->cpu = data->pid = data->tid = -1;
	312	data->stream_id = data->id = data->time = -1ULL;
	313
	314	if (event->header.type != PERF_RECORD_SAMPLE) {
	315	if (!sample_id_all)
	316	return 0;
8115d60c	317	return perf_event__parse_id_sample(event, type, data);
d0dd74e8 ACM	318	}
	319
	320	array = event->sample.array;
	321
	322	if (type & PERF_SAMPLE_IP) {
	323	data->ip = event->ip.ip;
	324	array++;
	325	}
	326
	327	if (type & PERF_SAMPLE_TID) {
	328	u32 p = (u32 )array;
	329	data->pid = p[0];
	330	data->tid = p[1];
	331	array++;
	332	}
	333
	334	if (type & PERF_SAMPLE_TIME) {
	335	data->time = *array;
	336	array++;
	337	}
	338
	339	if (type & PERF_SAMPLE_ADDR) {
	340	data->addr = *array;
	341	array++;
	342	}
	343
	344	data->id = -1ULL;
	345	if (type & PERF_SAMPLE_ID) {
	346	data->id = *array;
	347	array++;
	348	}
	349
	350	if (type & PERF_SAMPLE_STREAM_ID) {
	351	data->stream_id = *array;
	352	array++;
	353	}
	354
	355	if (type & PERF_SAMPLE_CPU) {
	356	u32 p = (u32 )array;
	357	data->cpu = *p;
	358	array++;
	359	}
	360
	361	if (type & PERF_SAMPLE_PERIOD) {
	362	data->period = *array;
	363	array++;
	364	}
	365
	366	if (type & PERF_SAMPLE_READ) {
	367	fprintf(stderr, "PERF_SAMPLE_READ is unsuported for now\n");
	368	return -1;
	369	}
	370
	371	if (type & PERF_SAMPLE_CALLCHAIN) {
	372	data->callchain = (struct ip_callchain *)array;
	373	array += 1 + data->callchain->nr;
	374	}
	375
	376	if (type & PERF_SAMPLE_RAW) {
	377	u32 p = (u32 )array;
	378	data->raw_size = *p;
	379	p++;
	380	data->raw_data = p;
	381	}
382
383	return 0;
384	}