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