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