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