[net-next-2.6.git] / tools / perf / util / event.c

#include <linux/types.h>
#include "event.h"
#include "debug.h"
#include "session.h"
#include "sort.h"
#include "string.h"
#include "strlist.h"
#include "thread.h"

static pid_t event__synthesize_comm(pid_t pid, int full,
				    int (*process)(event_t *event,
						   struct perf_session *session),
				    struct perf_session *session)
{
	event_t ev;
	char filename[PATH_MAX];
	char bf[BUFSIZ];
	FILE *fp;
	size_t size = 0;
	DIR *tasks;
	struct dirent dirent, *next;
	pid_t tgid = 0;

	snprintf(filename, sizeof(filename), "/proc/%d/status", pid);

	fp = fopen(filename, "r");
	if (fp == NULL) {
out_race:
		/*
		 * We raced with a task exiting - just return:
		 */
		pr_debug("couldn't open %s\n", filename);
		return 0;
	}

	memset(&ev.comm, 0, sizeof(ev.comm));
	while (!ev.comm.comm[0] || !ev.comm.pid) {
		if (fgets(bf, sizeof(bf), fp) == NULL)
			goto out_failure;

		if (memcmp(bf, "Name:", 5) == 0) {
			char *name = bf + 5;
			while (*name && isspace(*name))
				++name;
			size = strlen(name) - 1;
			memcpy(ev.comm.comm, name, size++);
		} else if (memcmp(bf, "Tgid:", 5) == 0) {
			char *tgids = bf + 5;
			while (*tgids && isspace(*tgids))
				++tgids;
			tgid = ev.comm.pid = atoi(tgids);
		}
	}

	ev.comm.header.type = PERF_RECORD_COMM;
	size = ALIGN(size, sizeof(u64));
	ev.comm.header.size = sizeof(ev.comm) - (sizeof(ev.comm.comm) - size);

	if (!full) {
		ev.comm.tid = pid;

		process(&ev, session);
		goto out_fclose;
	}

	snprintf(filename, sizeof(filename), "/proc/%d/task", pid);

	tasks = opendir(filename);
	if (tasks == NULL)
		goto out_race;

	while (!readdir_r(tasks, &dirent, &next) && next) {
		char *end;
		pid = strtol(dirent.d_name, &end, 10);
		if (*end)
			continue;

		ev.comm.tid = pid;

		process(&ev, session);
	}
	closedir(tasks);

out_fclose:
	fclose(fp);
	return tgid;

out_failure:
	pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
	return -1;
}

static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
					 int (*process)(event_t *event,
							struct perf_session *session),
					 struct perf_session *session)
{
	char filename[PATH_MAX];
	FILE *fp;

	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);

	fp = fopen(filename, "r");
	if (fp == NULL) {
		/*
		 * We raced with a task exiting - just return:
		 */
		pr_debug("couldn't open %s\n", filename);
		return -1;
	}

	while (1) {
		char bf[BUFSIZ], *pbf = bf;
		event_t ev = {
			.header = { .type = PERF_RECORD_MMAP },
		};
		int n;
		size_t size;
		if (fgets(bf, sizeof(bf), fp) == NULL)
			break;

		/* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
		n = hex2u64(pbf, &ev.mmap.start);
		if (n < 0)
			continue;
		pbf += n + 1;
		n = hex2u64(pbf, &ev.mmap.len);
		if (n < 0)
			continue;
		pbf += n + 3;
		if (*pbf == 'x') { /* vm_exec */
			char *execname = strchr(bf, '/');

			/* Catch VDSO */
			if (execname == NULL)
				execname = strstr(bf, "[vdso]");

			if (execname == NULL)
				continue;

			size = strlen(execname);
			execname[size - 1] = '\0'; /* Remove \n */
			memcpy(ev.mmap.filename, execname, size);
			size = ALIGN(size, sizeof(u64));
			ev.mmap.len -= ev.mmap.start;
			ev.mmap.header.size = (sizeof(ev.mmap) -
					       (sizeof(ev.mmap.filename) - size));
			ev.mmap.pid = tgid;
			ev.mmap.tid = pid;

			process(&ev, session);
		}
	}

	fclose(fp);
	return 0;
}

int event__synthesize_thread(pid_t pid,
			     int (*process)(event_t *event,
					    struct perf_session *session),
			     struct perf_session *session)
{
	pid_t tgid = event__synthesize_comm(pid, 1, process, session);
	if (tgid == -1)
		return -1;
	return event__synthesize_mmap_events(pid, tgid, process, session);
}

void event__synthesize_threads(int (*process)(event_t *event,
					      struct perf_session *session),
			       struct perf_session *session)
{
	DIR *proc;
	struct dirent dirent, *next;

	proc = opendir("/proc");

	while (!readdir_r(proc, &dirent, &next) && next) {
		char *end;
		pid_t pid = strtol(dirent.d_name, &end, 10);

		if (*end) /* only interested in proper numerical dirents */
			continue;

		event__synthesize_thread(pid, process, session);
	}

	closedir(proc);
}

static void thread__comm_adjust(struct thread *self)
{
	char *comm = self->comm;

	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	    (!symbol_conf.comm_list ||
	     strlist__has_entry(symbol_conf.comm_list, comm))) {
		unsigned int slen = strlen(comm);

		if (slen > comms__col_width) {
			comms__col_width = slen;
			threads__col_width = slen + 6;
		}
	}
}

static int thread__set_comm_adjust(struct thread *self, const char *comm)
{
	int ret = thread__set_comm(self, comm);

	if (ret)
		return ret;

	thread__comm_adjust(self);

	return 0;
}

int event__process_comm(event_t *self, struct perf_session *session)
{
	struct thread *thread = perf_session__findnew(session, self->comm.pid);

	dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);

	if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
		dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
		return -1;
	}

	return 0;
}

int event__process_lost(event_t *self, struct perf_session *session)
{
	dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
	session->events_stats.lost += self->lost.lost;
	return 0;
}

int event__process_mmap(event_t *self, struct perf_session *session)
{
	struct thread *thread = perf_session__findnew(session, self->mmap.pid);
	struct map *map = map__new(&self->mmap, MAP__FUNCTION,
				   session->cwd, session->cwdlen);

	dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
		    self->mmap.pid, self->mmap.tid,
		    (void *)(long)self->mmap.start,
		    (void *)(long)self->mmap.len,
		    (void *)(long)self->mmap.pgoff,
		    self->mmap.filename);

	if (thread == NULL || map == NULL)
		dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
	else
		thread__insert_map(thread, map);

	return 0;
}

int event__process_task(event_t *self, struct perf_session *session)
{
	struct thread *thread = perf_session__findnew(session, self->fork.pid);
	struct thread *parent = perf_session__findnew(session, self->fork.ppid);

	dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
		    self->fork.ppid, self->fork.ptid);
	/*
	 * A thread clone will have the same PID for both parent and child.
	 */
	if (thread == parent)
		return 0;

	if (self->header.type == PERF_RECORD_EXIT)
		return 0;

	if (thread == NULL || parent == NULL ||
	    thread__fork(thread, parent) < 0) {
		dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
		return -1;
	}

	return 0;
}

void thread__find_addr_location(struct thread *self,
				struct perf_session *session, u8 cpumode,
				enum map_type type, u64 addr,
				struct addr_location *al,
				symbol_filter_t filter)
{
	struct map_groups *mg = &self->mg;

	al->thread = self;
	al->addr = addr;

	if (cpumode == PERF_RECORD_MISC_KERNEL) {
		al->level = 'k';
		mg = &session->kmaps;
	} else if (cpumode == PERF_RECORD_MISC_USER)
		al->level = '.';
	else {
		al->level = 'H';
		al->map = NULL;
		al->sym = NULL;
		return;
	}
try_again:
	al->map = map_groups__find(mg, type, al->addr);
	if (al->map == NULL) {
		/*
		 * If this is outside of all known maps, and is a negative
		 * address, try to look it up in the kernel dso, as it might be
		 * a vsyscall or vdso (which executes in user-mode).
		 *
		 * XXX This is nasty, we should have a symbol list in the
		 * "[vdso]" dso, but for now lets use the old trick of looking
		 * in the whole kernel symbol list.
		 */
		if ((long long)al->addr < 0 && mg != &session->kmaps) {
			mg = &session->kmaps;
			goto try_again;
		}
		al->sym = NULL;
	} else {
		al->addr = al->map->map_ip(al->map, al->addr);
		al->sym = map__find_symbol(al->map, session, al->addr, filter);
	}
}

static void dso__calc_col_width(struct dso *self)
{
	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	    (!symbol_conf.dso_list ||
	     strlist__has_entry(symbol_conf.dso_list, self->name))) {
		unsigned int slen = strlen(self->name);
		if (slen > dsos__col_width)
			dsos__col_width = slen;
	}

	self->slen_calculated = 1;
}

int event__preprocess_sample(const event_t *self, struct perf_session *session,
			     struct addr_location *al, symbol_filter_t filter)
{
	u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
	struct thread *thread = perf_session__findnew(session, self->ip.pid);

	if (thread == NULL)
		return -1;

	if (symbol_conf.comm_list &&
	    !strlist__has_entry(symbol_conf.comm_list, thread->comm))
		goto out_filtered;

	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);

	thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
				   self->ip.ip, al, filter);
	dump_printf(" ...... dso: %s\n",
		    al->map ? al->map->dso->long_name :
			al->level == 'H' ? "[hypervisor]" : "<not found>");
	/*
	 * We have to do this here as we may have a dso with no symbol hit that
	 * has a name longer than the ones with symbols sampled.
	 */
	if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
		dso__calc_col_width(al->map->dso);

	if (symbol_conf.dso_list &&
	    (!al->map || !al->map->dso ||
	     !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) ||
	       (al->map->dso->short_name != al->map->dso->long_name &&
		strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
		goto out_filtered;

	if (symbol_conf.sym_list && al->sym &&
	    !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
		goto out_filtered;

	al->filtered = false;
	return 0;

out_filtered:
	al->filtered = true;
	return 0;
}

int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
{
	u64 *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++;
	}

	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) {
		pr_debug("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
234fbbf5 ACM	1	#include <linux/types.h>
	2	#include "event.h"
	3	#include "debug.h"
ec913369	4	#include "session.h"
c410a338	5	#include "sort.h"
234fbbf5	6	#include "string.h"
c410a338	7	#include "strlist.h"
62daacb5	8	#include "thread.h"
234fbbf5 ACM	9
234fbbf5 ACM	10	static pid_t event__synthesize_comm(pid_t pid, int full,
d8f66248 ACM	11	int (process)(event_t event,
	12	struct perf_session *session),
	13	struct perf_session *session)
234fbbf5 ACM	14	{
	15	event_t ev;
	16	char filename[PATH_MAX];
	17	char bf[BUFSIZ];
	18	FILE *fp;
	19	size_t size = 0;
	20	DIR *tasks;
	21	struct dirent dirent, *next;
	22	pid_t tgid = 0;
	23
	24	snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
	25
	26	fp = fopen(filename, "r");
	27	if (fp == NULL) {
	28	out_race:
	29	/*
	30	* We raced with a task exiting - just return:
	31	*/
	32	pr_debug("couldn't open %s\n", filename);
	33	return 0;
	34	}
	35
	36	memset(&ev.comm, 0, sizeof(ev.comm));
	37	while (!ev.comm.comm[0] \|\| !ev.comm.pid) {
	38	if (fgets(bf, sizeof(bf), fp) == NULL)
	39	goto out_failure;
	40
	41	if (memcmp(bf, "Name:", 5) == 0) {
	42	char *name = bf + 5;
	43	while (name && isspace(name))
	44	++name;
	45	size = strlen(name) - 1;
	46	memcpy(ev.comm.comm, name, size++);
	47	} else if (memcmp(bf, "Tgid:", 5) == 0) {
	48	char *tgids = bf + 5;
	49	while (tgids && isspace(tgids))
	50	++tgids;
	51	tgid = ev.comm.pid = atoi(tgids);
	52	}
	53	}
	54
	55	ev.comm.header.type = PERF_RECORD_COMM;
	56	size = ALIGN(size, sizeof(u64));
	57	ev.comm.header.size = sizeof(ev.comm) - (sizeof(ev.comm.comm) - size);
	58
	59	if (!full) {
	60	ev.comm.tid = pid;
	61
d8f66248	62	process(&ev, session);
234fbbf5 ACM	63	goto out_fclose;
	64	}
	65
	66	snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
	67
	68	tasks = opendir(filename);
	69	if (tasks == NULL)
	70	goto out_race;
	71
	72	while (!readdir_r(tasks, &dirent, &next) && next) {
	73	char *end;
	74	pid = strtol(dirent.d_name, &end, 10);
	75	if (*end)
	76	continue;
	77
	78	ev.comm.tid = pid;
	79
d8f66248	80	process(&ev, session);
234fbbf5 ACM	81	}
	82	closedir(tasks);
	83
	84	out_fclose:
	85	fclose(fp);
	86	return tgid;
	87
	88	out_failure:
	89	pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
	90	return -1;
	91	}
	92
	93	static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
d8f66248 ACM	94	int (process)(event_t event,
	95	struct perf_session *session),
	96	struct perf_session *session)
234fbbf5 ACM	97	{
	98	char filename[PATH_MAX];
	99	FILE *fp;
	100
	101	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
	102
	103	fp = fopen(filename, "r");
	104	if (fp == NULL) {
	105	/*
	106	* We raced with a task exiting - just return:
	107	*/
	108	pr_debug("couldn't open %s\n", filename);
	109	return -1;
	110	}
	111
	112	while (1) {
	113	char bf[BUFSIZ], *pbf = bf;
	114	event_t ev = {
	115	.header = { .type = PERF_RECORD_MMAP },
	116	};
	117	int n;
	118	size_t size;
	119	if (fgets(bf, sizeof(bf), fp) == NULL)
	120	break;
	121
	122	/* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
	123	n = hex2u64(pbf, &ev.mmap.start);
	124	if (n < 0)
	125	continue;
	126	pbf += n + 1;
	127	n = hex2u64(pbf, &ev.mmap.len);
	128	if (n < 0)
	129	continue;
	130	pbf += n + 3;
	131	if (pbf == 'x') { / vm_exec */
	132	char *execname = strchr(bf, '/');
	133
	134	/* Catch VDSO */
	135	if (execname == NULL)
	136	execname = strstr(bf, "[vdso]");
	137
	138	if (execname == NULL)
	139	continue;
	140
	141	size = strlen(execname);
	142	execname[size - 1] = '\0'; /* Remove \n */
	143	memcpy(ev.mmap.filename, execname, size);
	144	size = ALIGN(size, sizeof(u64));
	145	ev.mmap.len -= ev.mmap.start;
	146	ev.mmap.header.size = (sizeof(ev.mmap) -
	147	(sizeof(ev.mmap.filename) - size));
	148	ev.mmap.pid = tgid;
	149	ev.mmap.tid = pid;
	150
d8f66248	151	process(&ev, session);
234fbbf5 ACM	152	}
	153	}
	154
	155	fclose(fp);
	156	return 0;
	157	}
	158
d8f66248 ACM	159	int event__synthesize_thread(pid_t pid,
	160	int (process)(event_t event,
	161	struct perf_session *session),
	162	struct perf_session *session)
234fbbf5	163	{
d8f66248	164	pid_t tgid = event__synthesize_comm(pid, 1, process, session);
234fbbf5 ACM	165	if (tgid == -1)
234fbbf5 ACM	166	return -1;
d8f66248	167	return event__synthesize_mmap_events(pid, tgid, process, session);
234fbbf5 ACM	168	}
234fbbf5 ACM	169
d8f66248 ACM	170	void event__synthesize_threads(int (process)(event_t event,
	171	struct perf_session *session),
	172	struct perf_session *session)
234fbbf5 ACM	173	{
	174	DIR *proc;
	175	struct dirent dirent, *next;
	176
	177	proc = opendir("/proc");
	178
	179	while (!readdir_r(proc, &dirent, &next) && next) {
	180	char *end;
	181	pid_t pid = strtol(dirent.d_name, &end, 10);
	182
	183	if (end) / only interested in proper numerical dirents */
	184	continue;
	185
d8f66248	186	event__synthesize_thread(pid, process, session);
234fbbf5 ACM	187	}
	188
	189	closedir(proc);
	190	}
62daacb5	191
d599db3f ACM	192	static void thread__comm_adjust(struct thread *self)
	193	{
	194	char *comm = self->comm;
	195
	196	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	197	(!symbol_conf.comm_list \|\|
	198	strlist__has_entry(symbol_conf.comm_list, comm))) {
	199	unsigned int slen = strlen(comm);
	200
	201	if (slen > comms__col_width) {
	202	comms__col_width = slen;
	203	threads__col_width = slen + 6;
	204	}
	205	}
	206	}
	207
	208	static int thread__set_comm_adjust(struct thread self, const char comm)
	209	{
	210	int ret = thread__set_comm(self, comm);
	211
	212	if (ret)
	213	return ret;
	214
	215	thread__comm_adjust(self);
	216
	217	return 0;
	218	}
	219
b3165f41	220	int event__process_comm(event_t self, struct perf_session session)
62daacb5	221	{
b3165f41	222	struct thread *thread = perf_session__findnew(session, self->comm.pid);
62daacb5	223
bab81b62	224	dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
62daacb5	225
d599db3f	226	if (thread == NULL \|\| thread__set_comm_adjust(thread, self->comm.comm)) {
62daacb5 ACM	227	dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
	228	return -1;
	229	}
	230
	231	return 0;
	232	}
	233
f823e441	234	int event__process_lost(event_t self, struct perf_session session)
62daacb5 ACM	235	{
62daacb5 ACM	236	dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
f823e441	237	session->events_stats.lost += self->lost.lost;
62daacb5 ACM	238	return 0;
	239	}
	240
ec913369	241	int event__process_mmap(event_t self, struct perf_session session)
62daacb5	242	{
b3165f41	243	struct thread *thread = perf_session__findnew(session, self->mmap.pid);
62daacb5	244	struct map *map = map__new(&self->mmap, MAP__FUNCTION,
ec913369	245	session->cwd, session->cwdlen);
62daacb5 ACM	246
	247	dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
	248	self->mmap.pid, self->mmap.tid,
	249	(void *)(long)self->mmap.start,
	250	(void *)(long)self->mmap.len,
	251	(void *)(long)self->mmap.pgoff,
	252	self->mmap.filename);
	253
	254	if (thread == NULL \|\| map == NULL)
	255	dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
	256	else
	257	thread__insert_map(thread, map);
	258
	259	return 0;
	260	}
	261
b3165f41	262	int event__process_task(event_t self, struct perf_session session)
62daacb5	263	{
b3165f41 ACM	264	struct thread *thread = perf_session__findnew(session, self->fork.pid);
b3165f41 ACM	265	struct thread *parent = perf_session__findnew(session, self->fork.ppid);
62daacb5 ACM	266
	267	dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
	268	self->fork.ppid, self->fork.ptid);
	269	/*
	270	* A thread clone will have the same PID for both parent and child.
	271	*/
	272	if (thread == parent)
	273	return 0;
	274
	275	if (self->header.type == PERF_RECORD_EXIT)
	276	return 0;
	277
	278	if (thread == NULL \|\| parent == NULL \|\|
	279	thread__fork(thread, parent) < 0) {
	280	dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
	281	return -1;
	282	}
	283
	284	return 0;
	285	}
1ed091c4	286
4aa65636 ACM	287	void thread__find_addr_location(struct thread *self,
4aa65636 ACM	288	struct perf_session *session, u8 cpumode,
1ed091c4 ACM	289	enum map_type type, u64 addr,
	290	struct addr_location *al,
	291	symbol_filter_t filter)
	292	{
9958e1f0	293	struct map_groups *mg = &self->mg;
1ed091c4	294
9958e1f0	295	al->thread = self;
1ed091c4 ACM	296	al->addr = addr;
1ed091c4 ACM	297
7fbfc683	298	if (cpumode == PERF_RECORD_MISC_KERNEL) {
1ed091c4	299	al->level = 'k';
4aa65636	300	mg = &session->kmaps;
7fbfc683	301	} else if (cpumode == PERF_RECORD_MISC_USER)
1ed091c4 ACM	302	al->level = '.';
	303	else {
	304	al->level = 'H';
	305	al->map = NULL;
	306	al->sym = NULL;
	307	return;
	308	}
	309	try_again:
9958e1f0	310	al->map = map_groups__find(mg, type, al->addr);
1ed091c4 ACM	311	if (al->map == NULL) {
	312	/*
	313	* If this is outside of all known maps, and is a negative
	314	* address, try to look it up in the kernel dso, as it might be
	315	* a vsyscall or vdso (which executes in user-mode).
	316	*
	317	* XXX This is nasty, we should have a symbol list in the
	318	* "[vdso]" dso, but for now lets use the old trick of looking
	319	* in the whole kernel symbol list.
	320	*/
4aa65636 ACM	321	if ((long long)al->addr < 0 && mg != &session->kmaps) {
4aa65636 ACM	322	mg = &session->kmaps;
1ed091c4 ACM	323	goto try_again;
	324	}
	325	al->sym = NULL;
	326	} else {
	327	al->addr = al->map->map_ip(al->map, al->addr);
4aa65636	328	al->sym = map__find_symbol(al->map, session, al->addr, filter);
1ed091c4 ACM	329	}
	330	}
	331
c410a338 ACM	332	static void dso__calc_col_width(struct dso *self)
	333	{
	334	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	335	(!symbol_conf.dso_list \|\|
	336	strlist__has_entry(symbol_conf.dso_list, self->name))) {
	337	unsigned int slen = strlen(self->name);
	338	if (slen > dsos__col_width)
	339	dsos__col_width = slen;
	340	}
	341
	342	self->slen_calculated = 1;
	343	}
	344
b3165f41 ACM	345	int event__preprocess_sample(const event_t self, struct perf_session session,
b3165f41 ACM	346	struct addr_location *al, symbol_filter_t filter)
1ed091c4 ACM	347	{
1ed091c4 ACM	348	u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
b3165f41	349	struct thread *thread = perf_session__findnew(session, self->ip.pid);
1ed091c4 ACM	350
	351	if (thread == NULL)
	352	return -1;
	353
c410a338 ACM	354	if (symbol_conf.comm_list &&
	355	!strlist__has_entry(symbol_conf.comm_list, thread->comm))
	356	goto out_filtered;
	357
1ed091c4 ACM	358	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
1ed091c4 ACM	359
4aa65636	360	thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
1ed091c4 ACM	361	self->ip.ip, al, filter);
	362	dump_printf(" ...... dso: %s\n",
	363	al->map ? al->map->dso->long_name :
	364	al->level == 'H' ? "[hypervisor]" : "<not found>");
c410a338 ACM	365	/*
	366	* We have to do this here as we may have a dso with no symbol hit that
	367	* has a name longer than the ones with symbols sampled.
	368	*/
	369	if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
	370	dso__calc_col_width(al->map->dso);
	371
	372	if (symbol_conf.dso_list &&
	373	(!al->map \|\| !al->map->dso \|\|
	374	!(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) \|\|
	375	(al->map->dso->short_name != al->map->dso->long_name &&
	376	strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
	377	goto out_filtered;
	378
	379	if (symbol_conf.sym_list && al->sym &&
	380	!strlist__has_entry(symbol_conf.sym_list, al->sym->name))
	381	goto out_filtered;
	382
	383	al->filtered = false;
	384	return 0;
	385
	386	out_filtered:
	387	al->filtered = true;
1ed091c4 ACM	388	return 0;
1ed091c4 ACM	389	}
180f95e2 OH	390
	391	int event__parse_sample(event_t event, u64 type, struct sample_data data)
	392	{
	393	u64 *array = event->sample.array;
	394
	395	if (type & PERF_SAMPLE_IP) {
	396	data->ip = event->ip.ip;
	397	array++;
	398	}
	399
	400	if (type & PERF_SAMPLE_TID) {
	401	u32 p = (u32 )array;
	402	data->pid = p[0];
	403	data->tid = p[1];
	404	array++;
	405	}
	406
	407	if (type & PERF_SAMPLE_TIME) {
	408	data->time = *array;
	409	array++;
	410	}
	411
	412	if (type & PERF_SAMPLE_ADDR) {
	413	data->addr = *array;
	414	array++;
	415	}
	416
	417	if (type & PERF_SAMPLE_ID) {
	418	data->id = *array;
	419	array++;
	420	}
	421
	422	if (type & PERF_SAMPLE_STREAM_ID) {
	423	data->stream_id = *array;
	424	array++;
	425	}
	426
	427	if (type & PERF_SAMPLE_CPU) {
	428	u32 p = (u32 )array;
	429	data->cpu = *p;
	430	array++;
	431	}
	432
	433	if (type & PERF_SAMPLE_PERIOD) {
	434	data->period = *array;
	435	array++;
	436	}
	437
	438	if (type & PERF_SAMPLE_READ) {
	439	pr_debug("PERF_SAMPLE_READ is unsuported for now\n");
	440	return -1;
	441	}
	442
	443	if (type & PERF_SAMPLE_CALLCHAIN) {
	444	data->callchain = (struct ip_callchain *)array;
	445	array += 1 + data->callchain->nr;
	446	}
	447
	448	if (type & PERF_SAMPLE_RAW) {
	449	u32 p = (u32 )array;
	450	data->raw_size = *p;
	451	p++;
	452	data->raw_data = p;
	453	}
454
455	return 0;
456	}