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