probe-finder.c 41.7 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
static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
119
					 const char *path)
120
{
121
	int fd;
122

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

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

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

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

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

	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
static int debuginfo__init_online_kernel_dwarf(struct debuginfo *dbg,
184
					       Dwarf_Addr addr)
185
{
186 187
	dbg->dwfl = dwfl_begin(&kernel_callbacks);
	if (!dbg->dwfl)
188
		return -EINVAL;
189 190

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

194
	dbg->dbg = dwfl_addrdwarf(dbg->dwfl, addr, &dbg->bias);
195
	/* Here, check whether we could get a real dwarf */
196
	if (!dbg->dbg) {
197 198
		pr_debug("Failed to find kernel dwarf at %lx\n",
			 (unsigned long)addr);
199 200
		dwfl_end(dbg->dwfl);
		memset(dbg, 0, sizeof(*dbg));
201
		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 *dbg,
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
	return debuginfo__init_offline_dwarf(dbg, path);
220 221 222 223 224
}
#endif

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

229 230 231
	if (debuginfo__init_offline_dwarf(dbg, path) < 0) {
		free(dbg);
		dbg = NULL;
232 233
	}

234
	return dbg;
235 236 237 238
}

struct debuginfo *debuginfo__new_online_kernel(unsigned long addr)
{
239 240 241
	struct debuginfo *dbg = zalloc(sizeof(*dbg));

	if (!dbg)
242 243
		return NULL;

244 245 246
	if (debuginfo__init_online_kernel_dwarf(dbg, (Dwarf_Addr)addr) < 0) {
		free(dbg);
		dbg = NULL;
247 248
	}

249
	return dbg;
250 251
}

252
void debuginfo__delete(struct debuginfo *dbg)
253
{
254 255 256 257
	if (dbg) {
		if (dbg->dwfl)
			dwfl_end(dbg->dwfl);
		free(dbg);
258
	}
259
}
260

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

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

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

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

297
	/* TODO: handle more than 1 exprs */
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
	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;
		}
315 316
		return -ENOENT;
	}
317 318 319 320
found:
	if (nops == 0)
		/* TODO: Support const_value */
		return -ENOENT;
321 322

	if (op->atom == DW_OP_addr) {
323
static_var:
324 325
		if (!tvar)
			return 0;
326 327 328 329 330 331 332 333 334 335 336
		/* 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;
	}
337 338

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

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

364 365 366
	if (!tvar)
		return 0;

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

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

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

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

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

399 400 401 402 403 404 405
	/* 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;
	}

406 407
	bsize = dwarf_bitsize(vr_die);
	if (bsize > 0) {
408
		/* This is a bitfield */
409 410 411 412 413 414
		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));
415 416 417
		goto formatted;
	}

418 419 420 421 422
	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;
	}
423

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

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

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

468 469 470 471 472
	/* 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;
473
	}
474 475 476 477 478 479 480 481 482 483 484 485 486 487
	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;
488
	return 0;
489 490
}

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

	pr_debug("converting %s in %s\n", field->name, varname);
502 503 504 505
	if (die_get_real_type(vr_die, &type) == NULL) {
		pr_warning("Failed to get the type of %s.\n", varname);
		return -ENOENT;
	}
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
	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) {
522
			ref = zalloc(sizeof(struct probe_trace_arg_ref));
523 524 525 526 527 528 529
			if (ref == NULL)
				return -ENOMEM;
			if (*ref_ptr)
				(*ref_ptr)->next = ref;
			else
				*ref_ptr = ref;
		}
530
		ref->offset += dwarf_bytesize(&type) * field->index;
531 532 533 534 535 536
		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 */
537 538 539 540 541
		if (!field->ref) {
			pr_err("Semantic error: %s must be referred by '->'\n",
			       field->name);
			return -EINVAL;
		}
542
		/* Get the type pointed by this pointer */
543 544 545 546
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get the type of %s.\n", varname);
			return -ENOENT;
		}
547
		/* Verify it is a data structure  */
548 549 550 551
		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);
552 553
			return -EINVAL;
		}
554

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

586
	if (die_find_member(&type, field->name, die_mem) == NULL) {
A
Arnaldo Carvalho de Melo 已提交
587
		pr_warning("%s(type:%s) has no member %s.\n", varname,
588 589 590
			   dwarf_diename(&type), field->name);
		return -EINVAL;
	}
591 592

	/* Get the offset of the field */
593 594 595 596 597 598 599 600 601
	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;
		}
602
	}
603 604
	ref->offset += (long)offs;

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

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

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

623
	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
624
					&pf->sp_die, pf->tvar);
625 626 627 628 629 630
	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) {
631 632 633
		ret = convert_variable_fields(vr_die, pf->pvar->var,
					      pf->pvar->field, &pf->tvar->ref,
					      &die_mem);
634 635
		vr_die = &die_mem;
	}
636 637
	if (ret == 0)
		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
638
	/* *expr will be cached in libdw. Don't free it. */
639
	return ret;
640 641
}

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

649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
	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;
	}

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

682
	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
683
	/* Search child die for local variables and parameters. */
684 685 686 687
	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;
688
	}
689
	if (ret >= 0)
690 691
		ret = convert_variable(&vr_die, pf);

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

698
/* Convert subprogram DIE to trace point */
699 700 701
static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
				  Dwarf_Addr paddr, bool retprobe,
				  struct probe_trace_point *tp)
702
{
703
	Dwarf_Addr eaddr, highaddr;
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
	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);
732
	tp->address = (unsigned long)paddr;
733 734 735
	tp->symbol = strdup(symbol);
	if (!tp->symbol)
		return -ENOMEM;
736

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

747 748 749
	return 0;
}

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

757 758 759 760 761 762
	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 */
763
	if (!die_is_func_def(sc_die)) {
764
		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
765 766 767 768
			pr_warning("Failed to find probe point in any "
				   "functions.\n");
			return -ENOENT;
		}
769 770
	} else
		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
771

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

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

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

	return ret;
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
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;
}

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

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

867
	pf->addr = addr;
868 869 870 871 872 873 874
	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);
875

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

880 881 882 883
/* 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);
884 885
}

886 887 888 889
/* Find lines which match lazy pattern */
static int find_lazy_match_lines(struct list_head *head,
				 const char *fname, const char *pat)
{
890 891 892 893 894 895 896 897 898
	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));
899
		return -errno;
900 901
	}

902
	while ((len = getline(&line, &line_len, fp)) > 0) {
903

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

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

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

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

924 925 926 927
static int probe_point_lazy_walker(const char *fname, int lineno,
				   Dwarf_Addr addr, void *data)
{
	struct probe_finder *pf = data;
928
	Dwarf_Die *sc_die, die_mem;
929 930 931 932 933 934 935 936 937
	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;
938 939 940 941 942 943 944 945
	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);
946 947 948 949 950

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

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

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

967
	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
968 969
}

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

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

991
		ret = call_probe_finder(in_die, pf);
992
	}
993

994
	return ret;
995
}
996

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

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

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

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

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

1044
	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1045 1046
}

1047
static int find_probe_point_by_func(struct probe_finder *pf)
1048
{
1049 1050 1051 1052
	struct dwarf_callback_param _param = {.data = (void *)pf,
					      .retval = 0};
	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
	return _param.retval;
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 1085 1086
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;
}

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

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

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

	/* 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,
1112
			.found	  = 0,
1113 1114 1115 1116 1117
		};
		struct dwarf_callback_param probe_param = {
			.data = pf,
		};

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

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

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

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

found:
1156
	line_list__free(&pf->lcache);
1157

1158 1159 1160
	return ret;
}

1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
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;
1173
	struct probe_finder *pf = vf->pf;
1174 1175 1176 1177 1178 1179
	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,
1180 1181
					      vf->pf->fb_ops, &pf->sp_die,
					      NULL) == 0) {
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 1226 1227
			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;
}

1228
/* Add a found probe point into trace event list */
1229
static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1230 1231 1232 1233
{
	struct trace_event_finder *tf =
			container_of(pf, struct trace_event_finder, pf);
	struct probe_trace_event *tev;
1234
	struct perf_probe_arg *args;
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
	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++];

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

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

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

	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];
1273
		pf->tvar = &tev->args[i];
1274 1275
		/* Variable should be found from scope DIE */
		ret = find_variable(sc_die, pf);
1276
		if (ret != 0)
1277
			break;
1278 1279
	}

1280 1281 1282
end:
	free(args);
	return ret;
1283 1284 1285
}

/* Find probe_trace_events specified by perf_probe_event from debuginfo */
1286
int debuginfo__find_trace_events(struct debuginfo *dbg,
1287 1288
				 struct perf_probe_event *pev,
				 struct probe_trace_event **tevs, int max_tevs)
1289 1290 1291
{
	struct trace_event_finder tf = {
			.pf = {.pev = pev, .callback = add_probe_trace_event},
1292
			.mod = dbg->mod, .max_tevs = max_tevs};
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
	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;

1303
	ret = debuginfo__find_probes(dbg, &tf.pf);
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
	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,
1329 1330
						af->pf.fb_ops, &af->pf.sp_die,
						NULL);
1331 1332
		if (ret == 0) {
			ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
1333
			pr_debug2("Add new var: %s\n", buf);
1334 1335 1336 1337 1338
			if (ret > 0)
				strlist__add(vl->vars, buf);
		}
	}

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

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

	/* 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++];

1361
	/* Trace point should be converted from subprogram DIE */
1362
	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1363
				     pf->pev->point.retprobe, &vl->point);
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
	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;
1374
	af->child = true;
1375
	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1376

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

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

	return ret;
}

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

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

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

1428
/* Reverse search */
1429
int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
1430
				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
	addr += dbg->bias;
1439

1440
	/* Find cu die */
1441
	if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr - dbg->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
	if (fname) {
		ppt->file = strdup(fname);
		if (ppt->file == NULL) {
1525 1526
			free(ppt->function);
			ppt->function = NULL;
1527 1528 1529 1530
			ret = -ENOMEM;
			goto end;
		}
	}
1531
end:
1532 1533
	if (ret == 0 && (fname || func))
		ret = 1;	/* Found a point */
1534 1535 1536
	return ret;
}

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

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

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

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

1563
	return 0;
1564
}
1565

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

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

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

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

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

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

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

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

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

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

1649 1650 1651 1652 1653 1654 1655 1656
	/* 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};

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

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

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

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

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

1695
found:
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
	/* 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;
		}
	}

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