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