1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * probe-finder.c : C expression to kprobe event converter
   4 *
   5 * Written by Masami Hiramatsu <mhiramat@redhat.com>
   6 */
   7
   8#include <inttypes.h>
   9#include <sys/utsname.h>
  10#include <sys/types.h>
  11#include <sys/stat.h>
  12#include <fcntl.h>
  13#include <errno.h>
  14#include <stdio.h>
  15#include <unistd.h>
  16#include <stdlib.h>
  17#include <string.h>
  18#include <stdarg.h>
  19#include <dwarf-regs.h>
  20
  21#include <linux/bitops.h>
  22#include <linux/zalloc.h>
  23#include "event.h"
  24#include "dso.h"
  25#include "debug.h"
  26#include "intlist.h"
  27#include "strbuf.h"
  28#include "strlist.h"
  29#include "symbol.h"
  30#include "probe-finder.h"
  31#include "probe-file.h"
  32#include "string2.h"
  33
 
 
 
 
  34/* Kprobe tracer basic type is up to u64 */
  35#define MAX_BASIC_TYPE_BITS	64
  36
  37/* Dwarf FL wrappers */
  38static char *debuginfo_path;	/* Currently dummy */
  39
  40static const Dwfl_Callbacks offline_callbacks = {
  41	.find_debuginfo = dwfl_standard_find_debuginfo,
  42	.debuginfo_path = &debuginfo_path,
  43
  44	.section_address = dwfl_offline_section_address,
  45
  46	/* We use this table for core files too.  */
  47	.find_elf = dwfl_build_id_find_elf,
  48};
  49
  50/* Get a Dwarf from offline image */
  51static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
  52					 const char *path)
  53{
 
  54	int fd;
  55
  56	fd = open(path, O_RDONLY);
  57	if (fd < 0)
  58		return fd;
  59
  60	dbg->dwfl = dwfl_begin(&offline_callbacks);
  61	if (!dbg->dwfl)
  62		goto error;
  63
  64	dwfl_report_begin(dbg->dwfl);
  65	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
  66	if (!dbg->mod)
  67		goto error;
  68
  69	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
  70	if (!dbg->dbg)
  71		goto error;
  72
 
 
  73	dwfl_report_end(dbg->dwfl, NULL, NULL);
  74
  75	return 0;
  76error:
  77	if (dbg->dwfl)
  78		dwfl_end(dbg->dwfl);
  79	else
  80		close(fd);
  81	memset(dbg, 0, sizeof(*dbg));
  82
  83	return -ENOENT;
  84}
  85
  86static struct debuginfo *__debuginfo__new(const char *path)
  87{
  88	struct debuginfo *dbg = zalloc(sizeof(*dbg));
  89	if (!dbg)
  90		return NULL;
  91
  92	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
  93		zfree(&dbg);
  94	if (dbg)
  95		pr_debug("Open Debuginfo file: %s\n", path);
  96	return dbg;
  97}
  98
  99enum dso_binary_type distro_dwarf_types[] = {
 100	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
 101	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
 102	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
 103	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
 
 104	DSO_BINARY_TYPE__NOT_FOUND,
 105};
 106
 107struct debuginfo *debuginfo__new(const char *path)
 108{
 109	enum dso_binary_type *type;
 110	char buf[PATH_MAX], nil = '\0';
 111	struct dso *dso;
 112	struct debuginfo *dinfo = NULL;
 
 113
 114	/* Try to open distro debuginfo files */
 115	dso = dso__new(path);
 116	if (!dso)
 117		goto out;
 118
 
 
 
 
 119	for (type = distro_dwarf_types;
 120	     !dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
 121	     type++) {
 122		if (dso__read_binary_type_filename(dso, *type, &nil,
 123						   buf, PATH_MAX) < 0)
 124			continue;
 125		dinfo = __debuginfo__new(buf);
 126	}
 127	dso__put(dso);
 128
 129out:
 130	/* if failed to open all distro debuginfo, open given binary */
 131	return dinfo ? : __debuginfo__new(path);
 132}
 133
 134void debuginfo__delete(struct debuginfo *dbg)
 135{
 136	if (dbg) {
 137		if (dbg->dwfl)
 138			dwfl_end(dbg->dwfl);
 139		free(dbg);
 140	}
 141}
 142
 143/*
 144 * Probe finder related functions
 145 */
 146
 147static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
 148{
 149	struct probe_trace_arg_ref *ref;
 150	ref = zalloc(sizeof(struct probe_trace_arg_ref));
 151	if (ref != NULL)
 152		ref->offset = offs;
 153	return ref;
 154}
 155
 156/*
 157 * Convert a location into trace_arg.
 158 * If tvar == NULL, this just checks variable can be converted.
 159 * If fentry == true and vr_die is a parameter, do huristic search
 160 * for the location fuzzed by function entry mcount.
 161 */
 162static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
 163				     Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
 164				     unsigned int machine,
 165				     struct probe_trace_arg *tvar)
 166{
 167	Dwarf_Attribute attr;
 168	Dwarf_Addr tmp = 0;
 169	Dwarf_Op *op;
 170	size_t nops;
 171	unsigned int regn;
 172	Dwarf_Word offs = 0;
 173	bool ref = false;
 174	const char *regs;
 175	int ret, ret2 = 0;
 176
 177	if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
 178		goto static_var;
 179
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 180	/* TODO: handle more than 1 exprs */
 181	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
 182		return -EINVAL;	/* Broken DIE ? */
 183	if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
 184		ret = dwarf_entrypc(sp_die, &tmp);
 185		if (ret)
 186			return -ENOENT;
 187
 188		if (probe_conf.show_location_range &&
 189			(dwarf_tag(vr_die) == DW_TAG_variable)) {
 190			ret2 = -ERANGE;
 191		} else if (addr != tmp ||
 192			dwarf_tag(vr_die) != DW_TAG_formal_parameter) {
 193			return -ENOENT;
 194		}
 195
 196		ret = dwarf_highpc(sp_die, &tmp);
 197		if (ret)
 198			return -ENOENT;
 199		/*
 200		 * This is fuzzed by fentry mcount. We try to find the
 201		 * parameter location at the earliest address.
 202		 */
 203		for (addr += 1; addr <= tmp; addr++) {
 204			if (dwarf_getlocation_addr(&attr, addr, &op,
 205						   &nops, 1) > 0)
 206				goto found;
 207		}
 208		return -ENOENT;
 209	}
 210found:
 211	if (nops == 0)
 212		/* TODO: Support const_value */
 213		return -ENOENT;
 214
 215	if (op->atom == DW_OP_addr) {
 216static_var:
 217		if (!tvar)
 218			return ret2;
 219		/* Static variables on memory (not stack), make @varname */
 220		ret = strlen(dwarf_diename(vr_die));
 221		tvar->value = zalloc(ret + 2);
 222		if (tvar->value == NULL)
 223			return -ENOMEM;
 224		snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
 225		tvar->ref = alloc_trace_arg_ref((long)offs);
 226		if (tvar->ref == NULL)
 227			return -ENOMEM;
 228		return ret2;
 229	}
 230
 231	/* If this is based on frame buffer, set the offset */
 232	if (op->atom == DW_OP_fbreg) {
 233		if (fb_ops == NULL)
 234			return -ENOTSUP;
 235		ref = true;
 236		offs = op->number;
 237		op = &fb_ops[0];
 238	}
 239
 240	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
 241		regn = op->atom - DW_OP_breg0;
 242		offs += op->number;
 243		ref = true;
 244	} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
 245		regn = op->atom - DW_OP_reg0;
 246	} else if (op->atom == DW_OP_bregx) {
 247		regn = op->number;
 248		offs += op->number2;
 249		ref = true;
 250	} else if (op->atom == DW_OP_regx) {
 251		regn = op->number;
 252	} else {
 253		pr_debug("DW_OP %x is not supported.\n", op->atom);
 254		return -ENOTSUP;
 255	}
 256
 257	if (!tvar)
 258		return ret2;
 259
 260	regs = get_dwarf_regstr(regn, machine);
 261	if (!regs) {
 262		/* This should be a bug in DWARF or this tool */
 263		pr_warning("Mapping for the register number %u "
 264			   "missing on this architecture.\n", regn);
 265		return -ENOTSUP;
 266	}
 267
 268	tvar->value = strdup(regs);
 269	if (tvar->value == NULL)
 270		return -ENOMEM;
 271
 272	if (ref) {
 273		tvar->ref = alloc_trace_arg_ref((long)offs);
 274		if (tvar->ref == NULL)
 275			return -ENOMEM;
 276	}
 277	return ret2;
 278}
 279
 280#define BYTES_TO_BITS(nb)	((nb) * BITS_PER_LONG / sizeof(long))
 281
 282static int convert_variable_type(Dwarf_Die *vr_die,
 283				 struct probe_trace_arg *tvar,
 284				 const char *cast, bool user_access)
 285{
 286	struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
 287	Dwarf_Die type;
 288	char buf[16];
 289	char sbuf[STRERR_BUFSIZE];
 290	int bsize, boffs, total;
 291	int ret;
 292	char prefix;
 293
 294	/* TODO: check all types */
 295	if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "x") != 0 &&
 
 296	    strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) {
 297		/* Non string type is OK */
 298		/* and respect signedness/hexadecimal cast */
 299		tvar->type = strdup(cast);
 300		return (tvar->type == NULL) ? -ENOMEM : 0;
 301	}
 302
 303	bsize = dwarf_bitsize(vr_die);
 304	if (bsize > 0) {
 305		/* This is a bitfield */
 306		boffs = dwarf_bitoffset(vr_die);
 307		total = dwarf_bytesize(vr_die);
 308		if (boffs < 0 || total < 0)
 309			return -ENOENT;
 310		ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs,
 311				BYTES_TO_BITS(total));
 312		goto formatted;
 313	}
 314
 315	if (die_get_real_type(vr_die, &type) == NULL) {
 316		pr_warning("Failed to get a type information of %s.\n",
 317			   dwarf_diename(vr_die));
 318		return -ENOENT;
 319	}
 320
 321	pr_debug("%s type is %s.\n",
 322		 dwarf_diename(vr_die), dwarf_diename(&type));
 323
 324	if (cast && (!strcmp(cast, "string") || !strcmp(cast, "ustring"))) {
 325		/* String type */
 326		ret = dwarf_tag(&type);
 327		if (ret != DW_TAG_pointer_type &&
 328		    ret != DW_TAG_array_type) {
 329			pr_warning("Failed to cast into string: "
 330				   "%s(%s) is not a pointer nor array.\n",
 331				   dwarf_diename(vr_die), dwarf_diename(&type));
 332			return -EINVAL;
 333		}
 334		if (die_get_real_type(&type, &type) == NULL) {
 335			pr_warning("Failed to get a type"
 336				   " information.\n");
 337			return -ENOENT;
 338		}
 339		if (ret == DW_TAG_pointer_type) {
 340			while (*ref_ptr)
 341				ref_ptr = &(*ref_ptr)->next;
 342			/* Add new reference with offset +0 */
 343			*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
 344			if (*ref_ptr == NULL) {
 345				pr_warning("Out of memory error\n");
 346				return -ENOMEM;
 347			}
 348			(*ref_ptr)->user_access = user_access;
 349		}
 350		if (!die_compare_name(&type, "char") &&
 351		    !die_compare_name(&type, "unsigned char")) {
 352			pr_warning("Failed to cast into string: "
 353				   "%s is not (unsigned) char *.\n",
 354				   dwarf_diename(vr_die));
 355			return -EINVAL;
 356		}
 357		tvar->type = strdup(cast);
 358		return (tvar->type == NULL) ? -ENOMEM : 0;
 359	}
 360
 361	if (cast && (strcmp(cast, "u") == 0))
 362		prefix = 'u';
 363	else if (cast && (strcmp(cast, "s") == 0))
 364		prefix = 's';
 365	else if (cast && (strcmp(cast, "x") == 0) &&
 366		 probe_type_is_available(PROBE_TYPE_X))
 367		prefix = 'x';
 368	else
 369		prefix = die_is_signed_type(&type) ? 's' :
 370			 probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u';
 371
 372	ret = dwarf_bytesize(&type);
 373	if (ret <= 0)
 374		/* No size ... try to use default type */
 375		return 0;
 376	ret = BYTES_TO_BITS(ret);
 377
 378	/* Check the bitwidth */
 379	if (ret > MAX_BASIC_TYPE_BITS) {
 380		pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
 381			dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
 382		ret = MAX_BASIC_TYPE_BITS;
 383	}
 384	ret = snprintf(buf, 16, "%c%d", prefix, ret);
 385
 386formatted:
 387	if (ret < 0 || ret >= 16) {
 388		if (ret >= 16)
 389			ret = -E2BIG;
 390		pr_warning("Failed to convert variable type: %s\n",
 391			   str_error_r(-ret, sbuf, sizeof(sbuf)));
 392		return ret;
 393	}
 394	tvar->type = strdup(buf);
 395	if (tvar->type == NULL)
 396		return -ENOMEM;
 397	return 0;
 398}
 399
 400static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
 401				    struct perf_probe_arg_field *field,
 402				    struct probe_trace_arg_ref **ref_ptr,
 403				    Dwarf_Die *die_mem, bool user_access)
 404{
 405	struct probe_trace_arg_ref *ref = *ref_ptr;
 406	Dwarf_Die type;
 407	Dwarf_Word offs;
 408	int ret, tag;
 409
 410	pr_debug("converting %s in %s\n", field->name, varname);
 411	if (die_get_real_type(vr_die, &type) == NULL) {
 412		pr_warning("Failed to get the type of %s.\n", varname);
 413		return -ENOENT;
 414	}
 415	pr_debug2("Var real type: %s (%x)\n", dwarf_diename(&type),
 416		  (unsigned)dwarf_dieoffset(&type));
 417	tag = dwarf_tag(&type);
 418
 419	if (field->name[0] == '[' &&
 420	    (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
 421		/* Save original type for next field or type */
 422		memcpy(die_mem, &type, sizeof(*die_mem));
 423		/* Get the type of this array */
 424		if (die_get_real_type(&type, &type) == NULL) {
 425			pr_warning("Failed to get the type of %s.\n", varname);
 426			return -ENOENT;
 427		}
 428		pr_debug2("Array real type: %s (%x)\n", dwarf_diename(&type),
 429			 (unsigned)dwarf_dieoffset(&type));
 430		if (tag == DW_TAG_pointer_type) {
 431			ref = zalloc(sizeof(struct probe_trace_arg_ref));
 432			if (ref == NULL)
 433				return -ENOMEM;
 434			if (*ref_ptr)
 435				(*ref_ptr)->next = ref;
 436			else
 437				*ref_ptr = ref;
 438		}
 439		ref->offset += dwarf_bytesize(&type) * field->index;
 440		ref->user_access = user_access;
 441		goto next;
 442	} else if (tag == DW_TAG_pointer_type) {
 443		/* Check the pointer and dereference */
 444		if (!field->ref) {
 445			pr_err("Semantic error: %s must be referred by '->'\n",
 446			       field->name);
 447			return -EINVAL;
 448		}
 449		/* Get the type pointed by this pointer */
 450		if (die_get_real_type(&type, &type) == NULL) {
 451			pr_warning("Failed to get the type of %s.\n", varname);
 452			return -ENOENT;
 453		}
 454		/* Verify it is a data structure  */
 455		tag = dwarf_tag(&type);
 456		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
 457			pr_warning("%s is not a data structure nor a union.\n",
 458				   varname);
 459			return -EINVAL;
 460		}
 461
 462		ref = zalloc(sizeof(struct probe_trace_arg_ref));
 463		if (ref == NULL)
 464			return -ENOMEM;
 465		if (*ref_ptr)
 466			(*ref_ptr)->next = ref;
 467		else
 468			*ref_ptr = ref;
 469	} else {
 470		/* Verify it is a data structure  */
 471		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
 472			pr_warning("%s is not a data structure nor a union.\n",
 473				   varname);
 474			return -EINVAL;
 475		}
 476		if (field->name[0] == '[') {
 477			pr_err("Semantic error: %s is not a pointer"
 478			       " nor array.\n", varname);
 479			return -EINVAL;
 480		}
 481		/* While prcessing unnamed field, we don't care about this */
 482		if (field->ref && dwarf_diename(vr_die)) {
 483			pr_err("Semantic error: %s must be referred by '.'\n",
 484			       field->name);
 485			return -EINVAL;
 486		}
 487		if (!ref) {
 488			pr_warning("Structure on a register is not "
 489				   "supported yet.\n");
 490			return -ENOTSUP;
 491		}
 492	}
 493
 494	if (die_find_member(&type, field->name, die_mem) == NULL) {
 495		pr_warning("%s(type:%s) has no member %s.\n", varname,
 496			   dwarf_diename(&type), field->name);
 497		return -EINVAL;
 498	}
 499
 500	/* Get the offset of the field */
 501	if (tag == DW_TAG_union_type) {
 502		offs = 0;
 503	} else {
 504		ret = die_get_data_member_location(die_mem, &offs);
 505		if (ret < 0) {
 506			pr_warning("Failed to get the offset of %s.\n",
 507				   field->name);
 508			return ret;
 509		}
 510	}
 511	ref->offset += (long)offs;
 512	ref->user_access = user_access;
 513
 514	/* If this member is unnamed, we need to reuse this field */
 515	if (!dwarf_diename(die_mem))
 516		return convert_variable_fields(die_mem, varname, field,
 517						&ref, die_mem, user_access);
 518
 519next:
 520	/* Converting next field */
 521	if (field->next)
 522		return convert_variable_fields(die_mem, field->name,
 523				field->next, &ref, die_mem, user_access);
 524	else
 525		return 0;
 526}
 527
 
 
 
 
 
 
 
 
 528/* Show a variables in kprobe event format */
 529static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
 530{
 531	Dwarf_Die die_mem;
 532	int ret;
 533
 534	pr_debug("Converting variable %s into trace event.\n",
 535		 dwarf_diename(vr_die));
 536
 537	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
 538					&pf->sp_die, pf->machine, pf->tvar);
 
 
 
 539	if (ret == -ENOENT || ret == -EINVAL) {
 540		pr_err("Failed to find the location of the '%s' variable at this address.\n"
 541		       " Perhaps it has been optimized out.\n"
 542		       " Use -V with the --range option to show '%s' location range.\n",
 543		       pf->pvar->var, pf->pvar->var);
 544	} else if (ret == -ENOTSUP)
 545		pr_err("Sorry, we don't support this variable location yet.\n");
 546	else if (ret == 0 && pf->pvar->field) {
 547		ret = convert_variable_fields(vr_die, pf->pvar->var,
 548					      pf->pvar->field, &pf->tvar->ref,
 549					      &die_mem, pf->pvar->user_access);
 550		vr_die = &die_mem;
 551	}
 552	if (ret == 0)
 553		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type,
 554					    pf->pvar->user_access);
 555	/* *expr will be cached in libdw. Don't free it. */
 556	return ret;
 557}
 558
 559/* Find a variable in a scope DIE */
 560static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
 561{
 562	Dwarf_Die vr_die;
 563	char *buf, *ptr;
 564	int ret = 0;
 565
 566	/* Copy raw parameters */
 567	if (!is_c_varname(pf->pvar->var))
 568		return copy_to_probe_trace_arg(pf->tvar, pf->pvar);
 569
 570	if (pf->pvar->name)
 571		pf->tvar->name = strdup(pf->pvar->name);
 572	else {
 573		buf = synthesize_perf_probe_arg(pf->pvar);
 574		if (!buf)
 575			return -ENOMEM;
 576		ptr = strchr(buf, ':');	/* Change type separator to _ */
 577		if (ptr)
 578			*ptr = '_';
 579		pf->tvar->name = buf;
 580	}
 581	if (pf->tvar->name == NULL)
 582		return -ENOMEM;
 583
 584	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
 585	/* Search child die for local variables and parameters. */
 586	if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
 587		/* Search again in global variables */
 588		if (!die_find_variable_at(&pf->cu_die, pf->pvar->var,
 589						0, &vr_die)) {
 
 
 590			pr_warning("Failed to find '%s' in this function.\n",
 591				   pf->pvar->var);
 592			ret = -ENOENT;
 593		}
 594	}
 595	if (ret >= 0)
 596		ret = convert_variable(&vr_die, pf);
 597
 598	return ret;
 599}
 600
 601/* Convert subprogram DIE to trace point */
 602static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
 603				  Dwarf_Addr paddr, bool retprobe,
 604				  const char *function,
 605				  struct probe_trace_point *tp)
 606{
 607	Dwarf_Addr eaddr, highaddr;
 608	GElf_Sym sym;
 609	const char *symbol;
 610
 611	/* Verify the address is correct */
 612	if (dwarf_entrypc(sp_die, &eaddr) != 0) {
 613		pr_warning("Failed to get entry address of %s\n",
 614			   dwarf_diename(sp_die));
 615		return -ENOENT;
 616	}
 617	if (dwarf_highpc(sp_die, &highaddr) != 0) {
 618		pr_warning("Failed to get end address of %s\n",
 619			   dwarf_diename(sp_die));
 620		return -ENOENT;
 621	}
 622	if (paddr > highaddr) {
 623		pr_warning("Offset specified is greater than size of %s\n",
 624			   dwarf_diename(sp_die));
 625		return -EINVAL;
 626	}
 627
 628	symbol = dwarf_diename(sp_die);
 629	if (!symbol) {
 630		/* Try to get the symbol name from symtab */
 
 
 631		symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
 632		if (!symbol) {
 633			pr_warning("Failed to find symbol at 0x%lx\n",
 634				   (unsigned long)paddr);
 635			return -ENOENT;
 636		}
 637		eaddr = sym.st_value;
 638	}
 
 
 
 
 
 
 639	tp->offset = (unsigned long)(paddr - eaddr);
 640	tp->address = (unsigned long)paddr;
 641	tp->symbol = strdup(symbol);
 642	if (!tp->symbol)
 643		return -ENOMEM;
 644
 645	/* Return probe must be on the head of a subprogram */
 646	if (retprobe) {
 647		if (eaddr != paddr) {
 648			pr_warning("Failed to find \"%s%%return\",\n"
 649				   " because %s is an inlined function and"
 650				   " has no return point.\n", function,
 651				   function);
 652			return -EINVAL;
 653		}
 654		tp->retprobe = true;
 655	}
 656
 657	return 0;
 658}
 659
 660/* Call probe_finder callback with scope DIE */
 661static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
 662{
 663	Dwarf_Attribute fb_attr;
 664	Dwarf_Frame *frame = NULL;
 665	size_t nops;
 666	int ret;
 667
 668	if (!sc_die) {
 669		pr_err("Caller must pass a scope DIE. Program error.\n");
 670		return -EINVAL;
 671	}
 672
 673	/* If not a real subprogram, find a real one */
 674	if (!die_is_func_def(sc_die)) {
 675		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
 676			if (die_find_tailfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
 677				pr_warning("Ignoring tail call from %s\n",
 678						dwarf_diename(&pf->sp_die));
 679				return 0;
 680			} else {
 681				pr_warning("Failed to find probe point in any "
 682					   "functions.\n");
 683				return -ENOENT;
 684			}
 685		}
 686	} else
 687		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
 688
 689	/* Get the frame base attribute/ops from subprogram */
 690	dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
 691	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
 692	if (ret <= 0 || nops == 0) {
 693		pf->fb_ops = NULL;
 694#if _ELFUTILS_PREREQ(0, 142)
 695	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
 696		   (pf->cfi_eh != NULL || pf->cfi_dbg != NULL)) {
 697		if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&
 698		     (dwarf_cfi_addrframe(pf->cfi_dbg, pf->addr, &frame) != 0)) ||
 699		    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
 700			pr_warning("Failed to get call frame on 0x%jx\n",
 701				   (uintmax_t)pf->addr);
 702			free(frame);
 703			return -ENOENT;
 704		}
 705#endif
 706	}
 707
 708	/* Call finder's callback handler */
 709	ret = pf->callback(sc_die, pf);
 710
 711	/* Since *pf->fb_ops can be a part of frame. we should free it here. */
 712	free(frame);
 713	pf->fb_ops = NULL;
 714
 715	return ret;
 716}
 717
 718struct find_scope_param {
 719	const char *function;
 720	const char *file;
 721	int line;
 722	int diff;
 723	Dwarf_Die *die_mem;
 724	bool found;
 725};
 726
 727static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
 728{
 729	struct find_scope_param *fsp = data;
 730	const char *file;
 731	int lno;
 732
 733	/* Skip if declared file name does not match */
 734	if (fsp->file) {
 735		file = dwarf_decl_file(fn_die);
 736		if (!file || strcmp(fsp->file, file) != 0)
 737			return 0;
 738	}
 739	/* If the function name is given, that's what user expects */
 740	if (fsp->function) {
 741		if (die_match_name(fn_die, fsp->function)) {
 742			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
 743			fsp->found = true;
 744			return 1;
 745		}
 746	} else {
 747		/* With the line number, find the nearest declared DIE */
 748		dwarf_decl_line(fn_die, &lno);
 749		if (lno < fsp->line && fsp->diff > fsp->line - lno) {
 750			/* Keep a candidate and continue */
 751			fsp->diff = fsp->line - lno;
 752			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
 753			fsp->found = true;
 754		}
 755	}
 756	return 0;
 757}
 758
 
 
 
 
 
 
 
 
 
 
 759/* Find an appropriate scope fits to given conditions */
 760static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
 761{
 762	struct find_scope_param fsp = {
 763		.function = pf->pev->point.function,
 764		.file = pf->fname,
 765		.line = pf->lno,
 766		.diff = INT_MAX,
 767		.die_mem = die_mem,
 768		.found = false,
 769	};
 
 770
 771	cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);
 
 
 
 
 772
 773	return fsp.found ? die_mem : NULL;
 774}
 775
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 776static int probe_point_line_walker(const char *fname, int lineno,
 777				   Dwarf_Addr addr, void *data)
 778{
 779	struct probe_finder *pf = data;
 780	Dwarf_Die *sc_die, die_mem;
 781	int ret;
 782
 783	if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
 784		return 0;
 785
 
 
 
 786	pf->addr = addr;
 787	sc_die = find_best_scope(pf, &die_mem);
 788	if (!sc_die) {
 789		pr_warning("Failed to find scope of probe point.\n");
 790		return -ENOENT;
 791	}
 792
 793	ret = call_probe_finder(sc_die, pf);
 794
 795	/* Continue if no error, because the line will be in inline function */
 796	return ret < 0 ? ret : 0;
 797}
 798
 799/* Find probe point from its line number */
 800static int find_probe_point_by_line(struct probe_finder *pf)
 801{
 802	return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
 803}
 804
 805/* Find lines which match lazy pattern */
 806static int find_lazy_match_lines(struct intlist *list,
 807				 const char *fname, const char *pat)
 808{
 809	FILE *fp;
 810	char *line = NULL;
 811	size_t line_len;
 812	ssize_t len;
 813	int count = 0, linenum = 1;
 814	char sbuf[STRERR_BUFSIZE];
 815
 816	fp = fopen(fname, "r");
 817	if (!fp) {
 818		pr_warning("Failed to open %s: %s\n", fname,
 819			   str_error_r(errno, sbuf, sizeof(sbuf)));
 820		return -errno;
 821	}
 822
 823	while ((len = getline(&line, &line_len, fp)) > 0) {
 824
 825		if (line[len - 1] == '\n')
 826			line[len - 1] = '\0';
 827
 828		if (strlazymatch(line, pat)) {
 829			intlist__add(list, linenum);
 830			count++;
 831		}
 832		linenum++;
 833	}
 834
 835	if (ferror(fp))
 836		count = -errno;
 837	free(line);
 838	fclose(fp);
 839
 840	if (count == 0)
 841		pr_debug("No matched lines found in %s.\n", fname);
 842	return count;
 843}
 844
 845static int probe_point_lazy_walker(const char *fname, int lineno,
 846				   Dwarf_Addr addr, void *data)
 847{
 848	struct probe_finder *pf = data;
 849	Dwarf_Die *sc_die, die_mem;
 850	int ret;
 851
 852	if (!intlist__has_entry(pf->lcache, lineno) ||
 853	    strtailcmp(fname, pf->fname) != 0)
 854		return 0;
 855
 856	pr_debug("Probe line found: line:%d addr:0x%llx\n",
 857		 lineno, (unsigned long long)addr);
 858	pf->addr = addr;
 859	pf->lno = lineno;
 860	sc_die = find_best_scope(pf, &die_mem);
 861	if (!sc_die) {
 862		pr_warning("Failed to find scope of probe point.\n");
 863		return -ENOENT;
 864	}
 865
 866	ret = call_probe_finder(sc_die, pf);
 867
 868	/*
 869	 * Continue if no error, because the lazy pattern will match
 870	 * to other lines
 871	 */
 872	return ret < 0 ? ret : 0;
 873}
 874
 875/* Find probe points from lazy pattern  */
 876static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
 877{
 
 
 878	int ret = 0;
 879	char *fpath;
 880
 881	if (intlist__empty(pf->lcache)) {
 882		const char *comp_dir;
 883
 884		comp_dir = cu_get_comp_dir(&pf->cu_die);
 885		ret = get_real_path(pf->fname, comp_dir, &fpath);
 
 
 
 
 886		if (ret < 0) {
 887			pr_warning("Failed to find source file path.\n");
 888			return ret;
 889		}
 890
 891		/* Matching lazy line pattern */
 892		ret = find_lazy_match_lines(pf->lcache, fpath,
 893					    pf->pev->point.lazy_line);
 894		free(fpath);
 895		if (ret <= 0)
 896			return ret;
 897	}
 898
 899	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
 900}
 901
 902static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf)
 903{
 904	struct perf_probe_point *pp = &pf->pev->point;
 905
 906	/* Not uprobe? */
 907	if (!pf->pev->uprobes)
 908		return;
 909
 910	/* Compiled with optimization? */
 911	if (die_is_optimized_target(&pf->cu_die))
 912		return;
 913
 914	/* Don't know entrypc? */
 915	if (!pf->addr)
 916		return;
 917
 918	/* Only FUNC and FUNC@SRC are eligible. */
 919	if (!pp->function || pp->line || pp->retprobe || pp->lazy_line ||
 920	    pp->offset || pp->abs_address)
 921		return;
 922
 923	/* Not interested in func parameter? */
 924	if (!perf_probe_with_var(pf->pev))
 925		return;
 926
 927	pr_info("Target program is compiled without optimization. Skipping prologue.\n"
 928		"Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n",
 929		pf->addr);
 930
 931	die_skip_prologue(sp_die, &pf->cu_die, &pf->addr);
 932}
 933
 934static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 935{
 936	struct probe_finder *pf = data;
 937	struct perf_probe_point *pp = &pf->pev->point;
 938	Dwarf_Addr addr;
 939	int ret;
 940
 941	if (pp->lazy_line)
 942		ret = find_probe_point_lazy(in_die, pf);
 943	else {
 944		/* Get probe address */
 945		if (dwarf_entrypc(in_die, &addr) != 0) {
 946			pr_warning("Failed to get entry address of %s.\n",
 947				   dwarf_diename(in_die));
 948			return -ENOENT;
 949		}
 950		if (addr == 0) {
 951			pr_debug("%s has no valid entry address. skipped.\n",
 952				 dwarf_diename(in_die));
 953			return -ENOENT;
 954		}
 955		pf->addr = addr;
 956		pf->addr += pp->offset;
 957		pr_debug("found inline addr: 0x%jx\n",
 958			 (uintmax_t)pf->addr);
 959
 960		ret = call_probe_finder(in_die, pf);
 961	}
 962
 963	return ret;
 964}
 965
 966/* Callback parameter with return value for libdw */
 967struct dwarf_callback_param {
 968	void *data;
 969	int retval;
 970};
 971
 972/* Search function from function name */
 973static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
 974{
 975	struct dwarf_callback_param *param = data;
 976	struct probe_finder *pf = param->data;
 977	struct perf_probe_point *pp = &pf->pev->point;
 978
 979	/* Check tag and diename */
 980	if (!die_is_func_def(sp_die) ||
 981	    !die_match_name(sp_die, pp->function))
 982		return DWARF_CB_OK;
 983
 984	/* Check declared file */
 985	if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
 986		return DWARF_CB_OK;
 987
 988	pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die),
 989		 (unsigned long)dwarf_dieoffset(sp_die));
 990	pf->fname = dwarf_decl_file(sp_die);
 991	if (pp->line) { /* Function relative line */
 992		dwarf_decl_line(sp_die, &pf->lno);
 993		pf->lno += pp->line;
 994		param->retval = find_probe_point_by_line(pf);
 995	} else if (die_is_func_instance(sp_die)) {
 996		/* Instances always have the entry address */
 997		dwarf_entrypc(sp_die, &pf->addr);
 998		/* But in some case the entry address is 0 */
 999		if (pf->addr == 0) {
1000			pr_debug("%s has no entry PC. Skipped\n",
1001				 dwarf_diename(sp_die));
1002			param->retval = 0;
1003		/* Real function */
1004		} else if (pp->lazy_line)
1005			param->retval = find_probe_point_lazy(sp_die, pf);
1006		else {
1007			skip_prologue(sp_die, pf);
1008			pf->addr += pp->offset;
1009			/* TODO: Check the address in this function */
1010			param->retval = call_probe_finder(sp_die, pf);
1011		}
1012	} else if (!probe_conf.no_inlines) {
1013		/* Inlined function: search instances */
1014		param->retval = die_walk_instances(sp_die,
1015					probe_point_inline_cb, (void *)pf);
1016		/* This could be a non-existed inline definition */
1017		if (param->retval == -ENOENT)
1018			param->retval = 0;
1019	}
1020
1021	/* We need to find other candidates */
1022	if (strisglob(pp->function) && param->retval >= 0) {
1023		param->retval = 0;	/* We have to clear the result */
1024		return DWARF_CB_OK;
1025	}
1026
1027	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1028}
1029
1030static int find_probe_point_by_func(struct probe_finder *pf)
1031{
1032	struct dwarf_callback_param _param = {.data = (void *)pf,
1033					      .retval = 0};
1034	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
1035	return _param.retval;
1036}
1037
1038struct pubname_callback_param {
1039	char *function;
1040	char *file;
1041	Dwarf_Die *cu_die;
1042	Dwarf_Die *sp_die;
1043	int found;
1044};
1045
1046static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
1047{
1048	struct pubname_callback_param *param = data;
1049
1050	if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
1051		if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
1052			return DWARF_CB_OK;
1053
1054		if (die_match_name(param->sp_die, param->function)) {
1055			if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
1056				return DWARF_CB_OK;
1057
1058			if (param->file &&
1059			    strtailcmp(param->file, dwarf_decl_file(param->sp_die)))
1060				return DWARF_CB_OK;
1061
1062			param->found = 1;
1063			return DWARF_CB_ABORT;
1064		}
1065	}
1066
1067	return DWARF_CB_OK;
1068}
1069
1070static int debuginfo__find_probe_location(struct debuginfo *dbg,
1071				  struct probe_finder *pf)
1072{
1073	struct perf_probe_point *pp = &pf->pev->point;
1074	Dwarf_Off off, noff;
1075	size_t cuhl;
1076	Dwarf_Die *diep;
1077	int ret = 0;
1078
1079	off = 0;
1080	pf->lcache = intlist__new(NULL);
1081	if (!pf->lcache)
1082		return -ENOMEM;
1083
1084	/* Fastpath: lookup by function name from .debug_pubnames section */
1085	if (pp->function && !strisglob(pp->function)) {
1086		struct pubname_callback_param pubname_param = {
1087			.function = pp->function,
1088			.file	  = pp->file,
1089			.cu_die	  = &pf->cu_die,
1090			.sp_die	  = &pf->sp_die,
1091			.found	  = 0,
1092		};
1093		struct dwarf_callback_param probe_param = {
1094			.data = pf,
1095		};
1096
1097		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1098				  &pubname_param, 0);
1099		if (pubname_param.found) {
1100			ret = probe_point_search_cb(&pf->sp_die, &probe_param);
1101			if (ret)
1102				goto found;
1103		}
1104	}
1105
1106	/* Loop on CUs (Compilation Unit) */
1107	while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1108		/* Get the DIE(Debugging Information Entry) of this CU */
1109		diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
1110		if (!diep)
 
1111			continue;
 
1112
1113		/* Check if target file is included. */
1114		if (pp->file)
1115			pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1116		else
1117			pf->fname = NULL;
1118
1119		if (!pp->file || pf->fname) {
1120			if (pp->function)
1121				ret = find_probe_point_by_func(pf);
1122			else if (pp->lazy_line)
1123				ret = find_probe_point_lazy(&pf->cu_die, pf);
1124			else {
1125				pf->lno = pp->line;
1126				ret = find_probe_point_by_line(pf);
1127			}
1128			if (ret < 0)
1129				break;
1130		}
1131		off = noff;
1132	}
1133
1134found:
1135	intlist__delete(pf->lcache);
1136	pf->lcache = NULL;
1137
1138	return ret;
1139}
1140
1141/* Find probe points from debuginfo */
1142static int debuginfo__find_probes(struct debuginfo *dbg,
1143				  struct probe_finder *pf)
1144{
1145	int ret = 0;
1146	Elf *elf;
1147	GElf_Ehdr ehdr;
1148
1149	if (pf->cfi_eh || pf->cfi_dbg)
1150		return debuginfo__find_probe_location(dbg, pf);
1151
1152	/* Get the call frame information from this dwarf */
1153	elf = dwarf_getelf(dbg->dbg);
1154	if (elf == NULL)
1155		return -EINVAL;
1156
1157	if (gelf_getehdr(elf, &ehdr) == NULL)
1158		return -EINVAL;
1159
1160	pf->machine = ehdr.e_machine;
1161
1162#if _ELFUTILS_PREREQ(0, 142)
1163	do {
1164		GElf_Shdr shdr;
1165
1166		if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
1167		    shdr.sh_type == SHT_PROGBITS)
1168			pf->cfi_eh = dwarf_getcfi_elf(elf);
1169
1170		pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
1171	} while (0);
1172#endif
1173
1174	ret = debuginfo__find_probe_location(dbg, pf);
1175	return ret;
1176}
1177
1178struct local_vars_finder {
1179	struct probe_finder *pf;
1180	struct perf_probe_arg *args;
1181	bool vars;
1182	int max_args;
1183	int nargs;
1184	int ret;
1185};
1186
1187/* Collect available variables in this scope */
1188static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
1189{
1190	struct local_vars_finder *vf = data;
1191	struct probe_finder *pf = vf->pf;
1192	int tag;
1193
1194	tag = dwarf_tag(die_mem);
1195	if (tag == DW_TAG_formal_parameter ||
1196	    (tag == DW_TAG_variable && vf->vars)) {
1197		if (convert_variable_location(die_mem, vf->pf->addr,
1198					      vf->pf->fb_ops, &pf->sp_die,
1199					      pf->machine, NULL) == 0) {
1200			vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
1201			if (vf->args[vf->nargs].var == NULL) {
1202				vf->ret = -ENOMEM;
1203				return DIE_FIND_CB_END;
1204			}
1205			pr_debug(" %s", vf->args[vf->nargs].var);
1206			vf->nargs++;
1207		}
1208	}
1209
1210	if (dwarf_haspc(die_mem, vf->pf->addr))
1211		return DIE_FIND_CB_CONTINUE;
1212	else
1213		return DIE_FIND_CB_SIBLING;
1214}
1215
1216static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
1217			     struct perf_probe_arg *args)
1218{
1219	Dwarf_Die die_mem;
1220	int i;
1221	int n = 0;
1222	struct local_vars_finder vf = {.pf = pf, .args = args, .vars = false,
1223				.max_args = MAX_PROBE_ARGS, .ret = 0};
1224
1225	for (i = 0; i < pf->pev->nargs; i++) {
1226		/* var never be NULL */
1227		if (strcmp(pf->pev->args[i].var, PROBE_ARG_VARS) == 0)
1228			vf.vars = true;
1229		else if (strcmp(pf->pev->args[i].var, PROBE_ARG_PARAMS) != 0) {
1230			/* Copy normal argument */
1231			args[n] = pf->pev->args[i];
1232			n++;
1233			continue;
1234		}
1235		pr_debug("Expanding %s into:", pf->pev->args[i].var);
1236		vf.nargs = n;
1237		/* Special local variables */
1238		die_find_child(sc_die, copy_variables_cb, (void *)&vf,
1239			       &die_mem);
1240		pr_debug(" (%d)\n", vf.nargs - n);
1241		if (vf.ret < 0)
1242			return vf.ret;
1243		n = vf.nargs;
1244	}
1245	return n;
1246}
1247
1248static bool trace_event_finder_overlap(struct trace_event_finder *tf)
1249{
1250	int i;
1251
1252	for (i = 0; i < tf->ntevs; i++) {
1253		if (tf->pf.addr == tf->tevs[i].point.address)
1254			return true;
1255	}
1256	return false;
1257}
1258
1259/* Add a found probe point into trace event list */
1260static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1261{
1262	struct trace_event_finder *tf =
1263			container_of(pf, struct trace_event_finder, pf);
1264	struct perf_probe_point *pp = &pf->pev->point;
1265	struct probe_trace_event *tev;
1266	struct perf_probe_arg *args = NULL;
1267	int ret, i;
1268
1269	/*
1270	 * For some reason (e.g. different column assigned to same address)
1271	 * This callback can be called with the address which already passed.
1272	 * Ignore it first.
1273	 */
1274	if (trace_event_finder_overlap(tf))
1275		return 0;
1276
1277	/* Check number of tevs */
1278	if (tf->ntevs == tf->max_tevs) {
1279		pr_warning("Too many( > %d) probe point found.\n",
1280			   tf->max_tevs);
1281		return -ERANGE;
1282	}
1283	tev = &tf->tevs[tf->ntevs++];
1284
1285	/* Trace point should be converted from subprogram DIE */
1286	ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
1287				     pp->retprobe, pp->function, &tev->point);
1288	if (ret < 0)
1289		goto end;
1290
1291	tev->point.realname = strdup(dwarf_diename(sc_die));
1292	if (!tev->point.realname) {
1293		ret = -ENOMEM;
1294		goto end;
1295	}
1296
1297	pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1298		 tev->point.offset);
1299
1300	/* Expand special probe argument if exist */
1301	args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
1302	if (args == NULL) {
1303		ret = -ENOMEM;
1304		goto end;
1305	}
1306
1307	ret = expand_probe_args(sc_die, pf, args);
1308	if (ret < 0)
1309		goto end;
1310
1311	tev->nargs = ret;
1312	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1313	if (tev->args == NULL) {
1314		ret = -ENOMEM;
1315		goto end;
1316	}
1317
1318	/* Find each argument */
1319	for (i = 0; i < tev->nargs; i++) {
1320		pf->pvar = &args[i];
1321		pf->tvar = &tev->args[i];
1322		/* Variable should be found from scope DIE */
1323		ret = find_variable(sc_die, pf);
1324		if (ret != 0)
1325			break;
1326	}
1327
1328end:
1329	if (ret) {
1330		clear_probe_trace_event(tev);
1331		tf->ntevs--;
1332	}
1333	free(args);
1334	return ret;
1335}
1336
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1337/* Find probe_trace_events specified by perf_probe_event from debuginfo */
1338int debuginfo__find_trace_events(struct debuginfo *dbg,
1339				 struct perf_probe_event *pev,
1340				 struct probe_trace_event **tevs)
1341{
1342	struct trace_event_finder tf = {
1343			.pf = {.pev = pev, .callback = add_probe_trace_event},
1344			.max_tevs = probe_conf.max_probes, .mod = dbg->mod};
1345	int ret, i;
1346
1347	/* Allocate result tevs array */
1348	*tevs = zalloc(sizeof(struct probe_trace_event) * tf.max_tevs);
1349	if (*tevs == NULL)
1350		return -ENOMEM;
1351
1352	tf.tevs = *tevs;
1353	tf.ntevs = 0;
1354
 
 
 
1355	ret = debuginfo__find_probes(dbg, &tf.pf);
1356	if (ret < 0) {
 
 
 
1357		for (i = 0; i < tf.ntevs; i++)
1358			clear_probe_trace_event(&tf.tevs[i]);
1359		zfree(tevs);
1360		return ret;
1361	}
1362
1363	return (ret < 0) ? ret : tf.ntevs;
1364}
1365
1366/* Collect available variables in this scope */
1367static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1368{
1369	struct available_var_finder *af = data;
1370	struct variable_list *vl;
1371	struct strbuf buf = STRBUF_INIT;
1372	int tag, ret;
1373
1374	vl = &af->vls[af->nvls - 1];
1375
1376	tag = dwarf_tag(die_mem);
1377	if (tag == DW_TAG_formal_parameter ||
1378	    tag == DW_TAG_variable) {
1379		ret = convert_variable_location(die_mem, af->pf.addr,
1380						af->pf.fb_ops, &af->pf.sp_die,
1381						af->pf.machine, NULL);
1382		if (ret == 0 || ret == -ERANGE) {
1383			int ret2;
1384			bool externs = !af->child;
1385
1386			if (strbuf_init(&buf, 64) < 0)
1387				goto error;
1388
1389			if (probe_conf.show_location_range) {
1390				if (!externs)
1391					ret2 = strbuf_add(&buf,
1392						ret ? "[INV]\t" : "[VAL]\t", 6);
1393				else
1394					ret2 = strbuf_add(&buf, "[EXT]\t", 6);
1395				if (ret2)
1396					goto error;
1397			}
1398
1399			ret2 = die_get_varname(die_mem, &buf);
1400
1401			if (!ret2 && probe_conf.show_location_range &&
1402				!externs) {
1403				if (strbuf_addch(&buf, '\t') < 0)
1404					goto error;
1405				ret2 = die_get_var_range(&af->pf.sp_die,
1406							die_mem, &buf);
1407			}
1408
1409			pr_debug("Add new var: %s\n", buf.buf);
1410			if (ret2 == 0) {
1411				strlist__add(vl->vars,
1412					strbuf_detach(&buf, NULL));
1413			}
1414			strbuf_release(&buf);
1415		}
1416	}
1417
1418	if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1419		return DIE_FIND_CB_CONTINUE;
1420	else
1421		return DIE_FIND_CB_SIBLING;
1422error:
1423	strbuf_release(&buf);
1424	pr_debug("Error in strbuf\n");
1425	return DIE_FIND_CB_END;
1426}
1427
 
 
 
 
 
 
 
 
 
 
 
 
1428/* Add a found vars into available variables list */
1429static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1430{
1431	struct available_var_finder *af =
1432			container_of(pf, struct available_var_finder, pf);
1433	struct perf_probe_point *pp = &pf->pev->point;
1434	struct variable_list *vl;
1435	Dwarf_Die die_mem;
1436	int ret;
1437
 
 
 
 
 
 
 
 
1438	/* Check number of tevs */
1439	if (af->nvls == af->max_vls) {
1440		pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1441		return -ERANGE;
1442	}
1443	vl = &af->vls[af->nvls++];
1444
1445	/* Trace point should be converted from subprogram DIE */
1446	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1447				     pp->retprobe, pp->function, &vl->point);
1448	if (ret < 0)
1449		return ret;
1450
1451	pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1452		 vl->point.offset);
1453
1454	/* Find local variables */
1455	vl->vars = strlist__new(NULL, NULL);
1456	if (vl->vars == NULL)
1457		return -ENOMEM;
1458	af->child = true;
1459	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1460
1461	/* Find external variables */
1462	if (!probe_conf.show_ext_vars)
1463		goto out;
1464	/* Don't need to search child DIE for external vars. */
1465	af->child = false;
1466	die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1467
1468out:
1469	if (strlist__empty(vl->vars)) {
1470		strlist__delete(vl->vars);
1471		vl->vars = NULL;
1472	}
1473
1474	return ret;
1475}
1476
1477/*
1478 * Find available variables at given probe point
1479 * Return the number of found probe points. Return 0 if there is no
1480 * matched probe point. Return <0 if an error occurs.
1481 */
1482int debuginfo__find_available_vars_at(struct debuginfo *dbg,
1483				      struct perf_probe_event *pev,
1484				      struct variable_list **vls)
1485{
1486	struct available_var_finder af = {
1487			.pf = {.pev = pev, .callback = add_available_vars},
1488			.mod = dbg->mod,
1489			.max_vls = probe_conf.max_probes};
1490	int ret;
1491
1492	/* Allocate result vls array */
1493	*vls = zalloc(sizeof(struct variable_list) * af.max_vls);
1494	if (*vls == NULL)
1495		return -ENOMEM;
1496
1497	af.vls = *vls;
1498	af.nvls = 0;
1499
1500	ret = debuginfo__find_probes(dbg, &af.pf);
1501	if (ret < 0) {
1502		/* Free vlist for error */
1503		while (af.nvls--) {
1504			zfree(&af.vls[af.nvls].point.symbol);
1505			strlist__delete(af.vls[af.nvls].vars);
1506		}
1507		zfree(vls);
1508		return ret;
1509	}
1510
1511	return (ret < 0) ? ret : af.nvls;
1512}
1513
1514/* For the kernel module, we need a special code to get a DIE */
1515int debuginfo__get_text_offset(struct debuginfo *dbg, Dwarf_Addr *offs,
1516				bool adjust_offset)
1517{
1518	int n, i;
1519	Elf32_Word shndx;
1520	Elf_Scn *scn;
1521	Elf *elf;
1522	GElf_Shdr mem, *shdr;
1523	const char *p;
1524
1525	elf = dwfl_module_getelf(dbg->mod, &dbg->bias);
1526	if (!elf)
1527		return -EINVAL;
1528
1529	/* Get the number of relocations */
1530	n = dwfl_module_relocations(dbg->mod);
1531	if (n < 0)
1532		return -ENOENT;
1533	/* Search the relocation related .text section */
1534	for (i = 0; i < n; i++) {
1535		p = dwfl_module_relocation_info(dbg->mod, i, &shndx);
1536		if (strcmp(p, ".text") == 0) {
1537			/* OK, get the section header */
1538			scn = elf_getscn(elf, shndx);
1539			if (!scn)
1540				return -ENOENT;
1541			shdr = gelf_getshdr(scn, &mem);
1542			if (!shdr)
1543				return -ENOENT;
1544			*offs = shdr->sh_addr;
1545			if (adjust_offset)
1546				*offs -= shdr->sh_offset;
1547		}
1548	}
1549	return 0;
1550}
1551
1552/* Reverse search */
1553int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
1554				struct perf_probe_point *ppt)
1555{
1556	Dwarf_Die cudie, spdie, indie;
1557	Dwarf_Addr _addr = 0, baseaddr = 0;
1558	const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
1559	int baseline = 0, lineno = 0, ret = 0;
1560
1561	/* We always need to relocate the address for aranges */
1562	if (debuginfo__get_text_offset(dbg, &baseaddr, false) == 0)
1563		addr += baseaddr;
1564	/* Find cu die */
1565	if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
1566		pr_warning("Failed to find debug information for address %lx\n",
1567			   addr);
1568		ret = -EINVAL;
1569		goto end;
1570	}
1571
1572	/* Find a corresponding line (filename and lineno) */
1573	cu_find_lineinfo(&cudie, addr, &fname, &lineno);
1574	/* Don't care whether it failed or not */
1575
1576	/* Find a corresponding function (name, baseline and baseaddr) */
1577	if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
1578		/* Get function entry information */
1579		func = basefunc = dwarf_diename(&spdie);
1580		if (!func ||
1581		    dwarf_entrypc(&spdie, &baseaddr) != 0 ||
1582		    dwarf_decl_line(&spdie, &baseline) != 0) {
1583			lineno = 0;
1584			goto post;
1585		}
1586
1587		fname = dwarf_decl_file(&spdie);
1588		if (addr == (unsigned long)baseaddr) {
1589			/* Function entry - Relative line number is 0 */
1590			lineno = baseline;
1591			goto post;
1592		}
1593
1594		/* Track down the inline functions step by step */
1595		while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
1596						&indie)) {
1597			/* There is an inline function */
1598			if (dwarf_entrypc(&indie, &_addr) == 0 &&
1599			    _addr == addr) {
1600				/*
1601				 * addr is at an inline function entry.
1602				 * In this case, lineno should be the call-site
1603				 * line number. (overwrite lineinfo)
1604				 */
1605				lineno = die_get_call_lineno(&indie);
1606				fname = die_get_call_file(&indie);
1607				break;
1608			} else {
1609				/*
1610				 * addr is in an inline function body.
1611				 * Since lineno points one of the lines
1612				 * of the inline function, baseline should
1613				 * be the entry line of the inline function.
1614				 */
1615				tmp = dwarf_diename(&indie);
1616				if (!tmp ||
1617				    dwarf_decl_line(&indie, &baseline) != 0)
1618					break;
1619				func = tmp;
1620				spdie = indie;
1621			}
1622		}
1623		/* Verify the lineno and baseline are in a same file */
1624		tmp = dwarf_decl_file(&spdie);
1625		if (!tmp || strcmp(tmp, fname) != 0)
1626			lineno = 0;
1627	}
1628
1629post:
1630	/* Make a relative line number or an offset */
1631	if (lineno)
1632		ppt->line = lineno - baseline;
1633	else if (basefunc) {
1634		ppt->offset = addr - (unsigned long)baseaddr;
1635		func = basefunc;
1636	}
1637
1638	/* Duplicate strings */
1639	if (func) {
1640		ppt->function = strdup(func);
1641		if (ppt->function == NULL) {
1642			ret = -ENOMEM;
1643			goto end;
1644		}
1645	}
1646	if (fname) {
1647		ppt->file = strdup(fname);
1648		if (ppt->file == NULL) {
1649			zfree(&ppt->function);
1650			ret = -ENOMEM;
1651			goto end;
1652		}
1653	}
1654end:
1655	if (ret == 0 && (fname || func))
1656		ret = 1;	/* Found a point */
1657	return ret;
1658}
1659
1660/* Add a line and store the src path */
1661static int line_range_add_line(const char *src, unsigned int lineno,
1662			       struct line_range *lr)
1663{
1664	/* Copy source path */
1665	if (!lr->path) {
1666		lr->path = strdup(src);
1667		if (lr->path == NULL)
1668			return -ENOMEM;
1669	}
1670	return intlist__add(lr->line_list, lineno);
1671}
1672
1673static int line_range_walk_cb(const char *fname, int lineno,
1674			      Dwarf_Addr addr __maybe_unused,
1675			      void *data)
1676{
1677	struct line_finder *lf = data;
 
 
1678	int err;
1679
1680	if ((strtailcmp(fname, lf->fname) != 0) ||
1681	    (lf->lno_s > lineno || lf->lno_e < lineno))
1682		return 0;
1683
 
 
 
 
 
1684	err = line_range_add_line(fname, lineno, lf->lr);
1685	if (err < 0 && err != -EEXIST)
1686		return err;
1687
1688	return 0;
1689}
1690
1691/* Find line range from its line number */
1692static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1693{
1694	int ret;
1695
1696	ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1697
1698	/* Update status */
1699	if (ret >= 0)
1700		if (!intlist__empty(lf->lr->line_list))
1701			ret = lf->found = 1;
1702		else
1703			ret = 0;	/* Lines are not found */
1704	else {
1705		zfree(&lf->lr->path);
1706	}
1707	return ret;
1708}
1709
1710static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
1711{
1712	int ret = find_line_range_by_line(in_die, data);
1713
1714	/*
1715	 * We have to check all instances of inlined function, because
1716	 * some execution paths can be optimized out depends on the
1717	 * function argument of instances. However, if an error occurs,
1718	 * it should be handled by the caller.
1719	 */
1720	return ret < 0 ? ret : 0;
1721}
1722
1723/* Search function definition from function name */
1724static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1725{
1726	struct dwarf_callback_param *param = data;
1727	struct line_finder *lf = param->data;
1728	struct line_range *lr = lf->lr;
1729
1730	/* Check declared file */
1731	if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
1732		return DWARF_CB_OK;
1733
1734	if (die_is_func_def(sp_die) &&
1735	    die_match_name(sp_die, lr->function)) {
1736		lf->fname = dwarf_decl_file(sp_die);
1737		dwarf_decl_line(sp_die, &lr->offset);
1738		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1739		lf->lno_s = lr->offset + lr->start;
1740		if (lf->lno_s < 0)	/* Overflow */
1741			lf->lno_s = INT_MAX;
1742		lf->lno_e = lr->offset + lr->end;
1743		if (lf->lno_e < 0)	/* Overflow */
1744			lf->lno_e = INT_MAX;
1745		pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1746		lr->start = lf->lno_s;
1747		lr->end = lf->lno_e;
1748		if (!die_is_func_instance(sp_die))
1749			param->retval = die_walk_instances(sp_die,
1750						line_range_inline_cb, lf);
1751		else
1752			param->retval = find_line_range_by_line(sp_die, lf);
1753		return DWARF_CB_ABORT;
1754	}
1755	return DWARF_CB_OK;
1756}
1757
1758static int find_line_range_by_func(struct line_finder *lf)
1759{
1760	struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1761	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
1762	return param.retval;
1763}
1764
1765int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
1766{
1767	struct line_finder lf = {.lr = lr, .found = 0};
1768	int ret = 0;
1769	Dwarf_Off off = 0, noff;
1770	size_t cuhl;
1771	Dwarf_Die *diep;
1772	const char *comp_dir;
1773
1774	/* Fastpath: lookup by function name from .debug_pubnames section */
1775	if (lr->function) {
1776		struct pubname_callback_param pubname_param = {
1777			.function = lr->function, .file = lr->file,
1778			.cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
1779		struct dwarf_callback_param line_range_param = {
1780			.data = (void *)&lf, .retval = 0};
1781
1782		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1783				  &pubname_param, 0);
1784		if (pubname_param.found) {
1785			line_range_search_cb(&lf.sp_die, &line_range_param);
1786			if (lf.found)
1787				goto found;
1788		}
1789	}
1790
1791	/* Loop on CUs (Compilation Unit) */
1792	while (!lf.found && ret >= 0) {
1793		if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
1794				 NULL, NULL, NULL) != 0)
1795			break;
1796
1797		/* Get the DIE(Debugging Information Entry) of this CU */
1798		diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
1799		if (!diep)
 
1800			continue;
 
1801
1802		/* Check if target file is included. */
1803		if (lr->file)
1804			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1805		else
1806			lf.fname = 0;
1807
1808		if (!lr->file || lf.fname) {
1809			if (lr->function)
1810				ret = find_line_range_by_func(&lf);
1811			else {
1812				lf.lno_s = lr->start;
1813				lf.lno_e = lr->end;
1814				ret = find_line_range_by_line(NULL, &lf);
1815			}
1816		}
1817		off = noff;
1818	}
1819
1820found:
1821	/* Store comp_dir */
1822	if (lf.found) {
1823		comp_dir = cu_get_comp_dir(&lf.cu_die);
1824		if (comp_dir) {
1825			lr->comp_dir = strdup(comp_dir);
1826			if (!lr->comp_dir)
1827				ret = -ENOMEM;
1828		}
1829	}
1830
1831	pr_debug("path: %s\n", lr->path);
1832	return (ret < 0) ? ret : lf.found;
1833}
1834
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1835/*
1836 * Find a src file from a DWARF tag path. Prepend optional source path prefix
1837 * and chop off leading directories that do not exist. Result is passed back as
1838 * a newly allocated path on success.
1839 * Return 0 if file was found and readable, -errno otherwise.
1840 */
1841int get_real_path(const char *raw_path, const char *comp_dir,
1842			 char **new_path)
1843{
1844	const char *prefix = symbol_conf.source_prefix;
 
 
 
 
 
1845
1846	if (!prefix) {
1847		if (raw_path[0] != '/' && comp_dir)
1848			/* If not an absolute path, try to use comp_dir */
1849			prefix = comp_dir;
1850		else {
1851			if (access(raw_path, R_OK) == 0) {
1852				*new_path = strdup(raw_path);
1853				return *new_path ? 0 : -ENOMEM;
1854			} else
1855				return -errno;
1856		}
1857	}
1858
1859	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
1860	if (!*new_path)
1861		return -ENOMEM;
1862
1863	for (;;) {
1864		sprintf(*new_path, "%s/%s", prefix, raw_path);
1865
1866		if (access(*new_path, R_OK) == 0)
1867			return 0;
1868
1869		if (!symbol_conf.source_prefix) {
1870			/* In case of searching comp_dir, don't retry */
1871			zfree(new_path);
1872			return -errno;
1873		}
1874
1875		switch (errno) {
1876		case ENAMETOOLONG:
1877		case ENOENT:
1878		case EROFS:
1879		case EFAULT:
1880			raw_path = strchr(++raw_path, '/');
1881			if (!raw_path) {
1882				zfree(new_path);
1883				return -ENOENT;
1884			}
1885			continue;
1886
1887		default:
1888			zfree(new_path);
1889			return -errno;
1890		}
1891	}
1892}