[deliverable/linux.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  = al.addr;
	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) {
		/*
		 * We've seen cases (softice) where DWARF unwinder went
		 * through non executable mmaps, which we need to lookup
		 * in MAP__VARIABLE tree.
		 */
		thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
				      MAP__VARIABLE, 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
67540759	69	e->ip = al.addr;
8bd508b0 JO	70	e->map = al.map;
8bd508b0 JO	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	97	MAP__FUNCTION, addr, &al);
0ba98149 JO	98	if (!al.map) {
	99	/*
	100	* We've seen cases (softice) where DWARF unwinder went
	101	* through non executable mmaps, which we need to lookup
	102	* in MAP__VARIABLE tree.
	103	*/
	104	thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
	105	MAP__VARIABLE, addr, &al);
	106	}
	107
5ea84154 JO	108	if (!al.map) {
	109	pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
	110	return -1;
	111	}
	112
	113	if (!al.map->dso)
	114	return -1;
	115
	116	size = dso__data_read_addr(al.map->dso, al.map, ui->machine,
	117	addr, (u8 ) data, sizeof(data));
	118
	119	return !(size == sizeof(*data));
	120	}
	121
	122	static bool memory_read(Dwfl dwfl __maybe_unused, Dwarf_Addr addr, Dwarf_Word result,
	123	void *arg)
	124	{
	125	struct unwind_info *ui = arg;
	126	struct stack_dump *stack = &ui->sample->user_stack;
	127	u64 start, end;
	128	int offset;
	129	int ret;
	130
	131	ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP);
	132	if (ret)
	133	return false;
	134
	135	end = start + stack->size;
	136
	137	/* Check overflow. */
	138	if (addr + sizeof(Dwarf_Word) < addr)
	139	return false;
	140
	141	if (addr < start \|\| addr + sizeof(Dwarf_Word) > end) {
	142	ret = access_dso_mem(ui, addr, result);
	143	if (ret) {
	144	pr_debug("unwind: access_mem 0x%" PRIx64 " not inside range"
	145	" 0x%" PRIx64 "-0x%" PRIx64 "\n",
	146	addr, start, end);
	147	return false;
	148	}
	149	return true;
	150	}
	151
	152	offset = addr - start;
	153	result = (Dwarf_Word *)&stack->data[offset];
	154	pr_debug("unwind: access_mem addr 0x%" PRIx64 ", val %lx, offset %d\n",
	155	addr, (unsigned long)*result, offset);
	156	return true;
	157	}
	158
	159	static const Dwfl_Thread_Callbacks callbacks = {
	160	.next_thread = next_thread,
	161	.memory_read = memory_read,
	162	.set_initial_registers = libdw__arch_set_initial_registers,
	163	};
	164
	165	static int
	166	frame_callback(Dwfl_Frame state, void arg)
	167	{
	168	struct unwind_info *ui = arg;
	169	Dwarf_Addr pc;
	170
	171	if (!dwfl_frame_pc(state, &pc, NULL)) {
172	pr_err("%s", dwfl_errmsg(-1));
173	return DWARF_CB_ABORT;
174	}
175
176	return entry(pc, ui) \|\| !(--ui->max_stack) ?
177	DWARF_CB_ABORT : DWARF_CB_OK;
178	}
179
180	int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
dd8c17a5	181	struct thread *thread,
5ea84154 JO	182	struct perf_sample *data,
	183	int max_stack)
	184	{
8bd508b0	185	struct unwind_info *ui, ui_buf = {
5ea84154 JO	186	.sample = data,
5ea84154 JO	187	.thread = thread,
dd8c17a5	188	.machine = thread->mg->machine,
5ea84154 JO	189	.cb = cb,
	190	.arg = arg,
	191	.max_stack = max_stack,
	192	};
	193	Dwarf_Word ip;
8bd508b0	194	int err = -EINVAL, i;
5ea84154 JO	195
	196	if (!data->user_regs.regs)
	197	return -EINVAL;
	198
8bd508b0 JO	199	ui = zalloc(sizeof(ui_buf) + sizeof(ui_buf.entries[0]) * max_stack);
	200	if (!ui)
	201	return -ENOMEM;
	202
	203	*ui = ui_buf;
	204
	205	ui->dwfl = dwfl_begin(&offline_callbacks);
	206	if (!ui->dwfl)
5ea84154 JO	207	goto out;
	208
	209	err = perf_reg_value(&ip, &data->user_regs, PERF_REG_IP);
	210	if (err)
	211	goto out;
	212
8bd508b0	213	err = report_module(ip, ui);
5ea84154 JO	214	if (err)
	215	goto out;
	216
8bd508b0	217	if (!dwfl_attach_state(ui->dwfl, EM_NONE, thread->tid, &callbacks, ui))
5ea84154 JO	218	goto out;
5ea84154 JO	219
8bd508b0	220	err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui);
5ea84154	221
8bd508b0	222	if (err && !ui->max_stack)
5ea84154 JO	223	err = 0;
5ea84154 JO	224
8bd508b0 JO	225	/*
	226	* Display what we got based on the order setup.
	227	*/
	228	for (i = 0; i < ui->idx && !err; i++) {
	229	int j = i;
	230
	231	if (callchain_param.order == ORDER_CALLER)
	232	j = ui->idx - i - 1;
	233
	234	err = ui->entries[j].ip ? ui->cb(&ui->entries[j], ui->arg) : 0;
	235	}
	236
5ea84154 JO	237	out:
	238	if (err)
	239	pr_debug("unwind: failed with '%s'\n", dwfl_errmsg(-1));
	240
8bd508b0 JO	241	dwfl_end(ui->dwfl);
8bd508b0 JO	242	free(ui);
5ea84154 JO	243	return 0;
5ea84154 JO	244	}