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