blob: 5995d81d2badaf94f179639978997827fba4739b [file] [log] [blame]
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001/*
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302 * probe-event.c : perf-probe definition to probe_events format converter
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05003 *
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
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050022#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 <stdlib.h>
30#include <string.h>
Masami Hiramatsu4de189f2009-11-30 19:20:17 -050031#include <stdarg.h>
32#include <limits.h>
Masami Hiramatsue80711c2011-01-13 21:46:11 +090033#include <elf.h>
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050034
Masami Hiramatsu31facc52010-03-16 18:05:30 -040035#include "util.h"
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050036#include "event.h"
Masami Hiramatsu4de189f2009-11-30 19:20:17 -050037#include "strlist.h"
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050038#include "debug.h"
Masami Hiramatsu72041332010-01-05 17:47:10 -050039#include "cache.h"
Masami Hiramatsu631c9de2010-01-06 09:45:34 -050040#include "color.h"
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -040041#include "symbol.h"
42#include "thread.h"
Borislav Petkov553873e2013-12-09 17:14:23 +010043#include <api/fs/debugfs.h>
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -050044#include <api/fs/tracefs.h>
Irina Tirdea1d037ca2012-09-11 01:15:03 +030045#include "trace-event.h" /* For __maybe_unused */
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050046#include "probe-event.h"
Masami Hiramatsu4235b042010-03-16 18:06:12 -040047#include "probe-finder.h"
Srikar Dronamraju225466f2012-04-16 17:39:09 +053048#include "session.h"
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050049
50#define MAX_CMDLEN 256
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050051#define PERFPROBE_GROUP "probe"
52
Masami Hiramatsuf4d7da42010-03-16 18:06:05 -040053bool probe_event_dry_run; /* Dry run flag */
54
Masami Hiramatsu146a1432010-04-12 13:17:42 -040055#define semantic_error(msg ...) pr_err("Semantic error :" msg)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -050056
Masami Hiramatsu4de189f2009-11-30 19:20:17 -050057/* If there is no space to write, returns -E2BIG. */
58static int e_snprintf(char *str, size_t size, const char *format, ...)
Masami Hiramatsu84988452009-12-07 12:00:53 -050059 __attribute__((format(printf, 3, 4)));
60
61static int e_snprintf(char *str, size_t size, const char *format, ...)
Masami Hiramatsu4de189f2009-11-30 19:20:17 -050062{
63 int ret;
64 va_list ap;
65 va_start(ap, format);
66 ret = vsnprintf(str, size, format, ap);
67 va_end(ap);
68 if (ret >= (int)size)
69 ret = -E2BIG;
70 return ret;
71}
72
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -030073static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
Masami Hiramatsu981d05a2014-01-16 09:39:44 +000074static void clear_probe_trace_event(struct probe_trace_event *tev);
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +000075static struct machine *host_machine;
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -040076
Masami Hiramatsu469b9b82010-10-21 19:13:41 +090077/* Initialize symbol maps and path of vmlinux/modules */
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +000078static int init_symbol_maps(bool user_only)
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -040079{
Masami Hiramatsu146a1432010-04-12 13:17:42 -040080 int ret;
81
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -040082 symbol_conf.sort_by_name = true;
Namhyung Kim680d9262015-03-06 16:31:27 +090083 symbol_conf.allow_aliases = true;
Namhyung Kim0a7e6d12014-08-12 15:40:45 +090084 ret = symbol__init(NULL);
Masami Hiramatsu146a1432010-04-12 13:17:42 -040085 if (ret < 0) {
86 pr_debug("Failed to init symbol map.\n");
87 goto out;
88 }
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -040089
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +000090 if (host_machine || user_only) /* already initialized */
91 return 0;
Arnaldo Carvalho de Melod28c6222010-04-27 21:20:43 -030092
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +000093 if (symbol_conf.vmlinux_name)
94 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
95
96 host_machine = machine__new_host();
97 if (!host_machine) {
98 pr_debug("machine__new_host() failed.\n");
99 symbol__exit();
100 ret = -1;
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900101 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400102out:
103 if (ret < 0)
104 pr_warning("Failed to init vmlinux path.\n");
105 return ret;
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -0400106}
107
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000108static void exit_symbol_maps(void)
109{
110 if (host_machine) {
111 machine__delete(host_machine);
112 host_machine = NULL;
113 }
114 symbol__exit();
115}
116
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900117static struct symbol *__find_kernel_function_by_name(const char *name,
118 struct map **mapp)
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -0400119{
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000120 return machine__find_kernel_function_by_name(host_machine, name, mapp,
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900121 NULL);
122}
123
Masami Hiramatsu8f33f7d2014-02-06 05:32:20 +0000124static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
125{
126 return machine__find_kernel_function(host_machine, addr, mapp, NULL);
127}
128
129static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
130{
131 /* kmap->ref_reloc_sym should be set if host_machine is initialized */
132 struct kmap *kmap;
133
134 if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
135 return NULL;
136
137 kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
Wang Nanba927322015-04-07 08:22:45 +0000138 if (!kmap)
139 return NULL;
Masami Hiramatsu8f33f7d2014-02-06 05:32:20 +0000140 return kmap->ref_reloc_sym;
141}
142
143static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
144{
145 struct ref_reloc_sym *reloc_sym;
146 struct symbol *sym;
147 struct map *map;
148
149 /* ref_reloc_sym is just a label. Need a special fix*/
150 reloc_sym = kernel_get_ref_reloc_sym();
151 if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
152 return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
153 else {
154 sym = __find_kernel_function_by_name(name, &map);
155 if (sym)
156 return map->unmap_ip(map, sym->start) -
He Kuangf56847c2015-02-27 18:52:53 +0800157 ((reloc) ? 0 : map->reloc);
Masami Hiramatsu8f33f7d2014-02-06 05:32:20 +0000158 }
159 return 0;
160}
161
Masami Hiramatsue80711c2011-01-13 21:46:11 +0900162static struct map *kernel_get_module_map(const char *module)
163{
164 struct rb_node *nd;
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000165 struct map_groups *grp = &host_machine->kmaps;
Masami Hiramatsue80711c2011-01-13 21:46:11 +0900166
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900167 /* A file path -- this is an offline module */
168 if (module && strchr(module, '/'))
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000169 return machine__new_module(host_machine, 0, module);
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900170
Masami Hiramatsue80711c2011-01-13 21:46:11 +0900171 if (!module)
172 module = "kernel";
173
174 for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
175 struct map *pos = rb_entry(nd, struct map, rb_node);
176 if (strncmp(pos->dso->short_name + 1, module,
177 pos->dso->short_name_len - 2) == 0) {
178 return pos;
179 }
180 }
181 return NULL;
182}
183
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900184static struct map *get_target_map(const char *target, bool user)
185{
186 /* Init maps of given executable or kernel */
187 if (user)
188 return dso__new_map(target);
189 else
190 return kernel_get_module_map(target);
191}
192
193static void put_target_map(struct map *map, bool user)
194{
195 if (map && user) {
196 /* Only the user map needs to be released */
197 dso__delete(map->dso);
198 map__delete(map);
199 }
200}
201
202
Masami Hiramatsue80711c2011-01-13 21:46:11 +0900203static struct dso *kernel_get_module_dso(const char *module)
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900204{
205 struct dso *dso;
Franck Bui-Huufd930ff2010-12-10 14:06:03 +0100206 struct map *map;
207 const char *vmlinux_name;
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900208
209 if (module) {
Waiman Long8fa7d872014-09-29 16:07:28 -0400210 list_for_each_entry(dso, &host_machine->kernel_dsos.head,
211 node) {
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900212 if (strncmp(dso->short_name + 1, module,
213 dso->short_name_len - 2) == 0)
214 goto found;
215 }
216 pr_debug("Failed to find module %s.\n", module);
217 return NULL;
Franck Bui-Huufd930ff2010-12-10 14:06:03 +0100218 }
219
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000220 map = host_machine->vmlinux_maps[MAP__FUNCTION];
Franck Bui-Huufd930ff2010-12-10 14:06:03 +0100221 dso = map->dso;
222
223 vmlinux_name = symbol_conf.vmlinux_name;
224 if (vmlinux_name) {
Arnaldo Carvalho de Melo5230fb72013-12-10 11:58:52 -0300225 if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
Franck Bui-Huufd930ff2010-12-10 14:06:03 +0100226 return NULL;
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900227 } else {
Franck Bui-Huuc3a34e02010-12-10 14:07:14 +0100228 if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900229 pr_debug("Failed to load kernel map.\n");
230 return NULL;
231 }
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -0400232 }
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900233found:
Masami Hiramatsue80711c2011-01-13 21:46:11 +0900234 return dso;
235}
236
237const char *kernel_get_module_path(const char *module)
238{
239 struct dso *dso = kernel_get_module_dso(module);
240 return (dso) ? dso->long_name : NULL;
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900241}
242
Masami Hiramatsufb7345b2013-12-26 05:41:53 +0000243static int convert_exec_to_group(const char *exec, char **result)
244{
245 char *ptr1, *ptr2, *exec_copy;
246 char buf[64];
247 int ret;
248
249 exec_copy = strdup(exec);
250 if (!exec_copy)
251 return -ENOMEM;
252
253 ptr1 = basename(exec_copy);
254 if (!ptr1) {
255 ret = -EINVAL;
256 goto out;
257 }
258
259 ptr2 = strpbrk(ptr1, "-._");
260 if (ptr2)
261 *ptr2 = '\0';
262 ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
263 if (ret < 0)
264 goto out;
265
266 *result = strdup(buf);
267 ret = *result ? 0 : -ENOMEM;
268
269out:
270 free(exec_copy);
271 return ret;
272}
273
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900274static void clear_perf_probe_point(struct perf_probe_point *pp)
275{
276 free(pp->file);
277 free(pp->function);
278 free(pp->lazy_line);
279}
280
Masami Hiramatsueb948e52014-02-06 05:32:25 +0000281static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
282{
283 int i;
284
285 for (i = 0; i < ntevs; i++)
286 clear_probe_trace_event(tevs + i);
287}
288
Ingo Molnar89fe8082013-09-30 12:07:11 +0200289#ifdef HAVE_DWARF_SUPPORT
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900290/*
291 * Some binaries like glibc have special symbols which are on the symbol
292 * table, but not in the debuginfo. If we can find the address of the
293 * symbol from map, we can translate the address back to the probe point.
294 */
295static int find_alternative_probe_point(struct debuginfo *dinfo,
296 struct perf_probe_point *pp,
297 struct perf_probe_point *result,
298 const char *target, bool uprobes)
299{
300 struct map *map = NULL;
301 struct symbol *sym;
302 u64 address = 0;
303 int ret = -ENOENT;
304
305 /* This can work only for function-name based one */
306 if (!pp->function || pp->file)
307 return -ENOTSUP;
308
309 map = get_target_map(target, uprobes);
310 if (!map)
311 return -EINVAL;
312
313 /* Find the address of given function */
314 map__for_each_symbol_by_name(map, pp->function, sym) {
Masami Hiramatsue6d7c912015-03-22 20:40:22 +0900315 if (uprobes)
316 address = sym->start;
317 else
318 address = map->unmap_ip(map, sym->start);
Namhyung Kime578da32015-03-06 16:31:29 +0900319 break;
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900320 }
321 if (!address) {
322 ret = -ENOENT;
323 goto out;
324 }
Wang Nanf6c15622015-04-08 02:14:34 +0000325 pr_debug("Symbol %s address found : %" PRIx64 "\n",
326 pp->function, address);
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900327
328 ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
329 result);
330 if (ret <= 0)
331 ret = (!ret) ? -ENOENT : ret;
332 else {
333 result->offset += pp->offset;
334 result->line += pp->line;
He Kuang9d7b45c2015-04-13 19:41:28 +0800335 result->retprobe = pp->retprobe;
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900336 ret = 0;
337 }
338
339out:
340 put_target_map(map, uprobes);
341 return ret;
342
343}
344
345static int get_alternative_probe_event(struct debuginfo *dinfo,
346 struct perf_probe_event *pev,
347 struct perf_probe_point *tmp,
348 const char *target)
349{
350 int ret;
351
352 memcpy(tmp, &pev->point, sizeof(*tmp));
353 memset(&pev->point, 0, sizeof(pev->point));
354 ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
355 target, pev->uprobes);
356 if (ret < 0)
357 memcpy(&pev->point, tmp, sizeof(*tmp));
358
359 return ret;
360}
Masami Hiramatsua15ad2f2014-02-06 05:32:27 +0000361
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900362static int get_alternative_line_range(struct debuginfo *dinfo,
363 struct line_range *lr,
364 const char *target, bool user)
365{
David Ahern6d4a4892015-03-11 10:36:20 -0400366 struct perf_probe_point pp = { .function = lr->function,
367 .file = lr->file,
368 .line = lr->start };
369 struct perf_probe_point result;
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900370 int ret, len = 0;
371
David Ahern6d4a4892015-03-11 10:36:20 -0400372 memset(&result, 0, sizeof(result));
373
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900374 if (lr->end != INT_MAX)
375 len = lr->end - lr->start;
376 ret = find_alternative_probe_point(dinfo, &pp, &result,
377 target, user);
378 if (!ret) {
379 lr->function = result.function;
380 lr->file = result.file;
381 lr->start = result.line;
382 if (lr->end != INT_MAX)
383 lr->end = lr->start + len;
384 clear_perf_probe_point(&pp);
385 }
386 return ret;
387}
388
Masami Hiramatsuff741782011-06-27 16:27:39 +0900389/* Open new debuginfo of given module */
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000390static struct debuginfo *open_debuginfo(const char *module, bool silent)
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900391{
Masami Hiramatsua15ad2f2014-02-06 05:32:27 +0000392 const char *path = module;
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000393 struct debuginfo *ret;
Masami Hiramatsuff741782011-06-27 16:27:39 +0900394
Masami Hiramatsua15ad2f2014-02-06 05:32:27 +0000395 if (!module || !strchr(module, '/')) {
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900396 path = kernel_get_module_path(module);
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900397 if (!path) {
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000398 if (!silent)
399 pr_err("Failed to find path of %s module.\n",
400 module ?: "kernel");
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900401 return NULL;
402 }
Masami Hiramatsu469b9b82010-10-21 19:13:41 +0900403 }
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000404 ret = debuginfo__new(path);
405 if (!ret && !silent) {
406 pr_warning("The %s file has no debug information.\n", path);
407 if (!module || !strtailcmp(path, ".ko"))
408 pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
409 else
410 pr_warning("Rebuild with -g, ");
411 pr_warning("or install an appropriate debuginfo package.\n");
412 }
413 return ret;
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -0400414}
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300415
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000416
Masami Hiramatsu99ca4232014-01-16 09:39:49 +0000417static int get_text_start_address(const char *exec, unsigned long *address)
418{
419 Elf *elf;
420 GElf_Ehdr ehdr;
421 GElf_Shdr shdr;
422 int fd, ret = -ENOENT;
423
424 fd = open(exec, O_RDONLY);
425 if (fd < 0)
426 return -errno;
427
428 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
429 if (elf == NULL)
430 return -EINVAL;
431
432 if (gelf_getehdr(elf, &ehdr) == NULL)
433 goto out;
434
435 if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
436 goto out;
437
438 *address = shdr.sh_addr - shdr.sh_offset;
439 ret = 0;
440out:
441 elf_end(elf);
442 return ret;
443}
444
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000445/*
446 * Convert trace point to probe point with debuginfo
447 */
448static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
449 struct perf_probe_point *pp,
450 bool is_kprobe)
451{
452 struct debuginfo *dinfo = NULL;
453 unsigned long stext = 0;
454 u64 addr = tp->address;
455 int ret = -ENOENT;
456
457 /* convert the address to dwarf address */
458 if (!is_kprobe) {
459 if (!addr) {
460 ret = -EINVAL;
461 goto error;
462 }
463 ret = get_text_start_address(tp->module, &stext);
464 if (ret < 0)
465 goto error;
466 addr += stext;
467 } else {
468 addr = kernel_get_symbol_address_by_name(tp->symbol, false);
469 if (addr == 0)
470 goto error;
471 addr += tp->offset;
472 }
473
474 pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
475 tp->module ? : "kernel");
476
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000477 dinfo = open_debuginfo(tp->module, verbose == 0);
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000478 if (dinfo) {
479 ret = debuginfo__find_probe_point(dinfo,
480 (unsigned long)addr, pp);
481 debuginfo__delete(dinfo);
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000482 } else
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000483 ret = -ENOENT;
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000484
485 if (ret > 0) {
486 pp->retprobe = tp->retprobe;
487 return 0;
488 }
489error:
490 pr_debug("Failed to find corresponding probes from debuginfo.\n");
491 return ret ? : -ENOENT;
492}
493
Masami Hiramatsufb7345b2013-12-26 05:41:53 +0000494static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
495 int ntevs, const char *exec)
496{
497 int i, ret = 0;
Masami Hiramatsueb948e52014-02-06 05:32:25 +0000498 unsigned long stext = 0;
Masami Hiramatsufb7345b2013-12-26 05:41:53 +0000499
500 if (!exec)
501 return 0;
502
503 ret = get_text_start_address(exec, &stext);
504 if (ret < 0)
505 return ret;
506
507 for (i = 0; i < ntevs && ret >= 0; i++) {
Masami Hiramatsu981a2372014-02-05 05:18:58 +0000508 /* point.address is the addres of point.symbol + point.offset */
Masami Hiramatsueb948e52014-02-06 05:32:25 +0000509 tevs[i].point.address -= stext;
Masami Hiramatsufb7345b2013-12-26 05:41:53 +0000510 tevs[i].point.module = strdup(exec);
Masami Hiramatsueb948e52014-02-06 05:32:25 +0000511 if (!tevs[i].point.module) {
Masami Hiramatsufb7345b2013-12-26 05:41:53 +0000512 ret = -ENOMEM;
513 break;
514 }
515 tevs[i].uprobes = true;
516 }
517
518 return ret;
519}
520
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900521static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
522 int ntevs, const char *module)
523{
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900524 int i, ret = 0;
525 char *tmp;
526
527 if (!module)
528 return 0;
529
530 tmp = strrchr(module, '/');
531 if (tmp) {
532 /* This is a module path -- get the module name */
533 module = strdup(tmp + 1);
534 if (!module)
535 return -ENOMEM;
536 tmp = strchr(module, '.');
537 if (tmp)
538 *tmp = '\0';
539 tmp = (char *)module; /* For free() */
540 }
541
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900542 for (i = 0; i < ntevs; i++) {
543 tevs[i].point.module = strdup(module);
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900544 if (!tevs[i].point.module) {
545 ret = -ENOMEM;
546 break;
547 }
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900548 }
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900549
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -0300550 free(tmp);
Masami Hiramatsu14a8fd72011-06-27 16:27:51 +0900551 return ret;
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900552}
553
Masami Hiramatsudfef99c2014-02-06 05:32:16 +0000554/* Post processing the probe events */
555static int post_process_probe_trace_events(struct probe_trace_event *tevs,
556 int ntevs, const char *module,
557 bool uprobe)
558{
559 struct ref_reloc_sym *reloc_sym;
560 char *tmp;
561 int i;
562
563 if (uprobe)
564 return add_exec_to_probe_trace_events(tevs, ntevs, module);
565
566 /* Note that currently ref_reloc_sym based probe is not for drivers */
567 if (module)
568 return add_module_to_probe_trace_events(tevs, ntevs, module);
569
Masami Hiramatsu8f33f7d2014-02-06 05:32:20 +0000570 reloc_sym = kernel_get_ref_reloc_sym();
Masami Hiramatsudfef99c2014-02-06 05:32:16 +0000571 if (!reloc_sym) {
572 pr_warning("Relocated base symbol is not found!\n");
573 return -EINVAL;
574 }
575
576 for (i = 0; i < ntevs; i++) {
Namhyung Kim25dd9172015-01-14 20:18:08 +0900577 if (tevs[i].point.address && !tevs[i].point.retprobe) {
Masami Hiramatsudfef99c2014-02-06 05:32:16 +0000578 tmp = strdup(reloc_sym->name);
579 if (!tmp)
580 return -ENOMEM;
581 free(tevs[i].point.symbol);
582 tevs[i].point.symbol = tmp;
583 tevs[i].point.offset = tevs[i].point.address -
584 reloc_sym->unrelocated_addr;
585 }
586 }
587 return 0;
588}
589
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300590/* Try to find perf_probe_event with debuginfo */
Srikar Dronamraju0e608362010-07-29 19:43:51 +0530591static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900592 struct probe_trace_event **tevs,
Srikar Dronamraju4eced232012-02-02 19:50:40 +0530593 int max_tevs, const char *target)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300594{
595 bool need_dwarf = perf_probe_event_need_dwarf(pev);
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900596 struct perf_probe_point tmp;
Srikar Dronamraju225466f2012-04-16 17:39:09 +0530597 struct debuginfo *dinfo;
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900598 int ntevs, ret = 0;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300599
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000600 dinfo = open_debuginfo(target, !need_dwarf);
Srikar Dronamraju225466f2012-04-16 17:39:09 +0530601
Masami Hiramatsuff741782011-06-27 16:27:39 +0900602 if (!dinfo) {
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000603 if (need_dwarf)
Masami Hiramatsuff741782011-06-27 16:27:39 +0900604 return -ENOENT;
Masami Hiramatsuff741782011-06-27 16:27:39 +0900605 pr_debug("Could not open debuginfo. Try to use symbols.\n");
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300606 return 0;
607 }
608
Masami Hiramatsudfef99c2014-02-06 05:32:16 +0000609 pr_debug("Try to find probe point from debuginfo.\n");
Masami Hiramatsuff741782011-06-27 16:27:39 +0900610 /* Searching trace events corresponding to a probe event */
611 ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
612
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900613 if (ntevs == 0) { /* Not found, retry with an alternative */
614 ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
615 if (!ret) {
616 ntevs = debuginfo__find_trace_events(dinfo, pev,
617 tevs, max_tevs);
618 /*
619 * Write back to the original probe_event for
620 * setting appropriate (user given) event name
621 */
622 clear_perf_probe_point(&pev->point);
623 memcpy(&pev->point, &tmp, sizeof(tmp));
624 }
625 }
626
Masami Hiramatsuff741782011-06-27 16:27:39 +0900627 debuginfo__delete(dinfo);
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300628
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400629 if (ntevs > 0) { /* Succeeded to find trace events */
Masami Hiramatsudfef99c2014-02-06 05:32:16 +0000630 pr_debug("Found %d probe_trace_events.\n", ntevs);
631 ret = post_process_probe_trace_events(*tevs, ntevs,
632 target, pev->uprobes);
Masami Hiramatsu981d05a2014-01-16 09:39:44 +0000633 if (ret < 0) {
634 clear_probe_trace_events(*tevs, ntevs);
635 zfree(tevs);
636 }
Masami Hiramatsu190b57f2011-06-27 16:27:45 +0900637 return ret < 0 ? ret : ntevs;
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400638 }
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300639
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400640 if (ntevs == 0) { /* No error but failed to find probe point. */
Masami Hiramatsu0687eba2015-03-06 16:31:25 +0900641 pr_warning("Probe point '%s' not found.\n",
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400642 synthesize_perf_probe_point(&pev->point));
Masami Hiramatsu0687eba2015-03-06 16:31:25 +0900643 return -ENOENT;
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400644 }
645 /* Error path : ntevs < 0 */
Masami Hiramatsu15eca302010-04-21 15:56:24 -0400646 pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
647 if (ntevs == -EBADF) {
648 pr_warning("Warning: No dwarf info found in the vmlinux - "
649 "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
650 if (!need_dwarf) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +0900651 pr_debug("Trying to use symbols.\n");
Masami Hiramatsu15eca302010-04-21 15:56:24 -0400652 return 0;
653 }
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300654 }
Masami Hiramatsu15eca302010-04-21 15:56:24 -0400655 return ntevs;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300656}
657
658#define LINEBUF_SIZE 256
659#define NR_ADDITIONAL_LINES 2
660
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100661static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300662{
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +0000663 char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
Franck Bui-Huubefe3412010-12-20 15:18:01 +0100664 const char *color = show_num ? "" : PERF_COLOR_BLUE;
665 const char *prefix = NULL;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300666
Franck Bui-Huubefe3412010-12-20 15:18:01 +0100667 do {
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300668 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
669 goto error;
Franck Bui-Huubefe3412010-12-20 15:18:01 +0100670 if (skip)
671 continue;
672 if (!prefix) {
673 prefix = show_num ? "%7d " : " ";
674 color_fprintf(stdout, color, prefix, l);
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300675 }
Franck Bui-Huubefe3412010-12-20 15:18:01 +0100676 color_fprintf(stdout, color, "%s", buf);
677
678 } while (strchr(buf, '\n') == NULL);
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400679
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100680 return 1;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300681error:
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100682 if (ferror(fp)) {
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +0000683 pr_warning("File read error: %s\n",
684 strerror_r(errno, sbuf, sizeof(sbuf)));
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100685 return -1;
686 }
687 return 0;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300688}
689
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100690static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
691{
692 int rv = __show_one_line(fp, l, skip, show_num);
693 if (rv == 0) {
694 pr_warning("Source file is shorter than expected.\n");
695 rv = -1;
696 }
697 return rv;
698}
699
700#define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)
701#define show_one_line(f,l) _show_one_line(f,l,false,false)
702#define skip_one_line(f,l) _show_one_line(f,l,true,false)
703#define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)
704
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300705/*
706 * Show line-range always requires debuginfo to find source file and
707 * line number.
708 */
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900709static int __show_line_range(struct line_range *lr, const char *module,
710 bool user)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300711{
Masami Hiramatsud3b63d72010-04-14 18:39:42 -0400712 int l = 1;
Masami Hiramatsu5a622572014-02-06 05:32:09 +0000713 struct int_node *ln;
Masami Hiramatsuff741782011-06-27 16:27:39 +0900714 struct debuginfo *dinfo;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300715 FILE *fp;
Masami Hiramatsuff741782011-06-27 16:27:39 +0900716 int ret;
Masami Hiramatsu7cf0b792010-07-09 18:28:59 +0900717 char *tmp;
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +0000718 char sbuf[STRERR_BUFSIZE];
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300719
720 /* Search a line range */
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000721 dinfo = open_debuginfo(module, false);
722 if (!dinfo)
Masami Hiramatsuff741782011-06-27 16:27:39 +0900723 return -ENOENT;
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400724
Masami Hiramatsuff741782011-06-27 16:27:39 +0900725 ret = debuginfo__find_line_range(dinfo, lr);
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900726 if (!ret) { /* Not found, retry with an alternative */
727 ret = get_alternative_line_range(dinfo, lr, module, user);
728 if (!ret)
729 ret = debuginfo__find_line_range(dinfo, lr);
730 }
Masami Hiramatsuff741782011-06-27 16:27:39 +0900731 debuginfo__delete(dinfo);
Masami Hiramatsu5ee05b82014-06-06 07:14:06 +0000732 if (ret == 0 || ret == -ENOENT) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400733 pr_warning("Specified source line is not found.\n");
734 return -ENOENT;
735 } else if (ret < 0) {
Masami Hiramatsu5ee05b82014-06-06 07:14:06 +0000736 pr_warning("Debuginfo analysis failed.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400737 return ret;
738 }
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300739
Masami Hiramatsu7cf0b792010-07-09 18:28:59 +0900740 /* Convert source file path */
741 tmp = lr->path;
Masami Hiramatsu6a330a32010-07-09 18:29:11 +0900742 ret = get_real_path(tmp, lr->comp_dir, &lr->path);
He Kuanga78604d2015-03-04 18:01:42 +0800743
744 /* Free old path when new path is assigned */
745 if (tmp != lr->path)
746 free(tmp);
747
Masami Hiramatsu7cf0b792010-07-09 18:28:59 +0900748 if (ret < 0) {
Masami Hiramatsu5ee05b82014-06-06 07:14:06 +0000749 pr_warning("Failed to find source file path.\n");
Masami Hiramatsu7cf0b792010-07-09 18:28:59 +0900750 return ret;
751 }
752
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300753 setup_pager();
754
755 if (lr->function)
Masami Hiramatsu8737ebd2011-02-10 18:08:16 +0900756 fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300757 lr->start - lr->offset);
758 else
Franck Bui-Huu62c15fc2010-12-20 15:18:00 +0100759 fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300760
761 fp = fopen(lr->path, "r");
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400762 if (fp == NULL) {
763 pr_warning("Failed to open %s: %s\n", lr->path,
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +0000764 strerror_r(errno, sbuf, sizeof(sbuf)));
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400765 return -errno;
766 }
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300767 /* Skip to starting line number */
Franck Bui-Huu44b81e92010-12-20 15:18:02 +0100768 while (l < lr->start) {
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100769 ret = skip_one_line(fp, l++);
Franck Bui-Huu44b81e92010-12-20 15:18:02 +0100770 if (ret < 0)
771 goto end;
772 }
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300773
Masami Hiramatsu5a622572014-02-06 05:32:09 +0000774 intlist__for_each(ln, lr->line_list) {
775 for (; ln->i > l; l++) {
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100776 ret = show_one_line(fp, l - lr->offset);
Franck Bui-Huu44b81e92010-12-20 15:18:02 +0100777 if (ret < 0)
778 goto end;
779 }
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100780 ret = show_one_line_with_num(fp, l++ - lr->offset);
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400781 if (ret < 0)
782 goto end;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300783 }
784
785 if (lr->end == INT_MAX)
786 lr->end = l + NR_ADDITIONAL_LINES;
Franck Bui-Huufde52db2010-12-20 15:18:04 +0100787 while (l <= lr->end) {
788 ret = show_one_line_or_eof(fp, l++ - lr->offset);
789 if (ret <= 0)
Franck Bui-Huu44b81e92010-12-20 15:18:02 +0100790 break;
791 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400792end:
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300793 fclose(fp);
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400794 return ret;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300795}
796
Masami Hiramatsu2b394bc2014-09-17 08:40:54 +0000797int show_line_range(struct line_range *lr, const char *module, bool user)
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000798{
799 int ret;
800
Masami Hiramatsu2b394bc2014-09-17 08:40:54 +0000801 ret = init_symbol_maps(user);
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000802 if (ret < 0)
803 return ret;
Masami Hiramatsu811dd2a2015-03-06 16:31:22 +0900804 ret = __show_line_range(lr, module, user);
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000805 exit_symbol_maps();
806
807 return ret;
808}
809
Masami Hiramatsuff741782011-06-27 16:27:39 +0900810static int show_available_vars_at(struct debuginfo *dinfo,
811 struct perf_probe_event *pev,
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900812 int max_vls, struct strfilter *_filter,
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900813 bool externs, const char *target)
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900814{
815 char *buf;
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900816 int ret, i, nvars;
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900817 struct str_node *node;
818 struct variable_list *vls = NULL, *vl;
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900819 struct perf_probe_point tmp;
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900820 const char *var;
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900821
822 buf = synthesize_perf_probe_point(&pev->point);
823 if (!buf)
824 return -EINVAL;
825 pr_debug("Searching variables at %s\n", buf);
826
Masami Hiramatsuff741782011-06-27 16:27:39 +0900827 ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
828 max_vls, externs);
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900829 if (!ret) { /* Not found, retry with an alternative */
830 ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
831 if (!ret) {
832 ret = debuginfo__find_available_vars_at(dinfo, pev,
833 &vls, max_vls, externs);
834 /* Release the old probe_point */
835 clear_perf_probe_point(&tmp);
836 }
837 }
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900838 if (ret <= 0) {
Masami Hiramatsu69e96ea2014-06-06 07:13:59 +0000839 if (ret == 0 || ret == -ENOENT) {
840 pr_err("Failed to find the address of %s\n", buf);
841 ret = -ENOENT;
842 } else
843 pr_warning("Debuginfo analysis failed.\n");
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900844 goto end;
845 }
Masami Hiramatsu69e96ea2014-06-06 07:13:59 +0000846
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900847 /* Some variables are found */
848 fprintf(stdout, "Available variables at %s\n", buf);
849 for (i = 0; i < ret; i++) {
850 vl = &vls[i];
851 /*
852 * A probe point might be converted to
853 * several trace points.
854 */
855 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
856 vl->point.offset);
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300857 zfree(&vl->point.symbol);
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900858 nvars = 0;
859 if (vl->vars) {
860 strlist__for_each(node, vl->vars) {
861 var = strchr(node->s, '\t') + 1;
862 if (strfilter__compare(_filter, var)) {
863 fprintf(stdout, "\t\t%s\n", node->s);
864 nvars++;
865 }
866 }
867 strlist__delete(vl->vars);
868 }
869 if (nvars == 0)
870 fprintf(stdout, "\t\t(No matched variables)\n");
871 }
872 free(vls);
873end:
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900874 free(buf);
875 return ret;
876}
877
878/* Show available variables on given probe point */
879int show_available_vars(struct perf_probe_event *pevs, int npevs,
Masami Hiramatsubd09d7b2011-01-20 23:15:39 +0900880 int max_vls, const char *module,
881 struct strfilter *_filter, bool externs)
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900882{
Masami Hiramatsuff741782011-06-27 16:27:39 +0900883 int i, ret = 0;
884 struct debuginfo *dinfo;
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900885
Masami Hiramatsu2b394bc2014-09-17 08:40:54 +0000886 ret = init_symbol_maps(pevs->uprobes);
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900887 if (ret < 0)
888 return ret;
889
Masami Hiramatsu92561cb2014-08-15 01:44:32 +0000890 dinfo = open_debuginfo(module, false);
Masami Hiramatsuff741782011-06-27 16:27:39 +0900891 if (!dinfo) {
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000892 ret = -ENOENT;
893 goto out;
Masami Hiramatsuff741782011-06-27 16:27:39 +0900894 }
895
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900896 setup_pager();
897
Masami Hiramatsuff741782011-06-27 16:27:39 +0900898 for (i = 0; i < npevs && ret >= 0; i++)
899 ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +0900900 externs, module);
Masami Hiramatsuff741782011-06-27 16:27:39 +0900901
902 debuginfo__delete(dinfo);
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +0000903out:
904 exit_symbol_maps();
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900905 return ret;
906}
907
Ingo Molnar89fe8082013-09-30 12:07:11 +0200908#else /* !HAVE_DWARF_SUPPORT */
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300909
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000910static int
911find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
912 struct perf_probe_point *pp __maybe_unused,
913 bool is_kprobe __maybe_unused)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300914{
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +0000915 return -ENOSYS;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300916}
917
Srikar Dronamraju0e608362010-07-29 19:43:51 +0530918static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300919 struct probe_trace_event **tevs __maybe_unused,
Arnaldo Carvalho de Melo1d027ee2014-01-13 15:15:25 -0300920 int max_tevs __maybe_unused,
921 const char *target __maybe_unused)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300922{
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400923 if (perf_probe_event_need_dwarf(pev)) {
924 pr_warning("Debuginfo-analysis is not supported.\n");
925 return -ENOSYS;
926 }
Srikar Dronamraju225466f2012-04-16 17:39:09 +0530927
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300928 return 0;
929}
930
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300931int show_line_range(struct line_range *lr __maybe_unused,
Masami Hiramatsu2b394bc2014-09-17 08:40:54 +0000932 const char *module __maybe_unused,
933 bool user __maybe_unused)
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300934{
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400935 pr_warning("Debuginfo-analysis is not supported.\n");
936 return -ENOSYS;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -0300937}
938
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300939int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
940 int npevs __maybe_unused, int max_vls __maybe_unused,
941 const char *module __maybe_unused,
942 struct strfilter *filter __maybe_unused,
943 bool externs __maybe_unused)
Masami Hiramatsucf6eb482010-10-21 19:13:23 +0900944{
945 pr_warning("Debuginfo-analysis is not supported.\n");
946 return -ENOSYS;
947}
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -0400948#endif
949
Masami Hiramatsue53b00d2014-01-16 09:39:47 +0000950void line_range__clear(struct line_range *lr)
951{
Masami Hiramatsue53b00d2014-01-16 09:39:47 +0000952 free(lr->function);
953 free(lr->file);
954 free(lr->path);
955 free(lr->comp_dir);
Masami Hiramatsu5a622572014-02-06 05:32:09 +0000956 intlist__delete(lr->line_list);
Masami Hiramatsue53b00d2014-01-16 09:39:47 +0000957 memset(lr, 0, sizeof(*lr));
958}
959
Masami Hiramatsu5a622572014-02-06 05:32:09 +0000960int line_range__init(struct line_range *lr)
Masami Hiramatsue53b00d2014-01-16 09:39:47 +0000961{
962 memset(lr, 0, sizeof(*lr));
Masami Hiramatsu5a622572014-02-06 05:32:09 +0000963 lr->line_list = intlist__new(NULL);
964 if (!lr->line_list)
965 return -ENOMEM;
966 else
967 return 0;
Masami Hiramatsue53b00d2014-01-16 09:39:47 +0000968}
969
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +0100970static int parse_line_num(char **ptr, int *val, const char *what)
971{
972 const char *start = *ptr;
973
974 errno = 0;
975 *val = strtol(*ptr, ptr, 0);
976 if (errno || *ptr == start) {
977 semantic_error("'%s' is not a valid number.\n", what);
978 return -EINVAL;
979 }
980 return 0;
981}
982
Franck Bui-Huu9d95b582010-12-20 15:18:03 +0100983/*
984 * Stuff 'lr' according to the line range described by 'arg'.
985 * The line range syntax is described by:
986 *
987 * SRC[:SLN[+NUM|-ELN]]
Masami Hiramatsue116dfa2011-02-10 18:08:10 +0900988 * FNC[@SRC][:SLN[+NUM|-ELN]]
Franck Bui-Huu9d95b582010-12-20 15:18:03 +0100989 */
Masami Hiramatsu146a1432010-04-12 13:17:42 -0400990int parse_line_range_desc(const char *arg, struct line_range *lr)
Masami Hiramatsu631c9de2010-01-06 09:45:34 -0500991{
Masami Hiramatsue116dfa2011-02-10 18:08:10 +0900992 char *range, *file, *name = strdup(arg);
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +0100993 int err;
Franck Bui-Huu9d95b582010-12-20 15:18:03 +0100994
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +0100995 if (!name)
996 return -ENOMEM;
997
998 lr->start = 0;
999 lr->end = INT_MAX;
1000
1001 range = strchr(name, ':');
1002 if (range) {
1003 *range++ = '\0';
1004
1005 err = parse_line_num(&range, &lr->start, "start line");
1006 if (err)
1007 goto err;
1008
1009 if (*range == '+' || *range == '-') {
1010 const char c = *range++;
1011
1012 err = parse_line_num(&range, &lr->end, "end line");
1013 if (err)
1014 goto err;
1015
1016 if (c == '+') {
1017 lr->end += lr->start;
1018 /*
1019 * Adjust the number of lines here.
1020 * If the number of lines == 1, the
1021 * the end of line should be equal to
1022 * the start of line.
1023 */
1024 lr->end--;
1025 }
1026 }
1027
Masami Hiramatsud3b63d72010-04-14 18:39:42 -04001028 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001029
1030 err = -EINVAL;
Masami Hiramatsud3b63d72010-04-14 18:39:42 -04001031 if (lr->start > lr->end) {
Masami Hiramatsu631c9de2010-01-06 09:45:34 -05001032 semantic_error("Start line must be smaller"
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001033 " than end line.\n");
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001034 goto err;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001035 }
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001036 if (*range != '\0') {
1037 semantic_error("Tailing with invalid str '%s'.\n", range);
1038 goto err;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001039 }
Masami Hiramatsud3b63d72010-04-14 18:39:42 -04001040 }
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001041
Masami Hiramatsue116dfa2011-02-10 18:08:10 +09001042 file = strchr(name, '@');
1043 if (file) {
1044 *file = '\0';
1045 lr->file = strdup(++file);
1046 if (lr->file == NULL) {
1047 err = -ENOMEM;
1048 goto err;
1049 }
1050 lr->function = name;
1051 } else if (strchr(name, '.'))
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001052 lr->file = name;
Masami Hiramatsu631c9de2010-01-06 09:45:34 -05001053 else
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001054 lr->function = name;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001055
1056 return 0;
Franck Bui-Huu21dd9ae2010-12-20 15:18:05 +01001057err:
1058 free(name);
1059 return err;
Masami Hiramatsu631c9de2010-01-06 09:45:34 -05001060}
1061
Masami Hiramatsub7702a22009-12-16 17:24:15 -05001062/* Check the name is good for event/group */
1063static bool check_event_name(const char *name)
1064{
1065 if (!isalpha(*name) && *name != '_')
1066 return false;
1067 while (*++name != '\0') {
1068 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
1069 return false;
1070 }
1071 return true;
1072}
1073
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001074/* Parse probepoint definition. */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001075static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001076{
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001077 struct perf_probe_point *pp = &pev->point;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001078 char *ptr, *tmp;
1079 char c, nc = 0;
Naveen N. Rao3099c022015-04-28 17:35:34 +05301080 bool file_spec = false;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001081 /*
1082 * <Syntax>
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001083 * perf probe [EVENT=]SRC[:LN|;PTN]
1084 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
Masami Hiramatsuaf663d72009-12-15 10:32:18 -05001085 *
1086 * TODO:Group name support
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001087 */
1088
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001089 ptr = strpbrk(arg, ";=@+%");
1090 if (ptr && *ptr == '=') { /* Event name */
Masami Hiramatsuaf663d72009-12-15 10:32:18 -05001091 *ptr = '\0';
1092 tmp = ptr + 1;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001093 if (strchr(arg, ':')) {
1094 semantic_error("Group name is not supported yet.\n");
1095 return -ENOTSUP;
1096 }
1097 if (!check_event_name(arg)) {
Masami Hiramatsub7702a22009-12-16 17:24:15 -05001098 semantic_error("%s is bad for event name -it must "
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001099 "follow C symbol-naming rule.\n", arg);
1100 return -EINVAL;
1101 }
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001102 pev->event = strdup(arg);
1103 if (pev->event == NULL)
1104 return -ENOMEM;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001105 pev->group = NULL;
Masami Hiramatsuaf663d72009-12-15 10:32:18 -05001106 arg = tmp;
1107 }
1108
Naveen N. Rao3099c022015-04-28 17:35:34 +05301109 /*
1110 * Check arg is function or file name and copy it.
1111 *
1112 * We consider arg to be a file spec if and only if it satisfies
1113 * all of the below criteria::
1114 * - it does not include any of "+@%",
1115 * - it includes one of ":;", and
1116 * - it has a period '.' in the name.
1117 *
1118 * Otherwise, we consider arg to be a function specification.
1119 */
1120 if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) {
1121 /* This is a file spec if it includes a '.' before ; or : */
1122 if (memchr(arg, '.', ptr - arg))
1123 file_spec = true;
1124 }
1125
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001126 ptr = strpbrk(arg, ";:+@%");
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001127 if (ptr) {
1128 nc = *ptr;
1129 *ptr++ = '\0';
1130 }
1131
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001132 tmp = strdup(arg);
1133 if (tmp == NULL)
1134 return -ENOMEM;
1135
Naveen N. Rao3099c022015-04-28 17:35:34 +05301136 if (file_spec)
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001137 pp->file = tmp;
Naveen N. Rao3099c022015-04-28 17:35:34 +05301138 else
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001139 pp->function = tmp;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001140
1141 /* Parse other options */
1142 while (ptr) {
1143 arg = ptr;
1144 c = nc;
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001145 if (c == ';') { /* Lazy pattern must be the last part */
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001146 pp->lazy_line = strdup(arg);
1147 if (pp->lazy_line == NULL)
1148 return -ENOMEM;
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001149 break;
1150 }
1151 ptr = strpbrk(arg, ";:+@%");
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001152 if (ptr) {
1153 nc = *ptr;
1154 *ptr++ = '\0';
1155 }
1156 switch (c) {
1157 case ':': /* Line number */
1158 pp->line = strtoul(arg, &tmp, 0);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001159 if (*tmp != '\0') {
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001160 semantic_error("There is non-digit char"
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001161 " in line number.\n");
1162 return -EINVAL;
1163 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001164 break;
1165 case '+': /* Byte offset from a symbol */
1166 pp->offset = strtoul(arg, &tmp, 0);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001167 if (*tmp != '\0') {
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001168 semantic_error("There is non-digit character"
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001169 " in offset.\n");
1170 return -EINVAL;
1171 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001172 break;
1173 case '@': /* File name */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001174 if (pp->file) {
1175 semantic_error("SRC@SRC is not allowed.\n");
1176 return -EINVAL;
1177 }
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001178 pp->file = strdup(arg);
1179 if (pp->file == NULL)
1180 return -ENOMEM;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001181 break;
1182 case '%': /* Probe places */
1183 if (strcmp(arg, "return") == 0) {
1184 pp->retprobe = 1;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001185 } else { /* Others not supported yet */
1186 semantic_error("%%%s is not supported.\n", arg);
1187 return -ENOTSUP;
1188 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001189 break;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001190 default: /* Buggy case */
1191 pr_err("This program has a bug at %s:%d.\n",
1192 __FILE__, __LINE__);
1193 return -ENOTSUP;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001194 break;
1195 }
1196 }
1197
1198 /* Exclusion check */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001199 if (pp->lazy_line && pp->line) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001200 semantic_error("Lazy pattern can't be used with"
1201 " line number.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001202 return -EINVAL;
1203 }
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001204
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001205 if (pp->lazy_line && pp->offset) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001206 semantic_error("Lazy pattern can't be used with offset.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001207 return -EINVAL;
1208 }
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001209
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001210 if (pp->line && pp->offset) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001211 semantic_error("Offset can't be used with line number.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001212 return -EINVAL;
1213 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001214
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001215 if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001216 semantic_error("File always requires line number or "
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001217 "lazy pattern.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001218 return -EINVAL;
1219 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001220
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001221 if (pp->offset && !pp->function) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001222 semantic_error("Offset requires an entry function.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001223 return -EINVAL;
1224 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001225
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001226 if (pp->retprobe && !pp->function) {
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001227 semantic_error("Return probe requires an entry function.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001228 return -EINVAL;
1229 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001230
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001231 if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001232 semantic_error("Offset/Line/Lazy pattern can't be used with "
Masami Hiramatsu0e43e5d2010-12-17 22:12:11 +09001233 "return probe.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001234 return -EINVAL;
1235 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001236
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001237 pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
Masami Hiramatsu2a9c8c32010-02-25 08:36:12 -05001238 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1239 pp->lazy_line);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001240 return 0;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001241}
1242
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001243/* Parse perf-probe event argument */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001244static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001245{
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001246 char *tmp, *goodname;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001247 struct perf_probe_arg_field **fieldp;
1248
1249 pr_debug("parsing arg: %s into ", str);
1250
Masami Hiramatsu48481932010-04-12 13:16:53 -04001251 tmp = strchr(str, '=');
1252 if (tmp) {
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001253 arg->name = strndup(str, tmp - str);
1254 if (arg->name == NULL)
1255 return -ENOMEM;
Masami Hiramatsu11a1ca32010-04-12 13:17:22 -04001256 pr_debug("name:%s ", arg->name);
Masami Hiramatsu48481932010-04-12 13:16:53 -04001257 str = tmp + 1;
1258 }
1259
Masami Hiramatsu11a1ca32010-04-12 13:17:22 -04001260 tmp = strchr(str, ':');
1261 if (tmp) { /* Type setting */
1262 *tmp = '\0';
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001263 arg->type = strdup(tmp + 1);
1264 if (arg->type == NULL)
1265 return -ENOMEM;
Masami Hiramatsu11a1ca32010-04-12 13:17:22 -04001266 pr_debug("type:%s ", arg->type);
1267 }
1268
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001269 tmp = strpbrk(str, "-.[");
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001270 if (!is_c_varname(str) || !tmp) {
1271 /* A variable, register, symbol or special value */
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001272 arg->var = strdup(str);
1273 if (arg->var == NULL)
1274 return -ENOMEM;
Masami Hiramatsu48481932010-04-12 13:16:53 -04001275 pr_debug("%s\n", arg->var);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001276 return 0;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001277 }
1278
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001279 /* Structure fields or array element */
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001280 arg->var = strndup(str, tmp - str);
1281 if (arg->var == NULL)
1282 return -ENOMEM;
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001283 goodname = arg->var;
Masami Hiramatsu48481932010-04-12 13:16:53 -04001284 pr_debug("%s, ", arg->var);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001285 fieldp = &arg->field;
1286
1287 do {
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001288 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1289 if (*fieldp == NULL)
1290 return -ENOMEM;
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001291 if (*tmp == '[') { /* Array */
1292 str = tmp;
1293 (*fieldp)->index = strtol(str + 1, &tmp, 0);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001294 (*fieldp)->ref = true;
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001295 if (*tmp != ']' || tmp == str + 1) {
1296 semantic_error("Array index must be a"
1297 " number.\n");
1298 return -EINVAL;
1299 }
1300 tmp++;
1301 if (*tmp == '\0')
1302 tmp = NULL;
1303 } else { /* Structure */
1304 if (*tmp == '.') {
1305 str = tmp + 1;
1306 (*fieldp)->ref = false;
1307 } else if (tmp[1] == '>') {
1308 str = tmp + 2;
1309 (*fieldp)->ref = true;
1310 } else {
1311 semantic_error("Argument parse error: %s\n",
1312 str);
1313 return -EINVAL;
1314 }
1315 tmp = strpbrk(str, "-.[");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001316 }
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001317 if (tmp) {
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001318 (*fieldp)->name = strndup(str, tmp - str);
1319 if ((*fieldp)->name == NULL)
1320 return -ENOMEM;
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001321 if (*str != '[')
1322 goodname = (*fieldp)->name;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001323 pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1324 fieldp = &(*fieldp)->next;
1325 }
1326 } while (tmp);
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001327 (*fieldp)->name = strdup(str);
1328 if ((*fieldp)->name == NULL)
1329 return -ENOMEM;
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001330 if (*str != '[')
1331 goodname = (*fieldp)->name;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001332 pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
Masami Hiramatsudf0faf42010-04-12 13:17:00 -04001333
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001334 /* If no name is specified, set the last field name (not array index)*/
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001335 if (!arg->name) {
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001336 arg->name = strdup(goodname);
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001337 if (arg->name == NULL)
1338 return -ENOMEM;
1339 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001340 return 0;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001341}
1342
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001343/* Parse perf-probe event command */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001344int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001345{
Masami Hiramatsue1c01d62009-11-30 19:20:05 -05001346 char **argv;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001347 int argc, i, ret = 0;
Masami Hiramatsufac13fd2009-12-15 10:31:14 -05001348
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001349 argv = argv_split(cmd, &argc);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001350 if (!argv) {
1351 pr_debug("Failed to split arguments.\n");
1352 return -ENOMEM;
1353 }
1354 if (argc - 1 > MAX_PROBE_ARGS) {
1355 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1356 ret = -ERANGE;
1357 goto out;
1358 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001359 /* Parse probe point */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001360 ret = parse_perf_probe_point(argv[0], pev);
1361 if (ret < 0)
1362 goto out;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001363
Masami Hiramatsue1c01d62009-11-30 19:20:05 -05001364 /* Copy arguments and ensure return probe has no C argument */
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001365 pev->nargs = argc - 1;
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001366 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1367 if (pev->args == NULL) {
1368 ret = -ENOMEM;
1369 goto out;
1370 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001371 for (i = 0; i < pev->nargs && ret >= 0; i++) {
1372 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1373 if (ret >= 0 &&
1374 is_c_varname(pev->args[i].var) && pev->point.retprobe) {
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001375 semantic_error("You can't specify local variable for"
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001376 " kretprobe.\n");
1377 ret = -EINVAL;
1378 }
Masami Hiramatsue1c01d62009-11-30 19:20:05 -05001379 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001380out:
Masami Hiramatsue1c01d62009-11-30 19:20:05 -05001381 argv_free(argv);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001382
1383 return ret;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001384}
1385
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001386/* Return true if this perf_probe_event requires debuginfo */
1387bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001388{
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001389 int i;
1390
1391 if (pev->point.file || pev->point.line || pev->point.lazy_line)
1392 return true;
1393
1394 for (i = 0; i < pev->nargs; i++)
Masami Hiramatsu48481932010-04-12 13:16:53 -04001395 if (is_c_varname(pev->args[i].var))
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001396 return true;
1397
1398 return false;
1399}
1400
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301401/* Parse probe_events event into struct probe_point */
1402static int parse_probe_trace_command(const char *cmd,
Masami Hiramatsu190b57f2011-06-27 16:27:45 +09001403 struct probe_trace_event *tev)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001404{
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301405 struct probe_trace_point *tp = &tev->point;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001406 char pr;
1407 char *p;
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001408 char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001409 int ret, i, argc;
1410 char **argv;
1411
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301412 pr_debug("Parsing probe_events: %s\n", cmd);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001413 argv = argv_split(cmd, &argc);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001414 if (!argv) {
1415 pr_debug("Failed to split arguments.\n");
1416 return -ENOMEM;
1417 }
1418 if (argc < 2) {
1419 semantic_error("Too few probe arguments.\n");
1420 ret = -ERANGE;
1421 goto out;
1422 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001423
1424 /* Scan event and group name. */
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001425 argv0_str = strdup(argv[0]);
1426 if (argv0_str == NULL) {
1427 ret = -ENOMEM;
1428 goto out;
1429 }
1430 fmt1_str = strtok_r(argv0_str, ":", &fmt);
1431 fmt2_str = strtok_r(NULL, "/", &fmt);
1432 fmt3_str = strtok_r(NULL, " \t", &fmt);
1433 if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1434 || fmt3_str == NULL) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001435 semantic_error("Failed to parse event name: %s\n", argv[0]);
1436 ret = -EINVAL;
1437 goto out;
1438 }
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001439 pr = fmt1_str[0];
1440 tev->group = strdup(fmt2_str);
1441 tev->event = strdup(fmt3_str);
1442 if (tev->group == NULL || tev->event == NULL) {
1443 ret = -ENOMEM;
1444 goto out;
1445 }
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001446 pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001447
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001448 tp->retprobe = (pr == 'r');
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001449
Masami Hiramatsu190b57f2011-06-27 16:27:45 +09001450 /* Scan module name(if there), function name and offset */
1451 p = strchr(argv[1], ':');
1452 if (p) {
1453 tp->module = strndup(argv[1], p - argv[1]);
1454 p++;
1455 } else
1456 p = argv[1];
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001457 fmt1_str = strtok_r(p, "+", &fmt);
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +00001458 if (fmt1_str[0] == '0') /* only the address started with 0x */
1459 tp->address = strtoul(fmt1_str, NULL, 0);
1460 else {
1461 /* Only the symbol-based probe has offset */
1462 tp->symbol = strdup(fmt1_str);
1463 if (tp->symbol == NULL) {
1464 ret = -ENOMEM;
1465 goto out;
1466 }
1467 fmt2_str = strtok_r(NULL, "", &fmt);
1468 if (fmt2_str == NULL)
1469 tp->offset = 0;
1470 else
1471 tp->offset = strtoul(fmt2_str, NULL, 10);
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001472 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001473
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001474 tev->nargs = argc - 2;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301475 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001476 if (tev->args == NULL) {
1477 ret = -ENOMEM;
1478 goto out;
1479 }
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001480 for (i = 0; i < tev->nargs; i++) {
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001481 p = strchr(argv[i + 2], '=');
1482 if (p) /* We don't need which register is assigned. */
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001483 *p++ = '\0';
1484 else
1485 p = argv[i + 2];
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001486 tev->args[i].name = strdup(argv[i + 2]);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001487 /* TODO: parse regs and offset */
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001488 tev->args[i].value = strdup(p);
1489 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1490 ret = -ENOMEM;
1491 goto out;
1492 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001493 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001494 ret = 0;
1495out:
Irina Tirdeabcbd0042012-09-20 23:37:50 +03001496 free(argv0_str);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001497 argv_free(argv);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001498 return ret;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001499}
1500
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001501/* Compose only probe arg */
1502int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
1503{
1504 struct perf_probe_arg_field *field = pa->field;
1505 int ret;
1506 char *tmp = buf;
1507
Masami Hiramatsu48481932010-04-12 13:16:53 -04001508 if (pa->name && pa->var)
1509 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
1510 else
1511 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001512 if (ret <= 0)
1513 goto error;
1514 tmp += ret;
1515 len -= ret;
1516
1517 while (field) {
Masami Hiramatsub2a3c122010-05-19 15:57:42 -04001518 if (field->name[0] == '[')
1519 ret = e_snprintf(tmp, len, "%s", field->name);
1520 else
1521 ret = e_snprintf(tmp, len, "%s%s",
1522 field->ref ? "->" : ".", field->name);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001523 if (ret <= 0)
1524 goto error;
1525 tmp += ret;
1526 len -= ret;
1527 field = field->next;
1528 }
Masami Hiramatsu11a1ca32010-04-12 13:17:22 -04001529
1530 if (pa->type) {
1531 ret = e_snprintf(tmp, len, ":%s", pa->type);
1532 if (ret <= 0)
1533 goto error;
1534 tmp += ret;
1535 len -= ret;
1536 }
1537
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001538 return tmp - buf;
1539error:
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00001540 pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001541 return ret;
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001542}
1543
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001544/* Compose only probe point (not argument) */
1545static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001546{
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001547 char *buf, *tmp;
1548 char offs[32] = "", line[32] = "", file[32] = "";
1549 int ret, len;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05001550
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001551 buf = zalloc(MAX_CMDLEN);
1552 if (buf == NULL) {
1553 ret = -ENOMEM;
1554 goto error;
1555 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001556 if (pp->offset) {
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001557 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001558 if (ret <= 0)
1559 goto error;
1560 }
1561 if (pp->line) {
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001562 ret = e_snprintf(line, 32, ":%d", pp->line);
1563 if (ret <= 0)
1564 goto error;
1565 }
1566 if (pp->file) {
Franck Bui-Huu32ae2ad2010-12-23 16:04:23 +01001567 tmp = pp->file;
1568 len = strlen(tmp);
1569 if (len > 30) {
1570 tmp = strchr(pp->file + len - 30, '/');
1571 tmp = tmp ? tmp + 1 : pp->file + len - 30;
1572 }
1573 ret = e_snprintf(file, 32, "@%s", tmp);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001574 if (ret <= 0)
1575 goto error;
1576 }
1577
1578 if (pp->function)
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001579 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
1580 offs, pp->retprobe ? "%return" : "", line,
1581 file);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001582 else
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001583 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001584 if (ret <= 0)
1585 goto error;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001586
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001587 return buf;
1588error:
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00001589 pr_debug("Failed to synthesize perf probe point: %d\n", ret);
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001590 free(buf);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001591 return NULL;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001592}
1593
1594#if 0
1595char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1596{
1597 char *buf;
1598 int i, len, ret;
1599
1600 buf = synthesize_perf_probe_point(&pev->point);
1601 if (!buf)
1602 return NULL;
1603
1604 len = strlen(buf);
1605 for (i = 0; i < pev->nargs; i++) {
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001606 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001607 pev->args[i].name);
1608 if (ret <= 0) {
1609 free(buf);
1610 return NULL;
1611 }
1612 len += ret;
1613 }
1614
1615 return buf;
1616}
1617#endif
1618
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301619static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001620 char **buf, size_t *buflen,
1621 int depth)
1622{
1623 int ret;
1624 if (ref->next) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301625 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001626 buflen, depth + 1);
1627 if (depth < 0)
1628 goto out;
1629 }
1630
1631 ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
1632 if (ret < 0)
1633 depth = ret;
1634 else {
1635 *buf += ret;
1636 *buflen -= ret;
1637 }
1638out:
1639 return depth;
1640
1641}
1642
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301643static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001644 char *buf, size_t buflen)
1645{
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301646 struct probe_trace_arg_ref *ref = arg->ref;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001647 int ret, depth = 0;
1648 char *tmp = buf;
1649
1650 /* Argument name or separator */
1651 if (arg->name)
1652 ret = e_snprintf(buf, buflen, " %s=", arg->name);
1653 else
1654 ret = e_snprintf(buf, buflen, " ");
1655 if (ret < 0)
1656 return ret;
1657 buf += ret;
1658 buflen -= ret;
1659
Masami Hiramatsub7dcb852010-05-19 15:57:49 -04001660 /* Special case: @XXX */
1661 if (arg->value[0] == '@' && arg->ref)
1662 ref = ref->next;
1663
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001664 /* Dereferencing arguments */
Masami Hiramatsub7dcb852010-05-19 15:57:49 -04001665 if (ref) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301666 depth = __synthesize_probe_trace_arg_ref(ref, &buf,
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001667 &buflen, 1);
1668 if (depth < 0)
1669 return depth;
1670 }
1671
1672 /* Print argument value */
Masami Hiramatsub7dcb852010-05-19 15:57:49 -04001673 if (arg->value[0] == '@' && arg->ref)
1674 ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
1675 arg->ref->offset);
1676 else
1677 ret = e_snprintf(buf, buflen, "%s", arg->value);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001678 if (ret < 0)
1679 return ret;
1680 buf += ret;
1681 buflen -= ret;
1682
1683 /* Closing */
1684 while (depth--) {
1685 ret = e_snprintf(buf, buflen, ")");
1686 if (ret < 0)
1687 return ret;
1688 buf += ret;
1689 buflen -= ret;
1690 }
Masami Hiramatsu49849122010-04-12 13:17:15 -04001691 /* Print argument type */
1692 if (arg->type) {
1693 ret = e_snprintf(buf, buflen, ":%s", arg->type);
1694 if (ret <= 0)
1695 return ret;
1696 buf += ret;
1697 }
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001698
1699 return buf - tmp;
1700}
1701
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301702char *synthesize_probe_trace_command(struct probe_trace_event *tev)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001703{
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301704 struct probe_trace_point *tp = &tev->point;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001705 char *buf;
1706 int i, len, ret;
1707
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001708 buf = zalloc(MAX_CMDLEN);
1709 if (buf == NULL)
1710 return NULL;
1711
Masami Hiramatsueb948e52014-02-06 05:32:25 +00001712 len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1713 tev->group, tev->event);
1714 if (len <= 0)
1715 goto error;
1716
1717 /* Uprobes must have tp->address and tp->module */
1718 if (tev->uprobes && (!tp->address || !tp->module))
1719 goto error;
1720
1721 /* Use the tp->address for uprobes */
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301722 if (tev->uprobes)
Masami Hiramatsueb948e52014-02-06 05:32:25 +00001723 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
1724 tp->module, tp->address);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301725 else
Masami Hiramatsueb948e52014-02-06 05:32:25 +00001726 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301727 tp->module ?: "", tp->module ? ":" : "",
1728 tp->symbol, tp->offset);
1729
Masami Hiramatsueb948e52014-02-06 05:32:25 +00001730 if (ret <= 0)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001731 goto error;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00001732 len += ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001733
1734 for (i = 0; i < tev->nargs; i++) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301735 ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001736 MAX_CMDLEN - len);
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001737 if (ret <= 0)
1738 goto error;
1739 len += ret;
1740 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001741
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001742 return buf;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001743error:
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001744 free(buf);
1745 return NULL;
1746}
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001747
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +00001748static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1749 struct perf_probe_point *pp,
1750 bool is_kprobe)
1751{
1752 struct symbol *sym = NULL;
1753 struct map *map;
1754 u64 addr;
1755 int ret = -ENOENT;
1756
1757 if (!is_kprobe) {
1758 map = dso__new_map(tp->module);
1759 if (!map)
1760 goto out;
1761 addr = tp->address;
1762 sym = map__find_symbol(map, addr, NULL);
1763 } else {
1764 addr = kernel_get_symbol_address_by_name(tp->symbol, true);
1765 if (addr) {
1766 addr += tp->offset;
1767 sym = __find_kernel_function(addr, &map);
1768 }
1769 }
1770 if (!sym)
1771 goto out;
1772
1773 pp->retprobe = tp->retprobe;
1774 pp->offset = addr - map->unmap_ip(map, sym->start);
1775 pp->function = strdup(sym->name);
1776 ret = pp->function ? 0 : -ENOMEM;
1777
1778out:
1779 if (map && !is_kprobe) {
1780 dso__delete(map->dso);
1781 map__delete(map);
1782 }
1783
1784 return ret;
1785}
1786
1787static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1788 struct perf_probe_point *pp,
1789 bool is_kprobe)
1790{
1791 char buf[128];
1792 int ret;
1793
1794 ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
1795 if (!ret)
1796 return 0;
1797 ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
1798 if (!ret)
1799 return 0;
1800
1801 pr_debug("Failed to find probe point from both of dwarf and map.\n");
1802
1803 if (tp->symbol) {
1804 pp->function = strdup(tp->symbol);
1805 pp->offset = tp->offset;
1806 } else if (!tp->module && !is_kprobe) {
1807 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
1808 if (ret < 0)
1809 return ret;
1810 pp->function = strdup(buf);
1811 pp->offset = 0;
1812 }
1813 if (pp->function == NULL)
1814 return -ENOMEM;
1815
1816 pp->retprobe = tp->retprobe;
1817
1818 return 0;
1819}
1820
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301821static int convert_to_perf_probe_event(struct probe_trace_event *tev,
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301822 struct perf_probe_event *pev, bool is_kprobe)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001823{
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001824 char buf[64] = "";
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001825 int i, ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001826
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -03001827 /* Convert event/group name */
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001828 pev->event = strdup(tev->event);
1829 pev->group = strdup(tev->group);
1830 if (pev->event == NULL || pev->group == NULL)
1831 return -ENOMEM;
Masami Hiramatsufb1587d2010-03-16 18:06:19 -04001832
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -03001833 /* Convert trace_point to probe_point */
Masami Hiramatsu5a6f6312014-02-06 05:32:23 +00001834 ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001835 if (ret < 0)
1836 return ret;
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -03001837
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001838 /* Convert trace_arg to probe_arg */
1839 pev->nargs = tev->nargs;
Masami Hiramatsue334016f12010-04-12 13:17:49 -04001840 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1841 if (pev->args == NULL)
1842 return -ENOMEM;
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001843 for (i = 0; i < tev->nargs && ret >= 0; i++) {
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001844 if (tev->args[i].name)
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001845 pev->args[i].name = strdup(tev->args[i].name);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001846 else {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301847 ret = synthesize_probe_trace_arg(&tev->args[i],
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001848 buf, 64);
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001849 pev->args[i].name = strdup(buf);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001850 }
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04001851 if (pev->args[i].name == NULL && ret >= 0)
1852 ret = -ENOMEM;
1853 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001854
1855 if (ret < 0)
1856 clear_perf_probe_event(pev);
1857
1858 return ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001859}
1860
1861void clear_perf_probe_event(struct perf_probe_event *pev)
1862{
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001863 struct perf_probe_arg_field *field, *next;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001864 int i;
1865
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001866 free(pev->event);
1867 free(pev->group);
Masami Hiramatsu7afb3fa2015-04-01 19:25:39 +09001868 free(pev->target);
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +09001869 clear_perf_probe_point(&pev->point);
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001870
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001871 for (i = 0; i < pev->nargs; i++) {
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001872 free(pev->args[i].name);
1873 free(pev->args[i].var);
1874 free(pev->args[i].type);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001875 field = pev->args[i].field;
1876 while (field) {
1877 next = field->next;
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -03001878 zfree(&field->name);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04001879 free(field);
1880 field = next;
1881 }
1882 }
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001883 free(pev->args);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001884 memset(pev, 0, sizeof(*pev));
1885}
1886
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301887static void clear_probe_trace_event(struct probe_trace_event *tev)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001888{
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301889 struct probe_trace_arg_ref *ref, *next;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001890 int i;
1891
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001892 free(tev->event);
1893 free(tev->group);
1894 free(tev->point.symbol);
1895 free(tev->point.module);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001896 for (i = 0; i < tev->nargs; i++) {
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001897 free(tev->args[i].name);
1898 free(tev->args[i].value);
1899 free(tev->args[i].type);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001900 ref = tev->args[i].ref;
1901 while (ref) {
1902 next = ref->next;
1903 free(ref);
1904 ref = next;
1905 }
1906 }
Arnaldo Carvalho de Melof5385652013-12-26 15:54:57 -03001907 free(tev->args);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04001908 memset(tev, 0, sizeof(*tev));
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001909}
1910
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001911static void print_open_warning(int err, bool is_kprobe)
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301912{
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00001913 char sbuf[STRERR_BUFSIZE];
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301914
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001915 if (err == -ENOENT) {
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301916 const char *config;
1917
1918 if (!is_kprobe)
1919 config = "CONFIG_UPROBE_EVENTS";
1920 else
1921 config = "CONFIG_KPROBE_EVENTS";
1922
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001923 pr_warning("%cprobe_events file does not exist"
1924 " - please rebuild kernel with %s.\n",
1925 is_kprobe ? 'k' : 'u', config);
1926 } else if (err == -ENOTSUP)
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001927 pr_warning("Tracefs or debugfs is not mounted.\n");
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001928 else
1929 pr_warning("Failed to open %cprobe_events: %s\n",
1930 is_kprobe ? 'k' : 'u',
1931 strerror_r(-err, sbuf, sizeof(sbuf)));
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301932}
1933
Masami Hiramatsu467ec082014-08-13 16:12:50 +00001934static void print_both_open_warning(int kerr, int uerr)
1935{
1936 /* Both kprobes and uprobes are disabled, warn it. */
1937 if (kerr == -ENOTSUP && uerr == -ENOTSUP)
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001938 pr_warning("Tracefs or debugfs is not mounted.\n");
Masami Hiramatsu467ec082014-08-13 16:12:50 +00001939 else if (kerr == -ENOENT && uerr == -ENOENT)
1940 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
1941 "or/and CONFIG_UPROBE_EVENTS.\n");
1942 else {
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00001943 char sbuf[STRERR_BUFSIZE];
Masami Hiramatsu467ec082014-08-13 16:12:50 +00001944 pr_warning("Failed to open kprobe events: %s.\n",
1945 strerror_r(-kerr, sbuf, sizeof(sbuf)));
1946 pr_warning("Failed to open uprobe events: %s.\n",
1947 strerror_r(-uerr, sbuf, sizeof(sbuf)));
1948 }
1949}
1950
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001951static int open_probe_events(const char *trace_file, bool readwrite)
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001952{
1953 char buf[PATH_MAX];
Masami Hiramatsu7ca59892010-04-14 18:39:28 -04001954 const char *__debugfs;
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001955 const char *tracing_dir = "";
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001956 int ret;
1957
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001958 __debugfs = tracefs_find_mountpoint();
1959 if (__debugfs == NULL) {
1960 tracing_dir = "tracing/";
Masami Hiramatsu7ca59892010-04-14 18:39:28 -04001961
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001962 __debugfs = debugfs_find_mountpoint();
1963 if (__debugfs == NULL)
1964 return -ENOTSUP;
1965 }
1966
1967 ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
1968 __debugfs, tracing_dir, trace_file);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001969 if (ret >= 0) {
Masami Hiramatsu7ca59892010-04-14 18:39:28 -04001970 pr_debug("Opening %s write=%d\n", buf, readwrite);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04001971 if (readwrite && !probe_event_dry_run)
1972 ret = open(buf, O_RDWR, O_APPEND);
1973 else
1974 ret = open(buf, O_RDONLY, 0);
Masami Hiramatsuf4d7da42010-03-16 18:06:05 -04001975
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301976 if (ret < 0)
Masami Hiramatsu5e451872014-08-13 16:12:48 +00001977 ret = -errno;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001978 }
1979 return ret;
1980}
1981
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301982static int open_kprobe_events(bool readwrite)
1983{
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001984 return open_probe_events("kprobe_events", readwrite);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301985}
1986
1987static int open_uprobe_events(bool readwrite)
1988{
Steven Rostedt (Red Hat)23773ca2015-02-02 14:35:07 -05001989 return open_probe_events("uprobe_events", readwrite);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05301990}
1991
1992/* Get raw string list of current kprobe_events or uprobe_events */
Srikar Dronamraju0e608362010-07-29 19:43:51 +05301993static struct strlist *get_probe_trace_command_rawlist(int fd)
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05001994{
1995 int ret, idx;
1996 FILE *fp;
1997 char buf[MAX_CMDLEN];
1998 char *p;
1999 struct strlist *sl;
2000
2001 sl = strlist__new(true, NULL);
2002
2003 fp = fdopen(dup(fd), "r");
2004 while (!feof(fp)) {
2005 p = fgets(buf, MAX_CMDLEN, fp);
2006 if (!p)
2007 break;
2008
2009 idx = strlen(p) - 1;
2010 if (p[idx] == '\n')
2011 p[idx] = '\0';
2012 ret = strlist__add(sl, buf);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002013 if (ret < 0) {
Masami Hiramatsu6eb08662014-08-14 02:22:30 +00002014 pr_debug("strlist__add failed (%d)\n", ret);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002015 strlist__delete(sl);
2016 return NULL;
2017 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002018 }
2019 fclose(fp);
2020
2021 return sl;
2022}
2023
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002024struct kprobe_blacklist_node {
2025 struct list_head list;
2026 unsigned long start;
2027 unsigned long end;
2028 char *symbol;
2029};
2030
2031static void kprobe_blacklist__delete(struct list_head *blacklist)
2032{
2033 struct kprobe_blacklist_node *node;
2034
2035 while (!list_empty(blacklist)) {
2036 node = list_first_entry(blacklist,
2037 struct kprobe_blacklist_node, list);
2038 list_del(&node->list);
2039 free(node->symbol);
2040 free(node);
2041 }
2042}
2043
2044static int kprobe_blacklist__load(struct list_head *blacklist)
2045{
2046 struct kprobe_blacklist_node *node;
2047 const char *__debugfs = debugfs_find_mountpoint();
2048 char buf[PATH_MAX], *p;
2049 FILE *fp;
2050 int ret;
2051
2052 if (__debugfs == NULL)
2053 return -ENOTSUP;
2054
2055 ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2056 if (ret < 0)
2057 return ret;
2058
2059 fp = fopen(buf, "r");
2060 if (!fp)
2061 return -errno;
2062
2063 ret = 0;
2064 while (fgets(buf, PATH_MAX, fp)) {
2065 node = zalloc(sizeof(*node));
2066 if (!node) {
2067 ret = -ENOMEM;
2068 break;
2069 }
2070 INIT_LIST_HEAD(&node->list);
2071 list_add_tail(&node->list, blacklist);
2072 if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2073 ret = -EINVAL;
2074 break;
2075 }
2076 p = strchr(buf, '\t');
2077 if (p) {
2078 p++;
2079 if (p[strlen(p) - 1] == '\n')
2080 p[strlen(p) - 1] = '\0';
2081 } else
2082 p = (char *)"unknown";
2083 node->symbol = strdup(p);
2084 if (!node->symbol) {
2085 ret = -ENOMEM;
2086 break;
2087 }
2088 pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2089 node->start, node->end, node->symbol);
2090 ret++;
2091 }
2092 if (ret < 0)
2093 kprobe_blacklist__delete(blacklist);
2094 fclose(fp);
2095
2096 return ret;
2097}
2098
2099static struct kprobe_blacklist_node *
2100kprobe_blacklist__find_by_address(struct list_head *blacklist,
2101 unsigned long address)
2102{
2103 struct kprobe_blacklist_node *node;
2104
2105 list_for_each_entry(node, blacklist, list) {
2106 if (node->start <= address && address <= node->end)
2107 return node;
2108 }
2109
2110 return NULL;
2111}
2112
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002113/* Show an event */
Masami Hiramatsufb226cc2014-02-06 05:32:13 +00002114static int show_perf_probe_event(struct perf_probe_event *pev,
2115 const char *module)
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002116{
Masami Hiramatsu7e990a52009-12-15 10:31:21 -05002117 int i, ret;
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002118 char buf[128];
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002119 char *place;
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002120
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002121 /* Synthesize only event probe point */
2122 place = synthesize_perf_probe_point(&pev->point);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002123 if (!place)
2124 return -EINVAL;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002125
2126 ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
Masami Hiramatsu7e990a52009-12-15 10:31:21 -05002127 if (ret < 0)
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002128 return ret;
2129
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002130 pr_info(" %-20s (on %s", buf, place);
Masami Hiramatsufb226cc2014-02-06 05:32:13 +00002131 if (module)
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002132 pr_info(" in %s", module);
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002133
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002134 if (pev->nargs > 0) {
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002135 pr_info(" with");
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04002136 for (i = 0; i < pev->nargs; i++) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002137 ret = synthesize_perf_probe_arg(&pev->args[i],
2138 buf, 128);
2139 if (ret < 0)
2140 break;
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002141 pr_info(" %s", buf);
Masami Hiramatsu7df2f322010-03-16 18:06:26 -04002142 }
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002143 }
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002144 pr_info(")\n");
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002145 free(place);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002146 return ret;
Masami Hiramatsu278498d2009-12-08 17:02:40 -05002147}
2148
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002149static bool filter_probe_trace_event(struct probe_trace_event *tev,
2150 struct strfilter *filter)
2151{
2152 char tmp[128];
2153
2154 /* At first, check the event name itself */
2155 if (strfilter__compare(filter, tev->event))
2156 return true;
2157
2158 /* Next, check the combination of name and group */
2159 if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2160 return false;
2161 return strfilter__compare(filter, tmp);
2162}
2163
2164static int __show_perf_probe_events(int fd, bool is_kprobe,
2165 struct strfilter *filter)
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002166{
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302167 int ret = 0;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302168 struct probe_trace_event tev;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002169 struct perf_probe_event pev;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002170 struct strlist *rawlist;
2171 struct str_node *ent;
2172
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002173 memset(&tev, 0, sizeof(tev));
2174 memset(&pev, 0, sizeof(pev));
Masami Hiramatsu72041332010-01-05 17:47:10 -05002175
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302176 rawlist = get_probe_trace_command_rawlist(fd);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002177 if (!rawlist)
Masami Hiramatsu6eb08662014-08-14 02:22:30 +00002178 return -ENOMEM;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002179
Masami Hiramatsuadf365f2009-12-15 10:32:03 -05002180 strlist__for_each(ent, rawlist) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302181 ret = parse_probe_trace_command(ent->s, &tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002182 if (ret >= 0) {
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002183 if (!filter_probe_trace_event(&tev, filter))
2184 goto next;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302185 ret = convert_to_perf_probe_event(&tev, &pev,
2186 is_kprobe);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002187 if (ret >= 0)
Masami Hiramatsufb226cc2014-02-06 05:32:13 +00002188 ret = show_perf_probe_event(&pev,
2189 tev.point.module);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002190 }
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002191next:
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002192 clear_perf_probe_event(&pev);
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302193 clear_probe_trace_event(&tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002194 if (ret < 0)
2195 break;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002196 }
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002197 strlist__delete(rawlist);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002198
2199 return ret;
Masami Hiramatsu4de189f2009-11-30 19:20:17 -05002200}
2201
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302202/* List up current perf-probe events */
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002203int show_perf_probe_events(struct strfilter *filter)
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302204{
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002205 int kp_fd, up_fd, ret;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302206
2207 setup_pager();
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302208
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +00002209 ret = init_symbol_maps(false);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302210 if (ret < 0)
2211 return ret;
2212
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002213 kp_fd = open_kprobe_events(false);
2214 if (kp_fd >= 0) {
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002215 ret = __show_perf_probe_events(kp_fd, true, filter);
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002216 close(kp_fd);
2217 if (ret < 0)
2218 goto out;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302219 }
2220
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002221 up_fd = open_uprobe_events(false);
2222 if (kp_fd < 0 && up_fd < 0) {
Masami Hiramatsu467ec082014-08-13 16:12:50 +00002223 print_both_open_warning(kp_fd, up_fd);
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002224 ret = kp_fd;
2225 goto out;
2226 }
2227
2228 if (up_fd >= 0) {
Masami Hiramatsub6a89642015-04-24 18:47:50 +09002229 ret = __show_perf_probe_events(up_fd, false, filter);
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002230 close(up_fd);
2231 }
2232out:
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +00002233 exit_symbol_maps();
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302234 return ret;
2235}
2236
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002237/* Get current perf-probe event names */
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302238static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002239{
Masami Hiramatsufa282442009-12-08 17:03:23 -05002240 char buf[128];
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002241 struct strlist *sl, *rawlist;
2242 struct str_node *ent;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302243 struct probe_trace_event tev;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002244 int ret = 0;
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002245
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002246 memset(&tev, 0, sizeof(tev));
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302247 rawlist = get_probe_trace_command_rawlist(fd);
Masami Hiramatsu6eb08662014-08-14 02:22:30 +00002248 if (!rawlist)
2249 return NULL;
Masami Hiramatsue1d20172009-12-07 12:00:46 -05002250 sl = strlist__new(true, NULL);
Masami Hiramatsuadf365f2009-12-15 10:32:03 -05002251 strlist__for_each(ent, rawlist) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302252 ret = parse_probe_trace_command(ent->s, &tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002253 if (ret < 0)
2254 break;
Masami Hiramatsufa282442009-12-08 17:03:23 -05002255 if (include_group) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002256 ret = e_snprintf(buf, 128, "%s:%s", tev.group,
2257 tev.event);
2258 if (ret >= 0)
2259 ret = strlist__add(sl, buf);
Masami Hiramatsufa282442009-12-08 17:03:23 -05002260 } else
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002261 ret = strlist__add(sl, tev.event);
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302262 clear_probe_trace_event(&tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002263 if (ret < 0)
2264 break;
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002265 }
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002266 strlist__delete(rawlist);
2267
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002268 if (ret < 0) {
2269 strlist__delete(sl);
2270 return NULL;
2271 }
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002272 return sl;
2273}
2274
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302275static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002276{
Frederic Weisbecker6eca8cc2010-04-21 02:01:05 +02002277 int ret = 0;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302278 char *buf = synthesize_probe_trace_command(tev);
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00002279 char sbuf[STRERR_BUFSIZE];
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002280
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002281 if (!buf) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302282 pr_debug("Failed to synthesize probe trace event.\n");
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002283 return -EINVAL;
2284 }
2285
Masami Hiramatsufa282442009-12-08 17:03:23 -05002286 pr_debug("Writing event: %s\n", buf);
Masami Hiramatsuf4d7da42010-03-16 18:06:05 -04002287 if (!probe_event_dry_run) {
2288 ret = write(fd, buf, strlen(buf));
Namhyung Kim7949ba12015-01-10 19:33:48 +09002289 if (ret <= 0) {
2290 ret = -errno;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002291 pr_warning("Failed to write event: %s\n",
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00002292 strerror_r(errno, sbuf, sizeof(sbuf)));
Namhyung Kim7949ba12015-01-10 19:33:48 +09002293 }
Masami Hiramatsuf4d7da42010-03-16 18:06:05 -04002294 }
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002295 free(buf);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002296 return ret;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002297}
2298
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002299static int get_new_event_name(char *buf, size_t len, const char *base,
2300 struct strlist *namelist, bool allow_suffix)
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002301{
2302 int i, ret;
Masami Hiramatsu17f88fc2009-12-08 17:03:02 -05002303
Naveen N. Rao3099c022015-04-28 17:35:34 +05302304 if (*base == '.')
2305 base++;
2306
Masami Hiramatsu17f88fc2009-12-08 17:03:02 -05002307 /* Try no suffix */
2308 ret = e_snprintf(buf, len, "%s", base);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002309 if (ret < 0) {
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00002310 pr_debug("snprintf() failed: %d\n", ret);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002311 return ret;
2312 }
Masami Hiramatsu17f88fc2009-12-08 17:03:02 -05002313 if (!strlist__has_entry(namelist, buf))
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002314 return 0;
Masami Hiramatsu17f88fc2009-12-08 17:03:02 -05002315
Masami Hiramatsud761b082009-12-15 10:32:25 -05002316 if (!allow_suffix) {
2317 pr_warning("Error: event \"%s\" already exists. "
2318 "(Use -f to force duplicates.)\n", base);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002319 return -EEXIST;
Masami Hiramatsud761b082009-12-15 10:32:25 -05002320 }
2321
Masami Hiramatsu17f88fc2009-12-08 17:03:02 -05002322 /* Try to add suffix */
2323 for (i = 1; i < MAX_EVENT_INDEX; i++) {
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002324 ret = e_snprintf(buf, len, "%s_%d", base, i);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002325 if (ret < 0) {
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00002326 pr_debug("snprintf() failed: %d\n", ret);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002327 return ret;
2328 }
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002329 if (!strlist__has_entry(namelist, buf))
2330 break;
2331 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002332 if (i == MAX_EVENT_INDEX) {
2333 pr_warning("Too many events are on the same function.\n");
2334 ret = -ERANGE;
2335 }
2336
2337 return ret;
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002338}
2339
Masami Hiramatsu79702f62015-02-28 11:53:29 +09002340/* Warn if the current kernel's uprobe implementation is old */
2341static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2342{
2343 int i;
2344 char *buf = synthesize_probe_trace_command(tev);
2345
2346 /* Old uprobe event doesn't support memory dereference */
2347 if (!tev->uprobes || tev->nargs == 0 || !buf)
2348 goto out;
2349
2350 for (i = 0; i < tev->nargs; i++)
2351 if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2352 pr_warning("Please upgrade your kernel to at least "
2353 "3.14 to have access to feature %s\n",
2354 tev->args[i].value);
2355 break;
2356 }
2357out:
2358 free(buf);
2359}
2360
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302361static int __add_probe_trace_events(struct perf_probe_event *pev,
2362 struct probe_trace_event *tevs,
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002363 int ntevs, bool allow_suffix)
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002364{
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002365 int i, fd, ret;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302366 struct probe_trace_event *tev = NULL;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002367 char buf[64];
2368 const char *event, *group;
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002369 struct strlist *namelist;
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002370 LIST_HEAD(blacklist);
2371 struct kprobe_blacklist_node *node;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002372
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302373 if (pev->uprobes)
2374 fd = open_uprobe_events(true);
2375 else
2376 fd = open_kprobe_events(true);
2377
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002378 if (fd < 0) {
2379 print_open_warning(fd, !pev->uprobes);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002380 return fd;
Masami Hiramatsu5e451872014-08-13 16:12:48 +00002381 }
2382
Masami Hiramatsub498ce12009-11-30 19:20:25 -05002383 /* Get current event names */
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302384 namelist = get_probe_trace_event_names(fd, false);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002385 if (!namelist) {
2386 pr_debug("Failed to get current event list.\n");
2387 return -EIO;
2388 }
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002389 /* Get kprobe blacklist if exists */
2390 if (!pev->uprobes) {
2391 ret = kprobe_blacklist__load(&blacklist);
2392 if (ret < 0)
2393 pr_debug("No kprobe blacklist support, ignored\n");
2394 }
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002395
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002396 ret = 0;
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002397 pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04002398 for (i = 0; i < ntevs; i++) {
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002399 tev = &tevs[i];
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002400 /* Ensure that the address is NOT blacklisted */
2401 node = kprobe_blacklist__find_by_address(&blacklist,
2402 tev->point.address);
2403 if (node) {
2404 pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol);
2405 continue;
2406 }
2407
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002408 if (pev->event)
2409 event = pev->event;
2410 else
2411 if (pev->point.function)
2412 event = pev->point.function;
2413 else
2414 event = tev->point.symbol;
2415 if (pev->group)
2416 group = pev->group;
2417 else
2418 group = PERFPROBE_GROUP;
2419
2420 /* Get an unused new event name */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002421 ret = get_new_event_name(buf, 64, event,
2422 namelist, allow_suffix);
2423 if (ret < 0)
2424 break;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002425 event = buf;
2426
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04002427 tev->event = strdup(event);
2428 tev->group = strdup(group);
2429 if (tev->event == NULL || tev->group == NULL) {
2430 ret = -ENOMEM;
2431 break;
2432 }
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302433 ret = write_probe_trace_event(fd, tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002434 if (ret < 0)
2435 break;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002436 /* Add added event name to namelist */
2437 strlist__add(namelist, event);
2438
2439 /* Trick here - save current event/group */
2440 event = pev->event;
2441 group = pev->group;
2442 pev->event = tev->event;
2443 pev->group = tev->group;
Masami Hiramatsufb226cc2014-02-06 05:32:13 +00002444 show_perf_probe_event(pev, tev->point.module);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002445 /* Trick here - restore current event/group */
2446 pev->event = (char *)event;
2447 pev->group = (char *)group;
2448
2449 /*
2450 * Probes after the first probe which comes from same
2451 * user input are always allowed to add suffix, because
2452 * there might be several addresses corresponding to
2453 * one code line.
2454 */
2455 allow_suffix = true;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002456 }
Masami Hiramatsu79702f62015-02-28 11:53:29 +09002457 if (ret == -EINVAL && pev->uprobes)
2458 warn_uprobe_event_compat(tev);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002459
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002460 /* Note that it is possible to skip all events because of blacklist */
2461 if (ret >= 0 && tev->event) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002462 /* Show how to use the event. */
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002463 pr_info("\nYou can now use it in all perf tools, such as:\n\n");
2464 pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002465 tev->event);
2466 }
Masami Hiramatsua9b495b2009-12-08 17:02:47 -05002467
Masami Hiramatsu9aaf5a52015-02-19 23:31:13 +09002468 kprobe_blacklist__delete(&blacklist);
Masami Hiramatsue1d20172009-12-07 12:00:46 -05002469 strlist__delete(namelist);
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002470 close(fd);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002471 return ret;
Masami Hiramatsu50656ee2009-11-30 19:19:58 -05002472}
Masami Hiramatsufa282442009-12-08 17:03:23 -05002473
Namhyung Kim564c62a2015-01-14 20:18:07 +09002474static int find_probe_functions(struct map *map, char *name)
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002475{
Namhyung Kim564c62a2015-01-14 20:18:07 +09002476 int found = 0;
Arnaldo Carvalho de Melo0a3873a2015-01-16 16:40:25 -03002477 struct symbol *sym;
Namhyung Kim564c62a2015-01-14 20:18:07 +09002478
Arnaldo Carvalho de Melo0a3873a2015-01-16 16:40:25 -03002479 map__for_each_symbol_by_name(map, name, sym) {
Namhyung Kime578da32015-03-06 16:31:29 +09002480 found++;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002481 }
Namhyung Kim564c62a2015-01-14 20:18:07 +09002482
2483 return found;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002484}
2485
2486#define strdup_or_goto(str, label) \
2487 ({ char *__p = strdup(str); if (!__p) goto label; __p; })
2488
Naveen N. Rao7b6ff0b2015-04-28 17:35:40 +05302489void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2490 struct probe_trace_event *tev __maybe_unused,
2491 struct map *map __maybe_unused) { }
2492
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002493/*
2494 * Find probe function addresses from map.
2495 * Return an error or the number of found probe_trace_event
2496 */
2497static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2498 struct probe_trace_event **tevs,
2499 int max_tevs, const char *target)
2500{
2501 struct map *map = NULL;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002502 struct ref_reloc_sym *reloc_sym = NULL;
2503 struct symbol *sym;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002504 struct probe_trace_event *tev;
2505 struct perf_probe_point *pp = &pev->point;
2506 struct probe_trace_point *tp;
Namhyung Kim564c62a2015-01-14 20:18:07 +09002507 int num_matched_functions;
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002508 int ret, i;
2509
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +09002510 map = get_target_map(target, pev->uprobes);
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002511 if (!map) {
2512 ret = -EINVAL;
2513 goto out;
2514 }
2515
2516 /*
2517 * Load matched symbols: Since the different local symbols may have
2518 * same name but different addresses, this lists all the symbols.
2519 */
Namhyung Kim564c62a2015-01-14 20:18:07 +09002520 num_matched_functions = find_probe_functions(map, pp->function);
2521 if (num_matched_functions == 0) {
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002522 pr_err("Failed to find symbol %s in %s\n", pp->function,
2523 target ? : "kernel");
2524 ret = -ENOENT;
2525 goto out;
2526 } else if (num_matched_functions > max_tevs) {
2527 pr_err("Too many functions matched in %s\n",
2528 target ? : "kernel");
2529 ret = -E2BIG;
2530 goto out;
2531 }
2532
Namhyung Kim25dd9172015-01-14 20:18:08 +09002533 if (!pev->uprobes && !pp->retprobe) {
He Kuang0560a0c2015-03-20 09:56:56 +08002534 reloc_sym = kernel_get_ref_reloc_sym();
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002535 if (!reloc_sym) {
2536 pr_warning("Relocated base symbol is not found!\n");
2537 ret = -EINVAL;
2538 goto out;
2539 }
2540 }
2541
2542 /* Setup result trace-probe-events */
2543 *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2544 if (!*tevs) {
2545 ret = -ENOMEM;
2546 goto out;
2547 }
2548
2549 ret = 0;
Namhyung Kim564c62a2015-01-14 20:18:07 +09002550
Arnaldo Carvalho de Melo0a3873a2015-01-16 16:40:25 -03002551 map__for_each_symbol_by_name(map, pp->function, sym) {
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002552 tev = (*tevs) + ret;
2553 tp = &tev->point;
2554 if (ret == num_matched_functions) {
2555 pr_warning("Too many symbols are listed. Skip it.\n");
2556 break;
2557 }
2558 ret++;
2559
2560 if (pp->offset > sym->end - sym->start) {
2561 pr_warning("Offset %ld is bigger than the size of %s\n",
2562 pp->offset, sym->name);
2563 ret = -ENOENT;
2564 goto err_out;
2565 }
2566 /* Add one probe point */
2567 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2568 if (reloc_sym) {
2569 tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2570 tp->offset = tp->address - reloc_sym->addr;
2571 } else {
2572 tp->symbol = strdup_or_goto(sym->name, nomem_out);
2573 tp->offset = pp->offset;
2574 }
2575 tp->retprobe = pp->retprobe;
2576 if (target)
2577 tev->point.module = strdup_or_goto(target, nomem_out);
2578 tev->uprobes = pev->uprobes;
2579 tev->nargs = pev->nargs;
2580 if (tev->nargs) {
2581 tev->args = zalloc(sizeof(struct probe_trace_arg) *
2582 tev->nargs);
2583 if (tev->args == NULL)
2584 goto nomem_out;
2585 }
2586 for (i = 0; i < tev->nargs; i++) {
2587 if (pev->args[i].name)
2588 tev->args[i].name =
2589 strdup_or_goto(pev->args[i].name,
2590 nomem_out);
2591
2592 tev->args[i].value = strdup_or_goto(pev->args[i].var,
2593 nomem_out);
2594 if (pev->args[i].type)
2595 tev->args[i].type =
2596 strdup_or_goto(pev->args[i].type,
2597 nomem_out);
2598 }
Naveen N. Rao7b6ff0b2015-04-28 17:35:40 +05302599 arch__fix_tev_from_maps(pev, tev, map);
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002600 }
2601
2602out:
Masami Hiramatsu9b118ac2015-03-06 16:31:20 +09002603 put_target_map(map, pev->uprobes);
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002604 return ret;
2605
2606nomem_out:
2607 ret = -ENOMEM;
2608err_out:
2609 clear_probe_trace_events(*tevs, num_matched_functions);
2610 zfree(tevs);
2611 goto out;
2612}
2613
Naveen N. Raod5c2e2c2015-04-28 17:35:39 +05302614bool __weak arch__prefers_symtab(void) { return false; }
2615
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302616static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2617 struct probe_trace_event **tevs,
Srikar Dronamraju4eced232012-02-02 19:50:40 +05302618 int max_tevs, const char *target)
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -04002619{
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002620 int ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002621
Masami Hiramatsufb7345b2013-12-26 05:41:53 +00002622 if (pev->uprobes && !pev->group) {
2623 /* Replace group name if not given */
2624 ret = convert_exec_to_group(target, &pev->group);
2625 if (ret != 0) {
2626 pr_warning("Failed to make a group name.\n");
2627 return ret;
2628 }
2629 }
2630
Naveen N. Raod5c2e2c2015-04-28 17:35:39 +05302631 if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
2632 ret = find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
2633 if (ret > 0)
2634 return ret; /* Found in symbol table */
2635 }
2636
Masami Hiramatsu4b4da7f2010-03-22 13:10:26 -03002637 /* Convert perf_probe_event with debuginfo */
Srikar Dronamraju4eced232012-02-02 19:50:40 +05302638 ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
Masami Hiramatsue334016f12010-04-12 13:17:49 -04002639 if (ret != 0)
Masami Hiramatsu190b57f2011-06-27 16:27:45 +09002640 return ret; /* Found in debuginfo or got an error */
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -04002641
Masami Hiramatsueb948e52014-02-06 05:32:25 +00002642 return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002643}
2644
2645struct __event_package {
2646 struct perf_probe_event *pev;
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302647 struct probe_trace_event *tevs;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002648 int ntevs;
2649};
2650
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002651int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
Masami Hiramatsu7afb3fa2015-04-01 19:25:39 +09002652 int max_tevs, bool force_add)
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002653{
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002654 int i, j, ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002655 struct __event_package *pkgs;
2656
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302657 ret = 0;
Masami Hiramatsue334016f12010-04-12 13:17:49 -04002658 pkgs = zalloc(sizeof(struct __event_package) * npevs);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302659
Masami Hiramatsue334016f12010-04-12 13:17:49 -04002660 if (pkgs == NULL)
2661 return -ENOMEM;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002662
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +00002663 ret = init_symbol_maps(pevs->uprobes);
Masami Hiramatsu449e5b22010-08-03 11:11:40 +09002664 if (ret < 0) {
2665 free(pkgs);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002666 return ret;
Masami Hiramatsu449e5b22010-08-03 11:11:40 +09002667 }
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002668
2669 /* Loop 1: convert all events */
2670 for (i = 0; i < npevs; i++) {
2671 pkgs[i].pev = &pevs[i];
2672 /* Convert with or without debuginfo */
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302673 ret = convert_to_probe_trace_events(pkgs[i].pev,
Masami Hiramatsu469b9b82010-10-21 19:13:41 +09002674 &pkgs[i].tevs,
2675 max_tevs,
Masami Hiramatsu7afb3fa2015-04-01 19:25:39 +09002676 pkgs[i].pev->target);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002677 if (ret < 0)
2678 goto end;
2679 pkgs[i].ntevs = ret;
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002680 }
2681
2682 /* Loop 2: add all events */
Arnaldo Carvalho de Melo8635bf62011-02-22 06:56:18 -03002683 for (i = 0; i < npevs; i++) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302684 ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002685 pkgs[i].ntevs, force_add);
Arnaldo Carvalho de Melofbee6322011-02-21 13:23:57 -03002686 if (ret < 0)
2687 break;
2688 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002689end:
Masami Hiramatsu449e5b22010-08-03 11:11:40 +09002690 /* Loop 3: cleanup and free trace events */
2691 for (i = 0; i < npevs; i++) {
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002692 for (j = 0; j < pkgs[i].ntevs; j++)
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302693 clear_probe_trace_event(&pkgs[i].tevs[j]);
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -03002694 zfree(&pkgs[i].tevs);
Masami Hiramatsu449e5b22010-08-03 11:11:40 +09002695 }
2696 free(pkgs);
Masami Hiramatsuee45b6c2014-02-06 05:32:04 +00002697 exit_symbol_maps();
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002698
2699 return ret;
Masami Hiramatsue0faa8d2010-03-16 18:05:37 -04002700}
2701
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302702static int __del_trace_probe_event(int fd, struct str_node *ent)
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002703{
2704 char *p;
2705 char buf[128];
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002706 int ret;
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002707
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302708 /* Convert from perf-probe event to trace-probe event */
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002709 ret = e_snprintf(buf, 128, "-:%s", ent->s);
2710 if (ret < 0)
2711 goto error;
2712
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002713 p = strchr(buf + 2, ':');
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002714 if (!p) {
2715 pr_debug("Internal error: %s should have ':' but not.\n",
2716 ent->s);
2717 ret = -ENOTSUP;
2718 goto error;
2719 }
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002720 *p = '/';
2721
Masami Hiramatsu4235b042010-03-16 18:06:12 -04002722 pr_debug("Writing event: %s\n", buf);
2723 ret = write(fd, buf, strlen(buf));
Masami Hiramatsu44a56042011-10-04 19:45:04 +09002724 if (ret < 0) {
2725 ret = -errno;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002726 goto error;
Masami Hiramatsu44a56042011-10-04 19:45:04 +09002727 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002728
Masami Hiramatsu5e17b282014-10-27 16:31:31 -04002729 pr_info("Removed event: %s\n", ent->s);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002730 return 0;
2731error:
Masami Hiramatsu5f03cba2014-08-14 02:22:34 +00002732 pr_warning("Failed to delete event: %s\n",
2733 strerror_r(-ret, buf, sizeof(buf)));
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002734 return ret;
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002735}
2736
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302737static int del_trace_probe_event(int fd, const char *buf,
2738 struct strlist *namelist)
Masami Hiramatsufa282442009-12-08 17:03:23 -05002739{
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002740 struct str_node *ent, *n;
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002741 int ret = -ENOENT;
Masami Hiramatsufa282442009-12-08 17:03:23 -05002742
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002743 if (strpbrk(buf, "*?")) { /* Glob-exp */
2744 strlist__for_each_safe(ent, n, namelist)
2745 if (strglobmatch(ent->s, buf)) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302746 ret = __del_trace_probe_event(fd, ent);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002747 if (ret < 0)
2748 break;
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002749 strlist__remove(namelist, ent);
2750 }
2751 } else {
2752 ent = strlist__find(namelist, buf);
2753 if (ent) {
Srikar Dronamraju0e608362010-07-29 19:43:51 +05302754 ret = __del_trace_probe_event(fd, ent);
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002755 if (ret >= 0)
2756 strlist__remove(namelist, ent);
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002757 }
2758 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002759
2760 return ret;
Masami Hiramatsufa282442009-12-08 17:03:23 -05002761}
2762
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002763int del_perf_probe_events(struct strlist *dellist)
Masami Hiramatsufa282442009-12-08 17:03:23 -05002764{
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002765 int ret = -1, ret2, ufd = -1, kfd = -1;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302766 char buf[128];
Masami Hiramatsufa282442009-12-08 17:03:23 -05002767 const char *group, *event;
2768 char *p, *str;
2769 struct str_node *ent;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302770 struct strlist *namelist = NULL, *unamelist = NULL;
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002771
Masami Hiramatsufa282442009-12-08 17:03:23 -05002772 /* Get current event names */
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302773 kfd = open_kprobe_events(true);
Masami Hiramatsu467ec082014-08-13 16:12:50 +00002774 if (kfd >= 0)
2775 namelist = get_probe_trace_event_names(kfd, true);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302776
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302777 ufd = open_uprobe_events(true);
Masami Hiramatsu467ec082014-08-13 16:12:50 +00002778 if (ufd >= 0)
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302779 unamelist = get_probe_trace_event_names(ufd, true);
2780
Masami Hiramatsu467ec082014-08-13 16:12:50 +00002781 if (kfd < 0 && ufd < 0) {
2782 print_both_open_warning(kfd, ufd);
2783 goto error;
2784 }
2785
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002786 if (namelist == NULL && unamelist == NULL) {
2787 ret = -ENOENT;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302788 goto error;
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002789 }
Masami Hiramatsufa282442009-12-08 17:03:23 -05002790
Masami Hiramatsuadf365f2009-12-15 10:32:03 -05002791 strlist__for_each(ent, dellist) {
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04002792 str = strdup(ent->s);
2793 if (str == NULL) {
2794 ret = -ENOMEM;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302795 goto error;
Masami Hiramatsu02b95da2010-04-12 13:17:56 -04002796 }
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002797 pr_debug("Parsing: %s\n", str);
Masami Hiramatsufa282442009-12-08 17:03:23 -05002798 p = strchr(str, ':');
2799 if (p) {
2800 group = str;
2801 *p = '\0';
2802 event = p + 1;
2803 } else {
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002804 group = "*";
Masami Hiramatsufa282442009-12-08 17:03:23 -05002805 event = str;
2806 }
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302807
Naveen N. Rao3099c022015-04-28 17:35:34 +05302808 if (event && *event == '.')
2809 event++;
2810
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302811 ret = e_snprintf(buf, 128, "%s:%s", group, event);
2812 if (ret < 0) {
2813 pr_err("Failed to copy event.");
2814 free(str);
2815 goto error;
2816 }
2817
Masami Hiramatsubbbb5212009-12-15 10:32:10 -05002818 pr_debug("Group: %s, Event: %s\n", group, event);
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002819 free(str);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302820
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002821 ret = ret2 = -ENOENT;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302822 if (namelist)
2823 ret = del_trace_probe_event(kfd, buf, namelist);
2824
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002825 if ((ret >= 0 || ret == -ENOENT) && unamelist)
2826 ret2 = del_trace_probe_event(ufd, buf, unamelist);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302827
Masami Hiramatsu6dbe31f2015-04-23 22:46:14 +09002828 /* Since we can remove probes which already removed, don't check it */
2829 if (ret == -ENOENT && ret2 == -ENOENT)
2830 pr_debug("Event \"%s\" does not exist.\n", buf);
2831 else if (ret < 0 || ret2 < 0) {
2832 if (ret >= 0)
2833 ret = ret2;
2834 break;
2835 }
Masami Hiramatsufa282442009-12-08 17:03:23 -05002836 }
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302837
2838error:
2839 if (kfd >= 0) {
Srikar Dronamrajua23c4dc2012-05-31 17:16:43 +05302840 strlist__delete(namelist);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302841 close(kfd);
2842 }
2843
2844 if (ufd >= 0) {
Srikar Dronamrajua23c4dc2012-05-31 17:16:43 +05302845 strlist__delete(unamelist);
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302846 close(ufd);
2847 }
Masami Hiramatsu146a1432010-04-12 13:17:42 -04002848
2849 return ret;
Masami Hiramatsufa282442009-12-08 17:03:23 -05002850}
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302851
Masami Hiramatsu3c422582011-01-20 23:15:45 +09002852/* TODO: don't use a global variable for filter ... */
2853static struct strfilter *available_func_filter;
Masami Hiramatsufa282442009-12-08 17:03:23 -05002854
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002855/*
Masami Hiramatsu3c422582011-01-20 23:15:45 +09002856 * If a symbol corresponds to a function with global binding and
2857 * matches filter return 0. For all others return 1.
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002858 */
Irina Tirdea1d037ca2012-09-11 01:15:03 +03002859static int filter_available_functions(struct map *map __maybe_unused,
Masami Hiramatsu3c422582011-01-20 23:15:45 +09002860 struct symbol *sym)
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002861{
Namhyung Kime578da32015-03-06 16:31:29 +09002862 if (strfilter__compare(available_func_filter, sym->name))
Masami Hiramatsu3c422582011-01-20 23:15:45 +09002863 return 0;
2864 return 1;
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002865}
2866
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002867int show_available_funcs(const char *target, struct strfilter *_filter,
2868 bool user)
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002869{
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002870 struct map *map;
2871 int ret;
2872
2873 ret = init_symbol_maps(user);
2874 if (ret < 0)
2875 return ret;
2876
2877 /* Get a symbol map */
2878 if (user)
2879 map = dso__new_map(target);
2880 else
2881 map = kernel_get_module_map(target);
2882 if (!map) {
2883 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002884 return -EINVAL;
2885 }
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002886
2887 /* Load symbols with given filter */
2888 available_func_filter = _filter;
2889 if (map__load(map, filter_available_functions)) {
2890 pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
2891 goto end;
2892 }
Masami Hiramatsue80711c2011-01-13 21:46:11 +09002893 if (!dso__sorted_by_name(map->dso, map->type))
2894 dso__sort_by_name(map->dso, map->type);
2895
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002896 /* Show all (filtered) symbols */
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302897 setup_pager();
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002898 dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
2899end:
2900 if (user) {
2901 dso__delete(map->dso);
2902 map__delete(map);
2903 }
2904 exit_symbol_maps();
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302905
Masami Hiramatsu2df58632014-02-06 05:32:11 +00002906 return ret;
Srikar Dronamraju225466f2012-04-16 17:39:09 +05302907}
2908