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