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