aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2010-10-23 14:05:43 -0400
committerIngo Molnar <mingo@elte.hu>2010-10-23 14:05:43 -0400
commitb8ecad8b2f8757d51632b1ea6d602c1f7b9760a2 (patch)
tree5a03029dbf02df606fa48a82525eb321e59b5c33
parenteea4a0b19a2719e3e23b5450dd9fbe97789d2a57 (diff)
parent8bfb5e7d6a14b29cffddd113f4b0be7d9aafc1e8 (diff)
Merge branch 'perf/core' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux-2.6 into perf/urgent
Diffstat
-rw-r--r--include/linux/interrupt.h2
-rw-r--r--include/trace/events/irq.h54
-rw-r--r--kernel/softirq.c16
-rw-r--r--tools/perf/Documentation/perf-probe.txt18
-rw-r--r--tools/perf/builtin-probe.c78
-rw-r--r--tools/perf/util/map.h10
-rw-r--r--tools/perf/util/probe-event.c189
-rw-r--r--tools/perf/util/probe-event.h16
-rw-r--r--tools/perf/util/probe-finder.c644
-rw-r--r--tools/perf/util/probe-finder.h31
-rw-r--r--tools/perf/util/ui/browser.c1
11 files changed, 823 insertions, 236 deletions
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 414328577ced..07f741a075a7 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -410,7 +410,7 @@ extern void open_softirq(int nr, void (*action)(struct softirq_action *));
410extern void softirq_init(void); 410extern void softirq_init(void);
411static inline void __raise_softirq_irqoff(unsigned int nr) 411static inline void __raise_softirq_irqoff(unsigned int nr)
412{ 412{
413 trace_softirq_raise((struct softirq_action *)(unsigned long)nr, NULL); 413 trace_softirq_raise(nr);
414 or_softirq_pending(1UL << nr); 414 or_softirq_pending(1UL << nr);
415} 415}
416 416
diff --git a/include/trace/events/irq.h b/include/trace/events/irq.h
index 6fa7cbab7d93..1c09820df585 100644
--- a/include/trace/events/irq.h
+++ b/include/trace/events/irq.h
@@ -86,76 +86,62 @@ TRACE_EVENT(irq_handler_exit,
86 86
87DECLARE_EVENT_CLASS(softirq, 87DECLARE_EVENT_CLASS(softirq,
88 88
89 TP_PROTO(struct softirq_action *h, struct softirq_action *vec), 89 TP_PROTO(unsigned int vec_nr),
90 90
91 TP_ARGS(h, vec), 91 TP_ARGS(vec_nr),
92 92
93 TP_STRUCT__entry( 93 TP_STRUCT__entry(
94 __field( int, vec ) 94 __field( unsigned int, vec )
95 ), 95 ),
96 96
97 TP_fast_assign( 97 TP_fast_assign(
98 if (vec) 98 __entry->vec = vec_nr;
99 __entry->vec = (int)(h - vec);
100 else
101 __entry->vec = (int)(long)h;
102 ), 99 ),
103 100
104 TP_printk("vec=%d [action=%s]", __entry->vec, 101 TP_printk("vec=%u [action=%s]", __entry->vec,
105 show_softirq_name(__entry->vec)) 102 show_softirq_name(__entry->vec))
106); 103);
107 104
108/** 105/**
109 * softirq_entry - called immediately before the softirq handler 106 * softirq_entry - called immediately before the softirq handler
110 * @h: pointer to struct softirq_action 107 * @vec_nr: softirq vector number
111 * @vec: pointer to first struct softirq_action in softirq_vec array
112 * 108 *
113 * The @h parameter, contains a pointer to the struct softirq_action 109 * When used in combination with the softirq_exit tracepoint
114 * which has a pointer to the action handler that is called. By subtracting 110 * we can determine the softirq handler runtine.
115 * the @vec pointer from the @h pointer, we can determine the softirq
116 * number. Also, when used in combination with the softirq_exit tracepoint
117 * we can determine the softirq latency.
118 */ 111 */
119DEFINE_EVENT(softirq, softirq_entry, 112DEFINE_EVENT(softirq, softirq_entry,
120 113
121 TP_PROTO(struct softirq_action *h, struct softirq_action *vec), 114 TP_PROTO(unsigned int vec_nr),
122 115
123 TP_ARGS(h, vec) 116 TP_ARGS(vec_nr)
124); 117);
125 118
126/** 119/**
127 * softirq_exit - called immediately after the softirq handler returns 120 * softirq_exit - called immediately after the softirq handler returns
128 * @h: pointer to struct softirq_action 121 * @vec_nr: softirq vector number
129 * @vec: pointer to first struct softirq_action in softirq_vec array
130 * 122 *
131 * The @h parameter contains a pointer to the struct softirq_action 123 * When used in combination with the softirq_entry tracepoint
132 * that has handled the softirq. By subtracting the @vec pointer from 124 * we can determine the softirq handler runtine.
133 * the @h pointer, we can determine the softirq number. Also, when used in
134 * combination with the softirq_entry tracepoint we can determine the softirq
135 * latency.
136 */ 125 */
137DEFINE_EVENT(softirq, softirq_exit, 126DEFINE_EVENT(softirq, softirq_exit,
138 127
139 TP_PROTO(struct softirq_action *h, struct softirq_action *vec), 128 TP_PROTO(unsigned int vec_nr),
140 129
141 TP_ARGS(h, vec) 130 TP_ARGS(vec_nr)
142); 131);
143 132
144/** 133/**
145 * softirq_raise - called immediately when a softirq is raised 134 * softirq_raise - called immediately when a softirq is raised
146 * @h: pointer to struct softirq_action 135 * @vec_nr: softirq vector number
147 * @vec: pointer to first struct softirq_action in softirq_vec array
148 * 136 *
149 * The @h parameter contains a pointer to the softirq vector number which is 137 * When used in combination with the softirq_entry tracepoint
150 * raised. @vec is NULL and it means @h includes vector number not 138 * we can determine the softirq raise to run latency.
151 * softirq_action. When used in combination with the softirq_entry tracepoint
152 * we can determine the softirq raise latency.
153 */ 139 */
154DEFINE_EVENT(softirq, softirq_raise, 140DEFINE_EVENT(softirq, softirq_raise,
155 141
156 TP_PROTO(struct softirq_action *h, struct softirq_action *vec), 142 TP_PROTO(unsigned int vec_nr),
157 143
158 TP_ARGS(h, vec) 144 TP_ARGS(vec_nr)
159); 145);
160 146
161#endif /* _TRACE_IRQ_H */ 147#endif /* _TRACE_IRQ_H */
diff --git a/kernel/softirq.c b/kernel/softirq.c
index fc978889b194..e33fd71ed66a 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -229,18 +229,20 @@ restart:
229 229
230 do { 230 do {
231 if (pending & 1) { 231 if (pending & 1) {
232 unsigned int vec_nr = h - softirq_vec;
232 int prev_count = preempt_count(); 233 int prev_count = preempt_count();
233 kstat_incr_softirqs_this_cpu(h - softirq_vec);
234 234
235 trace_softirq_entry(h, softirq_vec); 235 kstat_incr_softirqs_this_cpu(vec_nr);
236
237 trace_softirq_entry(vec_nr);
236 h->action(h); 238 h->action(h);
237 trace_softirq_exit(h, softirq_vec); 239 trace_softirq_exit(vec_nr);
238 if (unlikely(prev_count != preempt_count())) { 240 if (unlikely(prev_count != preempt_count())) {
239 printk(KERN_ERR "huh, entered softirq %td %s %p" 241 printk(KERN_ERR "huh, entered softirq %u %s %p"
240 "with preempt_count %08x," 242 "with preempt_count %08x,"
241 " exited with %08x?\n", h - softirq_vec, 243 " exited with %08x?\n", vec_nr,
242 softirq_to_name[h - softirq_vec], 244 softirq_to_name[vec_nr], h->action,
243 h->action, prev_count, preempt_count()); 245 prev_count, preempt_count());
244 preempt_count() = prev_count; 246 preempt_count() = prev_count;
245 } 247 }
246 248
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 27d52dae5a43..62de1b7f4e76 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -16,7 +16,9 @@ or
16or 16or
17'perf probe' --list 17'perf probe' --list
18or 18or
19'perf probe' --line='FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]' 19'perf probe' [options] --line='FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]'
20or
21'perf probe' [options] --vars='PROBEPOINT'
20 22
21DESCRIPTION 23DESCRIPTION
22----------- 24-----------
@@ -31,6 +33,11 @@ OPTIONS
31--vmlinux=PATH:: 33--vmlinux=PATH::
32 Specify vmlinux path which has debuginfo (Dwarf binary). 34 Specify vmlinux path which has debuginfo (Dwarf binary).
33 35
36-m::
37--module=MODNAME::
38 Specify module name in which perf-probe searches probe points
39 or lines.
40
34-s:: 41-s::
35--source=PATH:: 42--source=PATH::
36 Specify path to kernel source. 43 Specify path to kernel source.
@@ -57,6 +64,15 @@ OPTIONS
57 Show source code lines which can be probed. This needs an argument 64 Show source code lines which can be probed. This needs an argument
58 which specifies a range of the source code. (see LINE SYNTAX for detail) 65 which specifies a range of the source code. (see LINE SYNTAX for detail)
59 66
67-V::
68--vars=::
69 Show available local variables at given probe point. The argument
70 syntax is same as PROBE SYNTAX, but NO ARGs.
71
72--externs::
73 (Only for --vars) Show external defined variables in addition to local
74 variables.
75
60-f:: 76-f::
61--force:: 77--force::
62 Forcibly add events with existing name. 78 Forcibly add events with existing name.
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 199d5e19554f..2e000c068cc5 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -50,14 +50,17 @@ static struct {
50 bool list_events; 50 bool list_events;
51 bool force_add; 51 bool force_add;
52 bool show_lines; 52 bool show_lines;
53 bool show_vars;
54 bool show_ext_vars;
55 bool mod_events;
53 int nevents; 56 int nevents;
54 struct perf_probe_event events[MAX_PROBES]; 57 struct perf_probe_event events[MAX_PROBES];
55 struct strlist *dellist; 58 struct strlist *dellist;
56 struct line_range line_range; 59 struct line_range line_range;
60 const char *target_module;
57 int max_probe_points; 61 int max_probe_points;
58} params; 62} params;
59 63
60
61/* Parse an event definition. Note that any error must die. */ 64/* Parse an event definition. Note that any error must die. */
62static int parse_probe_event(const char *str) 65static int parse_probe_event(const char *str)
63{ 66{
@@ -92,6 +95,7 @@ static int parse_probe_event_argv(int argc, const char **argv)
92 len = 0; 95 len = 0;
93 for (i = 0; i < argc; i++) 96 for (i = 0; i < argc; i++)
94 len += sprintf(&buf[len], "%s ", argv[i]); 97 len += sprintf(&buf[len], "%s ", argv[i]);
98 params.mod_events = true;
95 ret = parse_probe_event(buf); 99 ret = parse_probe_event(buf);
96 free(buf); 100 free(buf);
97 return ret; 101 return ret;
@@ -100,9 +104,10 @@ static int parse_probe_event_argv(int argc, const char **argv)
100static int opt_add_probe_event(const struct option *opt __used, 104static int opt_add_probe_event(const struct option *opt __used,
101 const char *str, int unset __used) 105 const char *str, int unset __used)
102{ 106{
103 if (str) 107 if (str) {
108 params.mod_events = true;
104 return parse_probe_event(str); 109 return parse_probe_event(str);
105 else 110 } else
106 return 0; 111 return 0;
107} 112}
108 113
@@ -110,6 +115,7 @@ static int opt_del_probe_event(const struct option *opt __used,
110 const char *str, int unset __used) 115 const char *str, int unset __used)
111{ 116{
112 if (str) { 117 if (str) {
118 params.mod_events = true;
113 if (!params.dellist) 119 if (!params.dellist)
114 params.dellist = strlist__new(true, NULL); 120 params.dellist = strlist__new(true, NULL);
115 strlist__add(params.dellist, str); 121 strlist__add(params.dellist, str);
@@ -130,6 +136,25 @@ static int opt_show_lines(const struct option *opt __used,
130 136
131 return ret; 137 return ret;
132} 138}
139
140static int opt_show_vars(const struct option *opt __used,
141 const char *str, int unset __used)
142{
143 struct perf_probe_event *pev = &params.events[params.nevents];
144 int ret;
145
146 if (!str)
147 return 0;
148
149 ret = parse_probe_event(str);
150 if (!ret && pev->nargs != 0) {
151 pr_err(" Error: '--vars' doesn't accept arguments.\n");
152 return -EINVAL;
153 }
154 params.show_vars = true;
155
156 return ret;
157}
133#endif 158#endif
134 159
135static const char * const probe_usage[] = { 160static const char * const probe_usage[] = {
@@ -138,7 +163,8 @@ static const char * const probe_usage[] = {
138 "perf probe [<options>] --del '[GROUP:]EVENT' ...", 163 "perf probe [<options>] --del '[GROUP:]EVENT' ...",
139 "perf probe --list", 164 "perf probe --list",
140#ifdef DWARF_SUPPORT 165#ifdef DWARF_SUPPORT
141 "perf probe --line 'LINEDESC'", 166 "perf probe [<options>] --line 'LINEDESC'",
167 "perf probe [<options>] --vars 'PROBEPOINT'",
142#endif 168#endif
143 NULL 169 NULL
144}; 170};
@@ -180,10 +206,17 @@ static const struct option options[] = {
180 OPT_CALLBACK('L', "line", NULL, 206 OPT_CALLBACK('L', "line", NULL,
181 "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]", 207 "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
182 "Show source code lines.", opt_show_lines), 208 "Show source code lines.", opt_show_lines),
209 OPT_CALLBACK('V', "vars", NULL,
210 "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
211 "Show accessible variables on PROBEDEF", opt_show_vars),
212 OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
213 "Show external variables too (with --vars only)"),
183 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 214 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
184 "file", "vmlinux pathname"), 215 "file", "vmlinux pathname"),
185 OPT_STRING('s', "source", &symbol_conf.source_prefix, 216 OPT_STRING('s', "source", &symbol_conf.source_prefix,
186 "directory", "path to kernel source"), 217 "directory", "path to kernel source"),
218 OPT_STRING('m', "module", &params.target_module,
219 "modname", "target module name"),
187#endif 220#endif
188 OPT__DRY_RUN(&probe_event_dry_run), 221 OPT__DRY_RUN(&probe_event_dry_run),
189 OPT_INTEGER('\0', "max-probes", &params.max_probe_points, 222 OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
@@ -217,7 +250,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
217 usage_with_options(probe_usage, options); 250 usage_with_options(probe_usage, options);
218 251
219 if (params.list_events) { 252 if (params.list_events) {
220 if (params.nevents != 0 || params.dellist) { 253 if (params.mod_events) {
221 pr_err(" Error: Don't use --list with --add/--del.\n"); 254 pr_err(" Error: Don't use --list with --add/--del.\n");
222 usage_with_options(probe_usage, options); 255 usage_with_options(probe_usage, options);
223 } 256 }
@@ -225,6 +258,10 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
225 pr_err(" Error: Don't use --list with --line.\n"); 258 pr_err(" Error: Don't use --list with --line.\n");
226 usage_with_options(probe_usage, options); 259 usage_with_options(probe_usage, options);
227 } 260 }
261 if (params.show_vars) {
262 pr_err(" Error: Don't use --list with --vars.\n");
263 usage_with_options(probe_usage, options);
264 }
228 ret = show_perf_probe_events(); 265 ret = show_perf_probe_events();
229 if (ret < 0) 266 if (ret < 0)
230 pr_err(" Error: Failed to show event list. (%d)\n", 267 pr_err(" Error: Failed to show event list. (%d)\n",
@@ -234,17 +271,35 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
234 271
235#ifdef DWARF_SUPPORT 272#ifdef DWARF_SUPPORT
236 if (params.show_lines) { 273 if (params.show_lines) {
237 if (params.nevents != 0 || params.dellist) { 274 if (params.mod_events) {
238 pr_warning(" Error: Don't use --line with" 275 pr_err(" Error: Don't use --line with"
239 " --add/--del.\n"); 276 " --add/--del.\n");
277 usage_with_options(probe_usage, options);
278 }
279 if (params.show_vars) {
280 pr_err(" Error: Don't use --line with --vars.\n");
240 usage_with_options(probe_usage, options); 281 usage_with_options(probe_usage, options);
241 } 282 }
242 283
243 ret = show_line_range(&params.line_range); 284 ret = show_line_range(&params.line_range, params.target_module);
244 if (ret < 0) 285 if (ret < 0)
245 pr_err(" Error: Failed to show lines. (%d)\n", ret); 286 pr_err(" Error: Failed to show lines. (%d)\n", ret);
246 return ret; 287 return ret;
247 } 288 }
289 if (params.show_vars) {
290 if (params.mod_events) {
291 pr_err(" Error: Don't use --vars with"
292 " --add/--del.\n");
293 usage_with_options(probe_usage, options);
294 }
295 ret = show_available_vars(params.events, params.nevents,
296 params.max_probe_points,
297 params.target_module,
298 params.show_ext_vars);
299 if (ret < 0)
300 pr_err(" Error: Failed to show vars. (%d)\n", ret);
301 return ret;
302 }
248#endif 303#endif
249 304
250 if (params.dellist) { 305 if (params.dellist) {
@@ -258,8 +313,9 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
258 313
259 if (params.nevents) { 314 if (params.nevents) {
260 ret = add_perf_probe_events(params.events, params.nevents, 315 ret = add_perf_probe_events(params.events, params.nevents,
261 params.force_add, 316 params.max_probe_points,
262 params.max_probe_points); 317 params.target_module,
318 params.force_add);
263 if (ret < 0) { 319 if (ret < 0) {
264 pr_err(" Error: Failed to add events. (%d)\n", ret); 320 pr_err(" Error: Failed to add events. (%d)\n", ret);
265 return ret; 321 return ret;
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 78575796d5f3..b397c0383728 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -215,6 +215,16 @@ struct symbol *map_groups__find_function_by_name(struct map_groups *self,
215 return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter); 215 return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
216} 216}
217 217
218static inline
219struct symbol *machine__find_kernel_function_by_name(struct machine *self,
220 const char *name,
221 struct map **mapp,
222 symbol_filter_t filter)
223{
224 return map_groups__find_function_by_name(&self->kmaps, name, mapp,
225 filter);
226}
227
218int map_groups__fixup_overlappings(struct map_groups *self, struct map *map, 228int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
219 int verbose, FILE *fp); 229 int verbose, FILE *fp);
220 230
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index fcc16e4349df..3b6a5297bf16 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -74,10 +74,9 @@ static int e_snprintf(char *str, size_t size, const char *format, ...)
74static char *synthesize_perf_probe_point(struct perf_probe_point *pp); 74static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
75static struct machine machine; 75static struct machine machine;
76 76
77/* Initialize symbol maps and path of vmlinux */ 77/* Initialize symbol maps and path of vmlinux/modules */
78static int init_vmlinux(void) 78static int init_vmlinux(void)
79{ 79{
80 struct dso *kernel;
81 int ret; 80 int ret;
82 81
83 symbol_conf.sort_by_name = true; 82 symbol_conf.sort_by_name = true;
@@ -91,33 +90,61 @@ static int init_vmlinux(void)
91 goto out; 90 goto out;
92 } 91 }
93 92
94 ret = machine__init(&machine, "/", 0); 93 ret = machine__init(&machine, "", HOST_KERNEL_ID);
95 if (ret < 0) 94 if (ret < 0)
96 goto out; 95 goto out;
97 96
98 kernel = dso__new_kernel(symbol_conf.vmlinux_name); 97 if (machine__create_kernel_maps(&machine) < 0) {
99 if (kernel == NULL) 98 pr_debug("machine__create_kernel_maps ");
100 die("Failed to create kernel dso."); 99 goto out;
101 100 }
102 ret = __machine__create_kernel_maps(&machine, kernel);
103 if (ret < 0)
104 pr_debug("Failed to create kernel maps.\n");
105
106out: 101out:
107 if (ret < 0) 102 if (ret < 0)
108 pr_warning("Failed to init vmlinux path.\n"); 103 pr_warning("Failed to init vmlinux path.\n");
109 return ret; 104 return ret;
110} 105}
111 106
107static struct symbol *__find_kernel_function_by_name(const char *name,
108 struct map **mapp)
109{
110 return machine__find_kernel_function_by_name(&machine, name, mapp,
111 NULL);
112}
113
114const char *kernel_get_module_path(const char *module)
115{
116 struct dso *dso;
117
118 if (module) {
119 list_for_each_entry(dso, &machine.kernel_dsos, node) {
120 if (strncmp(dso->short_name + 1, module,
121 dso->short_name_len - 2) == 0)
122 goto found;
123 }
124 pr_debug("Failed to find module %s.\n", module);
125 return NULL;
126 } else {
127 dso = machine.vmlinux_maps[MAP__FUNCTION]->dso;
128 if (dso__load_vmlinux_path(dso,
129 machine.vmlinux_maps[MAP__FUNCTION], NULL) < 0) {
130 pr_debug("Failed to load kernel map.\n");
131 return NULL;
132 }
133 }
134found:
135 return dso->long_name;
136}
137
112#ifdef DWARF_SUPPORT 138#ifdef DWARF_SUPPORT
113static int open_vmlinux(void) 139static int open_vmlinux(const char *module)
114{ 140{
115 if (map__load(machine.vmlinux_maps[MAP__FUNCTION], NULL) < 0) { 141 const char *path = kernel_get_module_path(module);
116 pr_debug("Failed to load kernel map.\n"); 142 if (!path) {
117 return -EINVAL; 143 pr_err("Failed to find path of %s module", module ?: "kernel");
144 return -ENOENT;
118 } 145 }
119 pr_debug("Try to open %s\n", machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name); 146 pr_debug("Try to open %s\n", path);
120 return open(machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name, O_RDONLY); 147 return open(path, O_RDONLY);
121} 148}
122 149
123/* 150/*
@@ -125,20 +152,19 @@ static int open_vmlinux(void)
125 * Currently only handles kprobes. 152 * Currently only handles kprobes.
126 */ 153 */
127static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp, 154static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
128 struct perf_probe_point *pp) 155 struct perf_probe_point *pp)
129{ 156{
130 struct symbol *sym; 157 struct symbol *sym;
131 int fd, ret = -ENOENT; 158 struct map *map;
159 u64 addr;
160 int ret = -ENOENT;
132 161
133 sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION], 162 sym = __find_kernel_function_by_name(tp->symbol, &map);
134 tp->symbol, NULL);
135 if (sym) { 163 if (sym) {
136 fd = open_vmlinux(); 164 addr = map->unmap_ip(map, sym->start + tp->offset);
137 if (fd >= 0) { 165 pr_debug("try to find %s+%ld@%llx\n", tp->symbol,
138 ret = find_perf_probe_point(fd, 166 tp->offset, addr);
139 sym->start + tp->offset, pp); 167 ret = find_perf_probe_point((unsigned long)addr, pp);
140 close(fd);
141 }
142 } 168 }
143 if (ret <= 0) { 169 if (ret <= 0) {
144 pr_debug("Failed to find corresponding probes from " 170 pr_debug("Failed to find corresponding probes from "
@@ -156,12 +182,12 @@ static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
156/* Try to find perf_probe_event with debuginfo */ 182/* Try to find perf_probe_event with debuginfo */
157static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 183static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
158 struct probe_trace_event **tevs, 184 struct probe_trace_event **tevs,
159 int max_tevs) 185 int max_tevs, const char *module)
160{ 186{
161 bool need_dwarf = perf_probe_event_need_dwarf(pev); 187 bool need_dwarf = perf_probe_event_need_dwarf(pev);
162 int fd, ntevs; 188 int fd, ntevs;
163 189
164 fd = open_vmlinux(); 190 fd = open_vmlinux(module);
165 if (fd < 0) { 191 if (fd < 0) {
166 if (need_dwarf) { 192 if (need_dwarf) {
167 pr_warning("Failed to open debuginfo file.\n"); 193 pr_warning("Failed to open debuginfo file.\n");
@@ -300,7 +326,7 @@ error:
300 * Show line-range always requires debuginfo to find source file and 326 * Show line-range always requires debuginfo to find source file and
301 * line number. 327 * line number.
302 */ 328 */
303int show_line_range(struct line_range *lr) 329int show_line_range(struct line_range *lr, const char *module)
304{ 330{
305 int l = 1; 331 int l = 1;
306 struct line_node *ln; 332 struct line_node *ln;
@@ -313,7 +339,7 @@ int show_line_range(struct line_range *lr)
313 if (ret < 0) 339 if (ret < 0)
314 return ret; 340 return ret;
315 341
316 fd = open_vmlinux(); 342 fd = open_vmlinux(module);
317 if (fd < 0) { 343 if (fd < 0) {
318 pr_warning("Failed to open debuginfo file.\n"); 344 pr_warning("Failed to open debuginfo file.\n");
319 return fd; 345 return fd;
@@ -378,11 +404,84 @@ end:
378 return ret; 404 return ret;
379} 405}
380 406
407static int show_available_vars_at(int fd, struct perf_probe_event *pev,
408 int max_vls, bool externs)
409{
410 char *buf;
411 int ret, i;
412 struct str_node *node;
413 struct variable_list *vls = NULL, *vl;
414
415 buf = synthesize_perf_probe_point(&pev->point);
416 if (!buf)
417 return -EINVAL;
418 pr_debug("Searching variables at %s\n", buf);
419
420 ret = find_available_vars_at(fd, pev, &vls, max_vls, externs);
421 if (ret > 0) {
422 /* Some variables were found */
423 fprintf(stdout, "Available variables at %s\n", buf);
424 for (i = 0; i < ret; i++) {
425 vl = &vls[i];
426 /*
427 * A probe point might be converted to
428 * several trace points.
429 */
430 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
431 vl->point.offset);
432 free(vl->point.symbol);
433 if (vl->vars) {
434 strlist__for_each(node, vl->vars)
435 fprintf(stdout, "\t\t%s\n", node->s);
436 strlist__delete(vl->vars);
437 } else
438 fprintf(stdout, "(No variables)\n");
439 }
440 free(vls);
441 } else
442 pr_err("Failed to find variables at %s (%d)\n", buf, ret);
443
444 free(buf);
445 return ret;
446}
447
448/* Show available variables on given probe point */
449int show_available_vars(struct perf_probe_event *pevs, int npevs,
450 int max_vls, const char *module, bool externs)
451{
452 int i, fd, ret = 0;
453
454 ret = init_vmlinux();
455 if (ret < 0)
456 return ret;
457
458 fd = open_vmlinux(module);
459 if (fd < 0) {
460 pr_warning("Failed to open debuginfo file.\n");
461 return fd;
462 }
463
464 setup_pager();
465
466 for (i = 0; i < npevs && ret >= 0; i++)
467 ret = show_available_vars_at(fd, &pevs[i], max_vls, externs);
468
469 close(fd);
470 return ret;
471}
472
381#else /* !DWARF_SUPPORT */ 473#else /* !DWARF_SUPPORT */
382 474
383static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp, 475static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
384 struct perf_probe_point *pp) 476 struct perf_probe_point *pp)
385{ 477{
478 struct symbol *sym;
479
480 sym = __find_kernel_function_by_name(tp->symbol, NULL);
481 if (!sym) {
482 pr_err("Failed to find symbol %s in kernel.\n", tp->symbol);
483 return -ENOENT;
484 }
386 pp->function = strdup(tp->symbol); 485 pp->function = strdup(tp->symbol);
387 if (pp->function == NULL) 486 if (pp->function == NULL)
388 return -ENOMEM; 487 return -ENOMEM;
@@ -394,7 +493,7 @@ static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
394 493
395static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 494static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
396 struct probe_trace_event **tevs __unused, 495 struct probe_trace_event **tevs __unused,
397 int max_tevs __unused) 496 int max_tevs __unused, const char *mod __unused)
398{ 497{
399 if (perf_probe_event_need_dwarf(pev)) { 498 if (perf_probe_event_need_dwarf(pev)) {
400 pr_warning("Debuginfo-analysis is not supported.\n"); 499 pr_warning("Debuginfo-analysis is not supported.\n");
@@ -403,12 +502,19 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
403 return 0; 502 return 0;
404} 503}
405 504
406int show_line_range(struct line_range *lr __unused) 505int show_line_range(struct line_range *lr __unused, const char *module __unused)
407{ 506{
408 pr_warning("Debuginfo-analysis is not supported.\n"); 507 pr_warning("Debuginfo-analysis is not supported.\n");
409 return -ENOSYS; 508 return -ENOSYS;
410} 509}
411 510
511int show_available_vars(struct perf_probe_event *pevs __unused,
512 int npevs __unused, int max_vls __unused,
513 const char *module __unused, bool externs __unused)
514{
515 pr_warning("Debuginfo-analysis is not supported.\n");
516 return -ENOSYS;
517}
412#endif 518#endif
413 519
414int parse_line_range_desc(const char *arg, struct line_range *lr) 520int parse_line_range_desc(const char *arg, struct line_range *lr)
@@ -1087,7 +1193,7 @@ error:
1087} 1193}
1088 1194
1089static int convert_to_perf_probe_event(struct probe_trace_event *tev, 1195static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1090 struct perf_probe_event *pev) 1196 struct perf_probe_event *pev)
1091{ 1197{
1092 char buf[64] = ""; 1198 char buf[64] = "";
1093 int i, ret; 1199 int i, ret;
@@ -1516,14 +1622,14 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
1516 1622
1517static int convert_to_probe_trace_events(struct perf_probe_event *pev, 1623static int convert_to_probe_trace_events(struct perf_probe_event *pev,
1518 struct probe_trace_event **tevs, 1624 struct probe_trace_event **tevs,
1519 int max_tevs) 1625 int max_tevs, const char *module)
1520{ 1626{
1521 struct symbol *sym; 1627 struct symbol *sym;
1522 int ret = 0, i; 1628 int ret = 0, i;
1523 struct probe_trace_event *tev; 1629 struct probe_trace_event *tev;
1524 1630
1525 /* Convert perf_probe_event with debuginfo */ 1631 /* Convert perf_probe_event with debuginfo */
1526 ret = try_to_find_probe_trace_events(pev, tevs, max_tevs); 1632 ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, module);
1527 if (ret != 0) 1633 if (ret != 0)
1528 return ret; 1634 return ret;
1529 1635
@@ -1572,8 +1678,7 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
1572 } 1678 }
1573 1679
1574 /* Currently just checking function name from symbol map */ 1680 /* Currently just checking function name from symbol map */
1575 sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION], 1681 sym = __find_kernel_function_by_name(tev->point.symbol, NULL);
1576 tev->point.symbol, NULL);
1577 if (!sym) { 1682 if (!sym) {
1578 pr_warning("Kernel symbol \'%s\' not found.\n", 1683 pr_warning("Kernel symbol \'%s\' not found.\n",
1579 tev->point.symbol); 1684 tev->point.symbol);
@@ -1596,7 +1701,7 @@ struct __event_package {
1596}; 1701};
1597 1702
1598int add_perf_probe_events(struct perf_probe_event *pevs, int npevs, 1703int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
1599 bool force_add, int max_tevs) 1704 int max_tevs, const char *module, bool force_add)
1600{ 1705{
1601 int i, j, ret; 1706 int i, j, ret;
1602 struct __event_package *pkgs; 1707 struct __event_package *pkgs;
@@ -1617,7 +1722,9 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
1617 pkgs[i].pev = &pevs[i]; 1722 pkgs[i].pev = &pevs[i];
1618 /* Convert with or without debuginfo */ 1723 /* Convert with or without debuginfo */
1619 ret = convert_to_probe_trace_events(pkgs[i].pev, 1724 ret = convert_to_probe_trace_events(pkgs[i].pev,
1620 &pkgs[i].tevs, max_tevs); 1725 &pkgs[i].tevs,
1726 max_tevs,
1727 module);
1621 if (ret < 0) 1728 if (ret < 0)
1622 goto end; 1729 goto end;
1623 pkgs[i].ntevs = ret; 1730 pkgs[i].ntevs = ret;
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 5af39243a25b..5accbedfea37 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -90,6 +90,12 @@ struct line_range {
90 struct list_head line_list; /* Visible lines */ 90 struct list_head line_list; /* Visible lines */
91}; 91};
92 92
93/* List of variables */
94struct variable_list {
95 struct probe_trace_point point; /* Actual probepoint */
96 struct strlist *vars; /* Available variables */
97};
98
93/* Command string to events */ 99/* Command string to events */
94extern int parse_perf_probe_command(const char *cmd, 100extern int parse_perf_probe_command(const char *cmd,
95 struct perf_probe_event *pev); 101 struct perf_probe_event *pev);
@@ -109,12 +115,18 @@ extern void clear_perf_probe_event(struct perf_probe_event *pev);
109/* Command string to line-range */ 115/* Command string to line-range */
110extern int parse_line_range_desc(const char *cmd, struct line_range *lr); 116extern int parse_line_range_desc(const char *cmd, struct line_range *lr);
111 117
118/* Internal use: Return kernel/module path */
119extern const char *kernel_get_module_path(const char *module);
112 120
113extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs, 121extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
114 bool force_add, int max_probe_points); 122 int max_probe_points, const char *module,
123 bool force_add);
115extern int del_perf_probe_events(struct strlist *dellist); 124extern int del_perf_probe_events(struct strlist *dellist);
116extern int show_perf_probe_events(void); 125extern int show_perf_probe_events(void);
117extern int show_line_range(struct line_range *lr); 126extern int show_line_range(struct line_range *lr, const char *module);
127extern int show_available_vars(struct perf_probe_event *pevs, int npevs,
128 int max_probe_points, const char *module,
129 bool externs);
118 130
119 131
120/* Maximum index number of event-name postfix */ 132/* Maximum index number of event-name postfix */
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 32b81f707ff5..c20bd52833aa 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -116,6 +116,101 @@ static void line_list__free(struct list_head *head)
116 } 116 }
117} 117}
118 118
119/* Dwarf FL wrappers */
120
121static int __linux_kernel_find_elf(Dwfl_Module *mod,
122 void **userdata,
123 const char *module_name,
124 Dwarf_Addr base,
125 char **file_name, Elf **elfp)
126{
127 int fd;
128 const char *path = kernel_get_module_path(module_name);
129
130 if (path) {
131 fd = open(path, O_RDONLY);
132 if (fd >= 0) {
133 *file_name = strdup(path);
134 return fd;
135 }
136 }
137 /* If failed, try to call standard method */
138 return dwfl_linux_kernel_find_elf(mod, userdata, module_name, base,
139 file_name, elfp);
140}
141
142static char *debuginfo_path; /* Currently dummy */
143
144static const Dwfl_Callbacks offline_callbacks = {
145 .find_debuginfo = dwfl_standard_find_debuginfo,
146 .debuginfo_path = &debuginfo_path,
147
148 .section_address = dwfl_offline_section_address,
149
150 /* We use this table for core files too. */
151 .find_elf = dwfl_build_id_find_elf,
152};
153
154static const Dwfl_Callbacks kernel_callbacks = {
155 .find_debuginfo = dwfl_standard_find_debuginfo,
156 .debuginfo_path = &debuginfo_path,
157
158 .find_elf = __linux_kernel_find_elf,
159 .section_address = dwfl_linux_kernel_module_section_address,
160};
161
162/* Get a Dwarf from offline image */
163static Dwarf *dwfl_init_offline_dwarf(int fd, Dwfl **dwflp, Dwarf_Addr *bias)
164{
165 Dwfl_Module *mod;
166 Dwarf *dbg = NULL;
167
168 if (!dwflp)
169 return NULL;
170
171 *dwflp = dwfl_begin(&offline_callbacks);
172 if (!*dwflp)
173 return NULL;
174
175 mod = dwfl_report_offline(*dwflp, "", "", fd);
176 if (!mod)
177 goto error;
178
179 dbg = dwfl_module_getdwarf(mod, bias);
180 if (!dbg) {
181error:
182 dwfl_end(*dwflp);
183 *dwflp = NULL;
184 }
185 return dbg;
186}
187
188/* Get a Dwarf from live kernel image */
189static Dwarf *dwfl_init_live_kernel_dwarf(Dwarf_Addr addr, Dwfl **dwflp,
190 Dwarf_Addr *bias)
191{
192 Dwarf *dbg;
193
194 if (!dwflp)
195 return NULL;
196
197 *dwflp = dwfl_begin(&kernel_callbacks);
198 if (!*dwflp)
199 return NULL;
200
201 /* Load the kernel dwarves: Don't care the result here */
202 dwfl_linux_kernel_report_kernel(*dwflp);
203 dwfl_linux_kernel_report_modules(*dwflp);
204
205 dbg = dwfl_addrdwarf(*dwflp, addr, bias);
206 /* Here, check whether we could get a real dwarf */
207 if (!dbg) {
208 dwfl_end(*dwflp);
209 *dwflp = NULL;
210 }
211 return dbg;
212}
213
119/* Dwarf wrappers */ 214/* Dwarf wrappers */
120 215
121/* Find the realpath of the target file. */ 216/* Find the realpath of the target file. */
@@ -160,26 +255,44 @@ static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
160 return name ? (strcmp(tname, name) == 0) : false; 255 return name ? (strcmp(tname, name) == 0) : false;
161} 256}
162 257
163/* Get type die, but skip qualifiers and typedef */ 258/* Get type die */
164static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem) 259static Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
165{ 260{
166 Dwarf_Attribute attr; 261 Dwarf_Attribute attr;
262
263 if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
264 dwarf_formref_die(&attr, die_mem))
265 return die_mem;
266 else
267 return NULL;
268}
269
270/* Get a type die, but skip qualifiers */
271static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
272{
167 int tag; 273 int tag;
168 274
169 do { 275 do {
170 if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL || 276 vr_die = die_get_type(vr_die, die_mem);
171 dwarf_formref_die(&attr, die_mem) == NULL) 277 if (!vr_die)
172 return NULL; 278 break;
173 279 tag = dwarf_tag(vr_die);
174 tag = dwarf_tag(die_mem);
175 vr_die = die_mem;
176 } while (tag == DW_TAG_const_type || 280 } while (tag == DW_TAG_const_type ||
177 tag == DW_TAG_restrict_type || 281 tag == DW_TAG_restrict_type ||
178 tag == DW_TAG_volatile_type || 282 tag == DW_TAG_volatile_type ||
179 tag == DW_TAG_shared_type || 283 tag == DW_TAG_shared_type);
180 tag == DW_TAG_typedef); 284
285 return vr_die;
286}
181 287
182 return die_mem; 288/* Get a type die, but skip qualifiers and typedef */
289static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
290{
291 do {
292 vr_die = __die_get_real_type(vr_die, die_mem);
293 } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
294
295 return vr_die;
183} 296}
184 297
185static bool die_is_signed_type(Dwarf_Die *tp_die) 298static bool die_is_signed_type(Dwarf_Die *tp_die)
@@ -320,25 +433,35 @@ static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
320 return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem); 433 return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
321} 434}
322 435
436struct __find_variable_param {
437 const char *name;
438 Dwarf_Addr addr;
439};
440
323static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data) 441static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
324{ 442{
325 const char *name = data; 443 struct __find_variable_param *fvp = data;
326 int tag; 444 int tag;
327 445
328 tag = dwarf_tag(die_mem); 446 tag = dwarf_tag(die_mem);
329 if ((tag == DW_TAG_formal_parameter || 447 if ((tag == DW_TAG_formal_parameter ||
330 tag == DW_TAG_variable) && 448 tag == DW_TAG_variable) &&
331 die_compare_name(die_mem, name)) 449 die_compare_name(die_mem, fvp->name))
332 return DIE_FIND_CB_FOUND; 450 return DIE_FIND_CB_FOUND;
333 451
334 return DIE_FIND_CB_CONTINUE; 452 if (dwarf_haspc(die_mem, fvp->addr))
453 return DIE_FIND_CB_CONTINUE;
454 else
455 return DIE_FIND_CB_SIBLING;
335} 456}
336 457
337/* Find a variable called 'name' */ 458/* Find a variable called 'name' at given address */
338static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name, 459static Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
339 Dwarf_Die *die_mem) 460 Dwarf_Addr addr, Dwarf_Die *die_mem)
340{ 461{
341 return die_find_child(sp_die, __die_find_variable_cb, (void *)name, 462 struct __find_variable_param fvp = { .name = name, .addr = addr};
463
464 return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
342 die_mem); 465 die_mem);
343} 466}
344 467
@@ -361,6 +484,60 @@ static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
361 die_mem); 484 die_mem);
362} 485}
363 486
487/* Get the name of given variable DIE */
488static int die_get_typename(Dwarf_Die *vr_die, char *buf, int len)
489{
490 Dwarf_Die type;
491 int tag, ret, ret2;
492 const char *tmp = "";
493
494 if (__die_get_real_type(vr_die, &type) == NULL)
495 return -ENOENT;
496
497 tag = dwarf_tag(&type);
498 if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
499 tmp = "*";
500 else if (tag == DW_TAG_subroutine_type) {
501 /* Function pointer */
502 ret = snprintf(buf, len, "(function_type)");
503 return (ret >= len) ? -E2BIG : ret;
504 } else {
505 if (!dwarf_diename(&type))
506 return -ENOENT;
507 if (tag == DW_TAG_union_type)
508 tmp = "union ";
509 else if (tag == DW_TAG_structure_type)
510 tmp = "struct ";
511 /* Write a base name */
512 ret = snprintf(buf, len, "%s%s", tmp, dwarf_diename(&type));
513 return (ret >= len) ? -E2BIG : ret;
514 }
515 ret = die_get_typename(&type, buf, len);
516 if (ret > 0) {
517 ret2 = snprintf(buf + ret, len - ret, "%s", tmp);
518 ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
519 }
520 return ret;
521}
522
523/* Get the name and type of given variable DIE, stored as "type\tname" */
524static int die_get_varname(Dwarf_Die *vr_die, char *buf, int len)
525{
526 int ret, ret2;
527
528 ret = die_get_typename(vr_die, buf, len);
529 if (ret < 0) {
530 pr_debug("Failed to get type, make it unknown.\n");
531 ret = snprintf(buf, len, "(unknown_type)");
532 }
533 if (ret > 0) {
534 ret2 = snprintf(buf + ret, len - ret, "\t%s",
535 dwarf_diename(vr_die));
536 ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
537 }
538 return ret;
539}
540
364/* 541/*
365 * Probe finder related functions 542 * Probe finder related functions
366 */ 543 */
@@ -374,8 +551,13 @@ static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
374 return ref; 551 return ref;
375} 552}
376 553
377/* Show a location */ 554/*
378static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf) 555 * Convert a location into trace_arg.
556 * If tvar == NULL, this just checks variable can be converted.
557 */
558static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
559 Dwarf_Op *fb_ops,
560 struct probe_trace_arg *tvar)
379{ 561{
380 Dwarf_Attribute attr; 562 Dwarf_Attribute attr;
381 Dwarf_Op *op; 563 Dwarf_Op *op;
@@ -384,20 +566,23 @@ static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf)
384 Dwarf_Word offs = 0; 566 Dwarf_Word offs = 0;
385 bool ref = false; 567 bool ref = false;
386 const char *regs; 568 const char *regs;
387 struct probe_trace_arg *tvar = pf->tvar;
388 int ret; 569 int ret;
389 570
571 if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
572 goto static_var;
573
390 /* TODO: handle more than 1 exprs */ 574 /* TODO: handle more than 1 exprs */
391 if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL || 575 if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL ||
392 dwarf_getlocation_addr(&attr, pf->addr, &op, &nops, 1) <= 0 || 576 dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0 ||
393 nops == 0) { 577 nops == 0) {
394 /* TODO: Support const_value */ 578 /* TODO: Support const_value */
395 pr_err("Failed to find the location of %s at this address.\n"
396 " Perhaps, it has been optimized out.\n", pf->pvar->var);
397 return -ENOENT; 579 return -ENOENT;
398 } 580 }
399 581
400 if (op->atom == DW_OP_addr) { 582 if (op->atom == DW_OP_addr) {
583static_var:
584 if (!tvar)
585 return 0;
401 /* Static variables on memory (not stack), make @varname */ 586 /* Static variables on memory (not stack), make @varname */
402 ret = strlen(dwarf_diename(vr_die)); 587 ret = strlen(dwarf_diename(vr_die));
403 tvar->value = zalloc(ret + 2); 588 tvar->value = zalloc(ret + 2);
@@ -412,14 +597,11 @@ static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf)
412 597
413 /* If this is based on frame buffer, set the offset */ 598 /* If this is based on frame buffer, set the offset */
414 if (op->atom == DW_OP_fbreg) { 599 if (op->atom == DW_OP_fbreg) {
415 if (pf->fb_ops == NULL) { 600 if (fb_ops == NULL)
416 pr_warning("The attribute of frame base is not "
417 "supported.\n");
418 return -ENOTSUP; 601 return -ENOTSUP;
419 }
420 ref = true; 602 ref = true;
421 offs = op->number; 603 offs = op->number;
422 op = &pf->fb_ops[0]; 604 op = &fb_ops[0];
423 } 605 }
424 606
425 if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) { 607 if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
@@ -435,13 +617,18 @@ static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf)
435 } else if (op->atom == DW_OP_regx) { 617 } else if (op->atom == DW_OP_regx) {
436 regn = op->number; 618 regn = op->number;
437 } else { 619 } else {
438 pr_warning("DW_OP %x is not supported.\n", op->atom); 620 pr_debug("DW_OP %x is not supported.\n", op->atom);
439 return -ENOTSUP; 621 return -ENOTSUP;
440 } 622 }
441 623
624 if (!tvar)
625 return 0;
626
442 regs = get_arch_regstr(regn); 627 regs = get_arch_regstr(regn);
443 if (!regs) { 628 if (!regs) {
444 pr_warning("Mapping for DWARF register number %u missing on this architecture.", regn); 629 /* This should be a bug in DWARF or this tool */
630 pr_warning("Mapping for DWARF register number %u "
631 "missing on this architecture.", regn);
445 return -ERANGE; 632 return -ERANGE;
446 } 633 }
447 634
@@ -666,8 +853,14 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
666 pr_debug("Converting variable %s into trace event.\n", 853 pr_debug("Converting variable %s into trace event.\n",
667 dwarf_diename(vr_die)); 854 dwarf_diename(vr_die));
668 855
669 ret = convert_variable_location(vr_die, pf); 856 ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
670 if (ret == 0 && pf->pvar->field) { 857 pf->tvar);
858 if (ret == -ENOENT)
859 pr_err("Failed to find the location of %s at this address.\n"
860 " Perhaps, it has been optimized out.\n", pf->pvar->var);
861 else if (ret == -ENOTSUP)
862 pr_err("Sorry, we don't support this variable location yet.\n");
863 else if (pf->pvar->field) {
671 ret = convert_variable_fields(vr_die, pf->pvar->var, 864 ret = convert_variable_fields(vr_die, pf->pvar->var,
672 pf->pvar->field, &pf->tvar->ref, 865 pf->pvar->field, &pf->tvar->ref,
673 &die_mem); 866 &die_mem);
@@ -722,56 +915,39 @@ static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
722 pr_debug("Searching '%s' variable in context.\n", 915 pr_debug("Searching '%s' variable in context.\n",
723 pf->pvar->var); 916 pf->pvar->var);
724 /* Search child die for local variables and parameters. */ 917 /* Search child die for local variables and parameters. */
725 if (die_find_variable(sp_die, pf->pvar->var, &vr_die)) 918 if (die_find_variable_at(sp_die, pf->pvar->var, pf->addr, &vr_die))
726 ret = convert_variable(&vr_die, pf); 919 ret = convert_variable(&vr_die, pf);
727 else { 920 else {
728 /* Search upper class */ 921 /* Search upper class */
729 nscopes = dwarf_getscopes_die(sp_die, &scopes); 922 nscopes = dwarf_getscopes_die(sp_die, &scopes);
730 if (nscopes > 0) { 923 while (nscopes-- > 1) {
731 ret = dwarf_getscopevar(scopes, nscopes, pf->pvar->var, 924 pr_debug("Searching variables in %s\n",
732 0, NULL, 0, 0, &vr_die); 925 dwarf_diename(&scopes[nscopes]));
733 if (ret >= 0) 926 /* We should check this scope, so give dummy address */
927 if (die_find_variable_at(&scopes[nscopes],
928 pf->pvar->var, 0,
929 &vr_die)) {
734 ret = convert_variable(&vr_die, pf); 930 ret = convert_variable(&vr_die, pf);
735 else 931 goto found;
736 ret = -ENOENT; 932 }
933 }
934 if (scopes)
737 free(scopes); 935 free(scopes);
738 } else 936 ret = -ENOENT;
739 ret = -ENOENT;
740 } 937 }
938found:
741 if (ret < 0) 939 if (ret < 0)
742 pr_warning("Failed to find '%s' in this function.\n", 940 pr_warning("Failed to find '%s' in this function.\n",
743 pf->pvar->var); 941 pf->pvar->var);
744 return ret; 942 return ret;
745} 943}
746 944
747/* Show a probe point to output buffer */ 945/* Convert subprogram DIE to trace point */
748static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf) 946static int convert_to_trace_point(Dwarf_Die *sp_die, Dwarf_Addr paddr,
947 bool retprobe, struct probe_trace_point *tp)
749{ 948{
750 struct probe_trace_event *tev;
751 Dwarf_Addr eaddr; 949 Dwarf_Addr eaddr;
752 Dwarf_Die die_mem;
753 const char *name; 950 const char *name;
754 int ret, i;
755 Dwarf_Attribute fb_attr;
756 size_t nops;
757
758 if (pf->ntevs == pf->max_tevs) {
759 pr_warning("Too many( > %d) probe point found.\n",
760 pf->max_tevs);
761 return -ERANGE;
762 }
763 tev = &pf->tevs[pf->ntevs++];
764
765 /* If no real subprogram, find a real one */
766 if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
767 sp_die = die_find_real_subprogram(&pf->cu_die,
768 pf->addr, &die_mem);
769 if (!sp_die) {
770 pr_warning("Failed to find probe point in any "
771 "functions.\n");
772 return -ENOENT;
773 }
774 }
775 951
776 /* Copy the name of probe point */ 952 /* Copy the name of probe point */
777 name = dwarf_diename(sp_die); 953 name = dwarf_diename(sp_die);
@@ -781,26 +957,45 @@ static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
781 dwarf_diename(sp_die)); 957 dwarf_diename(sp_die));
782 return -ENOENT; 958 return -ENOENT;
783 } 959 }
784 tev->point.symbol = strdup(name); 960 tp->symbol = strdup(name);
785 if (tev->point.symbol == NULL) 961 if (tp->symbol == NULL)
786 return -ENOMEM; 962 return -ENOMEM;
787 tev->point.offset = (unsigned long)(pf->addr - eaddr); 963 tp->offset = (unsigned long)(paddr - eaddr);
788 } else 964 } else
789 /* This function has no name. */ 965 /* This function has no name. */
790 tev->point.offset = (unsigned long)pf->addr; 966 tp->offset = (unsigned long)paddr;
791 967
792 /* Return probe must be on the head of a subprogram */ 968 /* Return probe must be on the head of a subprogram */
793 if (pf->pev->point.retprobe) { 969 if (retprobe) {
794 if (tev->point.offset != 0) { 970 if (eaddr != paddr) {
795 pr_warning("Return probe must be on the head of" 971 pr_warning("Return probe must be on the head of"
796 " a real function\n"); 972 " a real function\n");
797 return -EINVAL; 973 return -EINVAL;
798 } 974 }
799 tev->point.retprobe = true; 975 tp->retprobe = true;
800 } 976 }
801 977
802 pr_debug("Probe point found: %s+%lu\n", tev->point.symbol, 978 return 0;
803 tev->point.offset); 979}
980
981/* Call probe_finder callback with real subprogram DIE */
982static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
983{
984 Dwarf_Die die_mem;
985 Dwarf_Attribute fb_attr;
986 size_t nops;
987 int ret;
988
989 /* If no real subprogram, find a real one */
990 if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
991 sp_die = die_find_real_subprogram(&pf->cu_die,
992 pf->addr, &die_mem);
993 if (!sp_die) {
994 pr_warning("Failed to find probe point in any "
995 "functions.\n");
996 return -ENOENT;
997 }
998 }
804 999
805 /* Get the frame base attribute/ops */ 1000 /* Get the frame base attribute/ops */
806 dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr); 1001 dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
@@ -820,22 +1015,13 @@ static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
820#endif 1015#endif
821 } 1016 }
822 1017
823 /* Find each argument */ 1018 /* Call finder's callback handler */
824 tev->nargs = pf->pev->nargs; 1019 ret = pf->callback(sp_die, pf);
825 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
826 if (tev->args == NULL)
827 return -ENOMEM;
828 for (i = 0; i < pf->pev->nargs; i++) {
829 pf->pvar = &pf->pev->args[i];
830 pf->tvar = &tev->args[i];
831 ret = find_variable(sp_die, pf);
832 if (ret != 0)
833 return ret;
834 }
835 1020
836 /* *pf->fb_ops will be cached in libdw. Don't free it. */ 1021 /* *pf->fb_ops will be cached in libdw. Don't free it. */
837 pf->fb_ops = NULL; 1022 pf->fb_ops = NULL;
838 return 0; 1023
1024 return ret;
839} 1025}
840 1026
841/* Find probe point from its line number */ 1027/* Find probe point from its line number */
@@ -871,7 +1057,7 @@ static int find_probe_point_by_line(struct probe_finder *pf)
871 (int)i, lineno, (uintmax_t)addr); 1057 (int)i, lineno, (uintmax_t)addr);
872 pf->addr = addr; 1058 pf->addr = addr;
873 1059
874 ret = convert_probe_point(NULL, pf); 1060 ret = call_probe_finder(NULL, pf);
875 /* Continuing, because target line might be inlined. */ 1061 /* Continuing, because target line might be inlined. */
876 } 1062 }
877 return ret; 1063 return ret;
@@ -984,7 +1170,7 @@ static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
984 (int)i, lineno, (unsigned long long)addr); 1170 (int)i, lineno, (unsigned long long)addr);
985 pf->addr = addr; 1171 pf->addr = addr;
986 1172
987 ret = convert_probe_point(sp_die, pf); 1173 ret = call_probe_finder(sp_die, pf);
988 /* Continuing, because target line might be inlined. */ 1174 /* Continuing, because target line might be inlined. */
989 } 1175 }
990 /* TODO: deallocate lines, but how? */ 1176 /* TODO: deallocate lines, but how? */
@@ -1019,7 +1205,7 @@ static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
1019 pr_debug("found inline addr: 0x%jx\n", 1205 pr_debug("found inline addr: 0x%jx\n",
1020 (uintmax_t)pf->addr); 1206 (uintmax_t)pf->addr);
1021 1207
1022 param->retval = convert_probe_point(in_die, pf); 1208 param->retval = call_probe_finder(in_die, pf);
1023 if (param->retval < 0) 1209 if (param->retval < 0)
1024 return DWARF_CB_ABORT; 1210 return DWARF_CB_ABORT;
1025 } 1211 }
@@ -1057,7 +1243,7 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
1057 } 1243 }
1058 pf->addr += pp->offset; 1244 pf->addr += pp->offset;
1059 /* TODO: Check the address in this function */ 1245 /* TODO: Check the address in this function */
1060 param->retval = convert_probe_point(sp_die, pf); 1246 param->retval = call_probe_finder(sp_die, pf);
1061 } 1247 }
1062 } else { 1248 } else {
1063 struct dwarf_callback_param _param = {.data = (void *)pf, 1249 struct dwarf_callback_param _param = {.data = (void *)pf,
@@ -1079,90 +1265,276 @@ static int find_probe_point_by_func(struct probe_finder *pf)
1079 return _param.retval; 1265 return _param.retval;
1080} 1266}
1081 1267
1082/* Find probe_trace_events specified by perf_probe_event from debuginfo */ 1268/* Find probe points from debuginfo */
1083int find_probe_trace_events(int fd, struct perf_probe_event *pev, 1269static int find_probes(int fd, struct probe_finder *pf)
1084 struct probe_trace_event **tevs, int max_tevs)
1085{ 1270{
1086 struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs}; 1271 struct perf_probe_point *pp = &pf->pev->point;
1087 struct perf_probe_point *pp = &pev->point;
1088 Dwarf_Off off, noff; 1272 Dwarf_Off off, noff;
1089 size_t cuhl; 1273 size_t cuhl;
1090 Dwarf_Die *diep; 1274 Dwarf_Die *diep;
1091 Dwarf *dbg; 1275 Dwarf *dbg = NULL;
1276 Dwfl *dwfl;
1277 Dwarf_Addr bias; /* Currently ignored */
1092 int ret = 0; 1278 int ret = 0;
1093 1279
1094 pf.tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs); 1280 dbg = dwfl_init_offline_dwarf(fd, &dwfl, &bias);
1095 if (pf.tevs == NULL)
1096 return -ENOMEM;
1097 *tevs = pf.tevs;
1098 pf.ntevs = 0;
1099
1100 dbg = dwarf_begin(fd, DWARF_C_READ);
1101 if (!dbg) { 1281 if (!dbg) {
1102 pr_warning("No dwarf info found in the vmlinux - " 1282 pr_warning("No dwarf info found in the vmlinux - "
1103 "please rebuild with CONFIG_DEBUG_INFO=y.\n"); 1283 "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1104 free(pf.tevs);
1105 *tevs = NULL;
1106 return -EBADF; 1284 return -EBADF;
1107 } 1285 }
1108 1286
1109#if _ELFUTILS_PREREQ(0, 142) 1287#if _ELFUTILS_PREREQ(0, 142)
1110 /* Get the call frame information from this dwarf */ 1288 /* Get the call frame information from this dwarf */
1111 pf.cfi = dwarf_getcfi(dbg); 1289 pf->cfi = dwarf_getcfi(dbg);
1112#endif 1290#endif
1113 1291
1114 off = 0; 1292 off = 0;
1115 line_list__init(&pf.lcache); 1293 line_list__init(&pf->lcache);
1116 /* Loop on CUs (Compilation Unit) */ 1294 /* Loop on CUs (Compilation Unit) */
1117 while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) && 1295 while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) &&
1118 ret >= 0) { 1296 ret >= 0) {
1119 /* Get the DIE(Debugging Information Entry) of this CU */ 1297 /* Get the DIE(Debugging Information Entry) of this CU */
1120 diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die); 1298 diep = dwarf_offdie(dbg, off + cuhl, &pf->cu_die);
1121 if (!diep) 1299 if (!diep)
1122 continue; 1300 continue;
1123 1301
1124 /* Check if target file is included. */ 1302 /* Check if target file is included. */
1125 if (pp->file) 1303 if (pp->file)
1126 pf.fname = cu_find_realpath(&pf.cu_die, pp->file); 1304 pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1127 else 1305 else
1128 pf.fname = NULL; 1306 pf->fname = NULL;
1129 1307
1130 if (!pp->file || pf.fname) { 1308 if (!pp->file || pf->fname) {
1131 if (pp->function) 1309 if (pp->function)
1132 ret = find_probe_point_by_func(&pf); 1310 ret = find_probe_point_by_func(pf);
1133 else if (pp->lazy_line) 1311 else if (pp->lazy_line)
1134 ret = find_probe_point_lazy(NULL, &pf); 1312 ret = find_probe_point_lazy(NULL, pf);
1135 else { 1313 else {
1136 pf.lno = pp->line; 1314 pf->lno = pp->line;
1137 ret = find_probe_point_by_line(&pf); 1315 ret = find_probe_point_by_line(pf);
1138 } 1316 }
1139 } 1317 }
1140 off = noff; 1318 off = noff;
1141 } 1319 }
1142 line_list__free(&pf.lcache); 1320 line_list__free(&pf->lcache);
1143 dwarf_end(dbg); 1321 if (dwfl)
1322 dwfl_end(dwfl);
1144 1323
1145 return (ret < 0) ? ret : pf.ntevs; 1324 return ret;
1325}
1326
1327/* Add a found probe point into trace event list */
1328static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
1329{
1330 struct trace_event_finder *tf =
1331 container_of(pf, struct trace_event_finder, pf);
1332 struct probe_trace_event *tev;
1333 int ret, i;
1334
1335 /* Check number of tevs */
1336 if (tf->ntevs == tf->max_tevs) {
1337 pr_warning("Too many( > %d) probe point found.\n",
1338 tf->max_tevs);
1339 return -ERANGE;
1340 }
1341 tev = &tf->tevs[tf->ntevs++];
1342
1343 ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
1344 &tev->point);
1345 if (ret < 0)
1346 return ret;
1347
1348 pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1349 tev->point.offset);
1350
1351 /* Find each argument */
1352 tev->nargs = pf->pev->nargs;
1353 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1354 if (tev->args == NULL)
1355 return -ENOMEM;
1356 for (i = 0; i < pf->pev->nargs; i++) {
1357 pf->pvar = &pf->pev->args[i];
1358 pf->tvar = &tev->args[i];
1359 ret = find_variable(sp_die, pf);
1360 if (ret != 0)
1361 return ret;
1362 }
1363
1364 return 0;
1365}
1366
1367/* Find probe_trace_events specified by perf_probe_event from debuginfo */
1368int find_probe_trace_events(int fd, struct perf_probe_event *pev,
1369 struct probe_trace_event **tevs, int max_tevs)
1370{
1371 struct trace_event_finder tf = {
1372 .pf = {.pev = pev, .callback = add_probe_trace_event},
1373 .max_tevs = max_tevs};
1374 int ret;
1375
1376 /* Allocate result tevs array */
1377 *tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
1378 if (*tevs == NULL)
1379 return -ENOMEM;
1380
1381 tf.tevs = *tevs;
1382 tf.ntevs = 0;
1383
1384 ret = find_probes(fd, &tf.pf);
1385 if (ret < 0) {
1386 free(*tevs);
1387 *tevs = NULL;
1388 return ret;
1389 }
1390
1391 return (ret < 0) ? ret : tf.ntevs;
1392}
1393
1394#define MAX_VAR_LEN 64
1395
1396/* Collect available variables in this scope */
1397static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1398{
1399 struct available_var_finder *af = data;
1400 struct variable_list *vl;
1401 char buf[MAX_VAR_LEN];
1402 int tag, ret;
1403
1404 vl = &af->vls[af->nvls - 1];
1405
1406 tag = dwarf_tag(die_mem);
1407 if (tag == DW_TAG_formal_parameter ||
1408 tag == DW_TAG_variable) {
1409 ret = convert_variable_location(die_mem, af->pf.addr,
1410 af->pf.fb_ops, NULL);
1411 if (ret == 0) {
1412 ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
1413 pr_debug2("Add new var: %s\n", buf);
1414 if (ret > 0)
1415 strlist__add(vl->vars, buf);
1416 }
1417 }
1418
1419 if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1420 return DIE_FIND_CB_CONTINUE;
1421 else
1422 return DIE_FIND_CB_SIBLING;
1423}
1424
1425/* Add a found vars into available variables list */
1426static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
1427{
1428 struct available_var_finder *af =
1429 container_of(pf, struct available_var_finder, pf);
1430 struct variable_list *vl;
1431 Dwarf_Die die_mem, *scopes = NULL;
1432 int ret, nscopes;
1433
1434 /* Check number of tevs */
1435 if (af->nvls == af->max_vls) {
1436 pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1437 return -ERANGE;
1438 }
1439 vl = &af->vls[af->nvls++];
1440
1441 ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
1442 &vl->point);
1443 if (ret < 0)
1444 return ret;
1445
1446 pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1447 vl->point.offset);
1448
1449 /* Find local variables */
1450 vl->vars = strlist__new(true, NULL);
1451 if (vl->vars == NULL)
1452 return -ENOMEM;
1453 af->child = true;
1454 die_find_child(sp_die, collect_variables_cb, (void *)af, &die_mem);
1455
1456 /* Find external variables */
1457 if (!af->externs)
1458 goto out;
1459 /* Don't need to search child DIE for externs. */
1460 af->child = false;
1461 nscopes = dwarf_getscopes_die(sp_die, &scopes);
1462 while (nscopes-- > 1)
1463 die_find_child(&scopes[nscopes], collect_variables_cb,
1464 (void *)af, &die_mem);
1465 if (scopes)
1466 free(scopes);
1467
1468out:
1469 if (strlist__empty(vl->vars)) {
1470 strlist__delete(vl->vars);
1471 vl->vars = NULL;
1472 }
1473
1474 return ret;
1475}
1476
1477/* Find available variables at given probe point */
1478int find_available_vars_at(int fd, struct perf_probe_event *pev,
1479 struct variable_list **vls, int max_vls,
1480 bool externs)
1481{
1482 struct available_var_finder af = {
1483 .pf = {.pev = pev, .callback = add_available_vars},
1484 .max_vls = max_vls, .externs = externs};
1485 int ret;
1486
1487 /* Allocate result vls array */
1488 *vls = zalloc(sizeof(struct variable_list) * max_vls);
1489 if (*vls == NULL)
1490 return -ENOMEM;
1491
1492 af.vls = *vls;
1493 af.nvls = 0;
1494
1495 ret = find_probes(fd, &af.pf);
1496 if (ret < 0) {
1497 /* Free vlist for error */
1498 while (af.nvls--) {
1499 if (af.vls[af.nvls].point.symbol)
1500 free(af.vls[af.nvls].point.symbol);
1501 if (af.vls[af.nvls].vars)
1502 strlist__delete(af.vls[af.nvls].vars);
1503 }
1504 free(af.vls);
1505 *vls = NULL;
1506 return ret;
1507 }
1508
1509 return (ret < 0) ? ret : af.nvls;
1146} 1510}
1147 1511
1148/* Reverse search */ 1512/* Reverse search */
1149int find_perf_probe_point(int fd, unsigned long addr, 1513int find_perf_probe_point(unsigned long addr, struct perf_probe_point *ppt)
1150 struct perf_probe_point *ppt)
1151{ 1514{
1152 Dwarf_Die cudie, spdie, indie; 1515 Dwarf_Die cudie, spdie, indie;
1153 Dwarf *dbg; 1516 Dwarf *dbg = NULL;
1517 Dwfl *dwfl = NULL;
1154 Dwarf_Line *line; 1518 Dwarf_Line *line;
1155 Dwarf_Addr laddr, eaddr; 1519 Dwarf_Addr laddr, eaddr, bias = 0;
1156 const char *tmp; 1520 const char *tmp;
1157 int lineno, ret = 0; 1521 int lineno, ret = 0;
1158 bool found = false; 1522 bool found = false;
1159 1523
1160 dbg = dwarf_begin(fd, DWARF_C_READ); 1524 /* Open the live linux kernel */
1161 if (!dbg) 1525 dbg = dwfl_init_live_kernel_dwarf(addr, &dwfl, &bias);
1162 return -EBADF; 1526 if (!dbg) {
1527 pr_warning("No dwarf info found in the vmlinux - "
1528 "please rebuild with CONFIG_DEBUG_INFO=y.\n");
1529 ret = -EINVAL;
1530 goto end;
1531 }
1163 1532
1533 /* Adjust address with bias */
1534 addr += bias;
1164 /* Find cu die */ 1535 /* Find cu die */
1165 if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) { 1536 if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr - bias, &cudie)) {
1537 pr_warning("No CU DIE is found at %lx\n", addr);
1166 ret = -EINVAL; 1538 ret = -EINVAL;
1167 goto end; 1539 goto end;
1168 } 1540 }
@@ -1225,7 +1597,8 @@ found:
1225 } 1597 }
1226 1598
1227end: 1599end:
1228 dwarf_end(dbg); 1600 if (dwfl)
1601 dwfl_end(dwfl);
1229 if (ret >= 0) 1602 if (ret >= 0)
1230 ret = found ? 1 : 0; 1603 ret = found ? 1 : 0;
1231 return ret; 1604 return ret;
@@ -1358,6 +1731,8 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1358 struct line_finder *lf = param->data; 1731 struct line_finder *lf = param->data;
1359 struct line_range *lr = lf->lr; 1732 struct line_range *lr = lf->lr;
1360 1733
1734 pr_debug("find (%lx) %s\n", dwarf_dieoffset(sp_die),
1735 dwarf_diename(sp_die));
1361 if (dwarf_tag(sp_die) == DW_TAG_subprogram && 1736 if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
1362 die_compare_name(sp_die, lr->function)) { 1737 die_compare_name(sp_die, lr->function)) {
1363 lf->fname = dwarf_decl_file(sp_die); 1738 lf->fname = dwarf_decl_file(sp_die);
@@ -1401,10 +1776,12 @@ int find_line_range(int fd, struct line_range *lr)
1401 Dwarf_Off off = 0, noff; 1776 Dwarf_Off off = 0, noff;
1402 size_t cuhl; 1777 size_t cuhl;
1403 Dwarf_Die *diep; 1778 Dwarf_Die *diep;
1404 Dwarf *dbg; 1779 Dwarf *dbg = NULL;
1780 Dwfl *dwfl;
1781 Dwarf_Addr bias; /* Currently ignored */
1405 const char *comp_dir; 1782 const char *comp_dir;
1406 1783
1407 dbg = dwarf_begin(fd, DWARF_C_READ); 1784 dbg = dwfl_init_offline_dwarf(fd, &dwfl, &bias);
1408 if (!dbg) { 1785 if (!dbg) {
1409 pr_warning("No dwarf info found in the vmlinux - " 1786 pr_warning("No dwarf info found in the vmlinux - "
1410 "please rebuild with CONFIG_DEBUG_INFO=y.\n"); 1787 "please rebuild with CONFIG_DEBUG_INFO=y.\n");
@@ -1450,8 +1827,7 @@ int find_line_range(int fd, struct line_range *lr)
1450 } 1827 }
1451 1828
1452 pr_debug("path: %s\n", lr->path); 1829 pr_debug("path: %s\n", lr->path);
1453 dwarf_end(dbg); 1830 dwfl_end(dwfl);
1454
1455 return (ret < 0) ? ret : lf.found; 1831 return (ret < 0) ? ret : lf.found;
1456} 1832}
1457 1833
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 4507d519f183..bba69d455699 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -22,20 +22,27 @@ extern int find_probe_trace_events(int fd, struct perf_probe_event *pev,
22 int max_tevs); 22 int max_tevs);
23 23
24/* Find a perf_probe_point from debuginfo */ 24/* Find a perf_probe_point from debuginfo */
25extern int find_perf_probe_point(int fd, unsigned long addr, 25extern int find_perf_probe_point(unsigned long addr,
26 struct perf_probe_point *ppt); 26 struct perf_probe_point *ppt);
27 27
28/* Find a line range */
28extern int find_line_range(int fd, struct line_range *lr); 29extern int find_line_range(int fd, struct line_range *lr);
29 30
31/* Find available variables */
32extern int find_available_vars_at(int fd, struct perf_probe_event *pev,
33 struct variable_list **vls, int max_points,
34 bool externs);
35
30#include <dwarf.h> 36#include <dwarf.h>
31#include <libdw.h> 37#include <libdw.h>
38#include <libdwfl.h>
32#include <version.h> 39#include <version.h>
33 40
34struct probe_finder { 41struct probe_finder {
35 struct perf_probe_event *pev; /* Target probe event */ 42 struct perf_probe_event *pev; /* Target probe event */
36 struct probe_trace_event *tevs; /* Result trace events */ 43
37 int ntevs; /* Number of trace events */ 44 /* Callback when a probe point is found */
38 int max_tevs; /* Max number of trace events */ 45 int (*callback)(Dwarf_Die *sp_die, struct probe_finder *pf);
39 46
40 /* For function searching */ 47 /* For function searching */
41 int lno; /* Line number */ 48 int lno; /* Line number */
@@ -53,6 +60,22 @@ struct probe_finder {
53 struct probe_trace_arg *tvar; /* Current result variable */ 60 struct probe_trace_arg *tvar; /* Current result variable */
54}; 61};
55 62
63struct trace_event_finder {
64 struct probe_finder pf;
65 struct probe_trace_event *tevs; /* Found trace events */
66 int ntevs; /* Number of trace events */
67 int max_tevs; /* Max number of trace events */
68};
69
70struct available_var_finder {
71 struct probe_finder pf;
72 struct variable_list *vls; /* Found variable lists */
73 int nvls; /* Number of variable lists */
74 int max_vls; /* Max no. of variable lists */
75 bool externs; /* Find external vars too */
76 bool child; /* Search child scopes */
77};
78
56struct line_finder { 79struct line_finder {
57 struct line_range *lr; /* Target line range */ 80 struct line_range *lr; /* Target line range */
58 81
diff --git a/tools/perf/util/ui/browser.c b/tools/perf/util/ui/browser.c
index 6d0df809a2ed..8bc010edca25 100644
--- a/tools/perf/util/ui/browser.c
+++ b/tools/perf/util/ui/browser.c
@@ -1,4 +1,3 @@
1#include <slang.h>
2#include "libslang.h" 1#include "libslang.h"
3#include <linux/compiler.h> 2#include <linux/compiler.h>
4#include <linux/list.h> 3#include <linux/list.h>
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-02 19:48:18 -0500