tools/perf/util/probe-finder.c

   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, &param, 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, &param, 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