[mirror_ubuntu-zesty-kernel.git] / tools / perf / util / unwind-libdw.c

#include <linux/compiler.h>
#include <elfutils/libdw.h>
#include <elfutils/libdwfl.h>
#include <inttypes.h>
#include <errno.h>
#include "debug.h"
#include "unwind.h"
#include "unwind-libdw.h"
#include "machine.h"
#include "thread.h"
#include <linux/types.h>
#include "event.h"
#include "perf_regs.h"
#include "callchain.h"

static char *debuginfo_path;

static const Dwfl_Callbacks offline_callbacks = {
	.find_debuginfo		= dwfl_standard_find_debuginfo,
	.debuginfo_path		= &debuginfo_path,
	.section_address	= dwfl_offline_section_address,
};

static int __report_module(struct addr_location *al, u64 ip,
			    struct unwind_info *ui)
{
	Dwfl_Module *mod;
	struct dso *dso = NULL;

	thread__find_addr_location(ui->thread,
				   PERF_RECORD_MISC_USER,
				   MAP__FUNCTION, ip, al);

	if (al->map)
		dso = al->map->dso;

	if (!dso)
		return 0;

	mod = dwfl_addrmodule(ui->dwfl, ip);
	if (!mod)
		mod = dwfl_report_elf(ui->dwfl, dso->short_name,
				      dso->long_name, -1, al->map->start,
				      false);

	return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1;
}

static int report_module(u64 ip, struct unwind_info *ui)
{
	struct addr_location al;

	return __report_module(&al, ip, ui);
}

/*
 * Store all entries within entries array,
 * we will process it after we finish unwind.
 */
static int entry(u64 ip, struct unwind_info *ui)

{
	struct unwind_entry *e = &ui->entries[ui->idx++];
	struct addr_location al;

	if (__report_module(&al, ip, ui))
		return -1;

	e->ip  = ip;
	e->map = al.map;
	e->sym = al.sym;

	pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
		 al.sym ? al.sym->name : "''",
		 ip,
		 al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
	return 0;
}

static pid_t next_thread(Dwfl *dwfl, void *arg, void **thread_argp)
{
	/* We want only single thread to be processed. */
	if (*thread_argp != NULL)
		return 0;

	*thread_argp = arg;
	return dwfl_pid(dwfl);
}

static int access_dso_mem(struct unwind_info *ui, Dwarf_Addr addr,
			  Dwarf_Word *data)
{
	struct addr_location al;
	ssize_t size;

	thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
			      MAP__FUNCTION, addr, &al);
	if (!al.map) {
		pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
		return -1;
	}

	if (!al.map->dso)
		return -1;

	size = dso__data_read_addr(al.map->dso, al.map, ui->machine,
				   addr, (u8 *) data, sizeof(*data));

	return !(size == sizeof(*data));
}

static bool memory_read(Dwfl *dwfl __maybe_unused, Dwarf_Addr addr, Dwarf_Word *result,
			void *arg)
{
	struct unwind_info *ui = arg;
	struct stack_dump *stack = &ui->sample->user_stack;
	u64 start, end;
	int offset;
	int ret;

	ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP);
	if (ret)
		return false;

	end = start + stack->size;

	/* Check overflow. */
	if (addr + sizeof(Dwarf_Word) < addr)
		return false;

	if (addr < start || addr + sizeof(Dwarf_Word) > end) {
		ret = access_dso_mem(ui, addr, result);
		if (ret) {
			pr_debug("unwind: access_mem 0x%" PRIx64 " not inside range"
				 " 0x%" PRIx64 "-0x%" PRIx64 "\n",
				addr, start, end);
			return false;
		}
		return true;
	}

	offset  = addr - start;
	*result = *(Dwarf_Word *)&stack->data[offset];
	pr_debug("unwind: access_mem addr 0x%" PRIx64 ", val %lx, offset %d\n",
		 addr, (unsigned long)*result, offset);
	return true;
}

static const Dwfl_Thread_Callbacks callbacks = {
	.next_thread		= next_thread,
	.memory_read		= memory_read,
	.set_initial_registers	= libdw__arch_set_initial_registers,
};

static int
frame_callback(Dwfl_Frame *state, void *arg)
{
	struct unwind_info *ui = arg;
	Dwarf_Addr pc;

	if (!dwfl_frame_pc(state, &pc, NULL)) {
		pr_err("%s", dwfl_errmsg(-1));
		return DWARF_CB_ABORT;
	}

	return entry(pc, ui) || !(--ui->max_stack) ?
	       DWARF_CB_ABORT : DWARF_CB_OK;
}

int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
			struct thread *thread,
			struct perf_sample *data,
			int max_stack)
{
	struct unwind_info *ui, ui_buf = {
		.sample		= data,
		.thread		= thread,
		.machine	= thread->mg->machine,
		.cb		= cb,
		.arg		= arg,
		.max_stack	= max_stack,
	};
	Dwarf_Word ip;
	int err = -EINVAL, i;

	if (!data->user_regs.regs)
		return -EINVAL;

	ui = zalloc(sizeof(ui_buf) + sizeof(ui_buf.entries[0]) * max_stack);
	if (!ui)
		return -ENOMEM;

	*ui = ui_buf;

	ui->dwfl = dwfl_begin(&offline_callbacks);
	if (!ui->dwfl)
		goto out;

	err = perf_reg_value(&ip, &data->user_regs, PERF_REG_IP);
	if (err)
		goto out;

	err = report_module(ip, ui);
	if (err)
		goto out;

	if (!dwfl_attach_state(ui->dwfl, EM_NONE, thread->tid, &callbacks, ui))
		goto out;

	err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui);

	if (err && !ui->max_stack)
		err = 0;

	/*
	 * Display what we got based on the order setup.
	 */
	for (i = 0; i < ui->idx && !err; i++) {
		int j = i;

		if (callchain_param.order == ORDER_CALLER)
			j = ui->idx - i - 1;

		err = ui->entries[j].ip ? ui->cb(&ui->entries[j], ui->arg) : 0;
	}

 out:
	if (err)
		pr_debug("unwind: failed with '%s'\n", dwfl_errmsg(-1));

	dwfl_end(ui->dwfl);
	free(ui);
	return 0;
}
Commit	Line	Data
5ea84154 JO	1	#include <linux/compiler.h>
	2	#include <elfutils/libdw.h>
	3	#include <elfutils/libdwfl.h>
	4	#include <inttypes.h>
	5	#include <errno.h>
84f5d36f	6	#include "debug.h"
5ea84154 JO	7	#include "unwind.h"
	8	#include "unwind-libdw.h"
	9	#include "machine.h"
	10	#include "thread.h"
d944c4ee	11	#include <linux/types.h>
5ea84154 JO	12	#include "event.h"
5ea84154 JO	13	#include "perf_regs.h"
8bd508b0	14	#include "callchain.h"
5ea84154 JO	15
	16	static char *debuginfo_path;
	17
	18	static const Dwfl_Callbacks offline_callbacks = {
	19	.find_debuginfo = dwfl_standard_find_debuginfo,
	20	.debuginfo_path = &debuginfo_path,
	21	.section_address = dwfl_offline_section_address,
	22	};
	23
	24	static int __report_module(struct addr_location *al, u64 ip,
	25	struct unwind_info *ui)
	26	{
	27	Dwfl_Module *mod;
	28	struct dso *dso = NULL;
	29
bb871a9c	30	thread__find_addr_location(ui->thread,
5ea84154 JO	31	PERF_RECORD_MISC_USER,
	32	MAP__FUNCTION, ip, al);
	33
	34	if (al->map)
	35	dso = al->map->dso;
	36
	37	if (!dso)
	38	return 0;
	39
	40	mod = dwfl_addrmodule(ui->dwfl, ip);
	41	if (!mod)
	42	mod = dwfl_report_elf(ui->dwfl, dso->short_name,
	43	dso->long_name, -1, al->map->start,
	44	false);
	45
	46	return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1;
	47	}
	48
	49	static int report_module(u64 ip, struct unwind_info *ui)
	50	{
	51	struct addr_location al;
	52
	53	return __report_module(&al, ip, ui);
	54	}
	55
8bd508b0 JO	56	/*
	57	* Store all entries within entries array,
	58	* we will process it after we finish unwind.
	59	*/
5ea84154 JO	60	static int entry(u64 ip, struct unwind_info *ui)
	61
	62	{
8bd508b0	63	struct unwind_entry *e = &ui->entries[ui->idx++];
5ea84154 JO	64	struct addr_location al;
	65
	66	if (__report_module(&al, ip, ui))
	67	return -1;
	68
8bd508b0 JO	69	e->ip = ip;
	70	e->map = al.map;
	71	e->sym = al.sym;
5ea84154 JO	72
	73	pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
	74	al.sym ? al.sym->name : "''",
	75	ip,
	76	al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
8bd508b0	77	return 0;
5ea84154 JO	78	}
	79
	80	static pid_t next_thread(Dwfl dwfl, void arg, void **thread_argp)
	81	{
	82	/* We want only single thread to be processed. */
	83	if (*thread_argp != NULL)
	84	return 0;
	85
	86	*thread_argp = arg;
	87	return dwfl_pid(dwfl);
	88	}
	89
	90	static int access_dso_mem(struct unwind_info *ui, Dwarf_Addr addr,
	91	Dwarf_Word *data)
	92	{
	93	struct addr_location al;
	94	ssize_t size;
	95
bb871a9c	96	thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
5ea84154 JO	97	MAP__FUNCTION, addr, &al);
	98	if (!al.map) {
	99	pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
	100	return -1;
	101	}
	102
	103	if (!al.map->dso)
	104	return -1;
	105
	106	size = dso__data_read_addr(al.map->dso, al.map, ui->machine,
	107	addr, (u8 ) data, sizeof(data));
	108
	109	return !(size == sizeof(*data));
	110	}
	111
	112	static bool memory_read(Dwfl dwfl __maybe_unused, Dwarf_Addr addr, Dwarf_Word result,
	113	void *arg)
	114	{
	115	struct unwind_info *ui = arg;
	116	struct stack_dump *stack = &ui->sample->user_stack;
	117	u64 start, end;
	118	int offset;
	119	int ret;
	120
	121	ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP);
	122	if (ret)
	123	return false;
	124
	125	end = start + stack->size;
	126
	127	/* Check overflow. */
	128	if (addr + sizeof(Dwarf_Word) < addr)
	129	return false;
	130
	131	if (addr < start \|\| addr + sizeof(Dwarf_Word) > end) {
	132	ret = access_dso_mem(ui, addr, result);
	133	if (ret) {
	134	pr_debug("unwind: access_mem 0x%" PRIx64 " not inside range"
	135	" 0x%" PRIx64 "-0x%" PRIx64 "\n",
	136	addr, start, end);
	137	return false;
	138	}
	139	return true;
	140	}
	141
	142	offset = addr - start;
	143	result = (Dwarf_Word *)&stack->data[offset];
	144	pr_debug("unwind: access_mem addr 0x%" PRIx64 ", val %lx, offset %d\n",
	145	addr, (unsigned long)*result, offset);
	146	return true;
	147	}
	148
	149	static const Dwfl_Thread_Callbacks callbacks = {
	150	.next_thread = next_thread,
	151	.memory_read = memory_read,
	152	.set_initial_registers = libdw__arch_set_initial_registers,
	153	};
	154
	155	static int
	156	frame_callback(Dwfl_Frame state, void arg)
	157	{
	158	struct unwind_info *ui = arg;
	159	Dwarf_Addr pc;
	160
161	if (!dwfl_frame_pc(state, &pc, NULL)) {
162	pr_err("%s", dwfl_errmsg(-1));
163	return DWARF_CB_ABORT;
164	}
165
166	return entry(pc, ui) \|\| !(--ui->max_stack) ?
167	DWARF_CB_ABORT : DWARF_CB_OK;
168	}
169
170	int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
dd8c17a5	171	struct thread *thread,
5ea84154 JO	172	struct perf_sample *data,
	173	int max_stack)
	174	{
8bd508b0	175	struct unwind_info *ui, ui_buf = {
5ea84154 JO	176	.sample = data,
5ea84154 JO	177	.thread = thread,
dd8c17a5	178	.machine = thread->mg->machine,
5ea84154 JO	179	.cb = cb,
	180	.arg = arg,
	181	.max_stack = max_stack,
	182	};
	183	Dwarf_Word ip;
8bd508b0	184	int err = -EINVAL, i;
5ea84154 JO	185
	186	if (!data->user_regs.regs)
	187	return -EINVAL;
	188
8bd508b0 JO	189	ui = zalloc(sizeof(ui_buf) + sizeof(ui_buf.entries[0]) * max_stack);
	190	if (!ui)
	191	return -ENOMEM;
	192
	193	*ui = ui_buf;
	194
	195	ui->dwfl = dwfl_begin(&offline_callbacks);
	196	if (!ui->dwfl)
5ea84154 JO	197	goto out;
	198
	199	err = perf_reg_value(&ip, &data->user_regs, PERF_REG_IP);
	200	if (err)
	201	goto out;
	202
8bd508b0	203	err = report_module(ip, ui);
5ea84154 JO	204	if (err)
	205	goto out;
	206
8bd508b0	207	if (!dwfl_attach_state(ui->dwfl, EM_NONE, thread->tid, &callbacks, ui))
5ea84154 JO	208	goto out;
5ea84154 JO	209
8bd508b0	210	err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui);
5ea84154	211
8bd508b0	212	if (err && !ui->max_stack)
5ea84154 JO	213	err = 0;
5ea84154 JO	214
8bd508b0 JO	215	/*
	216	* Display what we got based on the order setup.
	217	*/
	218	for (i = 0; i < ui->idx && !err; i++) {
	219	int j = i;
	220
	221	if (callchain_param.order == ORDER_CALLER)
	222	j = ui->idx - i - 1;
	223
	224	err = ui->entries[j].ip ? ui->cb(&ui->entries[j], ui->arg) : 0;
	225	}
	226
5ea84154 JO	227	out:
	228	if (err)
	229	pr_debug("unwind: failed with '%s'\n", dwfl_errmsg(-1));
	230
8bd508b0 JO	231	dwfl_end(ui->dwfl);
8bd508b0 JO	232	free(ui);
5ea84154 JO	233	return 0;
5ea84154 JO	234	}