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
  35 #include "string.h"
  36 #include "event.h"
  37 #include "debug.h"
  38 #include "util.h"
  39 #include "probe-finder.h"
  40
  41
  42 /*
  43  * Generic dwarf analysis helpers
  44  */
  45
  46 #define X86_32_MAX_REGS 8
  47 const char *x86_32_regs_table[X86_32_MAX_REGS] = {
  48         "%ax",
  49         "%cx",
  50         "%dx",
  51         "%bx",
  52         "$stack",       /* Stack address instead of %sp */
  53         "%bp",
  54         "%si",
  55         "%di",
  56 };
  57
  58 #define X86_64_MAX_REGS 16
  59 const char *x86_64_regs_table[X86_64_MAX_REGS] = {
  60         "%ax",
  61         "%dx",
  62         "%cx",
  63         "%bx",
  64         "%si",
  65         "%di",
  66         "%bp",
  67         "%sp",
  68         "%r8",
  69         "%r9",
  70         "%r10",
  71         "%r11",
  72         "%r12",
  73         "%r13",
  74         "%r14",
  75         "%r15",
  76 };
  77
  78 /* TODO: switching by dwarf address size */
  79 #ifdef __x86_64__
  80 #define ARCH_MAX_REGS X86_64_MAX_REGS
  81 #define arch_regs_table x86_64_regs_table
  82 #else
  83 #define ARCH_MAX_REGS X86_32_MAX_REGS
  84 #define arch_regs_table x86_32_regs_table
  85 #endif
  86
  87 /* Kprobe tracer basic type is up to u64 */
  88 #define MAX_BASIC_TYPE_BITS     64
  89
  90 /* Return architecture dependent register string (for kprobe-tracer) */
  91 static const char *get_arch_regstr(unsigned int n)
  92 {
  93         return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
  94 }
  95
  96 /*
  97  * Compare the tail of two strings.
  98  * Return 0 if whole of either string is same as another's tail part.
  99  */
 100 static int strtailcmp(const char *s1, const char *s2)
 101 {
 102         int i1 = strlen(s1);
 103         int i2 = strlen(s2);
 104         while (--i1 >= 0 && --i2 >= 0) {
 105                 if (s1[i1] != s2[i2])
 106                         return s1[i1] - s2[i2];
 107         }
 108         return 0;
 109 }
 110
 111 /* Line number list operations */
 112
 113 /* Add a line to line number list */
 114 static void line_list__add_line(struct list_head *head, unsigned int line)
 115 {
 116         struct line_node *ln;
 117         struct list_head *p;
 118
 119         /* Reverse search, because new line will be the last one */
 120         list_for_each_entry_reverse(ln, head, list) {
 121                 if (ln->line < line) {
 122                         p = &ln->list;
 123                         goto found;
 124                 } else if (ln->line == line)    /* Already exist */
 125                         return ;
 126         }
 127         /* List is empty, or the smallest entry */
 128         p = head;
 129 found:
 130         pr_debug("line list: add a line %u\n", line);
 131         ln = xzalloc(sizeof(struct line_node));
 132         ln->line = line;
 133         INIT_LIST_HEAD(&ln->list);
 134         list_add(&ln->list, p);
 135 }
 136
 137 /* Check if the line in line number list */
 138 static int line_list__has_line(struct list_head *head, unsigned int line)
 139 {
 140         struct line_node *ln;
 141
 142         /* Reverse search, because new line will be the last one */
 143         list_for_each_entry(ln, head, list)
 144                 if (ln->line == line)
 145                         return 1;
 146
 147         return 0;
 148 }
 149
 150 /* Init line number list */
 151 static void line_list__init(struct list_head *head)
 152 {
 153         INIT_LIST_HEAD(head);
 154 }
 155
 156 /* Free line number list */
 157 static void line_list__free(struct list_head *head)
 158 {
 159         struct line_node *ln;
 160         while (!list_empty(head)) {
 161                 ln = list_first_entry(head, struct line_node, list);
 162                 list_del(&ln->list);
 163                 free(ln);
 164         }
 165 }
 166
 167 /* Dwarf wrappers */
 168
 169 /* Find the realpath of the target file. */
 170 static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
 171 {
 172         Dwarf_Files *files;
 173         size_t nfiles, i;
 174         const char *src = NULL;
 175         int ret;
 176
 177         if (!fname)
 178                 return NULL;
 179
 180         ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
 181         if (ret != 0)
 182                 return NULL;
 183
 184         for (i = 0; i < nfiles; i++) {
 185                 src = dwarf_filesrc(files, i, NULL, NULL);
 186                 if (strtailcmp(src, fname) == 0)
 187                         break;
 188         }
 189         if (i == nfiles)
 190                 return NULL;
 191         return src;
 192 }
 193
 194 /* Compare diename and tname */
 195 static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 196 {
 197         const char *name;
 198         name = dwarf_diename(dw_die);
 199         DIE_IF(name == NULL);
 200         return strcmp(tname, name);
 201 }
 202
 203 /* Get entry pc(or low pc, 1st entry of ranges)  of the die */
 204 static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
 205 {
 206         Dwarf_Addr epc;
 207         int ret;
 208
 209         ret = dwarf_entrypc(dw_die, &epc);
 210         DIE_IF(ret == -1);
 211         return epc;
 212 }
 213
 214 /* Get type die, but skip qualifiers and typedef */
 215 static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
 216 {
 217         Dwarf_Attribute attr;
 218         int tag;
 219
 220         do {
 221                 if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL ||
 222                     dwarf_formref_die(&attr, die_mem) == NULL)
 223                         return NULL;
 224
 225                 tag = dwarf_tag(die_mem);
 226                 vr_die = die_mem;
 227         } while (tag == DW_TAG_const_type ||
 228                  tag == DW_TAG_restrict_type ||
 229                  tag == DW_TAG_volatile_type ||
 230                  tag == DW_TAG_shared_type ||
 231                  tag == DW_TAG_typedef);
 232
 233         return die_mem;
 234 }
 235
 236 static bool die_is_signed_type(Dwarf_Die *tp_die)
 237 {
 238         Dwarf_Attribute attr;
 239         Dwarf_Word ret;
 240
 241         if (dwarf_attr(tp_die, DW_AT_encoding, &attr) == NULL ||
 242             dwarf_formudata(&attr, &ret) != 0)
 243                 return false;
 244
 245         return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
 246                 ret == DW_ATE_signed_fixed);
 247 }
 248
 249 static int die_get_byte_size(Dwarf_Die *tp_die)
 250 {
 251         Dwarf_Attribute attr;
 252         Dwarf_Word ret;
 253
 254         if (dwarf_attr(tp_die, DW_AT_byte_size, &attr) == NULL ||
 255             dwarf_formudata(&attr, &ret) != 0)
 256                 return 0;
 257
 258         return (int)ret;
 259 }
 260
 261 /* Return values for die_find callbacks */
 262 enum {
 263         DIE_FIND_CB_FOUND = 0,          /* End of Search */
 264         DIE_FIND_CB_CHILD = 1,          /* Search only children */
 265         DIE_FIND_CB_SIBLING = 2,        /* Search only siblings */
 266         DIE_FIND_CB_CONTINUE = 3,       /* Search children and siblings */
 267 };
 268
 269 /* Search a child die */
 270 static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
 271                                  int (*callback)(Dwarf_Die *, void *),
 272                                  void *data, Dwarf_Die *die_mem)
 273 {
 274         Dwarf_Die child_die;
 275         int ret;
 276
 277         ret = dwarf_child(rt_die, die_mem);
 278         if (ret != 0)
 279                 return NULL;
 280
 281         do {
 282                 ret = callback(die_mem, data);
 283                 if (ret == DIE_FIND_CB_FOUND)
 284                         return die_mem;
 285
 286                 if ((ret & DIE_FIND_CB_CHILD) &&
 287                     die_find_child(die_mem, callback, data, &child_die)) {
 288                         memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
 289                         return die_mem;
 290                 }
 291         } while ((ret & DIE_FIND_CB_SIBLING) &&
 292                  dwarf_siblingof(die_mem, die_mem) == 0);
 293
 294         return NULL;
 295 }
 296
 297 struct __addr_die_search_param {
 298         Dwarf_Addr      addr;
 299         Dwarf_Die       *die_mem;
 300 };
 301
 302 static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 303 {
 304         struct __addr_die_search_param *ad = data;
 305
 306         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
 307             dwarf_haspc(fn_die, ad->addr)) {
 308                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
 309                 return DWARF_CB_ABORT;
 310         }
 311         return DWARF_CB_OK;
 312 }
 313
 314 /* Search a real subprogram including this line, */
 315 static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
 316                                            Dwarf_Die *die_mem)
 317 {
 318         struct __addr_die_search_param ad;
 319         ad.addr = addr;
 320         ad.die_mem = die_mem;
 321         /* dwarf_getscopes can't find subprogram. */
 322         if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
 323                 return NULL;
 324         else
 325                 return die_mem;
 326 }
 327
 328 /* die_find callback for inline function search */
 329 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
 330 {
 331         Dwarf_Addr *addr = data;
 332
 333         if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
 334             dwarf_haspc(die_mem, *addr))
 335                 return DIE_FIND_CB_FOUND;
 336
 337         return DIE_FIND_CB_CONTINUE;
 338 }
 339
 340 /* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
 341 static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
 342                                       Dwarf_Die *die_mem)
 343 {
 344         return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
 345 }
 346
 347 static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
 348 {
 349         const char *name = data;
 350         int tag;
 351
 352         tag = dwarf_tag(die_mem);
 353         if ((tag == DW_TAG_formal_parameter ||
 354              tag == DW_TAG_variable) &&
 355             (die_compare_name(die_mem, name) == 0))
 356                 return DIE_FIND_CB_FOUND;
 357
 358         return DIE_FIND_CB_CONTINUE;
 359 }
 360
 361 /* Find a variable called 'name' */
 362 static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
 363                                     Dwarf_Die *die_mem)
 364 {
 365         return die_find_child(sp_die, __die_find_variable_cb, (void *)name,
 366                               die_mem);
 367 }
 368
 369 static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
 370 {
 371         const char *name = data;
 372
 373         if ((dwarf_tag(die_mem) == DW_TAG_member) &&
 374             (die_compare_name(die_mem, name) == 0))
 375                 return DIE_FIND_CB_FOUND;
 376
 377         return DIE_FIND_CB_SIBLING;
 378 }
 379
 380 /* Find a member called 'name' */
 381 static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
 382                                   Dwarf_Die *die_mem)
 383 {
 384         return die_find_child(st_die, __die_find_member_cb, (void *)name,
 385                               die_mem);
 386 }
 387
 388 /*
 389  * Probe finder related functions
 390  */
 391
 392 /* Show a location */
 393 static void convert_location(Dwarf_Op *op, struct probe_finder *pf)
 394 {
 395         unsigned int regn;
 396         Dwarf_Word offs = 0;
 397         bool ref = false;
 398         const char *regs;
 399         struct kprobe_trace_arg *tvar = pf->tvar;
 400
 401         /* TODO: support CFA */
 402         /* If this is based on frame buffer, set the offset */
 403         if (op->atom == DW_OP_fbreg) {
 404                 if (pf->fb_ops == NULL)
 405                         die("The attribute of frame base is not supported.\n");
 406                 ref = true;
 407                 offs = op->number;
 408                 op = &pf->fb_ops[0];
 409         }
 410
 411         if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
 412                 regn = op->atom - DW_OP_breg0;
 413                 offs += op->number;
 414                 ref = true;
 415         } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
 416                 regn = op->atom - DW_OP_reg0;
 417         } else if (op->atom == DW_OP_bregx) {
 418                 regn = op->number;
 419                 offs += op->number2;
 420                 ref = true;
 421         } else if (op->atom == DW_OP_regx) {
 422                 regn = op->number;
 423         } else
 424                 die("DW_OP %d is not supported.", op->atom);
 425
 426         regs = get_arch_regstr(regn);
 427         if (!regs)
 428                 die("%u exceeds max register number.", regn);
 429
 430         tvar->value = xstrdup(regs);
 431         if (ref) {
 432                 tvar->ref = xzalloc(sizeof(struct kprobe_trace_arg_ref));
 433                 tvar->ref->offset = (long)offs;
 434         }
 435 }
 436
 437 static void convert_variable_type(Dwarf_Die *vr_die,
 438                                   struct kprobe_trace_arg *targ)
 439 {
 440         Dwarf_Die type;
 441         char buf[16];
 442         int ret;
 443
 444         if (die_get_real_type(vr_die, &type) == NULL)
 445                 die("Failed to get a type information of %s.",
 446                     dwarf_diename(vr_die));
 447
 448         ret = die_get_byte_size(&type) * 8;
 449         if (ret) {
 450                 /* Check the bitwidth */
 451                 if (ret > MAX_BASIC_TYPE_BITS) {
 452                         pr_warning("  Warning: %s exceeds max-bitwidth."
 453                                    " Cut down to %d bits.\n",
 454                                    dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
 455                         ret = MAX_BASIC_TYPE_BITS;
 456                 }
 457
 458                 ret = snprintf(buf, 16, "%c%d",
 459                                die_is_signed_type(&type) ? 's' : 'u', ret);
 460                 if (ret < 0 || ret >= 16)
 461                         die("Failed to convert variable type.");
 462                 targ->type = xstrdup(buf);
 463         }
 464 }
 465
 466 static void convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
 467                                     struct perf_probe_arg_field *field,
 468                                     struct kprobe_trace_arg_ref **ref_ptr,
 469                                     Dwarf_Die *die_mem)
 470 {
 471         struct kprobe_trace_arg_ref *ref = *ref_ptr;
 472         Dwarf_Attribute attr;
 473         Dwarf_Die type;
 474         Dwarf_Word offs;
 475
 476         pr_debug("converting %s in %s\n", field->name, varname);
 477         if (die_get_real_type(vr_die, &type) == NULL)
 478                 die("Failed to get a type information of %s.", varname);
 479
 480         /* Check the pointer and dereference */
 481         if (dwarf_tag(&type) == DW_TAG_pointer_type) {
 482                 if (!field->ref)
 483                         die("Semantic error: %s must be referred by '->'",
 484                             field->name);
 485                 /* Get the type pointed by this pointer */
 486                 if (die_get_real_type(&type, &type) == NULL)
 487                         die("Failed to get a type information of %s.", varname);
 488
 489                 /* Verify it is a data structure  */
 490                 if (dwarf_tag(&type) != DW_TAG_structure_type)
 491                         die("%s is not a data structure.", varname);
 492
 493                 ref = xzalloc(sizeof(struct kprobe_trace_arg_ref));
 494                 if (*ref_ptr)
 495                         (*ref_ptr)->next = ref;
 496                 else
 497                         *ref_ptr = ref;
 498         } else {
 499                 /* Verify it is a data structure  */
 500                 if (dwarf_tag(&type) != DW_TAG_structure_type)
 501                         die("%s is not a data structure.", varname);
 502
 503                 if (field->ref)
 504                         die("Semantic error: %s must be referred by '.'",
 505                             field->name);
 506                 if (!ref)
 507                         die("Structure on a register is not supported yet.");
 508         }
 509
 510         if (die_find_member(&type, field->name, die_mem) == NULL)
 511                 die("%s(tyep:%s) has no member %s.", varname,
 512                     dwarf_diename(&type), field->name);
 513
 514         /* Get the offset of the field */
 515         if (dwarf_attr(die_mem, DW_AT_data_member_location, &attr) == NULL ||
 516             dwarf_formudata(&attr, &offs) != 0)
 517                 die("Failed to get the offset of %s.", field->name);
 518         ref->offset += (long)offs;
 519
 520         /* Converting next field */
 521         if (field->next)
 522                 convert_variable_fields(die_mem, field->name, field->next,
 523                                         &ref, die_mem);
 524 }
 525
 526 /* Show a variables in kprobe event format */
 527 static void convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
 528 {
 529         Dwarf_Attribute attr;
 530         Dwarf_Die die_mem;
 531         Dwarf_Op *expr;
 532         size_t nexpr;
 533         int ret;
 534
 535         if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
 536                 goto error;
 537         /* TODO: handle more than 1 exprs */
 538         ret = dwarf_getlocation_addr(&attr, pf->addr, &expr, &nexpr, 1);
 539         if (ret <= 0 || nexpr == 0)
 540                 goto error;
 541
 542         convert_location(expr, pf);
 543
 544         if (pf->pvar->field) {
 545                 convert_variable_fields(vr_die, pf->pvar->var,
 546                                         pf->pvar->field, &pf->tvar->ref,
 547                                         &die_mem);
 548                 vr_die = &die_mem;
 549         }
 550         convert_variable_type(vr_die, pf->tvar);
 551         /* *expr will be cached in libdw. Don't free it. */
 552         return ;
 553 error:
 554         /* TODO: Support const_value */
 555         die("Failed to find the location of %s at this address.\n"
 556             " Perhaps, it has been optimized out.", pf->pvar->var);
 557 }
 558
 559 /* Find a variable in a subprogram die */
 560 static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
 561 {
 562         Dwarf_Die vr_die;
 563         char buf[32];
 564
 565         /* TODO: Support arrays */
 566         if (pf->pvar->name)
 567                 pf->tvar->name = xstrdup(pf->pvar->name);
 568         else {
 569                 synthesize_perf_probe_arg(pf->pvar, buf, 32);
 570                 pf->tvar->name = xstrdup(buf);
 571         }
 572
 573         if (!is_c_varname(pf->pvar->var)) {
 574                 /* Copy raw parameters */
 575                 pf->tvar->value = xstrdup(pf->pvar->var);
 576         } else {
 577                 pr_debug("Searching '%s' variable in context.\n",
 578                          pf->pvar->var);
 579                 /* Search child die for local variables and parameters. */
 580                 if (!die_find_variable(sp_die, pf->pvar->var, &vr_die))
 581                         die("Failed to find '%s' in this function.",
 582                             pf->pvar->var);
 583                 convert_variable(&vr_die, pf);
 584         }
 585 }
 586
 587 /* Show a probe point to output buffer */
 588 static void convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
 589 {
 590         struct kprobe_trace_event *tev;
 591         Dwarf_Addr eaddr;
 592         Dwarf_Die die_mem;
 593         const char *name;
 594         int ret, i;
 595         Dwarf_Attribute fb_attr;
 596         size_t nops;
 597
 598         if (pf->ntevs == MAX_PROBES)
 599                 die("Too many( > %d) probe point found.\n", MAX_PROBES);
 600         tev = &pf->tevs[pf->ntevs++];
 601
 602         /* If no real subprogram, find a real one */
 603         if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
 604                 sp_die = die_find_real_subprogram(&pf->cu_die,
 605                                                  pf->addr, &die_mem);
 606                 if (!sp_die)
 607                         die("Probe point is not found in subprograms.");
 608         }
 609
 610         /* Copy the name of probe point */
 611         name = dwarf_diename(sp_die);
 612         if (name) {
 613                 dwarf_entrypc(sp_die, &eaddr);
 614                 tev->point.symbol = xstrdup(name);
 615                 tev->point.offset = (unsigned long)(pf->addr - eaddr);
 616         } else
 617                 /* This function has no name. */
 618                 tev->point.offset = (unsigned long)pf->addr;
 619
 620         pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
 621                  tev->point.offset);
 622
 623         /* Get the frame base attribute/ops */
 624         dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
 625         ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
 626         if (ret <= 0 || nops == 0)
 627                 pf->fb_ops = NULL;
 628
 629         /* Find each argument */
 630         /* TODO: use dwarf_cfi_addrframe */
 631         tev->nargs = pf->pev->nargs;
 632         tev->args = xzalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
 633         for (i = 0; i < pf->pev->nargs; i++) {
 634                 pf->pvar = &pf->pev->args[i];
 635                 pf->tvar = &tev->args[i];
 636                 find_variable(sp_die, pf);
 637         }
 638
 639         /* *pf->fb_ops will be cached in libdw. Don't free it. */
 640         pf->fb_ops = NULL;
 641 }
 642
 643 /* Find probe point from its line number */
 644 static void find_probe_point_by_line(struct probe_finder *pf)
 645 {
 646         Dwarf_Lines *lines;
 647         Dwarf_Line *line;
 648         size_t nlines, i;
 649         Dwarf_Addr addr;
 650         int lineno;
 651         int ret;
 652
 653         ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
 654         DIE_IF(ret != 0);
 655
 656         for (i = 0; i < nlines; i++) {
 657                 line = dwarf_onesrcline(lines, i);
 658                 dwarf_lineno(line, &lineno);
 659                 if (lineno != pf->lno)
 660                         continue;
 661
 662                 /* TODO: Get fileno from line, but how? */
 663                 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
 664                         continue;
 665
 666                 ret = dwarf_lineaddr(line, &addr);
 667                 DIE_IF(ret != 0);
 668                 pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
 669                          (int)i, lineno, (uintmax_t)addr);
 670                 pf->addr = addr;
 671
 672                 convert_probe_point(NULL, pf);
 673                 /* Continuing, because target line might be inlined. */
 674         }
 675 }
 676
 677 /* Find lines which match lazy pattern */
 678 static int find_lazy_match_lines(struct list_head *head,
 679                                  const char *fname, const char *pat)
 680 {
 681         char *fbuf, *p1, *p2;
 682         int fd, line, nlines = 0;
 683         struct stat st;
 684
 685         fd = open(fname, O_RDONLY);
 686         if (fd < 0)
 687                 die("failed to open %s", fname);
 688         DIE_IF(fstat(fd, &st) < 0);
 689         fbuf = xmalloc(st.st_size + 2);
 690         DIE_IF(read(fd, fbuf, st.st_size) < 0);
 691         close(fd);
 692         fbuf[st.st_size] = '\n';        /* Dummy line */
 693         fbuf[st.st_size + 1] = '\0';
 694         p1 = fbuf;
 695         line = 1;
 696         while ((p2 = strchr(p1, '\n')) != NULL) {
 697                 *p2 = '\0';
 698                 if (strlazymatch(p1, pat)) {
 699                         line_list__add_line(head, line);
 700                         nlines++;
 701                 }
 702                 line++;
 703                 p1 = p2 + 1;
 704         }
 705         free(fbuf);
 706         return nlines;
 707 }
 708
 709 /* Find probe points from lazy pattern  */
 710 static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
 711 {
 712         Dwarf_Lines *lines;
 713         Dwarf_Line *line;
 714         size_t nlines, i;
 715         Dwarf_Addr addr;
 716         Dwarf_Die die_mem;
 717         int lineno;
 718         int ret;
 719
 720         if (list_empty(&pf->lcache)) {
 721                 /* Matching lazy line pattern */
 722                 ret = find_lazy_match_lines(&pf->lcache, pf->fname,
 723                                             pf->pev->point.lazy_line);
 724                 if (ret <= 0)
 725                         die("No matched lines found in %s.", pf->fname);
 726         }
 727
 728         ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
 729         DIE_IF(ret != 0);
 730         for (i = 0; i < nlines; i++) {
 731                 line = dwarf_onesrcline(lines, i);
 732
 733                 dwarf_lineno(line, &lineno);
 734                 if (!line_list__has_line(&pf->lcache, lineno))
 735                         continue;
 736
 737                 /* TODO: Get fileno from line, but how? */
 738                 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
 739                         continue;
 740
 741                 ret = dwarf_lineaddr(line, &addr);
 742                 DIE_IF(ret != 0);
 743                 if (sp_die) {
 744                         /* Address filtering 1: does sp_die include addr? */
 745                         if (!dwarf_haspc(sp_die, addr))
 746                                 continue;
 747                         /* Address filtering 2: No child include addr? */
 748                         if (die_find_inlinefunc(sp_die, addr, &die_mem))
 749                                 continue;
 750                 }
 751
 752                 pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
 753                          (int)i, lineno, (unsigned long long)addr);
 754                 pf->addr = addr;
 755
 756                 convert_probe_point(sp_die, pf);
 757                 /* Continuing, because target line might be inlined. */
 758         }
 759         /* TODO: deallocate lines, but how? */
 760 }
 761
 762 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 763 {
 764         struct probe_finder *pf = (struct probe_finder *)data;
 765         struct perf_probe_point *pp = &pf->pev->point;
 766
 767         if (pp->lazy_line)
 768                 find_probe_point_lazy(in_die, pf);
 769         else {
 770                 /* Get probe address */
 771                 pf->addr = die_get_entrypc(in_die);
 772                 pf->addr += pp->offset;
 773                 pr_debug("found inline addr: 0x%jx\n",
 774                          (uintmax_t)pf->addr);
 775
 776                 convert_probe_point(in_die, pf);
 777         }
 778
 779         return DWARF_CB_OK;
 780 }
 781
 782 /* Search function from function name */
 783 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
 784 {
 785         struct probe_finder *pf = (struct probe_finder *)data;
 786         struct perf_probe_point *pp = &pf->pev->point;
 787
 788         /* Check tag and diename */
 789         if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
 790             die_compare_name(sp_die, pp->function) != 0)
 791                 return 0;
 792
 793         pf->fname = dwarf_decl_file(sp_die);
 794         if (pp->line) { /* Function relative line */
 795                 dwarf_decl_line(sp_die, &pf->lno);
 796                 pf->lno += pp->line;
 797                 find_probe_point_by_line(pf);
 798         } else if (!dwarf_func_inline(sp_die)) {
 799                 /* Real function */
 800                 if (pp->lazy_line)
 801                         find_probe_point_lazy(sp_die, pf);
 802                 else {
 803                         pf->addr = die_get_entrypc(sp_die);
 804                         pf->addr += pp->offset;
 805                         /* TODO: Check the address in this function */
 806                         convert_probe_point(sp_die, pf);
 807                 }
 808         } else
 809                 /* Inlined function: search instances */
 810                 dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);
 811
 812         return 1; /* Exit; no same symbol in this CU. */
 813 }
 814
 815 static void find_probe_point_by_func(struct probe_finder *pf)
 816 {
 817         dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
 818 }
 819
 820 /* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
 821 int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
 822                              struct kprobe_trace_event **tevs)
 823 {
 824         struct probe_finder pf = {.pev = pev};
 825         struct perf_probe_point *pp = &pev->point;
 826         Dwarf_Off off, noff;
 827         size_t cuhl;
 828         Dwarf_Die *diep;
 829         Dwarf *dbg;
 830
 831         pf.tevs = xzalloc(sizeof(struct kprobe_trace_event) * MAX_PROBES);
 832         *tevs = pf.tevs;
 833         pf.ntevs = 0;
 834
 835         dbg = dwarf_begin(fd, DWARF_C_READ);
 836         if (!dbg)
 837                 return -ENOENT;
 838
 839         off = 0;
 840         line_list__init(&pf.lcache);
 841         /* Loop on CUs (Compilation Unit) */
 842         while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
 843                 /* Get the DIE(Debugging Information Entry) of this CU */
 844                 diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
 845                 if (!diep)
 846                         continue;
 847
 848                 /* Check if target file is included. */
 849                 if (pp->file)
 850                         pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
 851                 else
 852                         pf.fname = NULL;
 853
 854                 if (!pp->file || pf.fname) {
 855                         if (pp->function)
 856                                 find_probe_point_by_func(&pf);
 857                         else if (pp->lazy_line)
 858                                 find_probe_point_lazy(NULL, &pf);
 859                         else {
 860                                 pf.lno = pp->line;
 861                                 find_probe_point_by_line(&pf);
 862                         }
 863                 }
 864                 off = noff;
 865         }
 866         line_list__free(&pf.lcache);
 867         dwarf_end(dbg);
 868
 869         return pf.ntevs;
 870 }
 871
 872 /* Reverse search */
 873 int find_perf_probe_point(int fd, unsigned long addr,
 874                           struct perf_probe_point *ppt)
 875 {
 876         Dwarf_Die cudie, spdie, indie;
 877         Dwarf *dbg;
 878         Dwarf_Line *line;
 879         Dwarf_Addr laddr, eaddr;
 880         const char *tmp;
 881         int lineno, ret = 0;
 882
 883         dbg = dwarf_begin(fd, DWARF_C_READ);
 884         if (!dbg)
 885                 return -ENOENT;
 886
 887         /* Find cu die */
 888         if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) {
 889                 ret = -EINVAL;
 890                 goto end;
 891         }
 892
 893         /* Find a corresponding line */
 894         line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
 895         if (line) {
 896                 dwarf_lineaddr(line, &laddr);
 897                 if ((Dwarf_Addr)addr == laddr) {
 898                         dwarf_lineno(line, &lineno);
 899                         ppt->line = lineno;
 900
 901                         tmp = dwarf_linesrc(line, NULL, NULL);
 902                         DIE_IF(!tmp);
 903                         ppt->file = xstrdup(tmp);
 904                         ret = 1;
 905                 }
 906         }
 907
 908         /* Find a corresponding function */
 909         if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
 910                 tmp = dwarf_diename(&spdie);
 911                 if (!tmp)
 912                         goto end;
 913
 914                 dwarf_entrypc(&spdie, &eaddr);
 915                 if (!lineno) {
 916                         /* We don't have a line number, let's use offset */
 917                         ppt->function = xstrdup(tmp);
 918                         ppt->offset = addr - (unsigned long)eaddr;
 919                         ret = 1;
 920                         goto end;
 921                 }
 922                 if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr, &indie)) {
 923                         /* addr in an inline function */
 924                         tmp = dwarf_diename(&indie);
 925                         if (!tmp)
 926                                 goto end;
 927                         dwarf_decl_line(&indie, &lineno);
 928                 } else {
 929                         if (eaddr == addr)      /* No offset: function entry */
 930                                 lineno = ppt->line;
 931                         else
 932                                 dwarf_decl_line(&spdie, &lineno);
 933                 }
 934                 ppt->function = xstrdup(tmp);
 935                 ppt->line -= lineno;    /* Make a relative line number */
 936         }
 937
 938 end:
 939         dwarf_end(dbg);
 940         return ret;
 941 }
 942
 943
 944 /* Find line range from its line number */
 945 static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
 946 {
 947         Dwarf_Lines *lines;
 948         Dwarf_Line *line;
 949         size_t nlines, i;
 950         Dwarf_Addr addr;
 951         int lineno;
 952         int ret;
 953         const char *src;
 954         Dwarf_Die die_mem;
 955
 956         line_list__init(&lf->lr->line_list);
 957         ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines);
 958         DIE_IF(ret != 0);
 959
 960         for (i = 0; i < nlines; i++) {
 961                 line = dwarf_onesrcline(lines, i);
 962                 ret = dwarf_lineno(line, &lineno);
 963                 DIE_IF(ret != 0);
 964                 if (lf->lno_s > lineno || lf->lno_e < lineno)
 965                         continue;
 966
 967                 if (sp_die) {
 968                         /* Address filtering 1: does sp_die include addr? */
 969                         ret = dwarf_lineaddr(line, &addr);
 970                         DIE_IF(ret != 0);
 971                         if (!dwarf_haspc(sp_die, addr))
 972                                 continue;
 973
 974                         /* Address filtering 2: No child include addr? */
 975                         if (die_find_inlinefunc(sp_die, addr, &die_mem))
 976                                 continue;
 977                 }
 978
 979                 /* TODO: Get fileno from line, but how? */
 980                 src = dwarf_linesrc(line, NULL, NULL);
 981                 if (strtailcmp(src, lf->fname) != 0)
 982                         continue;
 983
 984                 /* Copy real path */
 985                 if (!lf->lr->path)
 986                         lf->lr->path = xstrdup(src);
 987                 line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
 988         }
 989         /* Update status */
 990         if (!list_empty(&lf->lr->line_list))
 991                 lf->found = 1;
 992         else {
 993                 free(lf->lr->path);
 994                 lf->lr->path = NULL;
 995         }
 996 }
 997
 998 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
 999 {
1000         find_line_range_by_line(in_die, (struct line_finder *)data);
1001         return DWARF_CB_ABORT;  /* No need to find other instances */
1002 }
1003
1004 /* Search function from function name */
1005 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1006 {
1007         struct line_finder *lf = (struct line_finder *)data;
1008         struct line_range *lr = lf->lr;
1009
1010         if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
1011             die_compare_name(sp_die, lr->function) == 0) {
1012                 lf->fname = dwarf_decl_file(sp_die);
1013                 dwarf_decl_line(sp_die, &lr->offset);
1014                 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1015                 lf->lno_s = lr->offset + lr->start;
1016                 if (!lr->end)
1017                         lf->lno_e = INT_MAX;
1018                 else
1019                         lf->lno_e = lr->offset + lr->end;
1020                 lr->start = lf->lno_s;
1021                 lr->end = lf->lno_e;
1022                 if (dwarf_func_inline(sp_die))
1023                         dwarf_func_inline_instances(sp_die,
1024                                                     line_range_inline_cb, lf);
1025                 else
1026                         find_line_range_by_line(sp_die, lf);
1027                 return 1;
1028         }
1029         return 0;
1030 }
1031
1032 static void find_line_range_by_func(struct line_finder *lf)
1033 {
1034         dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
1035 }
1036
1037 int find_line_range(int fd, struct line_range *lr)
1038 {
1039         struct line_finder lf = {.lr = lr, .found = 0};
1040         int ret;
1041         Dwarf_Off off = 0, noff;
1042         size_t cuhl;
1043         Dwarf_Die *diep;
1044         Dwarf *dbg;
1045
1046         dbg = dwarf_begin(fd, DWARF_C_READ);
1047         if (!dbg)
1048                 return -ENOENT;
1049
1050         /* Loop on CUs (Compilation Unit) */
1051         while (!lf.found) {
1052                 ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
1053                 if (ret != 0)
1054                         break;
1055
1056                 /* Get the DIE(Debugging Information Entry) of this CU */
1057                 diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
1058                 if (!diep)
1059                         continue;
1060
1061                 /* Check if target file is included. */
1062                 if (lr->file)
1063                         lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1064                 else
1065                         lf.fname = 0;
1066
1067                 if (!lr->file || lf.fname) {
1068                         if (lr->function)
1069                                 find_line_range_by_func(&lf);
1070                         else {
1071                                 lf.lno_s = lr->start;
1072                                 if (!lr->end)
1073                                         lf.lno_e = INT_MAX;
1074                                 else
1075                                         lf.lno_e = lr->end;
1076                                 find_line_range_by_line(NULL, &lf);
1077                         }
1078                 }
1079                 off = noff;
1080         }
1081         pr_debug("path: %lx\n", (unsigned long)lr->path);
1082         dwarf_end(dbg);
1083         return lf.found;
1084 }
1085