probe-finder.c 41.9 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
/*
 * 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>
33
#include <dwarf-regs.h>
34

35
#include <linux/bitops.h>
36 37
#include "event.h"
#include "debug.h"
38
#include "util.h"
39
#include "symbol.h"
40 41
#include "probe-finder.h"

42 43 44
/* Kprobe tracer basic type is up to u64 */
#define MAX_BASIC_TYPE_BITS	64

45 46 47
/* Line number list operations */

/* Add a line to line number list */
48
static int line_list__add_line(struct list_head *head, int line)
49 50 51 52 53 54 55 56 57 58
{
	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 */
59
			return 1;
60 61 62 63 64
	}
	/* List is empty, or the smallest entry */
	p = head;
found:
	pr_debug("line list: add a line %u\n", line);
65 66 67
	ln = zalloc(sizeof(struct line_node));
	if (ln == NULL)
		return -ENOMEM;
68 69 70
	ln->line = line;
	INIT_LIST_HEAD(&ln->list);
	list_add(&ln->list, p);
71
	return 0;
72 73 74
}

/* Check if the line in line number list */
75
static int line_list__has_line(struct list_head *head, int line)
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 101 102 103
{
	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);
	}
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117
/* Dwarf FL wrappers */
static char *debuginfo_path;	/* Currently dummy */

static const Dwfl_Callbacks offline_callbacks = {
	.find_debuginfo = dwfl_standard_find_debuginfo,
	.debuginfo_path = &debuginfo_path,

	.section_address = dwfl_offline_section_address,

	/* We use this table for core files too.  */
	.find_elf = dwfl_build_id_find_elf,
};

/* Get a Dwarf from offline image */
118 119
static int debuginfo__init_offline_dwarf(struct debuginfo *self,
					 const char *path)
120
{
121
	int fd;
122

123 124 125
	fd = open(path, O_RDONLY);
	if (fd < 0)
		return fd;
126

127 128 129
	self->dwfl = dwfl_begin(&offline_callbacks);
	if (!self->dwfl)
		goto error;
130

131 132
	self->mod = dwfl_report_offline(self->dwfl, "", "", fd);
	if (!self->mod)
133 134
		goto error;

135
	self->dbg = dwfl_module_getdwarf(self->mod, &self->bias);
136 137 138 139
	if (!self->dbg)
		goto error;

	return 0;
140
error:
141 142 143 144 145 146 147
	if (self->dwfl)
		dwfl_end(self->dwfl);
	else
		close(fd);
	memset(self, 0, sizeof(*self));

	return -ENOENT;
148 149
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
#if _ELFUTILS_PREREQ(0, 148)
/* This method is buggy if elfutils is older than 0.148 */
static int __linux_kernel_find_elf(Dwfl_Module *mod,
				   void **userdata,
				   const char *module_name,
				   Dwarf_Addr base,
				   char **file_name, Elf **elfp)
{
	int fd;
	const char *path = kernel_get_module_path(module_name);

	pr_debug2("Use file %s for %s\n", path, module_name);
	if (path) {
		fd = open(path, O_RDONLY);
		if (fd >= 0) {
			*file_name = strdup(path);
			return fd;
		}
	}
	/* If failed, try to call standard method */
	return dwfl_linux_kernel_find_elf(mod, userdata, module_name, base,
					  file_name, elfp);
}

static const Dwfl_Callbacks kernel_callbacks = {
	.find_debuginfo = dwfl_standard_find_debuginfo,
	.debuginfo_path = &debuginfo_path,

	.find_elf = __linux_kernel_find_elf,
	.section_address = dwfl_linux_kernel_module_section_address,
};

182
/* Get a Dwarf from live kernel image */
183 184
static int debuginfo__init_online_kernel_dwarf(struct debuginfo *self,
					       Dwarf_Addr addr)
185
{
186 187 188
	self->dwfl = dwfl_begin(&kernel_callbacks);
	if (!self->dwfl)
		return -EINVAL;
189 190

	/* Load the kernel dwarves: Don't care the result here */
191 192
	dwfl_linux_kernel_report_kernel(self->dwfl);
	dwfl_linux_kernel_report_modules(self->dwfl);
193

194
	self->dbg = dwfl_addrdwarf(self->dwfl, addr, &self->bias);
195
	/* Here, check whether we could get a real dwarf */
196
	if (!self->dbg) {
197 198
		pr_debug("Failed to find kernel dwarf at %lx\n",
			 (unsigned long)addr);
199 200 201
		dwfl_end(self->dwfl);
		memset(self, 0, sizeof(*self));
		return -ENOENT;
202
	}
203 204

	return 0;
205
}
206 207
#else
/* With older elfutils, this just support kernel module... */
208
static int debuginfo__init_online_kernel_dwarf(struct debuginfo *self,
209
					       Dwarf_Addr addr __maybe_unused)
210 211 212 213 214
{
	const char *path = kernel_get_module_path("kernel");

	if (!path) {
		pr_err("Failed to find vmlinux path\n");
215
		return -ENOENT;
216 217 218
	}

	pr_debug2("Use file %s for debuginfo\n", path);
219 220 221 222 223 224 225 226
	return debuginfo__init_offline_dwarf(self, path);
}
#endif

struct debuginfo *debuginfo__new(const char *path)
{
	struct debuginfo *self = zalloc(sizeof(struct debuginfo));
	if (!self)
227 228
		return NULL;

229 230 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
	if (debuginfo__init_offline_dwarf(self, path) < 0) {
		free(self);
		self = NULL;
	}

	return self;
}

struct debuginfo *debuginfo__new_online_kernel(unsigned long addr)
{
	struct debuginfo *self = zalloc(sizeof(struct debuginfo));
	if (!self)
		return NULL;

	if (debuginfo__init_online_kernel_dwarf(self, (Dwarf_Addr)addr) < 0) {
		free(self);
		self = NULL;
	}

	return self;
}

void debuginfo__delete(struct debuginfo *self)
{
	if (self) {
		if (self->dwfl)
			dwfl_end(self->dwfl);
		free(self);
	}
258
}
259

260 261 262 263
/*
 * Probe finder related functions
 */

264
static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
265
{
266 267
	struct probe_trace_arg_ref *ref;
	ref = zalloc(sizeof(struct probe_trace_arg_ref));
268 269 270 271 272
	if (ref != NULL)
		ref->offset = offs;
	return ref;
}

273 274 275
/*
 * Convert a location into trace_arg.
 * If tvar == NULL, this just checks variable can be converted.
276 277
 * If fentry == true and vr_die is a parameter, do huristic search
 * for the location fuzzed by function entry mcount.
278 279
 */
static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
280
				     Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
281
				     struct probe_trace_arg *tvar)
282
{
283
	Dwarf_Attribute attr;
284
	Dwarf_Addr tmp = 0;
285 286
	Dwarf_Op *op;
	size_t nops;
287 288
	unsigned int regn;
	Dwarf_Word offs = 0;
289
	bool ref = false;
290
	const char *regs;
291 292
	int ret;

293 294 295
	if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
		goto static_var;

296
	/* TODO: handle more than 1 exprs */
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
		return -EINVAL;	/* Broken DIE ? */
	if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
		ret = dwarf_entrypc(sp_die, &tmp);
		if (ret || addr != tmp ||
		    dwarf_tag(vr_die) != DW_TAG_formal_parameter ||
		    dwarf_highpc(sp_die, &tmp))
			return -ENOENT;
		/*
		 * This is fuzzed by fentry mcount. We try to find the
		 * parameter location at the earliest address.
		 */
		for (addr += 1; addr <= tmp; addr++) {
			if (dwarf_getlocation_addr(&attr, addr, &op,
						   &nops, 1) > 0)
				goto found;
		}
314 315
		return -ENOENT;
	}
316 317 318 319
found:
	if (nops == 0)
		/* TODO: Support const_value */
		return -ENOENT;
320 321

	if (op->atom == DW_OP_addr) {
322
static_var:
323 324
		if (!tvar)
			return 0;
325 326 327 328 329 330 331 332 333 334 335
		/* Static variables on memory (not stack), make @varname */
		ret = strlen(dwarf_diename(vr_die));
		tvar->value = zalloc(ret + 2);
		if (tvar->value == NULL)
			return -ENOMEM;
		snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
		tvar->ref = alloc_trace_arg_ref((long)offs);
		if (tvar->ref == NULL)
			return -ENOMEM;
		return 0;
	}
336 337

	/* If this is based on frame buffer, set the offset */
338
	if (op->atom == DW_OP_fbreg) {
339
		if (fb_ops == NULL)
340
			return -ENOTSUP;
341
		ref = true;
342
		offs = op->number;
343
		op = &fb_ops[0];
344
	}
345

346 347 348
	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
		regn = op->atom - DW_OP_breg0;
		offs += op->number;
349
		ref = true;
350 351 352 353 354
	} 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;
355
		ref = true;
356 357
	} else if (op->atom == DW_OP_regx) {
		regn = op->number;
358
	} else {
359
		pr_debug("DW_OP %x is not supported.\n", op->atom);
360 361
		return -ENOTSUP;
	}
362

363 364 365
	if (!tvar)
		return 0;

366
	regs = get_arch_regstr(regn);
367
	if (!regs) {
368
		/* This should be a bug in DWARF or this tool */
M
Masami Hiramatsu 已提交
369 370
		pr_warning("Mapping for the register number %u "
			   "missing on this architecture.\n", regn);
371 372
		return -ERANGE;
	}
373

374 375 376 377
	tvar->value = strdup(regs);
	if (tvar->value == NULL)
		return -ENOMEM;

378
	if (ref) {
379
		tvar->ref = alloc_trace_arg_ref((long)offs);
380 381
		if (tvar->ref == NULL)
			return -ENOMEM;
382
	}
383
	return 0;
384 385
}

386 387
#define BYTES_TO_BITS(nb)	((nb) * BITS_PER_LONG / sizeof(long))

388
static int convert_variable_type(Dwarf_Die *vr_die,
389
				 struct probe_trace_arg *tvar,
390
				 const char *cast)
391
{
392
	struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
393 394
	Dwarf_Die type;
	char buf[16];
395
	int bsize, boffs, total;
396 397
	int ret;

398 399 400 401 402 403 404
	/* TODO: check all types */
	if (cast && strcmp(cast, "string") != 0) {
		/* Non string type is OK */
		tvar->type = strdup(cast);
		return (tvar->type == NULL) ? -ENOMEM : 0;
	}

405 406
	bsize = dwarf_bitsize(vr_die);
	if (bsize > 0) {
407
		/* This is a bitfield */
408 409 410 411 412 413
		boffs = dwarf_bitoffset(vr_die);
		total = dwarf_bytesize(vr_die);
		if (boffs < 0 || total < 0)
			return -ENOENT;
		ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs,
				BYTES_TO_BITS(total));
414 415 416
		goto formatted;
	}

417 418 419 420 421
	if (die_get_real_type(vr_die, &type) == NULL) {
		pr_warning("Failed to get a type information of %s.\n",
			   dwarf_diename(vr_die));
		return -ENOENT;
	}
422

423 424 425
	pr_debug("%s type is %s.\n",
		 dwarf_diename(vr_die), dwarf_diename(&type));

426 427 428 429 430
	if (cast && strcmp(cast, "string") == 0) {	/* String type */
		ret = dwarf_tag(&type);
		if (ret != DW_TAG_pointer_type &&
		    ret != DW_TAG_array_type) {
			pr_warning("Failed to cast into string: "
M
Masami Hiramatsu 已提交
431
				   "%s(%s) is not a pointer nor array.\n",
432 433 434
				   dwarf_diename(vr_die), dwarf_diename(&type));
			return -EINVAL;
		}
435 436 437 438 439
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get a type"
				   " information.\n");
			return -ENOENT;
		}
440 441 442 443
		if (ret == DW_TAG_pointer_type) {
			while (*ref_ptr)
				ref_ptr = &(*ref_ptr)->next;
			/* Add new reference with offset +0 */
444
			*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
445 446 447 448 449
			if (*ref_ptr == NULL) {
				pr_warning("Out of memory error\n");
				return -ENOMEM;
			}
		}
450 451
		if (!die_compare_name(&type, "char") &&
		    !die_compare_name(&type, "unsigned char")) {
452
			pr_warning("Failed to cast into string: "
M
Masami Hiramatsu 已提交
453
				   "%s is not (unsigned) char *.\n",
454 455 456 457 458 459 460
				   dwarf_diename(vr_die));
			return -EINVAL;
		}
		tvar->type = strdup(cast);
		return (tvar->type == NULL) ? -ENOMEM : 0;
	}

461 462
	ret = dwarf_bytesize(&type);
	if (ret <= 0)
463 464
		/* No size ... try to use default type */
		return 0;
465
	ret = BYTES_TO_BITS(ret);
466

467 468 469 470 471
	/* Check the bitwidth */
	if (ret > MAX_BASIC_TYPE_BITS) {
		pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
			dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
		ret = MAX_BASIC_TYPE_BITS;
472
	}
473 474 475 476 477 478 479 480 481 482 483 484 485 486
	ret = snprintf(buf, 16, "%c%d",
		       die_is_signed_type(&type) ? 's' : 'u', ret);

formatted:
	if (ret < 0 || ret >= 16) {
		if (ret >= 16)
			ret = -E2BIG;
		pr_warning("Failed to convert variable type: %s\n",
			   strerror(-ret));
		return ret;
	}
	tvar->type = strdup(buf);
	if (tvar->type == NULL)
		return -ENOMEM;
487
	return 0;
488 489
}

490
static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
491
				    struct perf_probe_arg_field *field,
492
				    struct probe_trace_arg_ref **ref_ptr,
493
				    Dwarf_Die *die_mem)
494
{
495
	struct probe_trace_arg_ref *ref = *ref_ptr;
496 497
	Dwarf_Die type;
	Dwarf_Word offs;
498
	int ret, tag;
499 500

	pr_debug("converting %s in %s\n", field->name, varname);
501 502 503 504
	if (die_get_real_type(vr_die, &type) == NULL) {
		pr_warning("Failed to get the type of %s.\n", varname);
		return -ENOENT;
	}
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
	pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
	tag = dwarf_tag(&type);

	if (field->name[0] == '[' &&
	    (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
		if (field->next)
			/* Save original type for next field */
			memcpy(die_mem, &type, sizeof(*die_mem));
		/* Get the type of this array */
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get the type of %s.\n", varname);
			return -ENOENT;
		}
		pr_debug2("Array real type: (%x)\n",
			 (unsigned)dwarf_dieoffset(&type));
		if (tag == DW_TAG_pointer_type) {
521
			ref = zalloc(sizeof(struct probe_trace_arg_ref));
522 523 524 525 526 527 528
			if (ref == NULL)
				return -ENOMEM;
			if (*ref_ptr)
				(*ref_ptr)->next = ref;
			else
				*ref_ptr = ref;
		}
529
		ref->offset += dwarf_bytesize(&type) * field->index;
530 531 532 533 534 535
		if (!field->next)
			/* Save vr_die for converting types */
			memcpy(die_mem, vr_die, sizeof(*die_mem));
		goto next;
	} else if (tag == DW_TAG_pointer_type) {
		/* Check the pointer and dereference */
536 537 538 539 540
		if (!field->ref) {
			pr_err("Semantic error: %s must be referred by '->'\n",
			       field->name);
			return -EINVAL;
		}
541
		/* Get the type pointed by this pointer */
542 543 544 545
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get the type of %s.\n", varname);
			return -ENOENT;
		}
546
		/* Verify it is a data structure  */
547 548 549 550
		tag = dwarf_tag(&type);
		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
			pr_warning("%s is not a data structure nor an union.\n",
				   varname);
551 552
			return -EINVAL;
		}
553

554
		ref = zalloc(sizeof(struct probe_trace_arg_ref));
555 556
		if (ref == NULL)
			return -ENOMEM;
557 558 559 560 561
		if (*ref_ptr)
			(*ref_ptr)->next = ref;
		else
			*ref_ptr = ref;
	} else {
562
		/* Verify it is a data structure  */
563 564 565
		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
			pr_warning("%s is not a data structure nor an union.\n",
				   varname);
566 567
			return -EINVAL;
		}
568
		if (field->name[0] == '[') {
M
Masami Hiramatsu 已提交
569 570
			pr_err("Semantic error: %s is not a pointor"
			       " nor array.\n", varname);
571 572
			return -EINVAL;
		}
573 574 575 576 577 578 579 580 581 582
		if (field->ref) {
			pr_err("Semantic error: %s must be referred by '.'\n",
			       field->name);
			return -EINVAL;
		}
		if (!ref) {
			pr_warning("Structure on a register is not "
				   "supported yet.\n");
			return -ENOTSUP;
		}
583 584
	}

585 586 587 588 589
	if (die_find_member(&type, field->name, die_mem) == NULL) {
		pr_warning("%s(tyep:%s) has no member %s.\n", varname,
			   dwarf_diename(&type), field->name);
		return -EINVAL;
	}
590 591

	/* Get the offset of the field */
592 593 594 595 596 597 598 599 600
	if (tag == DW_TAG_union_type) {
		offs = 0;
	} else {
		ret = die_get_data_member_location(die_mem, &offs);
		if (ret < 0) {
			pr_warning("Failed to get the offset of %s.\n",
				   field->name);
			return ret;
		}
601
	}
602 603
	ref->offset += (long)offs;

604
next:
605 606
	/* Converting next field */
	if (field->next)
607
		return convert_variable_fields(die_mem, field->name,
608
					field->next, &ref, die_mem);
609 610
	else
		return 0;
611 612
}

613
/* Show a variables in kprobe event format */
614
static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
615
{
616
	Dwarf_Die die_mem;
617 618
	int ret;

619 620
	pr_debug("Converting variable %s into trace event.\n",
		 dwarf_diename(vr_die));
621

622
	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
623
					&pf->sp_die, pf->tvar);
624 625 626 627 628 629
	if (ret == -ENOENT)
		pr_err("Failed to find the location of %s at this address.\n"
		       " Perhaps, it has been optimized out.\n", pf->pvar->var);
	else if (ret == -ENOTSUP)
		pr_err("Sorry, we don't support this variable location yet.\n");
	else if (pf->pvar->field) {
630 631 632
		ret = convert_variable_fields(vr_die, pf->pvar->var,
					      pf->pvar->field, &pf->tvar->ref,
					      &die_mem);
633 634
		vr_die = &die_mem;
	}
635 636
	if (ret == 0)
		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
637
	/* *expr will be cached in libdw. Don't free it. */
638
	return ret;
639 640
}

641 642
/* Find a variable in a scope DIE */
static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
643
{
644
	Dwarf_Die vr_die;
645
	char buf[32], *ptr;
646
	int ret = 0;
647

648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
	if (!is_c_varname(pf->pvar->var)) {
		/* Copy raw parameters */
		pf->tvar->value = strdup(pf->pvar->var);
		if (pf->tvar->value == NULL)
			return -ENOMEM;
		if (pf->pvar->type) {
			pf->tvar->type = strdup(pf->pvar->type);
			if (pf->tvar->type == NULL)
				return -ENOMEM;
		}
		if (pf->pvar->name) {
			pf->tvar->name = strdup(pf->pvar->name);
			if (pf->tvar->name == NULL)
				return -ENOMEM;
		} else
			pf->tvar->name = NULL;
		return 0;
	}

667
	if (pf->pvar->name)
668
		pf->tvar->name = strdup(pf->pvar->name);
669
	else {
670 671 672
		ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
		if (ret < 0)
			return ret;
673 674 675
		ptr = strchr(buf, ':');	/* Change type separator to _ */
		if (ptr)
			*ptr = '_';
676
		pf->tvar->name = strdup(buf);
677
	}
678 679
	if (pf->tvar->name == NULL)
		return -ENOMEM;
680

681
	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
682
	/* Search child die for local variables and parameters. */
683 684 685 686
	if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
		/* Search again in global variables */
		if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
			ret = -ENOENT;
687
	}
688
	if (ret >= 0)
689 690
		ret = convert_variable(&vr_die, pf);

691
	if (ret < 0)
692 693
		pr_warning("Failed to find '%s' in this function.\n",
			   pf->pvar->var);
694
	return ret;
695 696
}

697
/* Convert subprogram DIE to trace point */
698 699 700
static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
				  Dwarf_Addr paddr, bool retprobe,
				  struct probe_trace_point *tp)
701
{
702
	Dwarf_Addr eaddr, highaddr;
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
	GElf_Sym sym;
	const char *symbol;

	/* Verify the address is correct */
	if (dwarf_entrypc(sp_die, &eaddr) != 0) {
		pr_warning("Failed to get entry address of %s\n",
			   dwarf_diename(sp_die));
		return -ENOENT;
	}
	if (dwarf_highpc(sp_die, &highaddr) != 0) {
		pr_warning("Failed to get end address of %s\n",
			   dwarf_diename(sp_die));
		return -ENOENT;
	}
	if (paddr > highaddr) {
		pr_warning("Offset specified is greater than size of %s\n",
			   dwarf_diename(sp_die));
		return -EINVAL;
	}

	/* Get an appropriate symbol from symtab */
	symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
	if (!symbol) {
		pr_warning("Failed to find symbol at 0x%lx\n",
			   (unsigned long)paddr);
		return -ENOENT;
	}
	tp->offset = (unsigned long)(paddr - sym.st_value);
	tp->symbol = strdup(symbol);
	if (!tp->symbol)
		return -ENOMEM;
734

735
	/* Return probe must be on the head of a subprogram */
736 737
	if (retprobe) {
		if (eaddr != paddr) {
738
			pr_warning("Return probe must be on the head of"
M
Masami Hiramatsu 已提交
739
				   " a real function.\n");
740 741
			return -EINVAL;
		}
742
		tp->retprobe = true;
743 744
	}

745 746 747
	return 0;
}

748 749
/* Call probe_finder callback with scope DIE */
static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
750 751 752 753 754
{
	Dwarf_Attribute fb_attr;
	size_t nops;
	int ret;

755 756 757 758 759 760
	if (!sc_die) {
		pr_err("Caller must pass a scope DIE. Program error.\n");
		return -EINVAL;
	}

	/* If not a real subprogram, find a real one */
761
	if (!die_is_func_def(sc_die)) {
762
		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
763 764 765 766
			pr_warning("Failed to find probe point in any "
				   "functions.\n");
			return -ENOENT;
		}
767 768
	} else
		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
769

770 771
	/* Get the frame base attribute/ops from subprogram */
	dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
772
	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
773
	if (ret <= 0 || nops == 0) {
774
		pf->fb_ops = NULL;
775
#if _ELFUTILS_PREREQ(0, 142)
776 777 778
	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
		   pf->cfi != NULL) {
		Dwarf_Frame *frame;
779 780
		if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
		    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
M
Masami Hiramatsu 已提交
781
			pr_warning("Failed to get call frame on 0x%jx\n",
782 783 784
				   (uintmax_t)pf->addr);
			return -ENOENT;
		}
785
#endif
786
	}
787

788
	/* Call finder's callback handler */
789
	ret = pf->callback(sc_die, pf);
790 791 792

	/* *pf->fb_ops will be cached in libdw. Don't free it. */
	pf->fb_ops = NULL;
793 794

	return ret;
795 796
}

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
struct find_scope_param {
	const char *function;
	const char *file;
	int line;
	int diff;
	Dwarf_Die *die_mem;
	bool found;
};

static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
{
	struct find_scope_param *fsp = data;
	const char *file;
	int lno;

	/* Skip if declared file name does not match */
	if (fsp->file) {
		file = dwarf_decl_file(fn_die);
		if (!file || strcmp(fsp->file, file) != 0)
			return 0;
	}
	/* If the function name is given, that's what user expects */
	if (fsp->function) {
		if (die_compare_name(fn_die, fsp->function)) {
			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
			fsp->found = true;
			return 1;
		}
	} else {
		/* With the line number, find the nearest declared DIE */
		dwarf_decl_line(fn_die, &lno);
		if (lno < fsp->line && fsp->diff > fsp->line - lno) {
			/* Keep a candidate and continue */
			fsp->diff = fsp->line - lno;
			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
			fsp->found = true;
		}
	}
	return 0;
}

/* Find an appropriate scope fits to given conditions */
static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
{
	struct find_scope_param fsp = {
		.function = pf->pev->point.function,
		.file = pf->fname,
		.line = pf->lno,
		.diff = INT_MAX,
		.die_mem = die_mem,
		.found = false,
	};

	cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);

	return fsp.found ? die_mem : NULL;
}

855 856
static int probe_point_line_walker(const char *fname, int lineno,
				   Dwarf_Addr addr, void *data)
857
{
858
	struct probe_finder *pf = data;
859
	Dwarf_Die *sc_die, die_mem;
860
	int ret;
861

862 863
	if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
		return 0;
864

865
	pf->addr = addr;
866 867 868 869 870 871 872
	sc_die = find_best_scope(pf, &die_mem);
	if (!sc_die) {
		pr_warning("Failed to find scope of probe point.\n");
		return -ENOENT;
	}

	ret = call_probe_finder(sc_die, pf);
873

874
	/* Continue if no error, because the line will be in inline function */
875
	return ret < 0 ? ret : 0;
876
}
877

878 879 880 881
/* Find probe point from its line number */
static int find_probe_point_by_line(struct probe_finder *pf)
{
	return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
882 883
}

884 885 886 887
/* Find lines which match lazy pattern */
static int find_lazy_match_lines(struct list_head *head,
				 const char *fname, const char *pat)
{
888 889 890 891 892 893 894 895 896
	FILE *fp;
	char *line = NULL;
	size_t line_len;
	ssize_t len;
	int count = 0, linenum = 1;

	fp = fopen(fname, "r");
	if (!fp) {
		pr_warning("Failed to open %s: %s\n", fname, strerror(errno));
897
		return -errno;
898 899
	}

900
	while ((len = getline(&line, &line_len, fp)) > 0) {
901

902 903 904 905 906 907
		if (line[len - 1] == '\n')
			line[len - 1] = '\0';

		if (strlazymatch(line, pat)) {
			line_list__add_line(head, linenum);
			count++;
908
		}
909
		linenum++;
910
	}
911 912 913 914 915 916 917 918 919

	if (ferror(fp))
		count = -errno;
	free(line);
	fclose(fp);

	if (count == 0)
		pr_debug("No matched lines found in %s.\n", fname);
	return count;
920 921
}

922 923 924 925
static int probe_point_lazy_walker(const char *fname, int lineno,
				   Dwarf_Addr addr, void *data)
{
	struct probe_finder *pf = data;
926
	Dwarf_Die *sc_die, die_mem;
927 928 929 930 931 932 933 934 935
	int ret;

	if (!line_list__has_line(&pf->lcache, lineno) ||
	    strtailcmp(fname, pf->fname) != 0)
		return 0;

	pr_debug("Probe line found: line:%d addr:0x%llx\n",
		 lineno, (unsigned long long)addr);
	pf->addr = addr;
936 937 938 939 940 941 942 943
	pf->lno = lineno;
	sc_die = find_best_scope(pf, &die_mem);
	if (!sc_die) {
		pr_warning("Failed to find scope of probe point.\n");
		return -ENOENT;
	}

	ret = call_probe_finder(sc_die, pf);
944 945 946 947 948

	/*
	 * Continue if no error, because the lazy pattern will match
	 * to other lines
	 */
949
	return ret < 0 ? ret : 0;
950 951
}

952
/* Find probe points from lazy pattern  */
953
static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
954
{
955
	int ret = 0;
956 957 958 959

	if (list_empty(&pf->lcache)) {
		/* Matching lazy line pattern */
		ret = find_lazy_match_lines(&pf->lcache, pf->fname,
960
					    pf->pev->point.lazy_line);
961
		if (ret <= 0)
962
			return ret;
963 964
	}

965
	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
966 967
}

968 969
static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
{
970
	struct probe_finder *pf = data;
971
	struct perf_probe_point *pp = &pf->pev->point;
972
	Dwarf_Addr addr;
973
	int ret;
974

975
	if (pp->lazy_line)
976
		ret = find_probe_point_lazy(in_die, pf);
977 978
	else {
		/* Get probe address */
979
		if (dwarf_entrypc(in_die, &addr) != 0) {
M
Masami Hiramatsu 已提交
980
			pr_warning("Failed to get entry address of %s.\n",
981
				   dwarf_diename(in_die));
982
			return -ENOENT;
983 984
		}
		pf->addr = addr;
985 986 987 988
		pf->addr += pp->offset;
		pr_debug("found inline addr: 0x%jx\n",
			 (uintmax_t)pf->addr);

989
		ret = call_probe_finder(in_die, pf);
990
	}
991

992
	return ret;
993
}
994

995 996 997 998 999 1000
/* Callback parameter with return value for libdw */
struct dwarf_callback_param {
	void *data;
	int retval;
};

1001
/* Search function from function name */
1002
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
1003
{
1004 1005
	struct dwarf_callback_param *param = data;
	struct probe_finder *pf = param->data;
1006
	struct perf_probe_point *pp = &pf->pev->point;
1007

1008
	/* Check tag and diename */
1009 1010
	if (!die_is_func_def(sp_die) ||
	    !die_compare_name(sp_die, pp->function))
1011
		return DWARF_CB_OK;
1012

1013 1014 1015 1016
	/* Check declared file */
	if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
		return DWARF_CB_OK;

1017
	pf->fname = dwarf_decl_file(sp_die);
1018 1019 1020
	if (pp->line) { /* Function relative line */
		dwarf_decl_line(sp_die, &pf->lno);
		pf->lno += pp->line;
1021
		param->retval = find_probe_point_by_line(pf);
1022 1023
	} else if (!dwarf_func_inline(sp_die)) {
		/* Real function */
1024
		if (pp->lazy_line)
1025
			param->retval = find_probe_point_lazy(sp_die, pf);
1026
		else {
1027
			if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
M
Masami Hiramatsu 已提交
1028 1029
				pr_warning("Failed to get entry address of "
					   "%s.\n", dwarf_diename(sp_die));
1030 1031 1032
				param->retval = -ENOENT;
				return DWARF_CB_ABORT;
			}
1033 1034
			pf->addr += pp->offset;
			/* TODO: Check the address in this function */
1035
			param->retval = call_probe_finder(sp_die, pf);
1036
		}
1037
	} else
1038
		/* Inlined function: search instances */
1039 1040
		param->retval = die_walk_instances(sp_die,
					probe_point_inline_cb, (void *)pf);
1041

1042
	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1043 1044
}

1045
static int find_probe_point_by_func(struct probe_finder *pf)
1046
{
1047 1048 1049 1050
	struct dwarf_callback_param _param = {.data = (void *)pf,
					      .retval = 0};
	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
	return _param.retval;
1051 1052
}

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
struct pubname_callback_param {
	char *function;
	char *file;
	Dwarf_Die *cu_die;
	Dwarf_Die *sp_die;
	int found;
};

static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
{
	struct pubname_callback_param *param = data;

	if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
		if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
			return DWARF_CB_OK;

		if (die_compare_name(param->sp_die, param->function)) {
			if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
				return DWARF_CB_OK;

			if (param->file &&
			    strtailcmp(param->file, dwarf_decl_file(param->sp_die)))
				return DWARF_CB_OK;

			param->found = 1;
			return DWARF_CB_ABORT;
		}
	}

	return DWARF_CB_OK;
}

1085
/* Find probe points from debuginfo */
1086 1087
static int debuginfo__find_probes(struct debuginfo *self,
				  struct probe_finder *pf)
1088
{
1089
	struct perf_probe_point *pp = &pf->pev->point;
1090 1091 1092
	Dwarf_Off off, noff;
	size_t cuhl;
	Dwarf_Die *diep;
1093
	int ret = 0;
1094

1095
#if _ELFUTILS_PREREQ(0, 142)
1096
	/* Get the call frame information from this dwarf */
1097
	pf->cfi = dwarf_getcfi(self->dbg);
1098
#endif
1099

1100
	off = 0;
1101
	line_list__init(&pf->lcache);
1102 1103 1104 1105 1106 1107 1108 1109

	/* Fastpath: lookup by function name from .debug_pubnames section */
	if (pp->function) {
		struct pubname_callback_param pubname_param = {
			.function = pp->function,
			.file	  = pp->file,
			.cu_die	  = &pf->cu_die,
			.sp_die	  = &pf->sp_die,
1110
			.found	  = 0,
1111 1112 1113 1114 1115
		};
		struct dwarf_callback_param probe_param = {
			.data = pf,
		};

1116 1117
		dwarf_getpubnames(self->dbg, pubname_search_cb,
				  &pubname_param, 0);
1118 1119 1120 1121 1122 1123 1124
		if (pubname_param.found) {
			ret = probe_point_search_cb(&pf->sp_die, &probe_param);
			if (ret)
				goto found;
		}
	}

1125
	/* Loop on CUs (Compilation Unit) */
1126
	while (!dwarf_nextcu(self->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1127
		/* Get the DIE(Debugging Information Entry) of this CU */
1128
		diep = dwarf_offdie(self->dbg, off + cuhl, &pf->cu_die);
1129 1130
		if (!diep)
			continue;
1131 1132 1133

		/* Check if target file is included. */
		if (pp->file)
1134
			pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1135
		else
1136
			pf->fname = NULL;
1137

1138
		if (!pp->file || pf->fname) {
1139
			if (pp->function)
1140
				ret = find_probe_point_by_func(pf);
1141
			else if (pp->lazy_line)
1142
				ret = find_probe_point_lazy(NULL, pf);
1143
			else {
1144 1145
				pf->lno = pp->line;
				ret = find_probe_point_by_line(pf);
1146
			}
1147
			if (ret < 0)
1148
				break;
1149
		}
1150
		off = noff;
1151
	}
1152 1153

found:
1154
	line_list__free(&pf->lcache);
1155

1156 1157 1158
	return ret;
}

1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
struct local_vars_finder {
	struct probe_finder *pf;
	struct perf_probe_arg *args;
	int max_args;
	int nargs;
	int ret;
};

/* Collect available variables in this scope */
static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
{
	struct local_vars_finder *vf = data;
1171
	struct probe_finder *pf = vf->pf;
1172 1173 1174 1175 1176 1177
	int tag;

	tag = dwarf_tag(die_mem);
	if (tag == DW_TAG_formal_parameter ||
	    tag == DW_TAG_variable) {
		if (convert_variable_location(die_mem, vf->pf->addr,
1178 1179
					      vf->pf->fb_ops, &pf->sp_die,
					      NULL) == 0) {
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
			vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
			if (vf->args[vf->nargs].var == NULL) {
				vf->ret = -ENOMEM;
				return DIE_FIND_CB_END;
			}
			pr_debug(" %s", vf->args[vf->nargs].var);
			vf->nargs++;
		}
	}

	if (dwarf_haspc(die_mem, vf->pf->addr))
		return DIE_FIND_CB_CONTINUE;
	else
		return DIE_FIND_CB_SIBLING;
}

static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
			     struct perf_probe_arg *args)
{
	Dwarf_Die die_mem;
	int i;
	int n = 0;
	struct local_vars_finder vf = {.pf = pf, .args = args,
				.max_args = MAX_PROBE_ARGS, .ret = 0};

	for (i = 0; i < pf->pev->nargs; i++) {
		/* var never be NULL */
		if (strcmp(pf->pev->args[i].var, "$vars") == 0) {
			pr_debug("Expanding $vars into:");
			vf.nargs = n;
			/* Special local variables */
			die_find_child(sc_die, copy_variables_cb, (void *)&vf,
				       &die_mem);
			pr_debug(" (%d)\n", vf.nargs - n);
			if (vf.ret < 0)
				return vf.ret;
			n = vf.nargs;
		} else {
			/* Copy normal argument */
			args[n] = pf->pev->args[i];
			n++;
		}
	}
	return n;
}

1226
/* Add a found probe point into trace event list */
1227
static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1228 1229 1230 1231
{
	struct trace_event_finder *tf =
			container_of(pf, struct trace_event_finder, pf);
	struct probe_trace_event *tev;
1232
	struct perf_probe_arg *args;
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
	int ret, i;

	/* Check number of tevs */
	if (tf->ntevs == tf->max_tevs) {
		pr_warning("Too many( > %d) probe point found.\n",
			   tf->max_tevs);
		return -ERANGE;
	}
	tev = &tf->tevs[tf->ntevs++];

1243
	/* Trace point should be converted from subprogram DIE */
1244
	ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
1245
				     pf->pev->point.retprobe, &tev->point);
1246 1247 1248 1249 1250 1251
	if (ret < 0)
		return ret;

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

1252 1253 1254
	/* Expand special probe argument if exist */
	args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
	if (args == NULL)
1255
		return -ENOMEM;
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270

	ret = expand_probe_args(sc_die, pf, args);
	if (ret < 0)
		goto end;

	tev->nargs = ret;
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto end;
	}

	/* Find each argument */
	for (i = 0; i < tev->nargs; i++) {
		pf->pvar = &args[i];
1271
		pf->tvar = &tev->args[i];
1272 1273
		/* Variable should be found from scope DIE */
		ret = find_variable(sc_die, pf);
1274
		if (ret != 0)
1275
			break;
1276 1277
	}

1278 1279 1280
end:
	free(args);
	return ret;
1281 1282 1283
}

/* Find probe_trace_events specified by perf_probe_event from debuginfo */
1284 1285 1286
int debuginfo__find_trace_events(struct debuginfo *self,
				 struct perf_probe_event *pev,
				 struct probe_trace_event **tevs, int max_tevs)
1287 1288 1289
{
	struct trace_event_finder tf = {
			.pf = {.pev = pev, .callback = add_probe_trace_event},
1290
			.mod = self->mod, .max_tevs = max_tevs};
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
	int ret;

	/* Allocate result tevs array */
	*tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
	if (*tevs == NULL)
		return -ENOMEM;

	tf.tevs = *tevs;
	tf.ntevs = 0;

1301
	ret = debuginfo__find_probes(self, &tf.pf);
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
	if (ret < 0) {
		free(*tevs);
		*tevs = NULL;
		return ret;
	}

	return (ret < 0) ? ret : tf.ntevs;
}

#define MAX_VAR_LEN 64

/* Collect available variables in this scope */
static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
{
	struct available_var_finder *af = data;
	struct variable_list *vl;
	char buf[MAX_VAR_LEN];
	int tag, ret;

	vl = &af->vls[af->nvls - 1];

	tag = dwarf_tag(die_mem);
	if (tag == DW_TAG_formal_parameter ||
	    tag == DW_TAG_variable) {
		ret = convert_variable_location(die_mem, af->pf.addr,
1327 1328
						af->pf.fb_ops, &af->pf.sp_die,
						NULL);
1329 1330
		if (ret == 0) {
			ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
1331
			pr_debug2("Add new var: %s\n", buf);
1332 1333 1334 1335 1336
			if (ret > 0)
				strlist__add(vl->vars, buf);
		}
	}

1337
	if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1338 1339 1340 1341 1342 1343
		return DIE_FIND_CB_CONTINUE;
	else
		return DIE_FIND_CB_SIBLING;
}

/* Add a found vars into available variables list */
1344
static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1345 1346 1347 1348
{
	struct available_var_finder *af =
			container_of(pf, struct available_var_finder, pf);
	struct variable_list *vl;
1349 1350
	Dwarf_Die die_mem;
	int ret;
1351 1352 1353 1354 1355 1356 1357 1358

	/* Check number of tevs */
	if (af->nvls == af->max_vls) {
		pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
		return -ERANGE;
	}
	vl = &af->vls[af->nvls++];

1359
	/* Trace point should be converted from subprogram DIE */
1360
	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1361
				     pf->pev->point.retprobe, &vl->point);
1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
	if (ret < 0)
		return ret;

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

	/* Find local variables */
	vl->vars = strlist__new(true, NULL);
	if (vl->vars == NULL)
		return -ENOMEM;
1372
	af->child = true;
1373
	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1374

1375 1376 1377 1378 1379
	/* Find external variables */
	if (!af->externs)
		goto out;
	/* Don't need to search child DIE for externs. */
	af->child = false;
1380
	die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1381 1382

out:
1383 1384 1385 1386 1387 1388 1389 1390 1391
	if (strlist__empty(vl->vars)) {
		strlist__delete(vl->vars);
		vl->vars = NULL;
	}

	return ret;
}

/* Find available variables at given probe point */
1392 1393 1394 1395
int debuginfo__find_available_vars_at(struct debuginfo *self,
				      struct perf_probe_event *pev,
				      struct variable_list **vls,
				      int max_vls, bool externs)
1396 1397 1398
{
	struct available_var_finder af = {
			.pf = {.pev = pev, .callback = add_available_vars},
1399
			.mod = self->mod,
1400
			.max_vls = max_vls, .externs = externs};
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	int ret;

	/* Allocate result vls array */
	*vls = zalloc(sizeof(struct variable_list) * max_vls);
	if (*vls == NULL)
		return -ENOMEM;

	af.vls = *vls;
	af.nvls = 0;

1411
	ret = debuginfo__find_probes(self, &af.pf);
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
	if (ret < 0) {
		/* Free vlist for error */
		while (af.nvls--) {
			if (af.vls[af.nvls].point.symbol)
				free(af.vls[af.nvls].point.symbol);
			if (af.vls[af.nvls].vars)
				strlist__delete(af.vls[af.nvls].vars);
		}
		free(af.vls);
		*vls = NULL;
		return ret;
	}

	return (ret < 0) ? ret : af.nvls;
1426 1427
}

1428
/* Reverse search */
1429 1430
int debuginfo__find_probe_point(struct debuginfo *self, unsigned long addr,
				struct perf_probe_point *ppt)
1431 1432
{
	Dwarf_Die cudie, spdie, indie;
1433 1434
	Dwarf_Addr _addr = 0, baseaddr = 0;
	const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
1435
	int baseline = 0, lineno = 0, ret = 0;
1436

1437
	/* Adjust address with bias */
1438 1439
	addr += self->bias;

1440
	/* Find cu die */
1441
	if (!dwarf_addrdie(self->dbg, (Dwarf_Addr)addr - self->bias, &cudie)) {
M
Masami Hiramatsu 已提交
1442 1443
		pr_warning("Failed to find debug information for address %lx\n",
			   addr);
1444 1445 1446
		ret = -EINVAL;
		goto end;
	}
1447

1448 1449 1450
	/* Find a corresponding line (filename and lineno) */
	cu_find_lineinfo(&cudie, addr, &fname, &lineno);
	/* Don't care whether it failed or not */
1451

1452
	/* Find a corresponding function (name, baseline and baseaddr) */
1453
	if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
1454
		/* Get function entry information */
1455 1456
		func = basefunc = dwarf_diename(&spdie);
		if (!func ||
1457
		    dwarf_entrypc(&spdie, &baseaddr) != 0 ||
1458 1459
		    dwarf_decl_line(&spdie, &baseline) != 0) {
			lineno = 0;
1460
			goto post;
1461
		}
1462

1463
		fname = dwarf_decl_file(&spdie);
1464
		if (addr == (unsigned long)baseaddr) {
1465 1466
			/* Function entry - Relative line number is 0 */
			lineno = baseline;
1467 1468 1469 1470 1471 1472 1473
			goto post;
		}

		/* Track down the inline functions step by step */
		while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
						&indie)) {
			/* There is an inline function */
1474
			if (dwarf_entrypc(&indie, &_addr) == 0 &&
1475
			    _addr == addr) {
1476 1477 1478
				/*
				 * addr is at an inline function entry.
				 * In this case, lineno should be the call-site
1479
				 * line number. (overwrite lineinfo)
1480 1481
				 */
				lineno = die_get_call_lineno(&indie);
1482 1483 1484
				fname = die_get_call_file(&indie);
				break;
			} else {
1485 1486 1487 1488 1489 1490
				/*
				 * addr is in an inline function body.
				 * Since lineno points one of the lines
				 * of the inline function, baseline should
				 * be the entry line of the inline function.
				 */
1491
				tmp = dwarf_diename(&indie);
1492 1493 1494 1495 1496
				if (!tmp ||
				    dwarf_decl_line(&indie, &baseline) != 0)
					break;
				func = tmp;
				spdie = indie;
1497
			}
1498
		}
1499 1500 1501 1502
		/* Verify the lineno and baseline are in a same file */
		tmp = dwarf_decl_file(&spdie);
		if (!tmp || strcmp(tmp, fname) != 0)
			lineno = 0;
1503 1504 1505 1506 1507 1508
	}

post:
	/* Make a relative line number or an offset */
	if (lineno)
		ppt->line = lineno - baseline;
1509
	else if (basefunc) {
1510
		ppt->offset = addr - (unsigned long)baseaddr;
1511 1512
		func = basefunc;
	}
1513 1514 1515 1516

	/* Duplicate strings */
	if (func) {
		ppt->function = strdup(func);
1517 1518 1519 1520
		if (ppt->function == NULL) {
			ret = -ENOMEM;
			goto end;
		}
1521
	}
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
	if (fname) {
		ppt->file = strdup(fname);
		if (ppt->file == NULL) {
			if (ppt->function) {
				free(ppt->function);
				ppt->function = NULL;
			}
			ret = -ENOMEM;
			goto end;
		}
	}
1533
end:
1534 1535
	if (ret == 0 && (fname || func))
		ret = 1;	/* Found a point */
1536 1537 1538
	return ret;
}

1539 1540 1541 1542
/* Add a line and store the src path */
static int line_range_add_line(const char *src, unsigned int lineno,
			       struct line_range *lr)
{
1543
	/* Copy source path */
1544
	if (!lr->path) {
1545 1546 1547
		lr->path = strdup(src);
		if (lr->path == NULL)
			return -ENOMEM;
1548 1549 1550 1551
	}
	return line_list__add_line(&lr->line_list, lineno);
}

1552
static int line_range_walk_cb(const char *fname, int lineno,
1553
			      Dwarf_Addr addr __maybe_unused,
1554
			      void *data)
1555
{
1556
	struct line_finder *lf = data;
1557

1558
	if ((strtailcmp(fname, lf->fname) != 0) ||
1559
	    (lf->lno_s > lineno || lf->lno_e < lineno))
1560
		return 0;
1561

1562 1563
	if (line_range_add_line(fname, lineno, lf->lr) < 0)
		return -EINVAL;
1564

1565
	return 0;
1566
}
1567

1568
/* Find line range from its line number */
1569
static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1570
{
1571
	int ret;
1572

1573
	ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1574

1575
	/* Update status */
1576 1577 1578 1579 1580
	if (ret >= 0)
		if (!list_empty(&lf->lr->line_list))
			ret = lf->found = 1;
		else
			ret = 0;	/* Lines are not found */
1581 1582 1583 1584
	else {
		free(lf->lr->path);
		lf->lr->path = NULL;
	}
1585
	return ret;
1586 1587
}

1588 1589
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
{
1590
	find_line_range_by_line(in_die, data);
1591 1592 1593 1594 1595 1596

	/*
	 * We have to check all instances of inlined function, because
	 * some execution paths can be optimized out depends on the
	 * function argument of instances
	 */
1597
	return 0;
1598 1599
}

1600
/* Search function definition from function name */
1601
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1602
{
1603 1604
	struct dwarf_callback_param *param = data;
	struct line_finder *lf = param->data;
1605 1606
	struct line_range *lr = lf->lr;

1607 1608 1609 1610
	/* Check declared file */
	if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
		return DWARF_CB_OK;

1611
	if (die_is_func_def(sp_die) &&
1612
	    die_compare_name(sp_die, lr->function)) {
1613 1614
		lf->fname = dwarf_decl_file(sp_die);
		dwarf_decl_line(sp_die, &lr->offset);
1615
		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1616
		lf->lno_s = lr->offset + lr->start;
1617 1618 1619 1620
		if (lf->lno_s < 0)	/* Overflow */
			lf->lno_s = INT_MAX;
		lf->lno_e = lr->offset + lr->end;
		if (lf->lno_e < 0)	/* Overflow */
1621
			lf->lno_e = INT_MAX;
1622
		pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1623 1624
		lr->start = lf->lno_s;
		lr->end = lf->lno_e;
1625 1626 1627 1628
		if (dwarf_func_inline(sp_die))
			param->retval = die_walk_instances(sp_die,
						line_range_inline_cb, lf);
		else
1629 1630
			param->retval = find_line_range_by_line(sp_die, lf);
		return DWARF_CB_ABORT;
1631
	}
1632
	return DWARF_CB_OK;
1633 1634
}

1635
static int find_line_range_by_func(struct line_finder *lf)
1636
{
1637 1638 1639
	struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
	return param.retval;
1640 1641
}

1642
int debuginfo__find_line_range(struct debuginfo *self, struct line_range *lr)
1643
{
1644
	struct line_finder lf = {.lr = lr, .found = 0};
1645
	int ret = 0;
1646 1647 1648
	Dwarf_Off off = 0, noff;
	size_t cuhl;
	Dwarf_Die *diep;
1649
	const char *comp_dir;
1650

1651 1652 1653 1654 1655 1656 1657 1658
	/* Fastpath: lookup by function name from .debug_pubnames section */
	if (lr->function) {
		struct pubname_callback_param pubname_param = {
			.function = lr->function, .file = lr->file,
			.cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
		struct dwarf_callback_param line_range_param = {
			.data = (void *)&lf, .retval = 0};

1659 1660
		dwarf_getpubnames(self->dbg, pubname_search_cb,
				  &pubname_param, 0);
1661 1662 1663 1664 1665 1666 1667
		if (pubname_param.found) {
			line_range_search_cb(&lf.sp_die, &line_range_param);
			if (lf.found)
				goto found;
		}
	}

1668
	/* Loop on CUs (Compilation Unit) */
1669
	while (!lf.found && ret >= 0) {
1670 1671
		if (dwarf_nextcu(self->dbg, off, &noff, &cuhl,
				 NULL, NULL, NULL) != 0)
1672 1673 1674
			break;

		/* Get the DIE(Debugging Information Entry) of this CU */
1675
		diep = dwarf_offdie(self->dbg, off + cuhl, &lf.cu_die);
1676 1677
		if (!diep)
			continue;
1678 1679 1680

		/* Check if target file is included. */
		if (lr->file)
1681
			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1682
		else
1683
			lf.fname = 0;
1684

1685
		if (!lr->file || lf.fname) {
1686
			if (lr->function)
1687
				ret = find_line_range_by_func(&lf);
1688 1689
			else {
				lf.lno_s = lr->start;
1690
				lf.lno_e = lr->end;
1691
				ret = find_line_range_by_line(NULL, &lf);
1692 1693
			}
		}
1694
		off = noff;
1695
	}
1696

1697
found:
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
	/* Store comp_dir */
	if (lf.found) {
		comp_dir = cu_get_comp_dir(&lf.cu_die);
		if (comp_dir) {
			lr->comp_dir = strdup(comp_dir);
			if (!lr->comp_dir)
				ret = -ENOMEM;
		}
	}

1708
	pr_debug("path: %s\n", lr->path);
1709
	return (ret < 0) ? ret : lf.found;
1710 1711
}