[deliverable/linux.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,
				    event__handler_t process,
				    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,
					 event__handler_t process,
					 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,
				.misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_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_modules(event__handler_t process,
			      struct perf_session *session)
{
	struct rb_node *nd;

	for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]);
	     nd; nd = rb_next(nd)) {
		event_t ev;
		size_t size;
		struct map *pos = rb_entry(nd, struct map, rb_node);

		if (pos->dso->kernel)
			continue;

		size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
		memset(&ev, 0, sizeof(ev));
		ev.mmap.header.misc = 1; /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
		ev.mmap.header.type = PERF_RECORD_MMAP;
		ev.mmap.header.size = (sizeof(ev.mmap) -
				        (sizeof(ev.mmap.filename) - size));
		ev.mmap.start = pos->start;
		ev.mmap.len   = pos->end - pos->start;

		memcpy(ev.mmap.filename, pos->dso->long_name,
		       pos->dso->long_name_len + 1);
		process(&ev, session);
	}

	return 0;
}

int event__synthesize_thread(pid_t pid, event__handler_t process,
			     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(event__handler_t process,
			       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);
}

struct process_symbol_args {
	const char *name;
	u64	   start;
};

static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
{
	struct process_symbol_args *args = arg;

	/*
	 * Must be a function or at least an alias, as in PARISC64, where "_text" is
	 * an 'A' to the same address as "_stext".
	 */
	if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
	      type == 'A') || strcmp(name, args->name))
		return 0;

	args->start = start;
	return 1;
}

int event__synthesize_kernel_mmap(event__handler_t process,
				  struct perf_session *session,
				  const char *symbol_name)
{
	size_t size;
	event_t ev = {
		.header = {
			.type = PERF_RECORD_MMAP,
			.misc = 1, /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
		},
	};
	/*
	 * We should get this from /sys/kernel/sections/.text, but till that is
	 * available use this, and after it is use this as a fallback for older
	 * kernels.
	 */
	struct process_symbol_args args = { .name = symbol_name, };

	if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0)
		return -ENOENT;

	size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
			"[kernel.kallsyms.%s]", symbol_name) + 1;
	size = ALIGN(size, sizeof(u64));
	ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size));
	ev.mmap.pgoff = args.start;
	ev.mmap.start = session->vmlinux_maps[MAP__FUNCTION]->start;
	ev.mmap.len   = session->vmlinux_maps[MAP__FUNCTION]->end - ev.mmap.start ;

	return process(&ev, session);
}

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;
	struct map *map;

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

	if (self->mmap.pid == 0) {
		static const char kmmap_prefix[] = "[kernel.kallsyms.";

		if (self->mmap.filename[0] == '/') {
			char short_module_name[1024];
			char *name = strrchr(self->mmap.filename, '/'), *dot;

			if (name == NULL)
				goto out_problem;

			++name; /* skip / */
			dot = strrchr(name, '.');
			if (dot == NULL)
				goto out_problem;

			snprintf(short_module_name, sizeof(short_module_name),
				 "[%.*s]", (int)(dot - name), name);
			strxfrchar(short_module_name, '-', '_');

			map = perf_session__new_module_map(session,
							   self->mmap.start,
							   self->mmap.filename);
			if (map == NULL)
				goto out_problem;

			name = strdup(short_module_name);
			if (name == NULL)
				goto out_problem;

			map->dso->short_name = name;
			map->end = map->start + self->mmap.len;
		} else if (memcmp(self->mmap.filename, kmmap_prefix,
				sizeof(kmmap_prefix) - 1) == 0) {
			const char *symbol_name = (self->mmap.filename +
						   sizeof(kmmap_prefix) - 1);
			/*
			 * Should be there already, from the build-id table in
			 * the header.
			 */
			struct dso *kernel = __dsos__findnew(&dsos__kernel,
							     "[kernel.kallsyms]");
			if (kernel == NULL)
				goto out_problem;

			kernel->kernel = 1;
			if (__map_groups__create_kernel_maps(&session->kmaps,
							     session->vmlinux_maps,
							     kernel) < 0)
				goto out_problem;

			session->vmlinux_maps[MAP__FUNCTION]->start = self->mmap.start;
			session->vmlinux_maps[MAP__FUNCTION]->end   = self->mmap.start + self->mmap.len;

			perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
								 self->mmap.pgoff);
		}
		return 0;
	}

	thread = perf_session__findnew(session, self->mmap.pid);
	map = map__new(&self->mmap, MAP__FUNCTION,
		       session->cwd, session->cwdlen);

	if (thread == NULL || map == NULL)
		goto out_problem;

	thread__insert_map(thread, map);
	return 0;

out_problem:
	dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
	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_map(struct thread *self,
			   struct perf_session *session, u8 cpumode,
			   enum map_type type, u64 addr,
			   struct addr_location *al)
{
	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;
		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;
		}
	} else
		al->addr = al->map->map_ip(al->map, al->addr);
}

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)
{
	thread__find_addr_map(self, session, cpumode, type, addr, al);
	if (al->map != NULL)
		al->sym = map__find_symbol(al->map, session, al->addr, filter);
	else
		al->sym = NULL;
}

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,
cf553114	11	event__handler_t process,
d8f66248	12	struct perf_session *session)
234fbbf5 ACM	13	{
	14	event_t ev;
	15	char filename[PATH_MAX];
	16	char bf[BUFSIZ];
	17	FILE *fp;
	18	size_t size = 0;
	19	DIR *tasks;
	20	struct dirent dirent, *next;
	21	pid_t tgid = 0;
	22
	23	snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
	24
	25	fp = fopen(filename, "r");
	26	if (fp == NULL) {
	27	out_race:
	28	/*
	29	* We raced with a task exiting - just return:
	30	*/
	31	pr_debug("couldn't open %s\n", filename);
	32	return 0;
	33	}
	34
	35	memset(&ev.comm, 0, sizeof(ev.comm));
	36	while (!ev.comm.comm[0] \|\| !ev.comm.pid) {
	37	if (fgets(bf, sizeof(bf), fp) == NULL)
	38	goto out_failure;
	39
	40	if (memcmp(bf, "Name:", 5) == 0) {
	41	char *name = bf + 5;
	42	while (name && isspace(name))
	43	++name;
	44	size = strlen(name) - 1;
	45	memcpy(ev.comm.comm, name, size++);
	46	} else if (memcmp(bf, "Tgid:", 5) == 0) {
	47	char *tgids = bf + 5;
	48	while (tgids && isspace(tgids))
	49	++tgids;
	50	tgid = ev.comm.pid = atoi(tgids);
	51	}
	52	}
	53
	54	ev.comm.header.type = PERF_RECORD_COMM;
	55	size = ALIGN(size, sizeof(u64));
	56	ev.comm.header.size = sizeof(ev.comm) - (sizeof(ev.comm.comm) - size);
	57
	58	if (!full) {
	59	ev.comm.tid = pid;
	60
d8f66248	61	process(&ev, session);
234fbbf5 ACM	62	goto out_fclose;
	63	}
	64
	65	snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
	66
	67	tasks = opendir(filename);
	68	if (tasks == NULL)
	69	goto out_race;
	70
	71	while (!readdir_r(tasks, &dirent, &next) && next) {
	72	char *end;
	73	pid = strtol(dirent.d_name, &end, 10);
	74	if (*end)
	75	continue;
	76
	77	ev.comm.tid = pid;
	78
d8f66248	79	process(&ev, session);
234fbbf5 ACM	80	}
	81	closedir(tasks);
	82
	83	out_fclose:
	84	fclose(fp);
	85	return tgid;
	86
	87	out_failure:
	88	pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
	89	return -1;
	90	}
	91
	92	static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
cf553114	93	event__handler_t process,
d8f66248	94	struct perf_session *session)
234fbbf5 ACM	95	{
	96	char filename[PATH_MAX];
	97	FILE *fp;
	98
	99	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
	100
	101	fp = fopen(filename, "r");
	102	if (fp == NULL) {
	103	/*
	104	* We raced with a task exiting - just return:
	105	*/
	106	pr_debug("couldn't open %s\n", filename);
	107	return -1;
	108	}
	109
	110	while (1) {
	111	char bf[BUFSIZ], *pbf = bf;
	112	event_t ev = {
18c3daa4 ACM	113	.header = {
	114	.type = PERF_RECORD_MMAP,
	115	.misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_mmap */
	116	},
234fbbf5 ACM	117	};
	118	int n;
	119	size_t size;
	120	if (fgets(bf, sizeof(bf), fp) == NULL)
	121	break;
	122
	123	/* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */
	124	n = hex2u64(pbf, &ev.mmap.start);
	125	if (n < 0)
	126	continue;
	127	pbf += n + 1;
	128	n = hex2u64(pbf, &ev.mmap.len);
	129	if (n < 0)
	130	continue;
	131	pbf += n + 3;
	132	if (pbf == 'x') { / vm_exec */
	133	char *execname = strchr(bf, '/');
	134
	135	/* Catch VDSO */
	136	if (execname == NULL)
	137	execname = strstr(bf, "[vdso]");
	138
	139	if (execname == NULL)
	140	continue;
	141
	142	size = strlen(execname);
	143	execname[size - 1] = '\0'; /* Remove \n */
	144	memcpy(ev.mmap.filename, execname, size);
	145	size = ALIGN(size, sizeof(u64));
	146	ev.mmap.len -= ev.mmap.start;
	147	ev.mmap.header.size = (sizeof(ev.mmap) -
	148	(sizeof(ev.mmap.filename) - size));
	149	ev.mmap.pid = tgid;
	150	ev.mmap.tid = pid;
	151
d8f66248	152	process(&ev, session);
234fbbf5 ACM	153	}
	154	}
	155
	156	fclose(fp);
	157	return 0;
	158	}
	159
b7cece76 ACM	160	int event__synthesize_modules(event__handler_t process,
	161	struct perf_session *session)
	162	{
	163	struct rb_node *nd;
	164
	165	for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]);
	166	nd; nd = rb_next(nd)) {
	167	event_t ev;
	168	size_t size;
	169	struct map *pos = rb_entry(nd, struct map, rb_node);
	170
	171	if (pos->dso->kernel)
	172	continue;
	173
	174	size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
	175	memset(&ev, 0, sizeof(ev));
18c3daa4	176	ev.mmap.header.misc = 1; /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
b7cece76 ACM	177	ev.mmap.header.type = PERF_RECORD_MMAP;
	178	ev.mmap.header.size = (sizeof(ev.mmap) -
	179	(sizeof(ev.mmap.filename) - size));
	180	ev.mmap.start = pos->start;
	181	ev.mmap.len = pos->end - pos->start;
	182
	183	memcpy(ev.mmap.filename, pos->dso->long_name,
	184	pos->dso->long_name_len + 1);
	185	process(&ev, session);
	186	}
	187
	188	return 0;
	189	}
	190
cf553114	191	int event__synthesize_thread(pid_t pid, event__handler_t process,
d8f66248	192	struct perf_session *session)
234fbbf5	193	{
d8f66248	194	pid_t tgid = event__synthesize_comm(pid, 1, process, session);
234fbbf5 ACM	195	if (tgid == -1)
234fbbf5 ACM	196	return -1;
d8f66248	197	return event__synthesize_mmap_events(pid, tgid, process, session);
234fbbf5 ACM	198	}
234fbbf5 ACM	199
cf553114	200	void event__synthesize_threads(event__handler_t process,
d8f66248	201	struct perf_session *session)
234fbbf5 ACM	202	{
	203	DIR *proc;
	204	struct dirent dirent, *next;
	205
	206	proc = opendir("/proc");
	207
	208	while (!readdir_r(proc, &dirent, &next) && next) {
	209	char *end;
	210	pid_t pid = strtol(dirent.d_name, &end, 10);
	211
	212	if (end) / only interested in proper numerical dirents */
	213	continue;
	214
d8f66248	215	event__synthesize_thread(pid, process, session);
234fbbf5 ACM	216	}
	217
	218	closedir(proc);
	219	}
62daacb5	220
56b03f3c ACM	221	struct process_symbol_args {
	222	const char *name;
	223	u64 start;
	224	};
	225
	226	static int find_symbol_cb(void arg, const char name, char type, u64 start)
	227	{
	228	struct process_symbol_args *args = arg;
	229
881516eb ACM	230	/*
	231	* Must be a function or at least an alias, as in PARISC64, where "_text" is
	232	* an 'A' to the same address as "_stext".
	233	*/
	234	if (!(symbol_type__is_a(type, MAP__FUNCTION) \|\|
	235	type == 'A') \|\| strcmp(name, args->name))
56b03f3c ACM	236	return 0;
	237
	238	args->start = start;
	239	return 1;
	240	}
	241
cf553114	242	int event__synthesize_kernel_mmap(event__handler_t process,
56b03f3c ACM	243	struct perf_session *session,
	244	const char *symbol_name)
	245	{
	246	size_t size;
	247	event_t ev = {
18c3daa4 ACM	248	.header = {
	249	.type = PERF_RECORD_MMAP,
	250	.misc = 1, /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
	251	},
56b03f3c ACM	252	};
	253	/*
	254	* We should get this from /sys/kernel/sections/.text, but till that is
	255	* available use this, and after it is use this as a fallback for older
	256	* kernels.
	257	*/
	258	struct process_symbol_args args = { .name = symbol_name, };
	259
9e201442	260	if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0)
56b03f3c ACM	261	return -ENOENT;
	262
	263	size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
	264	"[kernel.kallsyms.%s]", symbol_name) + 1;
	265	size = ALIGN(size, sizeof(u64));
	266	ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size));
b7cece76 ACM	267	ev.mmap.pgoff = args.start;
	268	ev.mmap.start = session->vmlinux_maps[MAP__FUNCTION]->start;
	269	ev.mmap.len = session->vmlinux_maps[MAP__FUNCTION]->end - ev.mmap.start ;
56b03f3c ACM	270
	271	return process(&ev, session);
	272	}
	273
d599db3f ACM	274	static void thread__comm_adjust(struct thread *self)
	275	{
	276	char *comm = self->comm;
	277
	278	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	279	(!symbol_conf.comm_list \|\|
	280	strlist__has_entry(symbol_conf.comm_list, comm))) {
	281	unsigned int slen = strlen(comm);
	282
	283	if (slen > comms__col_width) {
	284	comms__col_width = slen;
	285	threads__col_width = slen + 6;
	286	}
	287	}
	288	}
	289
	290	static int thread__set_comm_adjust(struct thread self, const char comm)
	291	{
	292	int ret = thread__set_comm(self, comm);
	293
	294	if (ret)
	295	return ret;
	296
	297	thread__comm_adjust(self);
	298
	299	return 0;
	300	}
	301
b3165f41	302	int event__process_comm(event_t self, struct perf_session session)
62daacb5	303	{
b3165f41	304	struct thread *thread = perf_session__findnew(session, self->comm.pid);
62daacb5	305
bab81b62	306	dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
62daacb5	307
d599db3f	308	if (thread == NULL \|\| thread__set_comm_adjust(thread, self->comm.comm)) {
62daacb5 ACM	309	dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
	310	return -1;
	311	}
	312
	313	return 0;
	314	}
	315
f823e441	316	int event__process_lost(event_t self, struct perf_session session)
62daacb5 ACM	317	{
62daacb5 ACM	318	dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
f823e441	319	session->events_stats.lost += self->lost.lost;
62daacb5 ACM	320	return 0;
	321	}
	322
ec913369	323	int event__process_mmap(event_t self, struct perf_session session)
62daacb5	324	{
56b03f3c ACM	325	struct thread *thread;
56b03f3c ACM	326	struct map *map;
62daacb5	327
0d755034 ACM	328	dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
	329	self->mmap.pid, self->mmap.tid, self->mmap.start,
	330	self->mmap.len, self->mmap.pgoff, self->mmap.filename);
62daacb5	331
b7cece76 ACM	332	if (self->mmap.pid == 0) {
	333	static const char kmmap_prefix[] = "[kernel.kallsyms.";
	334
	335	if (self->mmap.filename[0] == '/') {
	336	char short_module_name[1024];
	337	char name = strrchr(self->mmap.filename, '/'), dot;
	338
	339	if (name == NULL)
	340	goto out_problem;
	341
	342	++name; /* skip / */
	343	dot = strrchr(name, '.');
	344	if (dot == NULL)
	345	goto out_problem;
	346
	347	snprintf(short_module_name, sizeof(short_module_name),
	348	"[%.*s]", (int)(dot - name), name);
	349	strxfrchar(short_module_name, '-', '_');
	350
	351	map = perf_session__new_module_map(session,
	352	self->mmap.start,
460848fc	353	self->mmap.filename);
b7cece76 ACM	354	if (map == NULL)
	355	goto out_problem;
	356
460848fc	357	name = strdup(short_module_name);
b7cece76 ACM	358	if (name == NULL)
	359	goto out_problem;
	360
460848fc	361	map->dso->short_name = name;
b7cece76 ACM	362	map->end = map->start + self->mmap.len;
	363	} else if (memcmp(self->mmap.filename, kmmap_prefix,
	364	sizeof(kmmap_prefix) - 1) == 0) {
	365	const char *symbol_name = (self->mmap.filename +
	366	sizeof(kmmap_prefix) - 1);
	367	/*
	368	* Should be there already, from the build-id table in
	369	* the header.
	370	*/
	371	struct dso *kernel = __dsos__findnew(&dsos__kernel,
	372	"[kernel.kallsyms]");
	373	if (kernel == NULL)
	374	goto out_problem;
	375
f162f87a	376	kernel->kernel = 1;
b7cece76 ACM	377	if (__map_groups__create_kernel_maps(&session->kmaps,
	378	session->vmlinux_maps,
	379	kernel) < 0)
	380	goto out_problem;
	381
	382	session->vmlinux_maps[MAP__FUNCTION]->start = self->mmap.start;
	383	session->vmlinux_maps[MAP__FUNCTION]->end = self->mmap.start + self->mmap.len;
	384
	385	perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
	386	self->mmap.pgoff);
	387	}
56b03f3c ACM	388	return 0;
	389	}
	390
	391	thread = perf_session__findnew(session, self->mmap.pid);
	392	map = map__new(&self->mmap, MAP__FUNCTION,
	393	session->cwd, session->cwdlen);
	394
62daacb5	395	if (thread == NULL \|\| map == NULL)
b7cece76 ACM	396	goto out_problem;
	397
	398	thread__insert_map(thread, map);
	399	return 0;
62daacb5	400
b7cece76 ACM	401	out_problem:
b7cece76 ACM	402	dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
62daacb5 ACM	403	return 0;
	404	}
	405
b3165f41	406	int event__process_task(event_t self, struct perf_session session)
62daacb5	407	{
b3165f41 ACM	408	struct thread *thread = perf_session__findnew(session, self->fork.pid);
b3165f41 ACM	409	struct thread *parent = perf_session__findnew(session, self->fork.ppid);
62daacb5 ACM	410
	411	dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
	412	self->fork.ppid, self->fork.ptid);
	413	/*
	414	* A thread clone will have the same PID for both parent and child.
	415	*/
	416	if (thread == parent)
	417	return 0;
	418
	419	if (self->header.type == PERF_RECORD_EXIT)
	420	return 0;
	421
	422	if (thread == NULL \|\| parent == NULL \|\|
	423	thread__fork(thread, parent) < 0) {
	424	dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
	425	return -1;
	426	}
	427
	428	return 0;
	429	}
1ed091c4	430
59ee68ec ACM	431	void thread__find_addr_map(struct thread *self,
	432	struct perf_session *session, u8 cpumode,
	433	enum map_type type, u64 addr,
	434	struct addr_location *al)
1ed091c4	435	{
9958e1f0	436	struct map_groups *mg = &self->mg;
1ed091c4	437
9958e1f0	438	al->thread = self;
1ed091c4 ACM	439	al->addr = addr;
	440
	441	if (cpumode & PERF_RECORD_MISC_KERNEL) {
	442	al->level = 'k';
4aa65636	443	mg = &session->kmaps;
1ed091c4 ACM	444	} else if (cpumode & PERF_RECORD_MISC_USER)
	445	al->level = '.';
	446	else {
	447	al->level = 'H';
	448	al->map = NULL;
1ed091c4 ACM	449	return;
	450	}
	451	try_again:
9958e1f0	452	al->map = map_groups__find(mg, type, al->addr);
1ed091c4 ACM	453	if (al->map == NULL) {
	454	/*
	455	* If this is outside of all known maps, and is a negative
	456	* address, try to look it up in the kernel dso, as it might be
	457	* a vsyscall or vdso (which executes in user-mode).
	458	*
	459	* XXX This is nasty, we should have a symbol list in the
	460	* "[vdso]" dso, but for now lets use the old trick of looking
	461	* in the whole kernel symbol list.
	462	*/
4aa65636 ACM	463	if ((long long)al->addr < 0 && mg != &session->kmaps) {
4aa65636 ACM	464	mg = &session->kmaps;
1ed091c4 ACM	465	goto try_again;
1ed091c4 ACM	466	}
59ee68ec	467	} else
1ed091c4	468	al->addr = al->map->map_ip(al->map, al->addr);
59ee68ec ACM	469	}
	470
	471	void thread__find_addr_location(struct thread *self,
	472	struct perf_session *session, u8 cpumode,
	473	enum map_type type, u64 addr,
	474	struct addr_location *al,
	475	symbol_filter_t filter)
	476	{
	477	thread__find_addr_map(self, session, cpumode, type, addr, al);
	478	if (al->map != NULL)
4aa65636	479	al->sym = map__find_symbol(al->map, session, al->addr, filter);
59ee68ec ACM	480	else
59ee68ec ACM	481	al->sym = NULL;
1ed091c4 ACM	482	}
1ed091c4 ACM	483
c410a338 ACM	484	static void dso__calc_col_width(struct dso *self)
	485	{
	486	if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
	487	(!symbol_conf.dso_list \|\|
	488	strlist__has_entry(symbol_conf.dso_list, self->name))) {
	489	unsigned int slen = strlen(self->name);
	490	if (slen > dsos__col_width)
	491	dsos__col_width = slen;
	492	}
	493
	494	self->slen_calculated = 1;
	495	}
	496
b3165f41 ACM	497	int event__preprocess_sample(const event_t self, struct perf_session session,
b3165f41 ACM	498	struct addr_location *al, symbol_filter_t filter)
1ed091c4 ACM	499	{
1ed091c4 ACM	500	u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
b3165f41	501	struct thread *thread = perf_session__findnew(session, self->ip.pid);
1ed091c4 ACM	502
	503	if (thread == NULL)
	504	return -1;
	505
c410a338 ACM	506	if (symbol_conf.comm_list &&
	507	!strlist__has_entry(symbol_conf.comm_list, thread->comm))
	508	goto out_filtered;
	509
1ed091c4 ACM	510	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
1ed091c4 ACM	511
4aa65636	512	thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
1ed091c4 ACM	513	self->ip.ip, al, filter);
	514	dump_printf(" ...... dso: %s\n",
	515	al->map ? al->map->dso->long_name :
	516	al->level == 'H' ? "[hypervisor]" : "<not found>");
c410a338 ACM	517	/*
	518	* We have to do this here as we may have a dso with no symbol hit that
	519	* has a name longer than the ones with symbols sampled.
	520	*/
	521	if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
	522	dso__calc_col_width(al->map->dso);
	523
	524	if (symbol_conf.dso_list &&
	525	(!al->map \|\| !al->map->dso \|\|
	526	!(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) \|\|
	527	(al->map->dso->short_name != al->map->dso->long_name &&
	528	strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
	529	goto out_filtered;
	530
	531	if (symbol_conf.sym_list && al->sym &&
	532	!strlist__has_entry(symbol_conf.sym_list, al->sym->name))
	533	goto out_filtered;
	534
	535	al->filtered = false;
	536	return 0;
	537
	538	out_filtered:
	539	al->filtered = true;
1ed091c4 ACM	540	return 0;
1ed091c4 ACM	541	}
180f95e2 OH	542
	543	int event__parse_sample(event_t event, u64 type, struct sample_data data)
	544	{
	545	u64 *array = event->sample.array;
	546
	547	if (type & PERF_SAMPLE_IP) {
	548	data->ip = event->ip.ip;
	549	array++;
	550	}
	551
	552	if (type & PERF_SAMPLE_TID) {
	553	u32 p = (u32 )array;
	554	data->pid = p[0];
	555	data->tid = p[1];
	556	array++;
	557	}
	558
	559	if (type & PERF_SAMPLE_TIME) {
	560	data->time = *array;
	561	array++;
	562	}
	563
	564	if (type & PERF_SAMPLE_ADDR) {
	565	data->addr = *array;
	566	array++;
	567	}
	568
	569	if (type & PERF_SAMPLE_ID) {
	570	data->id = *array;
	571	array++;
	572	}
	573
	574	if (type & PERF_SAMPLE_STREAM_ID) {
	575	data->stream_id = *array;
	576	array++;
	577	}
	578
	579	if (type & PERF_SAMPLE_CPU) {
	580	u32 p = (u32 )array;
	581	data->cpu = *p;
	582	array++;
	583	}
	584
	585	if (type & PERF_SAMPLE_PERIOD) {
	586	data->period = *array;
	587	array++;
	588	}
	589
	590	if (type & PERF_SAMPLE_READ) {
	591	pr_debug("PERF_SAMPLE_READ is unsuported for now\n");
	592	return -1;
	593	}
	594
	595	if (type & PERF_SAMPLE_CALLCHAIN) {
	596	data->callchain = (struct ip_callchain *)array;
	597	array += 1 + data->callchain->nr;
	598	}
	599
	600	if (type & PERF_SAMPLE_RAW) {
	601	u32 p = (u32 )array;
	602	data->raw_size = *p;
	603	p++;
	604	data->raw_data = p;
	605	}
606
607	return 0;
608	}