probe-finder.c 46.1 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
/*
 * 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 <stdlib.h>
#include <string.h>
#include <stdarg.h>
32
#include <dwarf-regs.h>
33

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

44 45 46
/* Kprobe tracer basic type is up to u64 */
#define MAX_BASIC_TYPE_BITS	64

47 48 49 50 51 52 53 54 55 56 57 58 59 60
/* 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 */
61
static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
62
					 const char *path)
63
{
64
	int fd;
65

66 67 68
	fd = open(path, O_RDONLY);
	if (fd < 0)
		return fd;
69

70 71
	dbg->dwfl = dwfl_begin(&offline_callbacks);
	if (!dbg->dwfl)
72
		goto error;
73

74
	dwfl_report_begin(dbg->dwfl);
75 76
	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
	if (!dbg->mod)
77 78
		goto error;

79 80
	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
	if (!dbg->dbg)
81 82
		goto error;

83 84
	dwfl_report_end(dbg->dwfl, NULL, NULL);

85
	return 0;
86
error:
87 88
	if (dbg->dwfl)
		dwfl_end(dbg->dwfl);
89 90
	else
		close(fd);
91
	memset(dbg, 0, sizeof(*dbg));
92 93

	return -ENOENT;
94 95
}

96
static struct debuginfo *__debuginfo__new(const char *path)
97
{
98 99
	struct debuginfo *dbg = zalloc(sizeof(*dbg));
	if (!dbg)
100 101
		return NULL;

102 103
	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
		zfree(&dbg);
104 105
	if (dbg)
		pr_debug("Open Debuginfo file: %s\n", path);
106
	return dbg;
107 108
}

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
enum dso_binary_type distro_dwarf_types[] = {
	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
	DSO_BINARY_TYPE__NOT_FOUND,
};

struct debuginfo *debuginfo__new(const char *path)
{
	enum dso_binary_type *type;
	char buf[PATH_MAX], nil = '\0';
	struct dso *dso;
	struct debuginfo *dinfo = NULL;

	/* Try to open distro debuginfo files */
	dso = dso__new(path);
	if (!dso)
		goto out;

	for (type = distro_dwarf_types;
	     !dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
	     type++) {
		if (dso__read_binary_type_filename(dso, *type, &nil,
						   buf, PATH_MAX) < 0)
			continue;
		dinfo = __debuginfo__new(buf);
	}
137
	dso__put(dso);
138 139 140 141 142 143

out:
	/* if failed to open all distro debuginfo, open given binary */
	return dinfo ? : __debuginfo__new(path);
}

144
void debuginfo__delete(struct debuginfo *dbg)
145
{
146 147 148 149
	if (dbg) {
		if (dbg->dwfl)
			dwfl_end(dbg->dwfl);
		free(dbg);
150
	}
151
}
152

153 154 155 156
/*
 * Probe finder related functions
 */

157
static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
158
{
159 160
	struct probe_trace_arg_ref *ref;
	ref = zalloc(sizeof(struct probe_trace_arg_ref));
161 162 163 164 165
	if (ref != NULL)
		ref->offset = offs;
	return ref;
}

166 167 168
/*
 * Convert a location into trace_arg.
 * If tvar == NULL, this just checks variable can be converted.
169 170
 * If fentry == true and vr_die is a parameter, do huristic search
 * for the location fuzzed by function entry mcount.
171 172
 */
static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
173
				     Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
174
				     unsigned int machine,
175
				     struct probe_trace_arg *tvar)
176
{
177
	Dwarf_Attribute attr;
178
	Dwarf_Addr tmp = 0;
179 180
	Dwarf_Op *op;
	size_t nops;
181 182
	unsigned int regn;
	Dwarf_Word offs = 0;
183
	bool ref = false;
184
	const char *regs;
185
	int ret, ret2 = 0;
186

187 188 189
	if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
		goto static_var;

190
	/* TODO: handle more than 1 exprs */
191 192 193 194
	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);
195 196 197 198 199 200 201 202 203 204 205 206 207
		if (ret)
			return -ENOENT;

		if (probe_conf.show_location_range &&
			(dwarf_tag(vr_die) == DW_TAG_variable)) {
			ret2 = -ERANGE;
		} else if (addr != tmp ||
			dwarf_tag(vr_die) != DW_TAG_formal_parameter) {
			return -ENOENT;
		}

		ret = dwarf_highpc(sp_die, &tmp);
		if (ret)
208 209 210 211 212 213 214 215 216 217
			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;
		}
218 219
		return -ENOENT;
	}
220 221 222 223
found:
	if (nops == 0)
		/* TODO: Support const_value */
		return -ENOENT;
224 225

	if (op->atom == DW_OP_addr) {
226
static_var:
227
		if (!tvar)
228
			return ret2;
229 230 231 232 233 234 235 236 237
		/* 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;
238
		return ret2;
239
	}
240 241

	/* If this is based on frame buffer, set the offset */
242
	if (op->atom == DW_OP_fbreg) {
243
		if (fb_ops == NULL)
244
			return -ENOTSUP;
245
		ref = true;
246
		offs = op->number;
247
		op = &fb_ops[0];
248
	}
249

250 251 252
	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
		regn = op->atom - DW_OP_breg0;
		offs += op->number;
253
		ref = true;
254 255 256 257 258
	} 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;
259
		ref = true;
260 261
	} else if (op->atom == DW_OP_regx) {
		regn = op->number;
262
	} else {
263
		pr_debug("DW_OP %x is not supported.\n", op->atom);
264 265
		return -ENOTSUP;
	}
266

267
	if (!tvar)
268
		return ret2;
269

270
	regs = get_dwarf_regstr(regn, machine);
271
	if (!regs) {
272
		/* This should be a bug in DWARF or this tool */
M
Masami Hiramatsu 已提交
273 274
		pr_warning("Mapping for the register number %u "
			   "missing on this architecture.\n", regn);
275
		return -ENOTSUP;
276
	}
277

278 279 280 281
	tvar->value = strdup(regs);
	if (tvar->value == NULL)
		return -ENOMEM;

282
	if (ref) {
283
		tvar->ref = alloc_trace_arg_ref((long)offs);
284 285
		if (tvar->ref == NULL)
			return -ENOMEM;
286
	}
287
	return ret2;
288 289
}

290 291
#define BYTES_TO_BITS(nb)	((nb) * BITS_PER_LONG / sizeof(long))

292
static int convert_variable_type(Dwarf_Die *vr_die,
293
				 struct probe_trace_arg *tvar,
294
				 const char *cast)
295
{
296
	struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
297 298
	Dwarf_Die type;
	char buf[16];
299
	char sbuf[STRERR_BUFSIZE];
300
	int bsize, boffs, total;
301
	int ret;
302
	char prefix;
303

304
	/* TODO: check all types */
305
	if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "x") != 0 &&
306
	    strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) {
307
		/* Non string type is OK */
308
		/* and respect signedness/hexadecimal cast */
309 310 311 312
		tvar->type = strdup(cast);
		return (tvar->type == NULL) ? -ENOMEM : 0;
	}

313 314
	bsize = dwarf_bitsize(vr_die);
	if (bsize > 0) {
315
		/* This is a bitfield */
316 317 318 319 320 321
		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));
322 323 324
		goto formatted;
	}

325 326 327 328 329
	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;
	}
330

331 332 333
	pr_debug("%s type is %s.\n",
		 dwarf_diename(vr_die), dwarf_diename(&type));

334 335 336 337 338
	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 已提交
339
				   "%s(%s) is not a pointer nor array.\n",
340 341 342
				   dwarf_diename(vr_die), dwarf_diename(&type));
			return -EINVAL;
		}
343 344 345 346 347
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get a type"
				   " information.\n");
			return -ENOENT;
		}
348 349 350 351
		if (ret == DW_TAG_pointer_type) {
			while (*ref_ptr)
				ref_ptr = &(*ref_ptr)->next;
			/* Add new reference with offset +0 */
352
			*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
353 354 355 356 357
			if (*ref_ptr == NULL) {
				pr_warning("Out of memory error\n");
				return -ENOMEM;
			}
		}
358 359
		if (!die_compare_name(&type, "char") &&
		    !die_compare_name(&type, "unsigned char")) {
360
			pr_warning("Failed to cast into string: "
M
Masami Hiramatsu 已提交
361
				   "%s is not (unsigned) char *.\n",
362 363 364 365 366 367 368
				   dwarf_diename(vr_die));
			return -EINVAL;
		}
		tvar->type = strdup(cast);
		return (tvar->type == NULL) ? -ENOMEM : 0;
	}

369
	if (cast && (strcmp(cast, "u") == 0))
370
		prefix = 'u';
371
	else if (cast && (strcmp(cast, "s") == 0))
372 373 374 375
		prefix = 's';
	else if (cast && (strcmp(cast, "x") == 0) &&
		 probe_type_is_available(PROBE_TYPE_X))
		prefix = 'x';
376
	else
377 378
		prefix = die_is_signed_type(&type) ? 's' :
			 probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u';
379

380 381
	ret = dwarf_bytesize(&type);
	if (ret <= 0)
382 383
		/* No size ... try to use default type */
		return 0;
384
	ret = BYTES_TO_BITS(ret);
385

386 387 388 389 390
	/* 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;
391
	}
392
	ret = snprintf(buf, 16, "%c%d", prefix, ret);
393 394 395 396 397 398

formatted:
	if (ret < 0 || ret >= 16) {
		if (ret >= 16)
			ret = -E2BIG;
		pr_warning("Failed to convert variable type: %s\n",
399
			   str_error_r(-ret, sbuf, sizeof(sbuf)));
400 401 402 403 404
		return ret;
	}
	tvar->type = strdup(buf);
	if (tvar->type == NULL)
		return -ENOMEM;
405
	return 0;
406 407
}

408
static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
409
				    struct perf_probe_arg_field *field,
410
				    struct probe_trace_arg_ref **ref_ptr,
411
				    Dwarf_Die *die_mem)
412
{
413
	struct probe_trace_arg_ref *ref = *ref_ptr;
414 415
	Dwarf_Die type;
	Dwarf_Word offs;
416
	int ret, tag;
417 418

	pr_debug("converting %s in %s\n", field->name, varname);
419 420 421 422
	if (die_get_real_type(vr_die, &type) == NULL) {
		pr_warning("Failed to get the type of %s.\n", varname);
		return -ENOENT;
	}
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
	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) {
439
			ref = zalloc(sizeof(struct probe_trace_arg_ref));
440 441 442 443 444 445 446
			if (ref == NULL)
				return -ENOMEM;
			if (*ref_ptr)
				(*ref_ptr)->next = ref;
			else
				*ref_ptr = ref;
		}
447
		ref->offset += dwarf_bytesize(&type) * field->index;
448 449 450 451 452 453
		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 */
454 455 456 457 458
		if (!field->ref) {
			pr_err("Semantic error: %s must be referred by '->'\n",
			       field->name);
			return -EINVAL;
		}
459
		/* Get the type pointed by this pointer */
460 461 462 463
		if (die_get_real_type(&type, &type) == NULL) {
			pr_warning("Failed to get the type of %s.\n", varname);
			return -ENOENT;
		}
464
		/* Verify it is a data structure  */
465 466 467 468
		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);
469 470
			return -EINVAL;
		}
471

472
		ref = zalloc(sizeof(struct probe_trace_arg_ref));
473 474
		if (ref == NULL)
			return -ENOMEM;
475 476 477 478 479
		if (*ref_ptr)
			(*ref_ptr)->next = ref;
		else
			*ref_ptr = ref;
	} else {
480
		/* Verify it is a data structure  */
481 482 483
		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
			pr_warning("%s is not a data structure nor an union.\n",
				   varname);
484 485
			return -EINVAL;
		}
486
		if (field->name[0] == '[') {
487
			pr_err("Semantic error: %s is not a pointer"
M
Masami Hiramatsu 已提交
488
			       " nor array.\n", varname);
489 490
			return -EINVAL;
		}
491 492
		/* While prcessing unnamed field, we don't care about this */
		if (field->ref && dwarf_diename(vr_die)) {
493 494 495 496 497 498 499 500 501
			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;
		}
502 503
	}

504
	if (die_find_member(&type, field->name, die_mem) == NULL) {
A
Arnaldo Carvalho de Melo 已提交
505
		pr_warning("%s(type:%s) has no member %s.\n", varname,
506 507 508
			   dwarf_diename(&type), field->name);
		return -EINVAL;
	}
509 510

	/* Get the offset of the field */
511 512 513 514 515 516 517 518 519
	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;
		}
520
	}
521 522
	ref->offset += (long)offs;

523 524 525 526 527
	/* If this member is unnamed, we need to reuse this field */
	if (!dwarf_diename(die_mem))
		return convert_variable_fields(die_mem, varname, field,
						&ref, die_mem);

528
next:
529 530
	/* Converting next field */
	if (field->next)
531
		return convert_variable_fields(die_mem, field->name,
532
					field->next, &ref, die_mem);
533 534
	else
		return 0;
535 536
}

537
/* Show a variables in kprobe event format */
538
static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
539
{
540
	Dwarf_Die die_mem;
541 542
	int ret;

543 544
	pr_debug("Converting variable %s into trace event.\n",
		 dwarf_diename(vr_die));
545

546
	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
547
					&pf->sp_die, pf->machine, pf->tvar);
548 549 550 551 552 553
	if (ret == -ENOENT || ret == -EINVAL) {
		pr_err("Failed to find the location of the '%s' variable at this address.\n"
		       " Perhaps it has been optimized out.\n"
		       " Use -V with the --range option to show '%s' location range.\n",
		       pf->pvar->var, pf->pvar->var);
	} else if (ret == -ENOTSUP)
554
		pr_err("Sorry, we don't support this variable location yet.\n");
555
	else if (ret == 0 && pf->pvar->field) {
556 557 558
		ret = convert_variable_fields(vr_die, pf->pvar->var,
					      pf->pvar->field, &pf->tvar->ref,
					      &die_mem);
559 560
		vr_die = &die_mem;
	}
561 562
	if (ret == 0)
		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
563
	/* *expr will be cached in libdw. Don't free it. */
564
	return ret;
565 566
}

567 568
/* Find a variable in a scope DIE */
static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
569
{
570
	Dwarf_Die vr_die;
571
	char *buf, *ptr;
572
	int ret = 0;
573

574 575 576
	/* Copy raw parameters */
	if (!is_c_varname(pf->pvar->var))
		return copy_to_probe_trace_arg(pf->tvar, pf->pvar);
577

578
	if (pf->pvar->name)
579
		pf->tvar->name = strdup(pf->pvar->name);
580
	else {
581 582 583
		buf = synthesize_perf_probe_arg(pf->pvar);
		if (!buf)
			return -ENOMEM;
584 585 586
		ptr = strchr(buf, ':');	/* Change type separator to _ */
		if (ptr)
			*ptr = '_';
587
		pf->tvar->name = buf;
588
	}
589 590
	if (pf->tvar->name == NULL)
		return -ENOMEM;
591

592
	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
593
	/* Search child die for local variables and parameters. */
594 595
	if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
		/* Search again in global variables */
596 597
		if (!die_find_variable_at(&pf->cu_die, pf->pvar->var,
						0, &vr_die)) {
598 599
			pr_warning("Failed to find '%s' in this function.\n",
				   pf->pvar->var);
600
			ret = -ENOENT;
601
		}
602
	}
603
	if (ret >= 0)
604 605
		ret = convert_variable(&vr_die, pf);

606
	return ret;
607 608
}

609
/* Convert subprogram DIE to trace point */
610 611
static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
				  Dwarf_Addr paddr, bool retprobe,
612
				  const char *function,
613
				  struct probe_trace_point *tp)
614
{
615
	Dwarf_Addr eaddr, highaddr;
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
	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;
	}

636
	symbol = dwarf_diename(sp_die);
637
	if (!symbol) {
638 639 640 641 642 643 644 645
		/* Try to get the symbol name 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;
		}
		eaddr = sym.st_value;
646
	}
647
	tp->offset = (unsigned long)(paddr - eaddr);
648
	tp->address = (unsigned long)paddr;
649 650 651
	tp->symbol = strdup(symbol);
	if (!tp->symbol)
		return -ENOMEM;
652

653
	/* Return probe must be on the head of a subprogram */
654 655
	if (retprobe) {
		if (eaddr != paddr) {
656 657 658 659
			pr_warning("Failed to find \"%s%%return\",\n"
				   " because %s is an inlined function and"
				   " has no return point.\n", function,
				   function);
660 661
			return -EINVAL;
		}
662
		tp->retprobe = true;
663 664
	}

665 666 667
	return 0;
}

668 669
/* Call probe_finder callback with scope DIE */
static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
670 671
{
	Dwarf_Attribute fb_attr;
672
	Dwarf_Frame *frame = NULL;
673 674 675
	size_t nops;
	int ret;

676 677 678 679 680 681
	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 */
682
	if (!die_is_func_def(sc_die)) {
683
		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
684 685 686 687 688 689 690 691 692
			if (die_find_tailfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
				pr_warning("Ignoring tail call from %s\n",
						dwarf_diename(&pf->sp_die));
				return 0;
			} else {
				pr_warning("Failed to find probe point in any "
					   "functions.\n");
				return -ENOENT;
			}
693
		}
694 695
	} else
		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
696

697 698
	/* Get the frame base attribute/ops from subprogram */
	dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
699
	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
700
	if (ret <= 0 || nops == 0) {
701
		pf->fb_ops = NULL;
702
#if _ELFUTILS_PREREQ(0, 142)
703
	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
704 705 706
		   (pf->cfi_eh != NULL || pf->cfi_dbg != NULL)) {
		if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&
		     (dwarf_cfi_addrframe(pf->cfi_dbg, pf->addr, &frame) != 0)) ||
707
		    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
M
Masami Hiramatsu 已提交
708
			pr_warning("Failed to get call frame on 0x%jx\n",
709
				   (uintmax_t)pf->addr);
710 711
			free(frame);
			return -ENOENT;
712
		}
713
#endif
714
	}
715

716
	/* Call finder's callback handler */
717
	ret = pf->callback(sc_die, pf);
718

719 720
	/* Since *pf->fb_ops can be a part of frame. we should free it here. */
	free(frame);
721
	pf->fb_ops = NULL;
722 723

	return ret;
724 725
}

726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
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) {
749
		if (die_match_name(fn_die, fsp->function)) {
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
			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;
}

784 785
static int probe_point_line_walker(const char *fname, int lineno,
				   Dwarf_Addr addr, void *data)
786
{
787
	struct probe_finder *pf = data;
788
	Dwarf_Die *sc_die, die_mem;
789
	int ret;
790

791 792
	if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
		return 0;
793

794
	pf->addr = addr;
795 796 797 798 799 800 801
	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);
802

803
	/* Continue if no error, because the line will be in inline function */
804
	return ret < 0 ? ret : 0;
805
}
806

807 808 809 810
/* 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);
811 812
}

813
/* Find lines which match lazy pattern */
814
static int find_lazy_match_lines(struct intlist *list,
815 816
				 const char *fname, const char *pat)
{
817 818 819 820 821
	FILE *fp;
	char *line = NULL;
	size_t line_len;
	ssize_t len;
	int count = 0, linenum = 1;
822
	char sbuf[STRERR_BUFSIZE];
823 824 825

	fp = fopen(fname, "r");
	if (!fp) {
826
		pr_warning("Failed to open %s: %s\n", fname,
827
			   str_error_r(errno, sbuf, sizeof(sbuf)));
828
		return -errno;
829 830
	}

831
	while ((len = getline(&line, &line_len, fp)) > 0) {
832

833 834 835 836
		if (line[len - 1] == '\n')
			line[len - 1] = '\0';

		if (strlazymatch(line, pat)) {
837
			intlist__add(list, linenum);
838
			count++;
839
		}
840
		linenum++;
841
	}
842 843 844 845 846 847 848 849 850

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

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

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

860
	if (!intlist__has_entry(pf->lcache, lineno) ||
861 862 863 864 865 866
	    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;
867 868 869 870 871 872 873 874
	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);
875 876 877 878 879

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

883
/* Find probe points from lazy pattern  */
884
static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
885
{
886
	int ret = 0;
887
	char *fpath;
888

889
	if (intlist__empty(pf->lcache)) {
890 891 892 893 894 895 896 897 898
		const char *comp_dir;

		comp_dir = cu_get_comp_dir(&pf->cu_die);
		ret = get_real_path(pf->fname, comp_dir, &fpath);
		if (ret < 0) {
			pr_warning("Failed to find source file path.\n");
			return ret;
		}

899
		/* Matching lazy line pattern */
900
		ret = find_lazy_match_lines(pf->lcache, fpath,
901
					    pf->pev->point.lazy_line);
902
		free(fpath);
903
		if (ret <= 0)
904
			return ret;
905 906
	}

907
	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
908 909
}

910 911 912 913 914 915 916 917 918
static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf)
{
	struct perf_probe_point *pp = &pf->pev->point;

	/* Not uprobe? */
	if (!pf->pev->uprobes)
		return;

	/* Compiled with optimization? */
919
	if (die_is_optimized_target(&pf->cu_die))
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
		return;

	/* Don't know entrypc? */
	if (!pf->addr)
		return;

	/* Only FUNC and FUNC@SRC are eligible. */
	if (!pp->function || pp->line || pp->retprobe || pp->lazy_line ||
	    pp->offset || pp->abs_address)
		return;

	/* Not interested in func parameter? */
	if (!perf_probe_with_var(pf->pev))
		return;

	pr_info("Target program is compiled without optimization. Skipping prologue.\n"
		"Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n",
		pf->addr);

939
	die_skip_prologue(sp_die, &pf->cu_die, &pf->addr);
940 941
}

942 943
static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
{
944
	struct probe_finder *pf = data;
945
	struct perf_probe_point *pp = &pf->pev->point;
946
	Dwarf_Addr addr;
947
	int ret;
948

949
	if (pp->lazy_line)
950
		ret = find_probe_point_lazy(in_die, pf);
951 952
	else {
		/* Get probe address */
953
		if (dwarf_entrypc(in_die, &addr) != 0) {
M
Masami Hiramatsu 已提交
954
			pr_warning("Failed to get entry address of %s.\n",
955
				   dwarf_diename(in_die));
956
			return -ENOENT;
957 958
		}
		pf->addr = addr;
959 960 961 962
		pf->addr += pp->offset;
		pr_debug("found inline addr: 0x%jx\n",
			 (uintmax_t)pf->addr);

963
		ret = call_probe_finder(in_die, pf);
964
	}
965

966
	return ret;
967
}
968

969 970 971 972 973 974
/* Callback parameter with return value for libdw */
struct dwarf_callback_param {
	void *data;
	int retval;
};

975
/* Search function from function name */
976
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
977
{
978 979
	struct dwarf_callback_param *param = data;
	struct probe_finder *pf = param->data;
980
	struct perf_probe_point *pp = &pf->pev->point;
981

982
	/* Check tag and diename */
983
	if (!die_is_func_def(sp_die) ||
984
	    !die_match_name(sp_die, pp->function))
985
		return DWARF_CB_OK;
986

987 988 989 990
	/* Check declared file */
	if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
		return DWARF_CB_OK;

991 992
	pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die),
		 (unsigned long)dwarf_dieoffset(sp_die));
993
	pf->fname = dwarf_decl_file(sp_die);
994 995 996
	if (pp->line) { /* Function relative line */
		dwarf_decl_line(sp_die, &pf->lno);
		pf->lno += pp->line;
997
		param->retval = find_probe_point_by_line(pf);
998 999 1000
	} else if (die_is_func_instance(sp_die)) {
		/* Instances always have the entry address */
		dwarf_entrypc(sp_die, &pf->addr);
1001
		/* Real function */
1002
		if (pp->lazy_line)
1003
			param->retval = find_probe_point_lazy(sp_die, pf);
1004
		else {
1005
			skip_prologue(sp_die, pf);
1006 1007
			pf->addr += pp->offset;
			/* TODO: Check the address in this function */
1008
			param->retval = call_probe_finder(sp_die, pf);
1009
		}
1010
	} else if (!probe_conf.no_inlines) {
1011
		/* Inlined function: search instances */
1012 1013
		param->retval = die_walk_instances(sp_die,
					probe_point_inline_cb, (void *)pf);
1014
		/* This could be a non-existed inline definition */
1015
		if (param->retval == -ENOENT)
1016 1017 1018 1019 1020 1021 1022 1023
			param->retval = 0;
	}

	/* We need to find other candidates */
	if (strisglob(pp->function) && param->retval >= 0) {
		param->retval = 0;	/* We have to clear the result */
		return DWARF_CB_OK;
	}
1024

1025
	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1026 1027
}

1028
static int find_probe_point_by_func(struct probe_finder *pf)
1029
{
1030 1031 1032 1033
	struct dwarf_callback_param _param = {.data = (void *)pf,
					      .retval = 0};
	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
	return _param.retval;
1034 1035
}

1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
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;

1052
		if (die_match_name(param->sp_die, param->function)) {
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
			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;
}

1068
static int debuginfo__find_probe_location(struct debuginfo *dbg,
1069
				  struct probe_finder *pf)
1070
{
1071
	struct perf_probe_point *pp = &pf->pev->point;
1072 1073 1074
	Dwarf_Off off, noff;
	size_t cuhl;
	Dwarf_Die *diep;
1075
	int ret = 0;
1076 1077

	off = 0;
1078 1079 1080
	pf->lcache = intlist__new(NULL);
	if (!pf->lcache)
		return -ENOMEM;
1081 1082

	/* Fastpath: lookup by function name from .debug_pubnames section */
1083
	if (pp->function && !strisglob(pp->function)) {
1084 1085 1086 1087 1088
		struct pubname_callback_param pubname_param = {
			.function = pp->function,
			.file	  = pp->file,
			.cu_die	  = &pf->cu_die,
			.sp_die	  = &pf->sp_die,
1089
			.found	  = 0,
1090 1091 1092 1093 1094
		};
		struct dwarf_callback_param probe_param = {
			.data = pf,
		};

1095
		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1096
				  &pubname_param, 0);
1097 1098 1099 1100 1101 1102 1103
		if (pubname_param.found) {
			ret = probe_point_search_cb(&pf->sp_die, &probe_param);
			if (ret)
				goto found;
		}
	}

1104
	/* Loop on CUs (Compilation Unit) */
1105
	while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1106
		/* Get the DIE(Debugging Information Entry) of this CU */
1107
		diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
1108 1109
		if (!diep)
			continue;
1110 1111 1112

		/* Check if target file is included. */
		if (pp->file)
1113
			pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1114
		else
1115
			pf->fname = NULL;
1116

1117
		if (!pp->file || pf->fname) {
1118
			if (pp->function)
1119
				ret = find_probe_point_by_func(pf);
1120
			else if (pp->lazy_line)
1121
				ret = find_probe_point_lazy(&pf->cu_die, pf);
1122
			else {
1123 1124
				pf->lno = pp->line;
				ret = find_probe_point_by_line(pf);
1125
			}
1126
			if (ret < 0)
1127
				break;
1128
		}
1129
		off = noff;
1130
	}
1131 1132

found:
1133 1134
	intlist__delete(pf->lcache);
	pf->lcache = NULL;
1135

1136 1137 1138
	return ret;
}

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
/* Find probe points from debuginfo */
static int debuginfo__find_probes(struct debuginfo *dbg,
				  struct probe_finder *pf)
{
	int ret = 0;
	Elf *elf;
	GElf_Ehdr ehdr;

	if (pf->cfi_eh || pf->cfi_dbg)
		return debuginfo__find_probe_location(dbg, pf);

	/* Get the call frame information from this dwarf */
	elf = dwarf_getelf(dbg->dbg);
	if (elf == NULL)
		return -EINVAL;

	if (gelf_getehdr(elf, &ehdr) == NULL)
		return -EINVAL;

1158 1159 1160 1161 1162 1163 1164 1165 1166
	pf->machine = ehdr.e_machine;

#if _ELFUTILS_PREREQ(0, 142)
	do {
		GElf_Shdr shdr;

		if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
		    shdr.sh_type == SHT_PROGBITS)
			pf->cfi_eh = dwarf_getcfi_elf(elf);
1167

1168 1169
		pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
	} while (0);
1170 1171 1172 1173 1174 1175
#endif

	ret = debuginfo__find_probe_location(dbg, pf);
	return ret;
}

1176 1177 1178
struct local_vars_finder {
	struct probe_finder *pf;
	struct perf_probe_arg *args;
1179
	bool vars;
1180 1181 1182 1183 1184 1185 1186 1187 1188
	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;
1189
	struct probe_finder *pf = vf->pf;
1190 1191 1192 1193
	int tag;

	tag = dwarf_tag(die_mem);
	if (tag == DW_TAG_formal_parameter ||
1194
	    (tag == DW_TAG_variable && vf->vars)) {
1195
		if (convert_variable_location(die_mem, vf->pf->addr,
1196
					      vf->pf->fb_ops, &pf->sp_die,
1197
					      pf->machine, NULL) == 0) {
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
			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;
1220
	struct local_vars_finder vf = {.pf = pf, .args = args, .vars = false,
1221 1222 1223 1224
				.max_args = MAX_PROBE_ARGS, .ret = 0};

	for (i = 0; i < pf->pev->nargs; i++) {
		/* var never be NULL */
1225 1226 1227
		if (strcmp(pf->pev->args[i].var, PROBE_ARG_VARS) == 0)
			vf.vars = true;
		else if (strcmp(pf->pev->args[i].var, PROBE_ARG_PARAMS) != 0) {
1228 1229 1230
			/* Copy normal argument */
			args[n] = pf->pev->args[i];
			n++;
1231
			continue;
1232
		}
1233 1234 1235 1236 1237 1238 1239 1240 1241
		pr_debug("Expanding %s into:", pf->pev->args[i].var);
		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;
1242 1243 1244 1245
	}
	return n;
}

1246
/* Add a found probe point into trace event list */
1247
static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1248 1249 1250
{
	struct trace_event_finder *tf =
			container_of(pf, struct trace_event_finder, pf);
1251
	struct perf_probe_point *pp = &pf->pev->point;
1252
	struct probe_trace_event *tev;
1253
	struct perf_probe_arg *args = NULL;
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
	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++];

1264
	/* Trace point should be converted from subprogram DIE */
1265
	ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
1266
				     pp->retprobe, pp->function, &tev->point);
1267
	if (ret < 0)
1268
		goto end;
1269

1270
	tev->point.realname = strdup(dwarf_diename(sc_die));
1271 1272 1273 1274
	if (!tev->point.realname) {
		ret = -ENOMEM;
		goto end;
	}
1275

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

1279 1280
	/* Expand special probe argument if exist */
	args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
1281 1282 1283 1284
	if (args == NULL) {
		ret = -ENOMEM;
		goto end;
	}
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299

	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];
1300
		pf->tvar = &tev->args[i];
1301 1302
		/* Variable should be found from scope DIE */
		ret = find_variable(sc_die, pf);
1303
		if (ret != 0)
1304
			break;
1305 1306
	}

1307
end:
1308 1309 1310 1311
	if (ret) {
		clear_probe_trace_event(tev);
		tf->ntevs--;
	}
1312 1313
	free(args);
	return ret;
1314 1315 1316
}

/* Find probe_trace_events specified by perf_probe_event from debuginfo */
1317
int debuginfo__find_trace_events(struct debuginfo *dbg,
1318
				 struct perf_probe_event *pev,
1319
				 struct probe_trace_event **tevs)
1320 1321 1322
{
	struct trace_event_finder tf = {
			.pf = {.pev = pev, .callback = add_probe_trace_event},
1323
			.max_tevs = probe_conf.max_probes, .mod = dbg->mod};
1324
	int ret, i;
1325 1326

	/* Allocate result tevs array */
1327
	*tevs = zalloc(sizeof(struct probe_trace_event) * tf.max_tevs);
1328 1329 1330 1331 1332 1333
	if (*tevs == NULL)
		return -ENOMEM;

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

1334
	ret = debuginfo__find_probes(dbg, &tf.pf);
1335
	if (ret < 0) {
1336 1337
		for (i = 0; i < tf.ntevs; i++)
			clear_probe_trace_event(&tf.tevs[i]);
1338
		zfree(tevs);
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
		return ret;
	}

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

/* 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;
1350
	struct strbuf buf = STRBUF_INIT;
1351 1352 1353 1354 1355 1356 1357 1358
	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,
1359
						af->pf.fb_ops, &af->pf.sp_die,
1360
						af->pf.machine, NULL);
1361 1362 1363
		if (ret == 0 || ret == -ERANGE) {
			int ret2;
			bool externs = !af->child;
1364

1365 1366
			if (strbuf_init(&buf, 64) < 0)
				goto error;
1367 1368

			if (probe_conf.show_location_range) {
1369 1370 1371 1372 1373 1374 1375
				if (!externs)
					ret2 = strbuf_add(&buf,
						ret ? "[INV]\t" : "[VAL]\t", 6);
				else
					ret2 = strbuf_add(&buf, "[EXT]\t", 6);
				if (ret2)
					goto error;
1376 1377 1378 1379 1380 1381
			}

			ret2 = die_get_varname(die_mem, &buf);

			if (!ret2 && probe_conf.show_location_range &&
				!externs) {
1382 1383
				if (strbuf_addch(&buf, '\t') < 0)
					goto error;
1384 1385 1386 1387 1388 1389
				ret2 = die_get_var_range(&af->pf.sp_die,
							die_mem, &buf);
			}

			pr_debug("Add new var: %s\n", buf.buf);
			if (ret2 == 0) {
1390 1391
				strlist__add(vl->vars,
					strbuf_detach(&buf, NULL));
1392 1393
			}
			strbuf_release(&buf);
1394 1395 1396
		}
	}

1397
	if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1398 1399 1400
		return DIE_FIND_CB_CONTINUE;
	else
		return DIE_FIND_CB_SIBLING;
1401 1402 1403 1404
error:
	strbuf_release(&buf);
	pr_debug("Error in strbuf\n");
	return DIE_FIND_CB_END;
1405 1406 1407
}

/* Add a found vars into available variables list */
1408
static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1409 1410 1411
{
	struct available_var_finder *af =
			container_of(pf, struct available_var_finder, pf);
1412
	struct perf_probe_point *pp = &pf->pev->point;
1413
	struct variable_list *vl;
1414 1415
	Dwarf_Die die_mem;
	int ret;
1416 1417 1418 1419 1420 1421 1422 1423

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

1424
	/* Trace point should be converted from subprogram DIE */
1425
	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1426
				     pp->retprobe, pp->function, &vl->point);
1427 1428 1429 1430 1431 1432 1433
	if (ret < 0)
		return ret;

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

	/* Find local variables */
1434
	vl->vars = strlist__new(NULL, NULL);
1435 1436
	if (vl->vars == NULL)
		return -ENOMEM;
1437
	af->child = true;
1438
	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1439

1440
	/* Find external variables */
1441
	if (!probe_conf.show_ext_vars)
1442
		goto out;
1443
	/* Don't need to search child DIE for external vars. */
1444
	af->child = false;
1445
	die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1446 1447

out:
1448 1449 1450 1451 1452 1453 1454 1455
	if (strlist__empty(vl->vars)) {
		strlist__delete(vl->vars);
		vl->vars = NULL;
	}

	return ret;
}

1456 1457 1458 1459 1460
/*
 * Find available variables at given probe point
 * Return the number of found probe points. Return 0 if there is no
 * matched probe point. Return <0 if an error occurs.
 */
1461
int debuginfo__find_available_vars_at(struct debuginfo *dbg,
1462
				      struct perf_probe_event *pev,
1463
				      struct variable_list **vls)
1464 1465 1466
{
	struct available_var_finder af = {
			.pf = {.pev = pev, .callback = add_available_vars},
1467
			.mod = dbg->mod,
1468
			.max_vls = probe_conf.max_probes};
1469 1470 1471
	int ret;

	/* Allocate result vls array */
1472
	*vls = zalloc(sizeof(struct variable_list) * af.max_vls);
1473 1474 1475 1476 1477 1478
	if (*vls == NULL)
		return -ENOMEM;

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

1479
	ret = debuginfo__find_probes(dbg, &af.pf);
1480 1481 1482
	if (ret < 0) {
		/* Free vlist for error */
		while (af.nvls--) {
1483
			zfree(&af.vls[af.nvls].point.symbol);
1484
			strlist__delete(af.vls[af.nvls].vars);
1485
		}
1486
		zfree(vls);
1487 1488 1489 1490
		return ret;
	}

	return (ret < 0) ? ret : af.nvls;
1491 1492
}

1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
/* For the kernel module, we need a special code to get a DIE */
static int debuginfo__get_text_offset(struct debuginfo *dbg, Dwarf_Addr *offs)
{
	int n, i;
	Elf32_Word shndx;
	Elf_Scn *scn;
	Elf *elf;
	GElf_Shdr mem, *shdr;
	const char *p;

	elf = dwfl_module_getelf(dbg->mod, &dbg->bias);
	if (!elf)
		return -EINVAL;

	/* Get the number of relocations */
	n = dwfl_module_relocations(dbg->mod);
	if (n < 0)
		return -ENOENT;
	/* Search the relocation related .text section */
	for (i = 0; i < n; i++) {
		p = dwfl_module_relocation_info(dbg->mod, i, &shndx);
		if (strcmp(p, ".text") == 0) {
			/* OK, get the section header */
			scn = elf_getscn(elf, shndx);
			if (!scn)
				return -ENOENT;
			shdr = gelf_getshdr(scn, &mem);
			if (!shdr)
				return -ENOENT;
			*offs = shdr->sh_addr;
		}
	}
	return 0;
}

1528
/* Reverse search */
1529
int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
1530
				struct perf_probe_point *ppt)
1531 1532
{
	Dwarf_Die cudie, spdie, indie;
1533 1534
	Dwarf_Addr _addr = 0, baseaddr = 0;
	const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
1535
	int baseline = 0, lineno = 0, ret = 0;
1536
	bool reloc = false;
1537

1538
retry:
1539
	/* Find cu die */
1540
	if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
1541 1542 1543 1544 1545
		if (!reloc && debuginfo__get_text_offset(dbg, &baseaddr) == 0) {
			addr += baseaddr;
			reloc = true;
			goto retry;
		}
M
Masami Hiramatsu 已提交
1546 1547
		pr_warning("Failed to find debug information for address %lx\n",
			   addr);
1548 1549 1550
		ret = -EINVAL;
		goto end;
	}
1551

1552 1553 1554
	/* Find a corresponding line (filename and lineno) */
	cu_find_lineinfo(&cudie, addr, &fname, &lineno);
	/* Don't care whether it failed or not */
1555

1556
	/* Find a corresponding function (name, baseline and baseaddr) */
1557
	if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
1558
		/* Get function entry information */
1559 1560
		func = basefunc = dwarf_diename(&spdie);
		if (!func ||
1561
		    dwarf_entrypc(&spdie, &baseaddr) != 0 ||
1562 1563
		    dwarf_decl_line(&spdie, &baseline) != 0) {
			lineno = 0;
1564
			goto post;
1565
		}
1566

1567
		fname = dwarf_decl_file(&spdie);
1568
		if (addr == (unsigned long)baseaddr) {
1569 1570
			/* Function entry - Relative line number is 0 */
			lineno = baseline;
1571 1572 1573 1574 1575 1576 1577
			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 */
1578
			if (dwarf_entrypc(&indie, &_addr) == 0 &&
1579
			    _addr == addr) {
1580 1581 1582
				/*
				 * addr is at an inline function entry.
				 * In this case, lineno should be the call-site
1583
				 * line number. (overwrite lineinfo)
1584 1585
				 */
				lineno = die_get_call_lineno(&indie);
1586 1587 1588
				fname = die_get_call_file(&indie);
				break;
			} else {
1589 1590 1591 1592 1593 1594
				/*
				 * 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.
				 */
1595
				tmp = dwarf_diename(&indie);
1596 1597 1598 1599 1600
				if (!tmp ||
				    dwarf_decl_line(&indie, &baseline) != 0)
					break;
				func = tmp;
				spdie = indie;
1601
			}
1602
		}
1603 1604 1605 1606
		/* Verify the lineno and baseline are in a same file */
		tmp = dwarf_decl_file(&spdie);
		if (!tmp || strcmp(tmp, fname) != 0)
			lineno = 0;
1607 1608 1609 1610 1611 1612
	}

post:
	/* Make a relative line number or an offset */
	if (lineno)
		ppt->line = lineno - baseline;
1613
	else if (basefunc) {
1614
		ppt->offset = addr - (unsigned long)baseaddr;
1615 1616
		func = basefunc;
	}
1617 1618 1619 1620

	/* Duplicate strings */
	if (func) {
		ppt->function = strdup(func);
1621 1622 1623 1624
		if (ppt->function == NULL) {
			ret = -ENOMEM;
			goto end;
		}
1625
	}
1626 1627 1628
	if (fname) {
		ppt->file = strdup(fname);
		if (ppt->file == NULL) {
1629
			zfree(&ppt->function);
1630 1631 1632 1633
			ret = -ENOMEM;
			goto end;
		}
	}
1634
end:
1635 1636
	if (ret == 0 && (fname || func))
		ret = 1;	/* Found a point */
1637 1638 1639
	return ret;
}

1640 1641 1642 1643
/* Add a line and store the src path */
static int line_range_add_line(const char *src, unsigned int lineno,
			       struct line_range *lr)
{
1644
	/* Copy source path */
1645
	if (!lr->path) {
1646 1647 1648
		lr->path = strdup(src);
		if (lr->path == NULL)
			return -ENOMEM;
1649
	}
1650
	return intlist__add(lr->line_list, lineno);
1651 1652
}

1653
static int line_range_walk_cb(const char *fname, int lineno,
1654
			      Dwarf_Addr addr __maybe_unused,
1655
			      void *data)
1656
{
1657
	struct line_finder *lf = data;
1658
	int err;
1659

1660
	if ((strtailcmp(fname, lf->fname) != 0) ||
1661
	    (lf->lno_s > lineno || lf->lno_e < lineno))
1662
		return 0;
1663

1664 1665 1666
	err = line_range_add_line(fname, lineno, lf->lr);
	if (err < 0 && err != -EEXIST)
		return err;
1667

1668
	return 0;
1669
}
1670

1671
/* Find line range from its line number */
1672
static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1673
{
1674
	int ret;
1675

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

1678
	/* Update status */
1679
	if (ret >= 0)
1680
		if (!intlist__empty(lf->lr->line_list))
1681 1682 1683
			ret = lf->found = 1;
		else
			ret = 0;	/* Lines are not found */
1684
	else {
1685
		zfree(&lf->lr->path);
1686
	}
1687
	return ret;
1688 1689
}

1690 1691
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
{
1692
	int ret = find_line_range_by_line(in_die, data);
1693 1694 1695 1696

	/*
	 * We have to check all instances of inlined function, because
	 * some execution paths can be optimized out depends on the
1697 1698
	 * function argument of instances. However, if an error occurs,
	 * it should be handled by the caller.
1699
	 */
1700
	return ret < 0 ? ret : 0;
1701 1702
}

1703
/* Search function definition from function name */
1704
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1705
{
1706 1707
	struct dwarf_callback_param *param = data;
	struct line_finder *lf = param->data;
1708 1709
	struct line_range *lr = lf->lr;

1710 1711 1712 1713
	/* Check declared file */
	if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
		return DWARF_CB_OK;

1714
	if (die_is_func_def(sp_die) &&
1715
	    die_match_name(sp_die, lr->function)) {
1716 1717
		lf->fname = dwarf_decl_file(sp_die);
		dwarf_decl_line(sp_die, &lr->offset);
1718
		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1719
		lf->lno_s = lr->offset + lr->start;
1720 1721 1722 1723
		if (lf->lno_s < 0)	/* Overflow */
			lf->lno_s = INT_MAX;
		lf->lno_e = lr->offset + lr->end;
		if (lf->lno_e < 0)	/* Overflow */
1724
			lf->lno_e = INT_MAX;
1725
		pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1726 1727
		lr->start = lf->lno_s;
		lr->end = lf->lno_e;
1728
		if (!die_is_func_instance(sp_die))
1729 1730 1731
			param->retval = die_walk_instances(sp_die,
						line_range_inline_cb, lf);
		else
1732 1733
			param->retval = find_line_range_by_line(sp_die, lf);
		return DWARF_CB_ABORT;
1734
	}
1735
	return DWARF_CB_OK;
1736 1737
}

1738
static int find_line_range_by_func(struct line_finder *lf)
1739
{
1740 1741 1742
	struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
	return param.retval;
1743 1744
}

1745
int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
1746
{
1747
	struct line_finder lf = {.lr = lr, .found = 0};
1748
	int ret = 0;
1749 1750 1751
	Dwarf_Off off = 0, noff;
	size_t cuhl;
	Dwarf_Die *diep;
1752
	const char *comp_dir;
1753

1754 1755 1756 1757 1758 1759 1760 1761
	/* 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};

1762
		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1763
				  &pubname_param, 0);
1764 1765 1766 1767 1768 1769 1770
		if (pubname_param.found) {
			line_range_search_cb(&lf.sp_die, &line_range_param);
			if (lf.found)
				goto found;
		}
	}

1771
	/* Loop on CUs (Compilation Unit) */
1772
	while (!lf.found && ret >= 0) {
1773
		if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
1774
				 NULL, NULL, NULL) != 0)
1775 1776 1777
			break;

		/* Get the DIE(Debugging Information Entry) of this CU */
1778
		diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
1779 1780
		if (!diep)
			continue;
1781 1782 1783

		/* Check if target file is included. */
		if (lr->file)
1784
			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1785
		else
1786
			lf.fname = 0;
1787

1788
		if (!lr->file || lf.fname) {
1789
			if (lr->function)
1790
				ret = find_line_range_by_func(&lf);
1791 1792
			else {
				lf.lno_s = lr->start;
1793
				lf.lno_e = lr->end;
1794
				ret = find_line_range_by_line(NULL, &lf);
1795 1796
			}
		}
1797
		off = noff;
1798
	}
1799

1800
found:
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
	/* 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;
		}
	}

1811
	pr_debug("path: %s\n", lr->path);
1812
	return (ret < 0) ? ret : lf.found;
1813 1814
}

1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
/*
 * Find a src file from a DWARF tag path. Prepend optional source path prefix
 * and chop off leading directories that do not exist. Result is passed back as
 * a newly allocated path on success.
 * Return 0 if file was found and readable, -errno otherwise.
 */
int get_real_path(const char *raw_path, const char *comp_dir,
			 char **new_path)
{
	const char *prefix = symbol_conf.source_prefix;

	if (!prefix) {
		if (raw_path[0] != '/' && comp_dir)
			/* If not an absolute path, try to use comp_dir */
			prefix = comp_dir;
		else {
			if (access(raw_path, R_OK) == 0) {
				*new_path = strdup(raw_path);
				return *new_path ? 0 : -ENOMEM;
			} else
				return -errno;
		}
	}

	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
	if (!*new_path)
		return -ENOMEM;

	for (;;) {
		sprintf(*new_path, "%s/%s", prefix, raw_path);

		if (access(*new_path, R_OK) == 0)
			return 0;

		if (!symbol_conf.source_prefix) {
			/* In case of searching comp_dir, don't retry */
			zfree(new_path);
			return -errno;
		}

		switch (errno) {
		case ENAMETOOLONG:
		case ENOENT:
		case EROFS:
		case EFAULT:
			raw_path = strchr(++raw_path, '/');
			if (!raw_path) {
				zfree(new_path);
				return -ENOENT;
			}
			continue;

		default:
			zfree(new_path);
			return -errno;
		}
	}
}