probe-finder.c 24.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * probe-finder.c : C expression to kprobe event converter
 *
 * Written by Masami Hiramatsu <mhiramat@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#include <sys/utsname.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
34

35
#include "string.h"
36 37
#include "event.h"
#include "debug.h"
38
#include "util.h"
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
#include "probe-finder.h"


/*
 * Generic dwarf analysis helpers
 */

#define X86_32_MAX_REGS 8
const char *x86_32_regs_table[X86_32_MAX_REGS] = {
	"%ax",
	"%cx",
	"%dx",
	"%bx",
	"$stack",	/* Stack address instead of %sp */
	"%bp",
	"%si",
	"%di",
};

#define X86_64_MAX_REGS 16
const char *x86_64_regs_table[X86_64_MAX_REGS] = {
	"%ax",
	"%dx",
	"%cx",
	"%bx",
	"%si",
	"%di",
	"%bp",
	"%sp",
	"%r8",
	"%r9",
	"%r10",
	"%r11",
	"%r12",
	"%r13",
	"%r14",
	"%r15",
};

/* TODO: switching by dwarf address size */
#ifdef __x86_64__
#define ARCH_MAX_REGS X86_64_MAX_REGS
#define arch_regs_table x86_64_regs_table
#else
#define ARCH_MAX_REGS X86_32_MAX_REGS
#define arch_regs_table x86_32_regs_table
#endif

/* Return architecture dependent register string (for kprobe-tracer) */
static const char *get_arch_regstr(unsigned int n)
{
	return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
}

/*
 * Compare the tail of two strings.
 * Return 0 if whole of either string is same as another's tail part.
 */
static int strtailcmp(const char *s1, const char *s2)
{
	int i1 = strlen(s1);
	int i2 = strlen(s2);
101
	while (--i1 >= 0 && --i2 >= 0) {
102 103 104 105 106 107
		if (s1[i1] != s2[i2])
			return s1[i1] - s2[i2];
	}
	return 0;
}

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
/* Line number list operations */

/* Add a line to line number list */
static void line_list__add_line(struct list_head *head, unsigned int line)
{
	struct line_node *ln;
	struct list_head *p;

	/* Reverse search, because new line will be the last one */
	list_for_each_entry_reverse(ln, head, list) {
		if (ln->line < line) {
			p = &ln->list;
			goto found;
		} else if (ln->line == line)	/* Already exist */
			return ;
	}
	/* List is empty, or the smallest entry */
	p = head;
found:
	pr_debug("line list: add a line %u\n", line);
128
	ln = xzalloc(sizeof(struct line_node));
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
	ln->line = line;
	INIT_LIST_HEAD(&ln->list);
	list_add(&ln->list, p);
}

/* Check if the line in line number list */
static int line_list__has_line(struct list_head *head, unsigned int line)
{
	struct line_node *ln;

	/* Reverse search, because new line will be the last one */
	list_for_each_entry(ln, head, list)
		if (ln->line == line)
			return 1;

	return 0;
}

/* Init line number list */
static void line_list__init(struct list_head *head)
{
	INIT_LIST_HEAD(head);
}

/* Free line number list */
static void line_list__free(struct list_head *head)
{
	struct line_node *ln;
	while (!list_empty(head)) {
		ln = list_first_entry(head, struct line_node, list);
		list_del(&ln->list);
		free(ln);
	}
}

/* Dwarf wrappers */

/* Find the realpath of the target file. */
static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
168
{
169 170
	Dwarf_Files *files;
	size_t nfiles, i;
171
	const char *src = NULL;
172 173 174
	int ret;

	if (!fname)
175
		return NULL;
176

177
	ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
178 179 180 181 182 183 184
	if (ret != 0)
		return NULL;

	for (i = 0; i < nfiles; i++) {
		src = dwarf_filesrc(files, i, NULL, NULL);
		if (strtailcmp(src, fname) == 0)
			break;
185
	}
186
	return src;
187 188
}

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
/* Compare diename and tname */
static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
{
	const char *name;
	name = dwarf_diename(dw_die);
	DIE_IF(name == NULL);
	return strcmp(tname, name);
}

/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
{
	Dwarf_Addr epc;
	int ret;

	ret = dwarf_entrypc(dw_die, &epc);
	DIE_IF(ret == -1);
	return epc;
}

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
/* Get type die, but skip qualifiers and typedef */
static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
{
	Dwarf_Attribute attr;
	int tag;

	do {
		if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL ||
		    dwarf_formref_die(&attr, die_mem) == NULL)
			return NULL;

		tag = dwarf_tag(die_mem);
		vr_die = die_mem;
	} while (tag == DW_TAG_const_type ||
		 tag == DW_TAG_restrict_type ||
		 tag == DW_TAG_volatile_type ||
		 tag == DW_TAG_shared_type ||
		 tag == DW_TAG_typedef);

	return die_mem;
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
/* Return values for die_find callbacks */
enum {
	DIE_FIND_CB_FOUND = 0,		/* End of Search */
	DIE_FIND_CB_CHILD = 1,		/* Search only children */
	DIE_FIND_CB_SIBLING = 2,	/* Search only siblings */
	DIE_FIND_CB_CONTINUE = 3,	/* Search children and siblings */
};

/* Search a child die */
static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
				 int (*callback)(Dwarf_Die *, void *),
				 void *data, Dwarf_Die *die_mem)
{
	Dwarf_Die child_die;
	int ret;

	ret = dwarf_child(rt_die, die_mem);
	if (ret != 0)
		return NULL;

	do {
		ret = callback(die_mem, data);
		if (ret == DIE_FIND_CB_FOUND)
			return die_mem;

		if ((ret & DIE_FIND_CB_CHILD) &&
		    die_find_child(die_mem, callback, data, &child_die)) {
			memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
			return die_mem;
		}
	} while ((ret & DIE_FIND_CB_SIBLING) &&
		 dwarf_siblingof(die_mem, die_mem) == 0);

	return NULL;
}

267 268 269 270 271 272
struct __addr_die_search_param {
	Dwarf_Addr	addr;
	Dwarf_Die	*die_mem;
};

static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
273
{
274
	struct __addr_die_search_param *ad = data;
275

276 277 278 279 280 281 282
	if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
	    dwarf_haspc(fn_die, ad->addr)) {
		memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
		return DWARF_CB_ABORT;
	}
	return DWARF_CB_OK;
}
283

284
/* Search a real subprogram including this line, */
285 286
static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
					   Dwarf_Die *die_mem)
287 288 289 290 291 292 293 294 295
{
	struct __addr_die_search_param ad;
	ad.addr = addr;
	ad.die_mem = die_mem;
	/* dwarf_getscopes can't find subprogram. */
	if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
		return NULL;
	else
		return die_mem;
296 297
}

298 299
/* die_find callback for inline function search */
static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
300
{
301
	Dwarf_Addr *addr = data;
302

303 304 305
	if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
	    dwarf_haspc(die_mem, *addr))
		return DIE_FIND_CB_FOUND;
306

307
	return DIE_FIND_CB_CONTINUE;
308 309
}

310 311 312
/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
				      Dwarf_Die *die_mem)
313
{
314
	return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
315 316
}

317
static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
318
{
319 320
	const char *name = data;
	int tag;
321

322 323 324 325 326 327 328
	tag = dwarf_tag(die_mem);
	if ((tag == DW_TAG_formal_parameter ||
	     tag == DW_TAG_variable) &&
	    (die_compare_name(die_mem, name) == 0))
		return DIE_FIND_CB_FOUND;

	return DIE_FIND_CB_CONTINUE;
329 330
}

331
/* Find a variable called 'name' */
332 333
static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
				    Dwarf_Die *die_mem)
334
{
335 336
	return die_find_child(sp_die, __die_find_variable_cb, (void *)name,
			      die_mem);
337 338
}

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
{
	const char *name = data;

	if ((dwarf_tag(die_mem) == DW_TAG_member) &&
	    (die_compare_name(die_mem, name) == 0))
		return DIE_FIND_CB_FOUND;

	return DIE_FIND_CB_SIBLING;
}

/* Find a member called 'name' */
static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
				  Dwarf_Die *die_mem)
{
	return die_find_child(st_die, __die_find_member_cb, (void *)name,
			      die_mem);
}

358 359 360 361 362
/*
 * Probe finder related functions
 */

/* Show a location */
363
static void convert_location(Dwarf_Op *op, struct probe_finder *pf)
364
{
365 366
	unsigned int regn;
	Dwarf_Word offs = 0;
367
	bool ref = false;
368
	const char *regs;
369
	struct kprobe_trace_arg *tvar = pf->tvar;
370

371
	/* TODO: support CFA */
372
	/* If this is based on frame buffer, set the offset */
373 374 375
	if (op->atom == DW_OP_fbreg) {
		if (pf->fb_ops == NULL)
			die("The attribute of frame base is not supported.\n");
376
		ref = true;
377 378 379
		offs = op->number;
		op = &pf->fb_ops[0];
	}
380

381 382 383
	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
		regn = op->atom - DW_OP_breg0;
		offs += op->number;
384
		ref = true;
385 386 387 388 389
	} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
		regn = op->atom - DW_OP_reg0;
	} else if (op->atom == DW_OP_bregx) {
		regn = op->number;
		offs += op->number2;
390
		ref = true;
391 392
	} else if (op->atom == DW_OP_regx) {
		regn = op->number;
393
	} else
394
		die("DW_OP %d is not supported.", op->atom);
395 396 397

	regs = get_arch_regstr(regn);
	if (!regs)
398
		die("%u exceeds max register number.", regn);
399

400 401 402 403 404
	tvar->value = xstrdup(regs);
	if (ref) {
		tvar->ref = xzalloc(sizeof(struct kprobe_trace_arg_ref));
		tvar->ref->offset = (long)offs;
	}
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
static void convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
				    struct perf_probe_arg_field *field,
				    struct kprobe_trace_arg_ref **ref_ptr)
{
	struct kprobe_trace_arg_ref *ref = *ref_ptr;
	Dwarf_Attribute attr;
	Dwarf_Die member;
	Dwarf_Die type;
	Dwarf_Word offs;

	pr_debug("converting %s in %s\n", field->name, varname);
	if (die_get_real_type(vr_die, &type) == NULL)
		die("Failed to get a type information of %s.", varname);

	/* Check the pointer and dereference */
	if (dwarf_tag(&type) == DW_TAG_pointer_type) {
		if (!field->ref)
			die("Semantic error: %s must be referred by '->'",
			    field->name);
		/* Get the type pointed by this pointer */
		if (die_get_real_type(&type, &type) == NULL)
			die("Failed to get a type information of %s.", varname);

		ref = xzalloc(sizeof(struct kprobe_trace_arg_ref));
		if (*ref_ptr)
			(*ref_ptr)->next = ref;
		else
			*ref_ptr = ref;
	} else {
		if (field->ref)
			die("Semantic error: %s must be referred by '.'",
			    field->name);
		if (!ref)
			die("Structure on a register is not supported yet.");
	}

	/* Verify it is a data structure  */
	if (dwarf_tag(&type) != DW_TAG_structure_type)
		die("%s is not a data structure.", varname);

	if (die_find_member(&type, field->name, &member) == NULL)
		die("%s(tyep:%s) has no member %s.", varname,
		    dwarf_diename(&type), field->name);

	/* Get the offset of the field */
	if (dwarf_attr(&member, DW_AT_data_member_location, &attr) == NULL ||
	    dwarf_formudata(&attr, &offs) != 0)
		die("Failed to get the offset of %s.", field->name);
	ref->offset += (long)offs;

	/* Converting next field */
	if (field->next)
		convert_variable_fields(&member, field->name, field->next,
					&ref);
}

463
/* Show a variables in kprobe event format */
464
static void convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
465 466
{
	Dwarf_Attribute attr;
467 468
	Dwarf_Op *expr;
	size_t nexpr;
469 470
	int ret;

471
	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
472
		goto error;
473
	/* TODO: handle more than 1 exprs */
474
	ret = dwarf_getlocation_addr(&attr, pf->addr, &expr, &nexpr, 1);
475
	if (ret <= 0 || nexpr == 0)
476
		goto error;
477

478
	convert_location(expr, pf);
479 480 481 482

	if (pf->pvar->field)
		convert_variable_fields(vr_die, pf->pvar->name,
					pf->pvar->field, &pf->tvar->ref);
483
	/* *expr will be cached in libdw. Don't free it. */
484 485
	return ;
error:
486
	/* TODO: Support const_value */
487
	die("Failed to find the location of %s at this address.\n"
488
	    " Perhaps, it has been optimized out.", pf->pvar->name);
489 490 491
}

/* Find a variable in a subprogram die */
492
static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
493
{
494
	Dwarf_Die vr_die;
495
	char buf[128];
496

497
	/* TODO: Support struct members and arrays */
498 499 500 501
	if (!is_c_varname(pf->pvar->name)) {
		/* Copy raw parameters */
		pf->tvar->value = xstrdup(pf->pvar->name);
	} else {
502 503
		synthesize_perf_probe_arg(pf->pvar, buf, 128);
		pf->tvar->name = xstrdup(buf);
504 505 506 507 508 509 510
		pr_debug("Searching '%s' variable in context.\n",
			 pf->pvar->name);
		/* Search child die for local variables and parameters. */
		if (!die_find_variable(sp_die, pf->pvar->name, &vr_die))
			die("Failed to find '%s' in this function.",
			    pf->pvar->name);
		convert_variable(&vr_die, pf);
511 512 513 514
	}
}

/* Show a probe point to output buffer */
515
static void convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
516
{
517
	struct kprobe_trace_event *tev;
518 519
	Dwarf_Addr eaddr;
	Dwarf_Die die_mem;
520
	const char *name;
521
	int ret, i;
522 523
	Dwarf_Attribute fb_attr;
	size_t nops;
524

525 526 527 528
	if (pf->ntevs == MAX_PROBES)
		die("Too many( > %d) probe point found.\n", MAX_PROBES);
	tev = &pf->tevs[pf->ntevs++];

529 530
	/* If no real subprogram, find a real one */
	if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
531
		sp_die = die_find_real_subprogram(&pf->cu_die,
532 533 534 535 536
						 pf->addr, &die_mem);
		if (!sp_die)
			die("Probe point is not found in subprograms.");
	}

537
	/* Copy the name of probe point */
538 539
	name = dwarf_diename(sp_die);
	if (name) {
540
		dwarf_entrypc(sp_die, &eaddr);
541 542 543
		tev->point.symbol = xstrdup(name);
		tev->point.offset = (unsigned long)(pf->addr - eaddr);
	} else
544
		/* This function has no name. */
545 546 547 548
		tev->point.offset = (unsigned long)pf->addr;

	pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
		 tev->point.offset);
549

550 551
	/* Get the frame base attribute/ops */
	dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
552
	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
553 554 555
	if (ret <= 0 || nops == 0)
		pf->fb_ops = NULL;

556
	/* Find each argument */
557
	/* TODO: use dwarf_cfi_addrframe */
558 559 560 561 562
	tev->nargs = pf->pev->nargs;
	tev->args = xzalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
	for (i = 0; i < pf->pev->nargs; i++) {
		pf->pvar = &pf->pev->args[i];
		pf->tvar = &tev->args[i];
563 564
		find_variable(sp_die, pf);
	}
565 566 567

	/* *pf->fb_ops will be cached in libdw. Don't free it. */
	pf->fb_ops = NULL;
568 569 570
}

/* Find probe point from its line number */
571
static void find_probe_point_by_line(struct probe_finder *pf)
572
{
573 574 575
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
576
	Dwarf_Addr addr;
577
	int lineno;
578 579
	int ret;

580 581
	ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
582

583 584 585
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);
		dwarf_lineno(line, &lineno);
586
		if (lineno != pf->lno)
587 588
			continue;

589 590 591
		/* TODO: Get fileno from line, but how? */
		if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
			continue;
592

593 594 595 596
		ret = dwarf_lineaddr(line, &addr);
		DIE_IF(ret != 0);
		pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
			 (int)i, lineno, (uintmax_t)addr);
597
		pf->addr = addr;
598

599
		convert_probe_point(NULL, pf);
600 601 602 603
		/* Continuing, because target line might be inlined. */
	}
}

604 605 606 607 608 609 610 611 612 613 614 615
/* Find lines which match lazy pattern */
static int find_lazy_match_lines(struct list_head *head,
				 const char *fname, const char *pat)
{
	char *fbuf, *p1, *p2;
	int fd, line, nlines = 0;
	struct stat st;

	fd = open(fname, O_RDONLY);
	if (fd < 0)
		die("failed to open %s", fname);
	DIE_IF(fstat(fd, &st) < 0);
616
	fbuf = xmalloc(st.st_size + 2);
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
	DIE_IF(read(fd, fbuf, st.st_size) < 0);
	close(fd);
	fbuf[st.st_size] = '\n';	/* Dummy line */
	fbuf[st.st_size + 1] = '\0';
	p1 = fbuf;
	line = 1;
	while ((p2 = strchr(p1, '\n')) != NULL) {
		*p2 = '\0';
		if (strlazymatch(p1, pat)) {
			line_list__add_line(head, line);
			nlines++;
		}
		line++;
		p1 = p2 + 1;
	}
	free(fbuf);
	return nlines;
}

/* Find probe points from lazy pattern  */
static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
{
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
	Dwarf_Addr addr;
	Dwarf_Die die_mem;
	int lineno;
	int ret;

	if (list_empty(&pf->lcache)) {
		/* Matching lazy line pattern */
		ret = find_lazy_match_lines(&pf->lcache, pf->fname,
650
					    pf->pev->point.lazy_line);
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
		if (ret <= 0)
			die("No matched lines found in %s.", pf->fname);
	}

	ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);

		dwarf_lineno(line, &lineno);
		if (!line_list__has_line(&pf->lcache, lineno))
			continue;

		/* TODO: Get fileno from line, but how? */
		if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
			continue;

		ret = dwarf_lineaddr(line, &addr);
		DIE_IF(ret != 0);
		if (sp_die) {
			/* Address filtering 1: does sp_die include addr? */
			if (!dwarf_haspc(sp_die, addr))
				continue;
			/* Address filtering 2: No child include addr? */
675
			if (die_find_inlinefunc(sp_die, addr, &die_mem))
676 677 678 679 680 681 682
				continue;
		}

		pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
			 (int)i, lineno, (unsigned long long)addr);
		pf->addr = addr;

683
		convert_probe_point(sp_die, pf);
684 685 686 687 688
		/* Continuing, because target line might be inlined. */
	}
	/* TODO: deallocate lines, but how? */
}

689 690 691
static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
{
	struct probe_finder *pf = (struct probe_finder *)data;
692
	struct perf_probe_point *pp = &pf->pev->point;
693

694 695 696 697 698 699 700 701 702
	if (pp->lazy_line)
		find_probe_point_lazy(in_die, pf);
	else {
		/* Get probe address */
		pf->addr = die_get_entrypc(in_die);
		pf->addr += pp->offset;
		pr_debug("found inline addr: 0x%jx\n",
			 (uintmax_t)pf->addr);

703
		convert_probe_point(in_die, pf);
704
	}
705 706 707

	return DWARF_CB_OK;
}
708

709
/* Search function from function name */
710
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
711 712
{
	struct probe_finder *pf = (struct probe_finder *)data;
713
	struct perf_probe_point *pp = &pf->pev->point;
714

715 716 717 718 719
	/* Check tag and diename */
	if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
	    die_compare_name(sp_die, pp->function) != 0)
		return 0;

720
	pf->fname = dwarf_decl_file(sp_die);
721 722 723 724 725 726
	if (pp->line) { /* Function relative line */
		dwarf_decl_line(sp_die, &pf->lno);
		pf->lno += pp->line;
		find_probe_point_by_line(pf);
	} else if (!dwarf_func_inline(sp_die)) {
		/* Real function */
727 728 729 730 731 732
		if (pp->lazy_line)
			find_probe_point_lazy(sp_die, pf);
		else {
			pf->addr = die_get_entrypc(sp_die);
			pf->addr += pp->offset;
			/* TODO: Check the address in this function */
733
			convert_probe_point(sp_die, pf);
734
		}
735 736 737 738 739
	} else
		/* Inlined function: search instances */
		dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);

	return 1; /* Exit; no same symbol in this CU. */
740 741
}

742
static void find_probe_point_by_func(struct probe_finder *pf)
743
{
744
	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
745 746
}

747 748 749
/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
			     struct kprobe_trace_event **tevs)
750
{
751 752
	struct probe_finder pf = {.pev = pev};
	struct perf_probe_point *pp = &pev->point;
753 754 755 756 757
	Dwarf_Off off, noff;
	size_t cuhl;
	Dwarf_Die *diep;
	Dwarf *dbg;

758 759 760 761
	pf.tevs = xzalloc(sizeof(struct kprobe_trace_event) * MAX_PROBES);
	*tevs = pf.tevs;
	pf.ntevs = 0;

762 763
	dbg = dwarf_begin(fd, DWARF_C_READ);
	if (!dbg)
764
		return -ENOENT;
765

766
	off = 0;
767
	line_list__init(&pf.lcache);
768 769
	/* Loop on CUs (Compilation Unit) */
	while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
770
		/* Get the DIE(Debugging Information Entry) of this CU */
771 772 773
		diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
		if (!diep)
			continue;
774 775 776

		/* Check if target file is included. */
		if (pp->file)
777
			pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
778
		else
779
			pf.fname = NULL;
780

781
		if (!pp->file || pf.fname) {
782
			if (pp->function)
783
				find_probe_point_by_func(&pf);
784 785
			else if (pp->lazy_line)
				find_probe_point_lazy(NULL, &pf);
786 787
			else {
				pf.lno = pp->line;
788
				find_probe_point_by_line(&pf);
789
			}
790
		}
791
		off = noff;
792
	}
793
	line_list__free(&pf.lcache);
794
	dwarf_end(dbg);
795

796
	return pf.ntevs;
797 798
}

799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
/* Reverse search */
int find_perf_probe_point(int fd, unsigned long addr,
			  struct perf_probe_point *ppt)
{
	Dwarf_Die cudie, spdie, indie;
	Dwarf *dbg;
	Dwarf_Line *line;
	Dwarf_Addr laddr, eaddr;
	const char *tmp;
	int lineno, ret = 0;

	dbg = dwarf_begin(fd, DWARF_C_READ);
	if (!dbg)
		return -ENOENT;

	/* Find cu die */
	if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie))
		return -EINVAL;

	/* Find a corresponding line */
	line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
	if (line) {
		dwarf_lineaddr(line, &laddr);
		if ((Dwarf_Addr)addr == laddr) {
			dwarf_lineno(line, &lineno);
			ppt->line = lineno;

			tmp = dwarf_linesrc(line, NULL, NULL);
			DIE_IF(!tmp);
			ppt->file = xstrdup(tmp);
			ret = 1;
		}
	}

	/* Find a corresponding function */
	if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
		tmp = dwarf_diename(&spdie);
		if (!tmp)
			goto end;

		dwarf_entrypc(&spdie, &eaddr);
		if (!lineno) {
			/* We don't have a line number, let's use offset */
			ppt->function = xstrdup(tmp);
			ppt->offset = addr - (unsigned long)eaddr;
			ret = 1;
			goto end;
		}
		if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr, &indie)) {
			/* addr in an inline function */
			tmp = dwarf_diename(&indie);
			if (!tmp)
				goto end;
			dwarf_decl_line(&indie, &lineno);
		} else {
			if (eaddr == addr)	/* No offset: function entry */
				lineno = ppt->line;
			else
				dwarf_decl_line(&spdie, &lineno);
		}
		ppt->function = xstrdup(tmp);
		ppt->line -= lineno;	/* Make a relative line number */
	}

end:
	dwarf_end(dbg);
	return ret;
}


869
/* Find line range from its line number */
870
static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
871
{
872 873 874
	Dwarf_Lines *lines;
	Dwarf_Line *line;
	size_t nlines, i;
875
	Dwarf_Addr addr;
876
	int lineno;
877
	int ret;
878
	const char *src;
879
	Dwarf_Die die_mem;
880

881
	line_list__init(&lf->lr->line_list);
882 883
	ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines);
	DIE_IF(ret != 0);
884

885 886
	for (i = 0; i < nlines; i++) {
		line = dwarf_onesrcline(lines, i);
887 888
		ret = dwarf_lineno(line, &lineno);
		DIE_IF(ret != 0);
889
		if (lf->lno_s > lineno || lf->lno_e < lineno)
890 891
			continue;

892 893 894 895 896 897 898 899
		if (sp_die) {
			/* Address filtering 1: does sp_die include addr? */
			ret = dwarf_lineaddr(line, &addr);
			DIE_IF(ret != 0);
			if (!dwarf_haspc(sp_die, addr))
				continue;

			/* Address filtering 2: No child include addr? */
900
			if (die_find_inlinefunc(sp_die, addr, &die_mem))
901 902 903
				continue;
		}

904 905 906
		/* TODO: Get fileno from line, but how? */
		src = dwarf_linesrc(line, NULL, NULL);
		if (strtailcmp(src, lf->fname) != 0)
907 908
			continue;

909 910
		/* Copy real path */
		if (!lf->lr->path)
911
			lf->lr->path = xstrdup(src);
912
		line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
913
	}
914
	/* Update status */
915 916
	if (!list_empty(&lf->lr->line_list))
		lf->found = 1;
917 918 919 920
	else {
		free(lf->lr->path);
		lf->lr->path = NULL;
	}
921 922
}

923 924 925 926 927 928
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
{
	find_line_range_by_line(in_die, (struct line_finder *)data);
	return DWARF_CB_ABORT;	/* No need to find other instances */
}

929
/* Search function from function name */
930
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
931 932 933 934
{
	struct line_finder *lf = (struct line_finder *)data;
	struct line_range *lr = lf->lr;

935 936 937 938
	if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
	    die_compare_name(sp_die, lr->function) == 0) {
		lf->fname = dwarf_decl_file(sp_die);
		dwarf_decl_line(sp_die, &lr->offset);
939
		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
940 941
		lf->lno_s = lr->offset + lr->start;
		if (!lr->end)
942
			lf->lno_e = INT_MAX;
943 944 945 946
		else
			lf->lno_e = lr->offset + lr->end;
		lr->start = lf->lno_s;
		lr->end = lf->lno_e;
947 948 949 950 951
		if (dwarf_func_inline(sp_die))
			dwarf_func_inline_instances(sp_die,
						    line_range_inline_cb, lf);
		else
			find_line_range_by_line(sp_die, lf);
952 953 954 955 956 957 958
		return 1;
	}
	return 0;
}

static void find_line_range_by_func(struct line_finder *lf)
{
959
	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
960 961 962 963
}

int find_line_range(int fd, struct line_range *lr)
{
964
	struct line_finder lf = {.lr = lr, .found = 0};
965
	int ret;
966 967 968 969 970 971 972
	Dwarf_Off off = 0, noff;
	size_t cuhl;
	Dwarf_Die *diep;
	Dwarf *dbg;

	dbg = dwarf_begin(fd, DWARF_C_READ);
	if (!dbg)
973 974
		return -ENOENT;

975
	/* Loop on CUs (Compilation Unit) */
976
	while (!lf.found) {
977 978
		ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
		if (ret != 0)
979 980 981
			break;

		/* Get the DIE(Debugging Information Entry) of this CU */
982 983 984
		diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
		if (!diep)
			continue;
985 986 987

		/* Check if target file is included. */
		if (lr->file)
988
			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
989
		else
990
			lf.fname = 0;
991

992
		if (!lr->file || lf.fname) {
993 994 995 996 997
			if (lr->function)
				find_line_range_by_func(&lf);
			else {
				lf.lno_s = lr->start;
				if (!lr->end)
998
					lf.lno_e = INT_MAX;
999 1000
				else
					lf.lno_e = lr->end;
1001
				find_line_range_by_line(NULL, &lf);
1002 1003
			}
		}
1004
		off = noff;
1005
	}
1006 1007
	pr_debug("path: %lx\n", (unsigned long)lr->path);
	dwarf_end(dbg);
1008 1009 1010
	return lf.found;
}