?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.8-rc8
[linux/fpc-iii.git] / tools / perf / util / probe-event.c
blob28733962cd80a63e1376b5b71f4771ab8f8857f7
1 /*
2 * probe-event.c : perf-probe definition to probe_events format converter
3 *
4 * Written by Masami Hiramatsu <mhiramat@redhat.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 *
20 */
21
22 #include <sys/utsname.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdarg.h>
32 #include <limits.h>
33 #include <elf.h>
34
35 #include "util.h"
36 #include "event.h"
37 #include "strlist.h"
38 #include "debug.h"
39 #include "cache.h"
40 #include "color.h"
41 #include "symbol.h"
42 #include "thread.h"
43 #include <api/fs/fs.h>
44 #include "trace-event.h" /* For __maybe_unused */
45 #include "probe-event.h"
46 #include "probe-finder.h"
47 #include "probe-file.h"
48 #include "session.h"
49
50 #define MAX_CMDLEN 256
51 #define PERFPROBE_GROUP "probe"
52
53 bool probe_event_dry_run; /* Dry run flag */
54 struct probe_conf probe_conf;
55
56 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
57
58 int e_snprintf(char *str, size_t size, const char *format, ...)
59 {
60 int ret;
61 va_list ap;
62 va_start(ap, format);
63 ret = vsnprintf(str, size, format, ap);
64 va_end(ap);
65 if (ret >= (int)size)
66 ret = -E2BIG;
67 return ret;
68 }
69
70 static struct machine *host_machine;
71
72 /* Initialize symbol maps and path of vmlinux/modules */
73 int init_probe_symbol_maps(bool user_only)
74 {
75 int ret;
76
77 symbol_conf.sort_by_name = true;
78 symbol_conf.allow_aliases = true;
79 ret = symbol__init(NULL);
80 if (ret < 0) {
81 pr_debug("Failed to init symbol map.\n");
82 goto out;
83 }
84
85 if (host_machine || user_only) /* already initialized */
86 return 0;
87
88 if (symbol_conf.vmlinux_name)
89 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
90
91 host_machine = machine__new_host();
92 if (!host_machine) {
93 pr_debug("machine__new_host() failed.\n");
94 symbol__exit();
95 ret = -1;
96 }
97 out:
98 if (ret < 0)
99 pr_warning("Failed to init vmlinux path.\n");
100 return ret;
101 }
102
103 void exit_probe_symbol_maps(void)
104 {
105 machine__delete(host_machine);
106 host_machine = NULL;
107 symbol__exit();
108 }
109
110 static struct symbol *__find_kernel_function_by_name(const char *name,
111 struct map **mapp)
112 {
113 return machine__find_kernel_function_by_name(host_machine, name, mapp,
114 NULL);
115 }
116
117 static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
118 {
119 return machine__find_kernel_function(host_machine, addr, mapp, NULL);
120 }
121
122 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
123 {
124 /* kmap->ref_reloc_sym should be set if host_machine is initialized */
125 struct kmap *kmap;
126 struct map *map = machine__kernel_map(host_machine);
127
128 if (map__load(map, NULL) < 0)
129 return NULL;
130
131 kmap = map__kmap(map);
132 if (!kmap)
133 return NULL;
134 return kmap->ref_reloc_sym;
135 }
136
137 static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
138 bool reloc, bool reladdr)
139 {
140 struct ref_reloc_sym *reloc_sym;
141 struct symbol *sym;
142 struct map *map;
143
144 /* ref_reloc_sym is just a label. Need a special fix*/
145 reloc_sym = kernel_get_ref_reloc_sym();
146 if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
147 *addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
148 else {
149 sym = __find_kernel_function_by_name(name, &map);
150 if (!sym)
151 return -ENOENT;
152 *addr = map->unmap_ip(map, sym->start) -
153 ((reloc) ? 0 : map->reloc) -
154 ((reladdr) ? map->start : 0);
155 }
156 return 0;
157 }
158
159 static struct map *kernel_get_module_map(const char *module)
160 {
161 struct map_groups *grp = &host_machine->kmaps;
162 struct maps *maps = &grp->maps[MAP__FUNCTION];
163 struct map *pos;
164
165 /* A file path -- this is an offline module */
166 if (module && strchr(module, '/'))
167 return machine__findnew_module_map(host_machine, 0, module);
168
169 if (!module)
170 module = "kernel";
171
172 for (pos = maps__first(maps); pos; pos = map__next(pos)) {
173 /* short_name is "[module]" */
174 if (strncmp(pos->dso->short_name + 1, module,
175 pos->dso->short_name_len - 2) == 0 &&
176 module[pos->dso->short_name_len - 2] == '\0') {
177 return pos;
178 }
179 }
180 return NULL;
181 }
182
183 struct map *get_target_map(const char *target, bool user)
184 {
185 /* Init maps of given executable or kernel */
186 if (user)
187 return dso__new_map(target);
188 else
189 return kernel_get_module_map(target);
190 }
191
192 static void put_target_map(struct map *map, bool user)
193 {
194 if (map && user) {
195 /* Only the user map needs to be released */
196 map__put(map);
197 }
198 }
199
200
201 static int convert_exec_to_group(const char *exec, char **result)
202 {
203 char *ptr1, *ptr2, *exec_copy;
204 char buf[64];
205 int ret;
206
207 exec_copy = strdup(exec);
208 if (!exec_copy)
209 return -ENOMEM;
210
211 ptr1 = basename(exec_copy);
212 if (!ptr1) {
213 ret = -EINVAL;
214 goto out;
215 }
216
217 ptr2 = strpbrk(ptr1, "-._");
218 if (ptr2)
219 *ptr2 = '\0';
220 ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
221 if (ret < 0)
222 goto out;
223
224 *result = strdup(buf);
225 ret = *result ? 0 : -ENOMEM;
226
227 out:
228 free(exec_copy);
229 return ret;
230 }
231
232 static void clear_perf_probe_point(struct perf_probe_point *pp)
233 {
234 free(pp->file);
235 free(pp->function);
236 free(pp->lazy_line);
237 }
238
239 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
240 {
241 int i;
242
243 for (i = 0; i < ntevs; i++)
244 clear_probe_trace_event(tevs + i);
245 }
246
247 static bool kprobe_blacklist__listed(unsigned long address);
248 static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
249 {
250 u64 etext_addr = 0;
251 int ret;
252
253 /* Get the address of _etext for checking non-probable text symbol */
254 ret = kernel_get_symbol_address_by_name("_etext", &etext_addr,
255 false, false);
256
257 if (ret == 0 && etext_addr < address)
258 pr_warning("%s is out of .text, skip it.\n", symbol);
259 else if (kprobe_blacklist__listed(address))
260 pr_warning("%s is blacklisted function, skip it.\n", symbol);
261 else
262 return false;
263
264 return true;
265 }
266
267 /*
268 * NOTE:
269 * '.gnu.linkonce.this_module' section of kernel module elf directly
270 * maps to 'struct module' from linux/module.h. This section contains
271 * actual module name which will be used by kernel after loading it.
272 * But, we cannot use 'struct module' here since linux/module.h is not
273 * exposed to user-space. Offset of 'name' has remained same from long
274 * time, so hardcoding it here.
275 */
276 #ifdef __LP64__
277 #define MOD_NAME_OFFSET 24
278 #else
279 #define MOD_NAME_OFFSET 12
280 #endif
281
282 /*
283 * @module can be module name of module file path. In case of path,
284 * inspect elf and find out what is actual module name.
285 * Caller has to free mod_name after using it.
286 */
287 static char *find_module_name(const char *module)
288 {
289 int fd;
290 Elf *elf;
291 GElf_Ehdr ehdr;
292 GElf_Shdr shdr;
293 Elf_Data *data;
294 Elf_Scn *sec;
295 char *mod_name = NULL;
296
297 fd = open(module, O_RDONLY);
298 if (fd < 0)
299 return NULL;
300
301 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
302 if (elf == NULL)
303 goto elf_err;
304
305 if (gelf_getehdr(elf, &ehdr) == NULL)
306 goto ret_err;
307
308 sec = elf_section_by_name(elf, &ehdr, &shdr,
309 ".gnu.linkonce.this_module", NULL);
310 if (!sec)
311 goto ret_err;
312
313 data = elf_getdata(sec, NULL);
314 if (!data || !data->d_buf)
315 goto ret_err;
316
317 mod_name = strdup((char *)data->d_buf + MOD_NAME_OFFSET);
318
319 ret_err:
320 elf_end(elf);
321 elf_err:
322 close(fd);
323 return mod_name;
324 }
325
326 #ifdef HAVE_DWARF_SUPPORT
327
328 static int kernel_get_module_dso(const char *module, struct dso **pdso)
329 {
330 struct dso *dso;
331 struct map *map;
332 const char *vmlinux_name;
333 int ret = 0;
334
335 if (module) {
336 char module_name[128];
337
338 snprintf(module_name, sizeof(module_name), "[%s]", module);
339 map = map_groups__find_by_name(&host_machine->kmaps, MAP__FUNCTION, module_name);
340 if (map) {
341 dso = map->dso;
342 goto found;
343 }
344 pr_debug("Failed to find module %s.\n", module);
345 return -ENOENT;
346 }
347
348 map = machine__kernel_map(host_machine);
349 dso = map->dso;
350
351 vmlinux_name = symbol_conf.vmlinux_name;
352 dso->load_errno = 0;
353 if (vmlinux_name)
354 ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL);
355 else
356 ret = dso__load_vmlinux_path(dso, map, NULL);
357 found:
358 *pdso = dso;
359 return ret;
360 }
361
362 /*
363 * Some binaries like glibc have special symbols which are on the symbol
364 * table, but not in the debuginfo. If we can find the address of the
365 * symbol from map, we can translate the address back to the probe point.
366 */
367 static int find_alternative_probe_point(struct debuginfo *dinfo,
368 struct perf_probe_point *pp,
369 struct perf_probe_point *result,
370 const char *target, bool uprobes)
371 {
372 struct map *map = NULL;
373 struct symbol *sym;
374 u64 address = 0;
375 int ret = -ENOENT;
376
377 /* This can work only for function-name based one */
378 if (!pp->function || pp->file)
379 return -ENOTSUP;
380
381 map = get_target_map(target, uprobes);
382 if (!map)
383 return -EINVAL;
384
385 /* Find the address of given function */
386 map__for_each_symbol_by_name(map, pp->function, sym) {
387 if (uprobes)
388 address = sym->start;
389 else
390 address = map->unmap_ip(map, sym->start) - map->reloc;
391 break;
392 }
393 if (!address) {
394 ret = -ENOENT;
395 goto out;
396 }
397 pr_debug("Symbol %s address found : %" PRIx64 "\n",
398 pp->function, address);
399
400 ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
401 result);
402 if (ret <= 0)
403 ret = (!ret) ? -ENOENT : ret;
404 else {
405 result->offset += pp->offset;
406 result->line += pp->line;
407 result->retprobe = pp->retprobe;
408 ret = 0;
409 }
410
411 out:
412 put_target_map(map, uprobes);
413 return ret;
414
415 }
416
417 static int get_alternative_probe_event(struct debuginfo *dinfo,
418 struct perf_probe_event *pev,
419 struct perf_probe_point *tmp)
420 {
421 int ret;
422
423 memcpy(tmp, &pev->point, sizeof(*tmp));
424 memset(&pev->point, 0, sizeof(pev->point));
425 ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
426 pev->target, pev->uprobes);
427 if (ret < 0)
428 memcpy(&pev->point, tmp, sizeof(*tmp));
429
430 return ret;
431 }
432
433 static int get_alternative_line_range(struct debuginfo *dinfo,
434 struct line_range *lr,
435 const char *target, bool user)
436 {
437 struct perf_probe_point pp = { .function = lr->function,
438 .file = lr->file,
439 .line = lr->start };
440 struct perf_probe_point result;
441 int ret, len = 0;
442
443 memset(&result, 0, sizeof(result));
444
445 if (lr->end != INT_MAX)
446 len = lr->end - lr->start;
447 ret = find_alternative_probe_point(dinfo, &pp, &result,
448 target, user);
449 if (!ret) {
450 lr->function = result.function;
451 lr->file = result.file;
452 lr->start = result.line;
453 if (lr->end != INT_MAX)
454 lr->end = lr->start + len;
455 clear_perf_probe_point(&pp);
456 }
457 return ret;
458 }
459
460 /* Open new debuginfo of given module */
461 static struct debuginfo *open_debuginfo(const char *module, bool silent)
462 {
463 const char *path = module;
464 char reason[STRERR_BUFSIZE];
465 struct debuginfo *ret = NULL;
466 struct dso *dso = NULL;
467 int err;
468
469 if (!module || !strchr(module, '/')) {
470 err = kernel_get_module_dso(module, &dso);
471 if (err < 0) {
472 if (!dso || dso->load_errno == 0) {
473 if (!str_error_r(-err, reason, STRERR_BUFSIZE))
474 strcpy(reason, "(unknown)");
475 } else
476 dso__strerror_load(dso, reason, STRERR_BUFSIZE);
477 if (!silent)
478 pr_err("Failed to find the path for %s: %s\n",
479 module ?: "kernel", reason);
480 return NULL;
481 }
482 path = dso->long_name;
483 }
484 ret = debuginfo__new(path);
485 if (!ret && !silent) {
486 pr_warning("The %s file has no debug information.\n", path);
487 if (!module || !strtailcmp(path, ".ko"))
488 pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
489 else
490 pr_warning("Rebuild with -g, ");
491 pr_warning("or install an appropriate debuginfo package.\n");
492 }
493 return ret;
494 }
495
496 /* For caching the last debuginfo */
497 static struct debuginfo *debuginfo_cache;
498 static char *debuginfo_cache_path;
499
500 static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
501 {
502 const char *path = module;
503
504 /* If the module is NULL, it should be the kernel. */
505 if (!module)
506 path = "kernel";
507
508 if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path))
509 goto out;
510
511 /* Copy module path */
512 free(debuginfo_cache_path);
513 debuginfo_cache_path = strdup(path);
514 if (!debuginfo_cache_path) {
515 debuginfo__delete(debuginfo_cache);
516 debuginfo_cache = NULL;
517 goto out;
518 }
519
520 debuginfo_cache = open_debuginfo(module, silent);
521 if (!debuginfo_cache)
522 zfree(&debuginfo_cache_path);
523 out:
524 return debuginfo_cache;
525 }
526
527 static void debuginfo_cache__exit(void)
528 {
529 debuginfo__delete(debuginfo_cache);
530 debuginfo_cache = NULL;
531 zfree(&debuginfo_cache_path);
532 }
533
534
535 static int get_text_start_address(const char *exec, unsigned long *address)
536 {
537 Elf *elf;
538 GElf_Ehdr ehdr;
539 GElf_Shdr shdr;
540 int fd, ret = -ENOENT;
541
542 fd = open(exec, O_RDONLY);
543 if (fd < 0)
544 return -errno;
545
546 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
547 if (elf == NULL) {
548 ret = -EINVAL;
549 goto out_close;
550 }
551
552 if (gelf_getehdr(elf, &ehdr) == NULL)
553 goto out;
554
555 if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
556 goto out;
557
558 *address = shdr.sh_addr - shdr.sh_offset;
559 ret = 0;
560 out:
561 elf_end(elf);
562 out_close:
563 close(fd);
564
565 return ret;
566 }
567
568 /*
569 * Convert trace point to probe point with debuginfo
570 */
571 static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
572 struct perf_probe_point *pp,
573 bool is_kprobe)
574 {
575 struct debuginfo *dinfo = NULL;
576 unsigned long stext = 0;
577 u64 addr = tp->address;
578 int ret = -ENOENT;
579
580 /* convert the address to dwarf address */
581 if (!is_kprobe) {
582 if (!addr) {
583 ret = -EINVAL;
584 goto error;
585 }
586 ret = get_text_start_address(tp->module, &stext);
587 if (ret < 0)
588 goto error;
589 addr += stext;
590 } else if (tp->symbol) {
591 /* If the module is given, this returns relative address */
592 ret = kernel_get_symbol_address_by_name(tp->symbol, &addr,
593 false, !!tp->module);
594 if (ret != 0)
595 goto error;
596 addr += tp->offset;
597 }
598
599 pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
600 tp->module ? : "kernel");
601
602 dinfo = debuginfo_cache__open(tp->module, verbose == 0);
603 if (dinfo)
604 ret = debuginfo__find_probe_point(dinfo,
605 (unsigned long)addr, pp);
606 else
607 ret = -ENOENT;
608
609 if (ret > 0) {
610 pp->retprobe = tp->retprobe;
611 return 0;
612 }
613 error:
614 pr_debug("Failed to find corresponding probes from debuginfo.\n");
615 return ret ? : -ENOENT;
616 }
617
618 static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
619 int ntevs, const char *exec)
620 {
621 int i, ret = 0;
622 unsigned long stext = 0;
623
624 if (!exec)
625 return 0;
626
627 ret = get_text_start_address(exec, &stext);
628 if (ret < 0)
629 return ret;
630
631 for (i = 0; i < ntevs && ret >= 0; i++) {
632 /* point.address is the addres of point.symbol + point.offset */
633 tevs[i].point.address -= stext;
634 tevs[i].point.module = strdup(exec);
635 if (!tevs[i].point.module) {
636 ret = -ENOMEM;
637 break;
638 }
639 tevs[i].uprobes = true;
640 }
641
642 return ret;
643 }
644
645 static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
646 int ntevs, const char *module)
647 {
648 int i, ret = 0;
649 char *mod_name = NULL;
650
651 if (!module)
652 return 0;
653
654 mod_name = find_module_name(module);
655
656 for (i = 0; i < ntevs; i++) {
657 tevs[i].point.module =
658 strdup(mod_name ? mod_name : module);
659 if (!tevs[i].point.module) {
660 ret = -ENOMEM;
661 break;
662 }
663 }
664
665 free(mod_name);
666 return ret;
667 }
668
669 static int
670 post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
671 int ntevs)
672 {
673 struct ref_reloc_sym *reloc_sym;
674 char *tmp;
675 int i, skipped = 0;
676
677 reloc_sym = kernel_get_ref_reloc_sym();
678 if (!reloc_sym) {
679 pr_warning("Relocated base symbol is not found!\n");
680 return -EINVAL;
681 }
682
683 for (i = 0; i < ntevs; i++) {
684 if (!tevs[i].point.address || tevs[i].point.retprobe)
685 continue;
686 /* If we found a wrong one, mark it by NULL symbol */
687 if (kprobe_warn_out_range(tevs[i].point.symbol,
688 tevs[i].point.address)) {
689 tmp = NULL;
690 skipped++;
691 } else {
692 tmp = strdup(reloc_sym->name);
693 if (!tmp)
694 return -ENOMEM;
695 }
696 /* If we have no realname, use symbol for it */
697 if (!tevs[i].point.realname)
698 tevs[i].point.realname = tevs[i].point.symbol;
699 else
700 free(tevs[i].point.symbol);
701 tevs[i].point.symbol = tmp;
702 tevs[i].point.offset = tevs[i].point.address -
703 reloc_sym->unrelocated_addr;
704 }
705 return skipped;
706 }
707
708 void __weak
709 arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
710 int ntevs __maybe_unused)
711 {
712 }
713
714 /* Post processing the probe events */
715 static int post_process_probe_trace_events(struct perf_probe_event *pev,
716 struct probe_trace_event *tevs,
717 int ntevs, const char *module,
718 bool uprobe)
719 {
720 int ret;
721
722 if (uprobe)
723 ret = add_exec_to_probe_trace_events(tevs, ntevs, module);
724 else if (module)
725 /* Currently ref_reloc_sym based probe is not for drivers */
726 ret = add_module_to_probe_trace_events(tevs, ntevs, module);
727 else
728 ret = post_process_kernel_probe_trace_events(tevs, ntevs);
729
730 if (ret >= 0)
731 arch__post_process_probe_trace_events(pev, ntevs);
732
733 return ret;
734 }
735
736 /* Try to find perf_probe_event with debuginfo */
737 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
738 struct probe_trace_event **tevs)
739 {
740 bool need_dwarf = perf_probe_event_need_dwarf(pev);
741 struct perf_probe_point tmp;
742 struct debuginfo *dinfo;
743 int ntevs, ret = 0;
744
745 dinfo = open_debuginfo(pev->target, !need_dwarf);
746 if (!dinfo) {
747 if (need_dwarf)
748 return -ENOENT;
749 pr_debug("Could not open debuginfo. Try to use symbols.\n");
750 return 0;
751 }
752
753 pr_debug("Try to find probe point from debuginfo.\n");
754 /* Searching trace events corresponding to a probe event */
755 ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
756
757 if (ntevs == 0) { /* Not found, retry with an alternative */
758 ret = get_alternative_probe_event(dinfo, pev, &tmp);
759 if (!ret) {
760 ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
761 /*
762 * Write back to the original probe_event for
763 * setting appropriate (user given) event name
764 */
765 clear_perf_probe_point(&pev->point);
766 memcpy(&pev->point, &tmp, sizeof(tmp));
767 }
768 }
769
770 debuginfo__delete(dinfo);
771
772 if (ntevs > 0) { /* Succeeded to find trace events */
773 pr_debug("Found %d probe_trace_events.\n", ntevs);
774 ret = post_process_probe_trace_events(pev, *tevs, ntevs,
775 pev->target, pev->uprobes);
776 if (ret < 0 || ret == ntevs) {
777 clear_probe_trace_events(*tevs, ntevs);
778 zfree(tevs);
779 }
780 if (ret != ntevs)
781 return ret < 0 ? ret : ntevs;
782 ntevs = 0;
783 /* Fall through */
784 }
785
786 if (ntevs == 0) { /* No error but failed to find probe point. */
787 pr_warning("Probe point '%s' not found.\n",
788 synthesize_perf_probe_point(&pev->point));
789 return -ENOENT;
790 }
791 /* Error path : ntevs < 0 */
792 pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
793 if (ntevs < 0) {
794 if (ntevs == -EBADF)
795 pr_warning("Warning: No dwarf info found in the vmlinux - "
796 "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
797 if (!need_dwarf) {
798 pr_debug("Trying to use symbols.\n");
799 return 0;
800 }
801 }
802 return ntevs;
803 }
804
805 #define LINEBUF_SIZE 256
806 #define NR_ADDITIONAL_LINES 2
807
808 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
809 {
810 char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
811 const char *color = show_num ? "" : PERF_COLOR_BLUE;
812 const char *prefix = NULL;
813
814 do {
815 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
816 goto error;
817 if (skip)
818 continue;
819 if (!prefix) {
820 prefix = show_num ? "%7d " : " ";
821 color_fprintf(stdout, color, prefix, l);
822 }
823 color_fprintf(stdout, color, "%s", buf);
824
825 } while (strchr(buf, '\n') == NULL);
826
827 return 1;
828 error:
829 if (ferror(fp)) {
830 pr_warning("File read error: %s\n",
831 str_error_r(errno, sbuf, sizeof(sbuf)));
832 return -1;
833 }
834 return 0;
835 }
836
837 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
838 {
839 int rv = __show_one_line(fp, l, skip, show_num);
840 if (rv == 0) {
841 pr_warning("Source file is shorter than expected.\n");
842 rv = -1;
843 }
844 return rv;
845 }
846
847 #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)
848 #define show_one_line(f,l) _show_one_line(f,l,false,false)
849 #define skip_one_line(f,l) _show_one_line(f,l,true,false)
850 #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)
851
852 /*
853 * Show line-range always requires debuginfo to find source file and
854 * line number.
855 */
856 static int __show_line_range(struct line_range *lr, const char *module,
857 bool user)
858 {
859 int l = 1;
860 struct int_node *ln;
861 struct debuginfo *dinfo;
862 FILE *fp;
863 int ret;
864 char *tmp;
865 char sbuf[STRERR_BUFSIZE];
866
867 /* Search a line range */
868 dinfo = open_debuginfo(module, false);
869 if (!dinfo)
870 return -ENOENT;
871
872 ret = debuginfo__find_line_range(dinfo, lr);
873 if (!ret) { /* Not found, retry with an alternative */
874 ret = get_alternative_line_range(dinfo, lr, module, user);
875 if (!ret)
876 ret = debuginfo__find_line_range(dinfo, lr);
877 }
878 debuginfo__delete(dinfo);
879 if (ret == 0 || ret == -ENOENT) {
880 pr_warning("Specified source line is not found.\n");
881 return -ENOENT;
882 } else if (ret < 0) {
883 pr_warning("Debuginfo analysis failed.\n");
884 return ret;
885 }
886
887 /* Convert source file path */
888 tmp = lr->path;
889 ret = get_real_path(tmp, lr->comp_dir, &lr->path);
890
891 /* Free old path when new path is assigned */
892 if (tmp != lr->path)
893 free(tmp);
894
895 if (ret < 0) {
896 pr_warning("Failed to find source file path.\n");
897 return ret;
898 }
899
900 setup_pager();
901
902 if (lr->function)
903 fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
904 lr->start - lr->offset);
905 else
906 fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
907
908 fp = fopen(lr->path, "r");
909 if (fp == NULL) {
910 pr_warning("Failed to open %s: %s\n", lr->path,
911 str_error_r(errno, sbuf, sizeof(sbuf)));
912 return -errno;
913 }
914 /* Skip to starting line number */
915 while (l < lr->start) {
916 ret = skip_one_line(fp, l++);
917 if (ret < 0)
918 goto end;
919 }
920
921 intlist__for_each_entry(ln, lr->line_list) {
922 for (; ln->i > l; l++) {
923 ret = show_one_line(fp, l - lr->offset);
924 if (ret < 0)
925 goto end;
926 }
927 ret = show_one_line_with_num(fp, l++ - lr->offset);
928 if (ret < 0)
929 goto end;
930 }
931
932 if (lr->end == INT_MAX)
933 lr->end = l + NR_ADDITIONAL_LINES;
934 while (l <= lr->end) {
935 ret = show_one_line_or_eof(fp, l++ - lr->offset);
936 if (ret <= 0)
937 break;
938 }
939 end:
940 fclose(fp);
941 return ret;
942 }
943
944 int show_line_range(struct line_range *lr, const char *module, bool user)
945 {
946 int ret;
947
948 ret = init_probe_symbol_maps(user);
949 if (ret < 0)
950 return ret;
951 ret = __show_line_range(lr, module, user);
952 exit_probe_symbol_maps();
953
954 return ret;
955 }
956
957 static int show_available_vars_at(struct debuginfo *dinfo,
958 struct perf_probe_event *pev,
959 struct strfilter *_filter)
960 {
961 char *buf;
962 int ret, i, nvars;
963 struct str_node *node;
964 struct variable_list *vls = NULL, *vl;
965 struct perf_probe_point tmp;
966 const char *var;
967
968 buf = synthesize_perf_probe_point(&pev->point);
969 if (!buf)
970 return -EINVAL;
971 pr_debug("Searching variables at %s\n", buf);
972
973 ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
974 if (!ret) { /* Not found, retry with an alternative */
975 ret = get_alternative_probe_event(dinfo, pev, &tmp);
976 if (!ret) {
977 ret = debuginfo__find_available_vars_at(dinfo, pev,
978 &vls);
979 /* Release the old probe_point */
980 clear_perf_probe_point(&tmp);
981 }
982 }
983 if (ret <= 0) {
984 if (ret == 0 || ret == -ENOENT) {
985 pr_err("Failed to find the address of %s\n", buf);
986 ret = -ENOENT;
987 } else
988 pr_warning("Debuginfo analysis failed.\n");
989 goto end;
990 }
991
992 /* Some variables are found */
993 fprintf(stdout, "Available variables at %s\n", buf);
994 for (i = 0; i < ret; i++) {
995 vl = &vls[i];
996 /*
997 * A probe point might be converted to
998 * several trace points.
999 */
1000 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
1001 vl->point.offset);
1002 zfree(&vl->point.symbol);
1003 nvars = 0;
1004 if (vl->vars) {
1005 strlist__for_each_entry(node, vl->vars) {
1006 var = strchr(node->s, '\t') + 1;
1007 if (strfilter__compare(_filter, var)) {
1008 fprintf(stdout, "\t\t%s\n", node->s);
1009 nvars++;
1010 }
1011 }
1012 strlist__delete(vl->vars);
1013 }
1014 if (nvars == 0)
1015 fprintf(stdout, "\t\t(No matched variables)\n");
1016 }
1017 free(vls);
1018 end:
1019 free(buf);
1020 return ret;
1021 }
1022
1023 /* Show available variables on given probe point */
1024 int show_available_vars(struct perf_probe_event *pevs, int npevs,
1025 struct strfilter *_filter)
1026 {
1027 int i, ret = 0;
1028 struct debuginfo *dinfo;
1029
1030 ret = init_probe_symbol_maps(pevs->uprobes);
1031 if (ret < 0)
1032 return ret;
1033
1034 dinfo = open_debuginfo(pevs->target, false);
1035 if (!dinfo) {
1036 ret = -ENOENT;
1037 goto out;
1038 }
1039
1040 setup_pager();
1041
1042 for (i = 0; i < npevs && ret >= 0; i++)
1043 ret = show_available_vars_at(dinfo, &pevs[i], _filter);
1044
1045 debuginfo__delete(dinfo);
1046 out:
1047 exit_probe_symbol_maps();
1048 return ret;
1049 }
1050
1051 #else /* !HAVE_DWARF_SUPPORT */
1052
1053 static void debuginfo_cache__exit(void)
1054 {
1055 }
1056
1057 static int
1058 find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
1059 struct perf_probe_point *pp __maybe_unused,
1060 bool is_kprobe __maybe_unused)
1061 {
1062 return -ENOSYS;
1063 }
1064
1065 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
1066 struct probe_trace_event **tevs __maybe_unused)
1067 {
1068 if (perf_probe_event_need_dwarf(pev)) {
1069 pr_warning("Debuginfo-analysis is not supported.\n");
1070 return -ENOSYS;
1071 }
1072
1073 return 0;
1074 }
1075
1076 int show_line_range(struct line_range *lr __maybe_unused,
1077 const char *module __maybe_unused,
1078 bool user __maybe_unused)
1079 {
1080 pr_warning("Debuginfo-analysis is not supported.\n");
1081 return -ENOSYS;
1082 }
1083
1084 int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1085 int npevs __maybe_unused,
1086 struct strfilter *filter __maybe_unused)
1087 {
1088 pr_warning("Debuginfo-analysis is not supported.\n");
1089 return -ENOSYS;
1090 }
1091 #endif
1092
1093 void line_range__clear(struct line_range *lr)
1094 {
1095 free(lr->function);
1096 free(lr->file);
1097 free(lr->path);
1098 free(lr->comp_dir);
1099 intlist__delete(lr->line_list);
1100 memset(lr, 0, sizeof(*lr));
1101 }
1102
1103 int line_range__init(struct line_range *lr)
1104 {
1105 memset(lr, 0, sizeof(*lr));
1106 lr->line_list = intlist__new(NULL);
1107 if (!lr->line_list)
1108 return -ENOMEM;
1109 else
1110 return 0;
1111 }
1112
1113 static int parse_line_num(char **ptr, int *val, const char *what)
1114 {
1115 const char *start = *ptr;
1116
1117 errno = 0;
1118 *val = strtol(*ptr, ptr, 0);
1119 if (errno || *ptr == start) {
1120 semantic_error("'%s' is not a valid number.\n", what);
1121 return -EINVAL;
1122 }
1123 return 0;
1124 }
1125
1126 /* Check the name is good for event, group or function */
1127 static bool is_c_func_name(const char *name)
1128 {
1129 if (!isalpha(*name) && *name != '_')
1130 return false;
1131 while (*++name != '\0') {
1132 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
1133 return false;
1134 }
1135 return true;
1136 }
1137
1138 /*
1139 * Stuff 'lr' according to the line range described by 'arg'.
1140 * The line range syntax is described by:
1141 *
1142 * SRC[:SLN[+NUM|-ELN]]
1143 * FNC[@SRC][:SLN[+NUM|-ELN]]
1144 */
1145 int parse_line_range_desc(const char *arg, struct line_range *lr)
1146 {
1147 char *range, *file, *name = strdup(arg);
1148 int err;
1149
1150 if (!name)
1151 return -ENOMEM;
1152
1153 lr->start = 0;
1154 lr->end = INT_MAX;
1155
1156 range = strchr(name, ':');
1157 if (range) {
1158 *range++ = '\0';
1159
1160 err = parse_line_num(&range, &lr->start, "start line");
1161 if (err)
1162 goto err;
1163
1164 if (*range == '+' || *range == '-') {
1165 const char c = *range++;
1166
1167 err = parse_line_num(&range, &lr->end, "end line");
1168 if (err)
1169 goto err;
1170
1171 if (c == '+') {
1172 lr->end += lr->start;
1173 /*
1174 * Adjust the number of lines here.
1175 * If the number of lines == 1, the
1176 * the end of line should be equal to
1177 * the start of line.
1178 */
1179 lr->end--;
1180 }
1181 }
1182
1183 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1184
1185 err = -EINVAL;
1186 if (lr->start > lr->end) {
1187 semantic_error("Start line must be smaller"
1188 " than end line.\n");
1189 goto err;
1190 }
1191 if (*range != '\0') {
1192 semantic_error("Tailing with invalid str '%s'.\n", range);
1193 goto err;
1194 }
1195 }
1196
1197 file = strchr(name, '@');
1198 if (file) {
1199 *file = '\0';
1200 lr->file = strdup(++file);
1201 if (lr->file == NULL) {
1202 err = -ENOMEM;
1203 goto err;
1204 }
1205 lr->function = name;
1206 } else if (strchr(name, '/') || strchr(name, '.'))
1207 lr->file = name;
1208 else if (is_c_func_name(name))/* We reuse it for checking funcname */
1209 lr->function = name;
1210 else { /* Invalid name */
1211 semantic_error("'%s' is not a valid function name.\n", name);
1212 err = -EINVAL;
1213 goto err;
1214 }
1215
1216 return 0;
1217 err:
1218 free(name);
1219 return err;
1220 }
1221
1222 static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
1223 {
1224 char *ptr;
1225
1226 ptr = strchr(*arg, ':');
1227 if (ptr) {
1228 *ptr = '\0';
1229 if (!pev->sdt && !is_c_func_name(*arg))
1230 goto ng_name;
1231 pev->group = strdup(*arg);
1232 if (!pev->group)
1233 return -ENOMEM;
1234 *arg = ptr + 1;
1235 } else
1236 pev->group = NULL;
1237 if (!pev->sdt && !is_c_func_name(*arg)) {
1238 ng_name:
1239 semantic_error("%s is bad for event name -it must "
1240 "follow C symbol-naming rule.\n", *arg);
1241 return -EINVAL;
1242 }
1243 pev->event = strdup(*arg);
1244 if (pev->event == NULL)
1245 return -ENOMEM;
1246
1247 return 0;
1248 }
1249
1250 /* Parse probepoint definition. */
1251 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1252 {
1253 struct perf_probe_point *pp = &pev->point;
1254 char *ptr, *tmp;
1255 char c, nc = 0;
1256 bool file_spec = false;
1257 int ret;
1258
1259 /*
1260 * <Syntax>
1261 * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
1262 * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1263 * perf probe %[GRP:]SDT_EVENT
1264 */
1265 if (!arg)
1266 return -EINVAL;
1267
1268 /*
1269 * If the probe point starts with '%',
1270 * or starts with "sdt_" and has a ':' but no '=',
1271 * then it should be a SDT/cached probe point.
1272 */
1273 if (arg[0] == '%' ||
1274 (!strncmp(arg, "sdt_", 4) &&
1275 !!strchr(arg, ':') && !strchr(arg, '='))) {
1276 pev->sdt = true;
1277 if (arg[0] == '%')
1278 arg++;
1279 }
1280
1281 ptr = strpbrk(arg, ";=@+%");
1282 if (pev->sdt) {
1283 if (ptr) {
1284 if (*ptr != '@') {
1285 semantic_error("%s must be an SDT name.\n",
1286 arg);
1287 return -EINVAL;
1288 }
1289 /* This must be a target file name or build id */
1290 tmp = build_id_cache__complement(ptr + 1);
1291 if (tmp) {
1292 pev->target = build_id_cache__origname(tmp);
1293 free(tmp);
1294 } else
1295 pev->target = strdup(ptr + 1);
1296 if (!pev->target)
1297 return -ENOMEM;
1298 *ptr = '\0';
1299 }
1300 ret = parse_perf_probe_event_name(&arg, pev);
1301 if (ret == 0) {
1302 if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
1303 ret = -errno;
1304 }
1305 return ret;
1306 }
1307
1308 if (ptr && *ptr == '=') { /* Event name */
1309 *ptr = '\0';
1310 tmp = ptr + 1;
1311 ret = parse_perf_probe_event_name(&arg, pev);
1312 if (ret < 0)
1313 return ret;
1314
1315 arg = tmp;
1316 }
1317
1318 /*
1319 * Check arg is function or file name and copy it.
1320 *
1321 * We consider arg to be a file spec if and only if it satisfies
1322 * all of the below criteria::
1323 * - it does not include any of "+@%",
1324 * - it includes one of ":;", and
1325 * - it has a period '.' in the name.
1326 *
1327 * Otherwise, we consider arg to be a function specification.
1328 */
1329 if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) {
1330 /* This is a file spec if it includes a '.' before ; or : */
1331 if (memchr(arg, '.', ptr - arg))
1332 file_spec = true;
1333 }
1334
1335 ptr = strpbrk(arg, ";:+@%");
1336 if (ptr) {
1337 nc = *ptr;
1338 *ptr++ = '\0';
1339 }
1340
1341 if (arg[0] == '\0')
1342 tmp = NULL;
1343 else {
1344 tmp = strdup(arg);
1345 if (tmp == NULL)
1346 return -ENOMEM;
1347 }
1348
1349 if (file_spec)
1350 pp->file = tmp;
1351 else {
1352 pp->function = tmp;
1353
1354 /*
1355 * Keep pp->function even if this is absolute address,
1356 * so it can mark whether abs_address is valid.
1357 * Which make 'perf probe lib.bin 0x0' possible.
1358 *
1359 * Note that checking length of tmp is not needed
1360 * because when we access tmp[1] we know tmp[0] is '0',
1361 * so tmp[1] should always valid (but could be '\0').
1362 */
1363 if (tmp && !strncmp(tmp, "0x", 2)) {
1364 pp->abs_address = strtoul(pp->function, &tmp, 0);
1365 if (*tmp != '\0') {
1366 semantic_error("Invalid absolute address.\n");
1367 return -EINVAL;
1368 }
1369 }
1370 }
1371
1372 /* Parse other options */
1373 while (ptr) {
1374 arg = ptr;
1375 c = nc;
1376 if (c == ';') { /* Lazy pattern must be the last part */
1377 pp->lazy_line = strdup(arg);
1378 if (pp->lazy_line == NULL)
1379 return -ENOMEM;
1380 break;
1381 }
1382 ptr = strpbrk(arg, ";:+@%");
1383 if (ptr) {
1384 nc = *ptr;
1385 *ptr++ = '\0';
1386 }
1387 switch (c) {
1388 case ':': /* Line number */
1389 pp->line = strtoul(arg, &tmp, 0);
1390 if (*tmp != '\0') {
1391 semantic_error("There is non-digit char"
1392 " in line number.\n");
1393 return -EINVAL;
1394 }
1395 break;
1396 case '+': /* Byte offset from a symbol */
1397 pp->offset = strtoul(arg, &tmp, 0);
1398 if (*tmp != '\0') {
1399 semantic_error("There is non-digit character"
1400 " in offset.\n");
1401 return -EINVAL;
1402 }
1403 break;
1404 case '@': /* File name */
1405 if (pp->file) {
1406 semantic_error("SRC@SRC is not allowed.\n");
1407 return -EINVAL;
1408 }
1409 pp->file = strdup(arg);
1410 if (pp->file == NULL)
1411 return -ENOMEM;
1412 break;
1413 case '%': /* Probe places */
1414 if (strcmp(arg, "return") == 0) {
1415 pp->retprobe = 1;
1416 } else { /* Others not supported yet */
1417 semantic_error("%%%s is not supported.\n", arg);
1418 return -ENOTSUP;
1419 }
1420 break;
1421 default: /* Buggy case */
1422 pr_err("This program has a bug at %s:%d.\n",
1423 __FILE__, __LINE__);
1424 return -ENOTSUP;
1425 break;
1426 }
1427 }
1428
1429 /* Exclusion check */
1430 if (pp->lazy_line && pp->line) {
1431 semantic_error("Lazy pattern can't be used with"
1432 " line number.\n");
1433 return -EINVAL;
1434 }
1435
1436 if (pp->lazy_line && pp->offset) {
1437 semantic_error("Lazy pattern can't be used with offset.\n");
1438 return -EINVAL;
1439 }
1440
1441 if (pp->line && pp->offset) {
1442 semantic_error("Offset can't be used with line number.\n");
1443 return -EINVAL;
1444 }
1445
1446 if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1447 semantic_error("File always requires line number or "
1448 "lazy pattern.\n");
1449 return -EINVAL;
1450 }
1451
1452 if (pp->offset && !pp->function) {
1453 semantic_error("Offset requires an entry function.\n");
1454 return -EINVAL;
1455 }
1456
1457 if (pp->retprobe && !pp->function) {
1458 semantic_error("Return probe requires an entry function.\n");
1459 return -EINVAL;
1460 }
1461
1462 if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1463 semantic_error("Offset/Line/Lazy pattern can't be used with "
1464 "return probe.\n");
1465 return -EINVAL;
1466 }
1467
1468 pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1469 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1470 pp->lazy_line);
1471 return 0;
1472 }
1473
1474 /* Parse perf-probe event argument */
1475 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1476 {
1477 char *tmp, *goodname;
1478 struct perf_probe_arg_field **fieldp;
1479
1480 pr_debug("parsing arg: %s into ", str);
1481
1482 tmp = strchr(str, '=');
1483 if (tmp) {
1484 arg->name = strndup(str, tmp - str);
1485 if (arg->name == NULL)
1486 return -ENOMEM;
1487 pr_debug("name:%s ", arg->name);
1488 str = tmp + 1;
1489 }
1490
1491 tmp = strchr(str, ':');
1492 if (tmp) { /* Type setting */
1493 *tmp = '\0';
1494 arg->type = strdup(tmp + 1);
1495 if (arg->type == NULL)
1496 return -ENOMEM;
1497 pr_debug("type:%s ", arg->type);
1498 }
1499
1500 tmp = strpbrk(str, "-.[");
1501 if (!is_c_varname(str) || !tmp) {
1502 /* A variable, register, symbol or special value */
1503 arg->var = strdup(str);
1504 if (arg->var == NULL)
1505 return -ENOMEM;
1506 pr_debug("%s\n", arg->var);
1507 return 0;
1508 }
1509
1510 /* Structure fields or array element */
1511 arg->var = strndup(str, tmp - str);
1512 if (arg->var == NULL)
1513 return -ENOMEM;
1514 goodname = arg->var;
1515 pr_debug("%s, ", arg->var);
1516 fieldp = &arg->field;
1517
1518 do {
1519 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1520 if (*fieldp == NULL)
1521 return -ENOMEM;
1522 if (*tmp == '[') { /* Array */
1523 str = tmp;
1524 (*fieldp)->index = strtol(str + 1, &tmp, 0);
1525 (*fieldp)->ref = true;
1526 if (*tmp != ']' || tmp == str + 1) {
1527 semantic_error("Array index must be a"
1528 " number.\n");
1529 return -EINVAL;
1530 }
1531 tmp++;
1532 if (*tmp == '\0')
1533 tmp = NULL;
1534 } else { /* Structure */
1535 if (*tmp == '.') {
1536 str = tmp + 1;
1537 (*fieldp)->ref = false;
1538 } else if (tmp[1] == '>') {
1539 str = tmp + 2;
1540 (*fieldp)->ref = true;
1541 } else {
1542 semantic_error("Argument parse error: %s\n",
1543 str);
1544 return -EINVAL;
1545 }
1546 tmp = strpbrk(str, "-.[");
1547 }
1548 if (tmp) {
1549 (*fieldp)->name = strndup(str, tmp - str);
1550 if ((*fieldp)->name == NULL)
1551 return -ENOMEM;
1552 if (*str != '[')
1553 goodname = (*fieldp)->name;
1554 pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1555 fieldp = &(*fieldp)->next;
1556 }
1557 } while (tmp);
1558 (*fieldp)->name = strdup(str);
1559 if ((*fieldp)->name == NULL)
1560 return -ENOMEM;
1561 if (*str != '[')
1562 goodname = (*fieldp)->name;
1563 pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1564
1565 /* If no name is specified, set the last field name (not array index)*/
1566 if (!arg->name) {
1567 arg->name = strdup(goodname);
1568 if (arg->name == NULL)
1569 return -ENOMEM;
1570 }
1571 return 0;
1572 }
1573
1574 /* Parse perf-probe event command */
1575 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1576 {
1577 char **argv;
1578 int argc, i, ret = 0;
1579
1580 argv = argv_split(cmd, &argc);
1581 if (!argv) {
1582 pr_debug("Failed to split arguments.\n");
1583 return -ENOMEM;
1584 }
1585 if (argc - 1 > MAX_PROBE_ARGS) {
1586 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1587 ret = -ERANGE;
1588 goto out;
1589 }
1590 /* Parse probe point */
1591 ret = parse_perf_probe_point(argv[0], pev);
1592 if (ret < 0)
1593 goto out;
1594
1595 /* Copy arguments and ensure return probe has no C argument */
1596 pev->nargs = argc - 1;
1597 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1598 if (pev->args == NULL) {
1599 ret = -ENOMEM;
1600 goto out;
1601 }
1602 for (i = 0; i < pev->nargs && ret >= 0; i++) {
1603 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1604 if (ret >= 0 &&
1605 is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1606 semantic_error("You can't specify local variable for"
1607 " kretprobe.\n");
1608 ret = -EINVAL;
1609 }
1610 }
1611 out:
1612 argv_free(argv);
1613
1614 return ret;
1615 }
1616
1617 /* Return true if this perf_probe_event requires debuginfo */
1618 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1619 {
1620 int i;
1621
1622 if (pev->point.file || pev->point.line || pev->point.lazy_line)
1623 return true;
1624
1625 for (i = 0; i < pev->nargs; i++)
1626 if (is_c_varname(pev->args[i].var) ||
1627 !strcmp(pev->args[i].var, "$params") ||
1628 !strcmp(pev->args[i].var, "$vars"))
1629 return true;
1630
1631 return false;
1632 }
1633
1634 /* Parse probe_events event into struct probe_point */
1635 int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1636 {
1637 struct probe_trace_point *tp = &tev->point;
1638 char pr;
1639 char *p;
1640 char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1641 int ret, i, argc;
1642 char **argv;
1643
1644 pr_debug("Parsing probe_events: %s\n", cmd);
1645 argv = argv_split(cmd, &argc);
1646 if (!argv) {
1647 pr_debug("Failed to split arguments.\n");
1648 return -ENOMEM;
1649 }
1650 if (argc < 2) {
1651 semantic_error("Too few probe arguments.\n");
1652 ret = -ERANGE;
1653 goto out;
1654 }
1655
1656 /* Scan event and group name. */
1657 argv0_str = strdup(argv[0]);
1658 if (argv0_str == NULL) {
1659 ret = -ENOMEM;
1660 goto out;
1661 }
1662 fmt1_str = strtok_r(argv0_str, ":", &fmt);
1663 fmt2_str = strtok_r(NULL, "/", &fmt);
1664 fmt3_str = strtok_r(NULL, " \t", &fmt);
1665 if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1666 || fmt3_str == NULL) {
1667 semantic_error("Failed to parse event name: %s\n", argv[0]);
1668 ret = -EINVAL;
1669 goto out;
1670 }
1671 pr = fmt1_str[0];
1672 tev->group = strdup(fmt2_str);
1673 tev->event = strdup(fmt3_str);
1674 if (tev->group == NULL || tev->event == NULL) {
1675 ret = -ENOMEM;
1676 goto out;
1677 }
1678 pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1679
1680 tp->retprobe = (pr == 'r');
1681
1682 /* Scan module name(if there), function name and offset */
1683 p = strchr(argv[1], ':');
1684 if (p) {
1685 tp->module = strndup(argv[1], p - argv[1]);
1686 if (!tp->module) {
1687 ret = -ENOMEM;
1688 goto out;
1689 }
1690 tev->uprobes = (tp->module[0] == '/');
1691 p++;
1692 } else
1693 p = argv[1];
1694 fmt1_str = strtok_r(p, "+", &fmt);
1695 /* only the address started with 0x */
1696 if (fmt1_str[0] == '0') {
1697 /*
1698 * Fix a special case:
1699 * if address == 0, kernel reports something like:
1700 * p:probe_libc/abs_0 /lib/libc-2.18.so:0x (null) arg1=%ax
1701 * Newer kernel may fix that, but we want to
1702 * support old kernel also.
1703 */
1704 if (strcmp(fmt1_str, "0x") == 0) {
1705 if (!argv[2] || strcmp(argv[2], "(null)")) {
1706 ret = -EINVAL;
1707 goto out;
1708 }
1709 tp->address = 0;
1710
1711 free(argv[2]);
1712 for (i = 2; argv[i + 1] != NULL; i++)
1713 argv[i] = argv[i + 1];
1714
1715 argv[i] = NULL;
1716 argc -= 1;
1717 } else
1718 tp->address = strtoul(fmt1_str, NULL, 0);
1719 } else {
1720 /* Only the symbol-based probe has offset */
1721 tp->symbol = strdup(fmt1_str);
1722 if (tp->symbol == NULL) {
1723 ret = -ENOMEM;
1724 goto out;
1725 }
1726 fmt2_str = strtok_r(NULL, "", &fmt);
1727 if (fmt2_str == NULL)
1728 tp->offset = 0;
1729 else
1730 tp->offset = strtoul(fmt2_str, NULL, 10);
1731 }
1732
1733 tev->nargs = argc - 2;
1734 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1735 if (tev->args == NULL) {
1736 ret = -ENOMEM;
1737 goto out;
1738 }
1739 for (i = 0; i < tev->nargs; i++) {
1740 p = strchr(argv[i + 2], '=');
1741 if (p) /* We don't need which register is assigned. */
1742 *p++ = '\0';
1743 else
1744 p = argv[i + 2];
1745 tev->args[i].name = strdup(argv[i + 2]);
1746 /* TODO: parse regs and offset */
1747 tev->args[i].value = strdup(p);
1748 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1749 ret = -ENOMEM;
1750 goto out;
1751 }
1752 }
1753 ret = 0;
1754 out:
1755 free(argv0_str);
1756 argv_free(argv);
1757 return ret;
1758 }
1759
1760 /* Compose only probe arg */
1761 char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1762 {
1763 struct perf_probe_arg_field *field = pa->field;
1764 struct strbuf buf;
1765 char *ret = NULL;
1766 int err;
1767
1768 if (strbuf_init(&buf, 64) < 0)
1769 return NULL;
1770
1771 if (pa->name && pa->var)
1772 err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1773 else
1774 err = strbuf_addstr(&buf, pa->name ?: pa->var);
1775 if (err)
1776 goto out;
1777
1778 while (field) {
1779 if (field->name[0] == '[')
1780 err = strbuf_addstr(&buf, field->name);
1781 else
1782 err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
1783 field->name);
1784 field = field->next;
1785 if (err)
1786 goto out;
1787 }
1788
1789 if (pa->type)
1790 if (strbuf_addf(&buf, ":%s", pa->type) < 0)
1791 goto out;
1792
1793 ret = strbuf_detach(&buf, NULL);
1794 out:
1795 strbuf_release(&buf);
1796 return ret;
1797 }
1798
1799 /* Compose only probe point (not argument) */
1800 char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1801 {
1802 struct strbuf buf;
1803 char *tmp, *ret = NULL;
1804 int len, err = 0;
1805
1806 if (strbuf_init(&buf, 64) < 0)
1807 return NULL;
1808
1809 if (pp->function) {
1810 if (strbuf_addstr(&buf, pp->function) < 0)
1811 goto out;
1812 if (pp->offset)
1813 err = strbuf_addf(&buf, "+%lu", pp->offset);
1814 else if (pp->line)
1815 err = strbuf_addf(&buf, ":%d", pp->line);
1816 else if (pp->retprobe)
1817 err = strbuf_addstr(&buf, "%return");
1818 if (err)
1819 goto out;
1820 }
1821 if (pp->file) {
1822 tmp = pp->file;
1823 len = strlen(tmp);
1824 if (len > 30) {
1825 tmp = strchr(pp->file + len - 30, '/');
1826 tmp = tmp ? tmp + 1 : pp->file + len - 30;
1827 }
1828 err = strbuf_addf(&buf, "@%s", tmp);
1829 if (!err && !pp->function && pp->line)
1830 err = strbuf_addf(&buf, ":%d", pp->line);
1831 }
1832 if (!err)
1833 ret = strbuf_detach(&buf, NULL);
1834 out:
1835 strbuf_release(&buf);
1836 return ret;
1837 }
1838
1839 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1840 {
1841 struct strbuf buf;
1842 char *tmp, *ret = NULL;
1843 int i;
1844
1845 if (strbuf_init(&buf, 64))
1846 return NULL;
1847 if (pev->event)
1848 if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
1849 pev->event) < 0)
1850 goto out;
1851
1852 tmp = synthesize_perf_probe_point(&pev->point);
1853 if (!tmp || strbuf_addstr(&buf, tmp) < 0)
1854 goto out;
1855 free(tmp);
1856
1857 for (i = 0; i < pev->nargs; i++) {
1858 tmp = synthesize_perf_probe_arg(pev->args + i);
1859 if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
1860 goto out;
1861 free(tmp);
1862 }
1863
1864 ret = strbuf_detach(&buf, NULL);
1865 out:
1866 strbuf_release(&buf);
1867 return ret;
1868 }
1869
1870 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1871 struct strbuf *buf, int depth)
1872 {
1873 int err;
1874 if (ref->next) {
1875 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1876 depth + 1);
1877 if (depth < 0)
1878 return depth;
1879 }
1880 err = strbuf_addf(buf, "%+ld(", ref->offset);
1881 return (err < 0) ? err : depth;
1882 }
1883
1884 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1885 struct strbuf *buf)
1886 {
1887 struct probe_trace_arg_ref *ref = arg->ref;
1888 int depth = 0, err;
1889
1890 /* Argument name or separator */
1891 if (arg->name)
1892 err = strbuf_addf(buf, " %s=", arg->name);
1893 else
1894 err = strbuf_addch(buf, ' ');
1895 if (err)
1896 return err;
1897
1898 /* Special case: @XXX */
1899 if (arg->value[0] == '@' && arg->ref)
1900 ref = ref->next;
1901
1902 /* Dereferencing arguments */
1903 if (ref) {
1904 depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
1905 if (depth < 0)
1906 return depth;
1907 }
1908
1909 /* Print argument value */
1910 if (arg->value[0] == '@' && arg->ref)
1911 err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
1912 else
1913 err = strbuf_addstr(buf, arg->value);
1914
1915 /* Closing */
1916 while (!err && depth--)
1917 err = strbuf_addch(buf, ')');
1918
1919 /* Print argument type */
1920 if (!err && arg->type)
1921 err = strbuf_addf(buf, ":%s", arg->type);
1922
1923 return err;
1924 }
1925
1926 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1927 {
1928 struct probe_trace_point *tp = &tev->point;
1929 struct strbuf buf;
1930 char *ret = NULL;
1931 int i, err;
1932
1933 /* Uprobes must have tp->module */
1934 if (tev->uprobes && !tp->module)
1935 return NULL;
1936
1937 if (strbuf_init(&buf, 32) < 0)
1938 return NULL;
1939
1940 if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1941 tev->group, tev->event) < 0)
1942 goto error;
1943 /*
1944 * If tp->address == 0, then this point must be a
1945 * absolute address uprobe.
1946 * try_to_find_absolute_address() should have made
1947 * tp->symbol to "0x0".
1948 */
1949 if (tev->uprobes && !tp->address) {
1950 if (!tp->symbol || strcmp(tp->symbol, "0x0"))
1951 goto error;
1952 }
1953
1954 /* Use the tp->address for uprobes */
1955 if (tev->uprobes)
1956 err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address);
1957 else if (!strncmp(tp->symbol, "0x", 2))
1958 /* Absolute address. See try_to_find_absolute_address() */
1959 err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
1960 tp->module ? ":" : "", tp->address);
1961 else
1962 err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
1963 tp->module ? ":" : "", tp->symbol, tp->offset);
1964 if (err)
1965 goto error;
1966
1967 for (i = 0; i < tev->nargs; i++)
1968 if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
1969 goto error;
1970
1971 ret = strbuf_detach(&buf, NULL);
1972 error:
1973 strbuf_release(&buf);
1974 return ret;
1975 }
1976
1977 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1978 struct perf_probe_point *pp,
1979 bool is_kprobe)
1980 {
1981 struct symbol *sym = NULL;
1982 struct map *map;
1983 u64 addr = tp->address;
1984 int ret = -ENOENT;
1985
1986 if (!is_kprobe) {
1987 map = dso__new_map(tp->module);
1988 if (!map)
1989 goto out;
1990 sym = map__find_symbol(map, addr, NULL);
1991 } else {
1992 if (tp->symbol && !addr) {
1993 if (kernel_get_symbol_address_by_name(tp->symbol,
1994 &addr, true, false) < 0)
1995 goto out;
1996 }
1997 if (addr) {
1998 addr += tp->offset;
1999 sym = __find_kernel_function(addr, &map);
2000 }
2001 }
2002
2003 if (!sym)
2004 goto out;
2005
2006 pp->retprobe = tp->retprobe;
2007 pp->offset = addr - map->unmap_ip(map, sym->start);
2008 pp->function = strdup(sym->name);
2009 ret = pp->function ? 0 : -ENOMEM;
2010
2011 out:
2012 if (map && !is_kprobe) {
2013 map__put(map);
2014 }
2015
2016 return ret;
2017 }
2018
2019 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2020 struct perf_probe_point *pp,
2021 bool is_kprobe)
2022 {
2023 char buf[128];
2024 int ret;
2025
2026 ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
2027 if (!ret)
2028 return 0;
2029 ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
2030 if (!ret)
2031 return 0;
2032
2033 pr_debug("Failed to find probe point from both of dwarf and map.\n");
2034
2035 if (tp->symbol) {
2036 pp->function = strdup(tp->symbol);
2037 pp->offset = tp->offset;
2038 } else {
2039 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
2040 if (ret < 0)
2041 return ret;
2042 pp->function = strdup(buf);
2043 pp->offset = 0;
2044 }
2045 if (pp->function == NULL)
2046 return -ENOMEM;
2047
2048 pp->retprobe = tp->retprobe;
2049
2050 return 0;
2051 }
2052
2053 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2054 struct perf_probe_event *pev, bool is_kprobe)
2055 {
2056 struct strbuf buf = STRBUF_INIT;
2057 int i, ret;
2058
2059 /* Convert event/group name */
2060 pev->event = strdup(tev->event);
2061 pev->group = strdup(tev->group);
2062 if (pev->event == NULL || pev->group == NULL)
2063 return -ENOMEM;
2064
2065 /* Convert trace_point to probe_point */
2066 ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2067 if (ret < 0)
2068 return ret;
2069
2070 /* Convert trace_arg to probe_arg */
2071 pev->nargs = tev->nargs;
2072 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
2073 if (pev->args == NULL)
2074 return -ENOMEM;
2075 for (i = 0; i < tev->nargs && ret >= 0; i++) {
2076 if (tev->args[i].name)
2077 pev->args[i].name = strdup(tev->args[i].name);
2078 else {
2079 if ((ret = strbuf_init(&buf, 32)) < 0)
2080 goto error;
2081 ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
2082 pev->args[i].name = strbuf_detach(&buf, NULL);
2083 }
2084 if (pev->args[i].name == NULL && ret >= 0)
2085 ret = -ENOMEM;
2086 }
2087 error:
2088 if (ret < 0)
2089 clear_perf_probe_event(pev);
2090
2091 return ret;
2092 }
2093
2094 void clear_perf_probe_event(struct perf_probe_event *pev)
2095 {
2096 struct perf_probe_arg_field *field, *next;
2097 int i;
2098
2099 free(pev->event);
2100 free(pev->group);
2101 free(pev->target);
2102 clear_perf_probe_point(&pev->point);
2103
2104 for (i = 0; i < pev->nargs; i++) {
2105 free(pev->args[i].name);
2106 free(pev->args[i].var);
2107 free(pev->args[i].type);
2108 field = pev->args[i].field;
2109 while (field) {
2110 next = field->next;
2111 zfree(&field->name);
2112 free(field);
2113 field = next;
2114 }
2115 }
2116 free(pev->args);
2117 memset(pev, 0, sizeof(*pev));
2118 }
2119
2120 #define strdup_or_goto(str, label) \
2121 ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
2122
2123 static int perf_probe_point__copy(struct perf_probe_point *dst,
2124 struct perf_probe_point *src)
2125 {
2126 dst->file = strdup_or_goto(src->file, out_err);
2127 dst->function = strdup_or_goto(src->function, out_err);
2128 dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
2129 dst->line = src->line;
2130 dst->retprobe = src->retprobe;
2131 dst->offset = src->offset;
2132 return 0;
2133
2134 out_err:
2135 clear_perf_probe_point(dst);
2136 return -ENOMEM;
2137 }
2138
2139 static int perf_probe_arg__copy(struct perf_probe_arg *dst,
2140 struct perf_probe_arg *src)
2141 {
2142 struct perf_probe_arg_field *field, **ppfield;
2143
2144 dst->name = strdup_or_goto(src->name, out_err);
2145 dst->var = strdup_or_goto(src->var, out_err);
2146 dst->type = strdup_or_goto(src->type, out_err);
2147
2148 field = src->field;
2149 ppfield = &(dst->field);
2150 while (field) {
2151 *ppfield = zalloc(sizeof(*field));
2152 if (!*ppfield)
2153 goto out_err;
2154 (*ppfield)->name = strdup_or_goto(field->name, out_err);
2155 (*ppfield)->index = field->index;
2156 (*ppfield)->ref = field->ref;
2157 field = field->next;
2158 ppfield = &((*ppfield)->next);
2159 }
2160 return 0;
2161 out_err:
2162 return -ENOMEM;
2163 }
2164
2165 int perf_probe_event__copy(struct perf_probe_event *dst,
2166 struct perf_probe_event *src)
2167 {
2168 int i;
2169
2170 dst->event = strdup_or_goto(src->event, out_err);
2171 dst->group = strdup_or_goto(src->group, out_err);
2172 dst->target = strdup_or_goto(src->target, out_err);
2173 dst->uprobes = src->uprobes;
2174
2175 if (perf_probe_point__copy(&dst->point, &src->point) < 0)
2176 goto out_err;
2177
2178 dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
2179 if (!dst->args)
2180 goto out_err;
2181 dst->nargs = src->nargs;
2182
2183 for (i = 0; i < src->nargs; i++)
2184 if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
2185 goto out_err;
2186 return 0;
2187
2188 out_err:
2189 clear_perf_probe_event(dst);
2190 return -ENOMEM;
2191 }
2192
2193 void clear_probe_trace_event(struct probe_trace_event *tev)
2194 {
2195 struct probe_trace_arg_ref *ref, *next;
2196 int i;
2197
2198 free(tev->event);
2199 free(tev->group);
2200 free(tev->point.symbol);
2201 free(tev->point.realname);
2202 free(tev->point.module);
2203 for (i = 0; i < tev->nargs; i++) {
2204 free(tev->args[i].name);
2205 free(tev->args[i].value);
2206 free(tev->args[i].type);
2207 ref = tev->args[i].ref;
2208 while (ref) {
2209 next = ref->next;
2210 free(ref);
2211 ref = next;
2212 }
2213 }
2214 free(tev->args);
2215 memset(tev, 0, sizeof(*tev));
2216 }
2217
2218 struct kprobe_blacklist_node {
2219 struct list_head list;
2220 unsigned long start;
2221 unsigned long end;
2222 char *symbol;
2223 };
2224
2225 static void kprobe_blacklist__delete(struct list_head *blacklist)
2226 {
2227 struct kprobe_blacklist_node *node;
2228
2229 while (!list_empty(blacklist)) {
2230 node = list_first_entry(blacklist,
2231 struct kprobe_blacklist_node, list);
2232 list_del(&node->list);
2233 free(node->symbol);
2234 free(node);
2235 }
2236 }
2237
2238 static int kprobe_blacklist__load(struct list_head *blacklist)
2239 {
2240 struct kprobe_blacklist_node *node;
2241 const char *__debugfs = debugfs__mountpoint();
2242 char buf[PATH_MAX], *p;
2243 FILE *fp;
2244 int ret;
2245
2246 if (__debugfs == NULL)
2247 return -ENOTSUP;
2248
2249 ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2250 if (ret < 0)
2251 return ret;
2252
2253 fp = fopen(buf, "r");
2254 if (!fp)
2255 return -errno;
2256
2257 ret = 0;
2258 while (fgets(buf, PATH_MAX, fp)) {
2259 node = zalloc(sizeof(*node));
2260 if (!node) {
2261 ret = -ENOMEM;
2262 break;
2263 }
2264 INIT_LIST_HEAD(&node->list);
2265 list_add_tail(&node->list, blacklist);
2266 if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2267 ret = -EINVAL;
2268 break;
2269 }
2270 p = strchr(buf, '\t');
2271 if (p) {
2272 p++;
2273 if (p[strlen(p) - 1] == '\n')
2274 p[strlen(p) - 1] = '\0';
2275 } else
2276 p = (char *)"unknown";
2277 node->symbol = strdup(p);
2278 if (!node->symbol) {
2279 ret = -ENOMEM;
2280 break;
2281 }
2282 pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2283 node->start, node->end, node->symbol);
2284 ret++;
2285 }
2286 if (ret < 0)
2287 kprobe_blacklist__delete(blacklist);
2288 fclose(fp);
2289
2290 return ret;
2291 }
2292
2293 static struct kprobe_blacklist_node *
2294 kprobe_blacklist__find_by_address(struct list_head *blacklist,
2295 unsigned long address)
2296 {
2297 struct kprobe_blacklist_node *node;
2298
2299 list_for_each_entry(node, blacklist, list) {
2300 if (node->start <= address && address <= node->end)
2301 return node;
2302 }
2303
2304 return NULL;
2305 }
2306
2307 static LIST_HEAD(kprobe_blacklist);
2308
2309 static void kprobe_blacklist__init(void)
2310 {
2311 if (!list_empty(&kprobe_blacklist))
2312 return;
2313
2314 if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
2315 pr_debug("No kprobe blacklist support, ignored\n");
2316 }
2317
2318 static void kprobe_blacklist__release(void)
2319 {
2320 kprobe_blacklist__delete(&kprobe_blacklist);
2321 }
2322
2323 static bool kprobe_blacklist__listed(unsigned long address)
2324 {
2325 return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
2326 }
2327
2328 static int perf_probe_event__sprintf(const char *group, const char *event,
2329 struct perf_probe_event *pev,
2330 const char *module,
2331 struct strbuf *result)
2332 {
2333 int i, ret;
2334 char *buf;
2335
2336 if (asprintf(&buf, "%s:%s", group, event) < 0)
2337 return -errno;
2338 ret = strbuf_addf(result, " %-20s (on ", buf);
2339 free(buf);
2340 if (ret)
2341 return ret;
2342
2343 /* Synthesize only event probe point */
2344 buf = synthesize_perf_probe_point(&pev->point);
2345 if (!buf)
2346 return -ENOMEM;
2347 ret = strbuf_addstr(result, buf);
2348 free(buf);
2349
2350 if (!ret && module)
2351 ret = strbuf_addf(result, " in %s", module);
2352
2353 if (!ret && pev->nargs > 0) {
2354 ret = strbuf_add(result, " with", 5);
2355 for (i = 0; !ret && i < pev->nargs; i++) {
2356 buf = synthesize_perf_probe_arg(&pev->args[i]);
2357 if (!buf)
2358 return -ENOMEM;
2359 ret = strbuf_addf(result, " %s", buf);
2360 free(buf);
2361 }
2362 }
2363 if (!ret)
2364 ret = strbuf_addch(result, ')');
2365
2366 return ret;
2367 }
2368
2369 /* Show an event */
2370 int show_perf_probe_event(const char *group, const char *event,
2371 struct perf_probe_event *pev,
2372 const char *module, bool use_stdout)
2373 {
2374 struct strbuf buf = STRBUF_INIT;
2375 int ret;
2376
2377 ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2378 if (ret >= 0) {
2379 if (use_stdout)
2380 printf("%s\n", buf.buf);
2381 else
2382 pr_info("%s\n", buf.buf);
2383 }
2384 strbuf_release(&buf);
2385
2386 return ret;
2387 }
2388
2389 static bool filter_probe_trace_event(struct probe_trace_event *tev,
2390 struct strfilter *filter)
2391 {
2392 char tmp[128];
2393
2394 /* At first, check the event name itself */
2395 if (strfilter__compare(filter, tev->event))
2396 return true;
2397
2398 /* Next, check the combination of name and group */
2399 if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2400 return false;
2401 return strfilter__compare(filter, tmp);
2402 }
2403
2404 static int __show_perf_probe_events(int fd, bool is_kprobe,
2405 struct strfilter *filter)
2406 {
2407 int ret = 0;
2408 struct probe_trace_event tev;
2409 struct perf_probe_event pev;
2410 struct strlist *rawlist;
2411 struct str_node *ent;
2412
2413 memset(&tev, 0, sizeof(tev));
2414 memset(&pev, 0, sizeof(pev));
2415
2416 rawlist = probe_file__get_rawlist(fd);
2417 if (!rawlist)
2418 return -ENOMEM;
2419
2420 strlist__for_each_entry(ent, rawlist) {
2421 ret = parse_probe_trace_command(ent->s, &tev);
2422 if (ret >= 0) {
2423 if (!filter_probe_trace_event(&tev, filter))
2424 goto next;
2425 ret = convert_to_perf_probe_event(&tev, &pev,
2426 is_kprobe);
2427 if (ret < 0)
2428 goto next;
2429 ret = show_perf_probe_event(pev.group, pev.event,
2430 &pev, tev.point.module,
2431 true);
2432 }
2433 next:
2434 clear_perf_probe_event(&pev);
2435 clear_probe_trace_event(&tev);
2436 if (ret < 0)
2437 break;
2438 }
2439 strlist__delete(rawlist);
2440 /* Cleanup cached debuginfo if needed */
2441 debuginfo_cache__exit();
2442
2443 return ret;
2444 }
2445
2446 /* List up current perf-probe events */
2447 int show_perf_probe_events(struct strfilter *filter)
2448 {
2449 int kp_fd, up_fd, ret;
2450
2451 setup_pager();
2452
2453 if (probe_conf.cache)
2454 return probe_cache__show_all_caches(filter);
2455
2456 ret = init_probe_symbol_maps(false);
2457 if (ret < 0)
2458 return ret;
2459
2460 ret = probe_file__open_both(&kp_fd, &up_fd, 0);
2461 if (ret < 0)
2462 return ret;
2463
2464 if (kp_fd >= 0)
2465 ret = __show_perf_probe_events(kp_fd, true, filter);
2466 if (up_fd >= 0 && ret >= 0)
2467 ret = __show_perf_probe_events(up_fd, false, filter);
2468 if (kp_fd > 0)
2469 close(kp_fd);
2470 if (up_fd > 0)
2471 close(up_fd);
2472 exit_probe_symbol_maps();
2473
2474 return ret;
2475 }
2476
2477 static int get_new_event_name(char *buf, size_t len, const char *base,
2478 struct strlist *namelist, bool allow_suffix)
2479 {
2480 int i, ret;
2481 char *p, *nbase;
2482
2483 if (*base == '.')
2484 base++;
2485 nbase = strdup(base);
2486 if (!nbase)
2487 return -ENOMEM;
2488
2489 /* Cut off the dot suffixes (e.g. .const, .isra)*/
2490 p = strchr(nbase, '.');
2491 if (p && p != nbase)
2492 *p = '\0';
2493
2494 /* Try no suffix number */
2495 ret = e_snprintf(buf, len, "%s", nbase);
2496 if (ret < 0) {
2497 pr_debug("snprintf() failed: %d\n", ret);
2498 goto out;
2499 }
2500 if (!strlist__has_entry(namelist, buf))
2501 goto out;
2502
2503 if (!allow_suffix) {
2504 pr_warning("Error: event \"%s\" already exists.\n"
2505 " Hint: Remove existing event by 'perf probe -d'\n"
2506 " or force duplicates by 'perf probe -f'\n"
2507 " or set 'force=yes' in BPF source.\n",
2508 buf);
2509 ret = -EEXIST;
2510 goto out;
2511 }
2512
2513 /* Try to add suffix */
2514 for (i = 1; i < MAX_EVENT_INDEX; i++) {
2515 ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2516 if (ret < 0) {
2517 pr_debug("snprintf() failed: %d\n", ret);
2518 goto out;
2519 }
2520 if (!strlist__has_entry(namelist, buf))
2521 break;
2522 }
2523 if (i == MAX_EVENT_INDEX) {
2524 pr_warning("Too many events are on the same function.\n");
2525 ret = -ERANGE;
2526 }
2527
2528 out:
2529 free(nbase);
2530 return ret;
2531 }
2532
2533 /* Warn if the current kernel's uprobe implementation is old */
2534 static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2535 {
2536 int i;
2537 char *buf = synthesize_probe_trace_command(tev);
2538
2539 /* Old uprobe event doesn't support memory dereference */
2540 if (!tev->uprobes || tev->nargs == 0 || !buf)
2541 goto out;
2542
2543 for (i = 0; i < tev->nargs; i++)
2544 if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2545 pr_warning("Please upgrade your kernel to at least "
2546 "3.14 to have access to feature %s\n",
2547 tev->args[i].value);
2548 break;
2549 }
2550 out:
2551 free(buf);
2552 }
2553
2554 /* Set new name from original perf_probe_event and namelist */
2555 static int probe_trace_event__set_name(struct probe_trace_event *tev,
2556 struct perf_probe_event *pev,
2557 struct strlist *namelist,
2558 bool allow_suffix)
2559 {
2560 const char *event, *group;
2561 char buf[64];
2562 int ret;
2563
2564 /* If probe_event or trace_event already have the name, reuse it */
2565 if (pev->event && !pev->sdt)
2566 event = pev->event;
2567 else if (tev->event)
2568 event = tev->event;
2569 else {
2570 /* Or generate new one from probe point */
2571 if (pev->point.function &&
2572 (strncmp(pev->point.function, "0x", 2) != 0) &&
2573 !strisglob(pev->point.function))
2574 event = pev->point.function;
2575 else
2576 event = tev->point.realname;
2577 }
2578 if (pev->group && !pev->sdt)
2579 group = pev->group;
2580 else if (tev->group)
2581 group = tev->group;
2582 else
2583 group = PERFPROBE_GROUP;
2584
2585 /* Get an unused new event name */
2586 ret = get_new_event_name(buf, 64, event,
2587 namelist, allow_suffix);
2588 if (ret < 0)
2589 return ret;
2590
2591 event = buf;
2592
2593 tev->event = strdup(event);
2594 tev->group = strdup(group);
2595 if (tev->event == NULL || tev->group == NULL)
2596 return -ENOMEM;
2597
2598 /* Add added event name to namelist */
2599 strlist__add(namelist, event);
2600 return 0;
2601 }
2602
2603 static int __open_probe_file_and_namelist(bool uprobe,
2604 struct strlist **namelist)
2605 {
2606 int fd;
2607
2608 fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2609 if (fd < 0)
2610 return fd;
2611
2612 /* Get current event names */
2613 *namelist = probe_file__get_namelist(fd);
2614 if (!(*namelist)) {
2615 pr_debug("Failed to get current event list.\n");
2616 close(fd);
2617 return -ENOMEM;
2618 }
2619 return fd;
2620 }
2621
2622 static int __add_probe_trace_events(struct perf_probe_event *pev,
2623 struct probe_trace_event *tevs,
2624 int ntevs, bool allow_suffix)
2625 {
2626 int i, fd[2] = {-1, -1}, up, ret;
2627 struct probe_trace_event *tev = NULL;
2628 struct probe_cache *cache = NULL;
2629 struct strlist *namelist[2] = {NULL, NULL};
2630
2631 up = pev->uprobes ? 1 : 0;
2632 fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
2633 if (fd[up] < 0)
2634 return fd[up];
2635
2636 ret = 0;
2637 for (i = 0; i < ntevs; i++) {
2638 tev = &tevs[i];
2639 up = tev->uprobes ? 1 : 0;
2640 if (fd[up] == -1) { /* Open the kprobe/uprobe_events */
2641 fd[up] = __open_probe_file_and_namelist(up,
2642 &namelist[up]);
2643 if (fd[up] < 0)
2644 goto close_out;
2645 }
2646 /* Skip if the symbol is out of .text or blacklisted */
2647 if (!tev->point.symbol && !pev->uprobes)
2648 continue;
2649
2650 /* Set new name for tev (and update namelist) */
2651 ret = probe_trace_event__set_name(tev, pev, namelist[up],
2652 allow_suffix);
2653 if (ret < 0)
2654 break;
2655
2656 ret = probe_file__add_event(fd[up], tev);
2657 if (ret < 0)
2658 break;
2659
2660 /*
2661 * Probes after the first probe which comes from same
2662 * user input are always allowed to add suffix, because
2663 * there might be several addresses corresponding to
2664 * one code line.
2665 */
2666 allow_suffix = true;
2667 }
2668 if (ret == -EINVAL && pev->uprobes)
2669 warn_uprobe_event_compat(tev);
2670 if (ret == 0 && probe_conf.cache) {
2671 cache = probe_cache__new(pev->target);
2672 if (!cache ||
2673 probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
2674 probe_cache__commit(cache) < 0)
2675 pr_warning("Failed to add event to probe cache\n");
2676 probe_cache__delete(cache);
2677 }
2678
2679 close_out:
2680 for (up = 0; up < 2; up++) {
2681 strlist__delete(namelist[up]);
2682 if (fd[up] >= 0)
2683 close(fd[up]);
2684 }
2685 return ret;
2686 }
2687
2688 static int find_probe_functions(struct map *map, char *name,
2689 struct symbol **syms)
2690 {
2691 int found = 0;
2692 struct symbol *sym;
2693 struct rb_node *tmp;
2694
2695 if (map__load(map, NULL) < 0)
2696 return 0;
2697
2698 map__for_each_symbol(map, sym, tmp) {
2699 if (strglobmatch(sym->name, name)) {
2700 found++;
2701 if (syms && found < probe_conf.max_probes)
2702 syms[found - 1] = sym;
2703 }
2704 }
2705
2706 return found;
2707 }
2708
2709 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2710 struct probe_trace_event *tev __maybe_unused,
2711 struct map *map __maybe_unused,
2712 struct symbol *sym __maybe_unused) { }
2713
2714 /*
2715 * Find probe function addresses from map.
2716 * Return an error or the number of found probe_trace_event
2717 */
2718 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2719 struct probe_trace_event **tevs)
2720 {
2721 struct map *map = NULL;
2722 struct ref_reloc_sym *reloc_sym = NULL;
2723 struct symbol *sym;
2724 struct symbol **syms = NULL;
2725 struct probe_trace_event *tev;
2726 struct perf_probe_point *pp = &pev->point;
2727 struct probe_trace_point *tp;
2728 int num_matched_functions;
2729 int ret, i, j, skipped = 0;
2730 char *mod_name;
2731
2732 map = get_target_map(pev->target, pev->uprobes);
2733 if (!map) {
2734 ret = -EINVAL;
2735 goto out;
2736 }
2737
2738 syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
2739 if (!syms) {
2740 ret = -ENOMEM;
2741 goto out;
2742 }
2743
2744 /*
2745 * Load matched symbols: Since the different local symbols may have
2746 * same name but different addresses, this lists all the symbols.
2747 */
2748 num_matched_functions = find_probe_functions(map, pp->function, syms);
2749 if (num_matched_functions == 0) {
2750 pr_err("Failed to find symbol %s in %s\n", pp->function,
2751 pev->target ? : "kernel");
2752 ret = -ENOENT;
2753 goto out;
2754 } else if (num_matched_functions > probe_conf.max_probes) {
2755 pr_err("Too many functions matched in %s\n",
2756 pev->target ? : "kernel");
2757 ret = -E2BIG;
2758 goto out;
2759 }
2760
2761 /* Note that the symbols in the kmodule are not relocated */
2762 if (!pev->uprobes && !pp->retprobe && !pev->target) {
2763 reloc_sym = kernel_get_ref_reloc_sym();
2764 if (!reloc_sym) {
2765 pr_warning("Relocated base symbol is not found!\n");
2766 ret = -EINVAL;
2767 goto out;
2768 }
2769 }
2770
2771 /* Setup result trace-probe-events */
2772 *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2773 if (!*tevs) {
2774 ret = -ENOMEM;
2775 goto out;
2776 }
2777
2778 ret = 0;
2779
2780 for (j = 0; j < num_matched_functions; j++) {
2781 sym = syms[j];
2782
2783 tev = (*tevs) + ret;
2784 tp = &tev->point;
2785 if (ret == num_matched_functions) {
2786 pr_warning("Too many symbols are listed. Skip it.\n");
2787 break;
2788 }
2789 ret++;
2790
2791 if (pp->offset > sym->end - sym->start) {
2792 pr_warning("Offset %ld is bigger than the size of %s\n",
2793 pp->offset, sym->name);
2794 ret = -ENOENT;
2795 goto err_out;
2796 }
2797 /* Add one probe point */
2798 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2799
2800 /* Check the kprobe (not in module) is within .text */
2801 if (!pev->uprobes && !pev->target &&
2802 kprobe_warn_out_range(sym->name, tp->address)) {
2803 tp->symbol = NULL; /* Skip it */
2804 skipped++;
2805 } else if (reloc_sym) {
2806 tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2807 tp->offset = tp->address - reloc_sym->addr;
2808 } else {
2809 tp->symbol = strdup_or_goto(sym->name, nomem_out);
2810 tp->offset = pp->offset;
2811 }
2812 tp->realname = strdup_or_goto(sym->name, nomem_out);
2813
2814 tp->retprobe = pp->retprobe;
2815 if (pev->target) {
2816 if (pev->uprobes) {
2817 tev->point.module = strdup_or_goto(pev->target,
2818 nomem_out);
2819 } else {
2820 mod_name = find_module_name(pev->target);
2821 tev->point.module =
2822 strdup(mod_name ? mod_name : pev->target);
2823 free(mod_name);
2824 if (!tev->point.module)
2825 goto nomem_out;
2826 }
2827 }
2828 tev->uprobes = pev->uprobes;
2829 tev->nargs = pev->nargs;
2830 if (tev->nargs) {
2831 tev->args = zalloc(sizeof(struct probe_trace_arg) *
2832 tev->nargs);
2833 if (tev->args == NULL)
2834 goto nomem_out;
2835 }
2836 for (i = 0; i < tev->nargs; i++) {
2837 if (pev->args[i].name)
2838 tev->args[i].name =
2839 strdup_or_goto(pev->args[i].name,
2840 nomem_out);
2841
2842 tev->args[i].value = strdup_or_goto(pev->args[i].var,
2843 nomem_out);
2844 if (pev->args[i].type)
2845 tev->args[i].type =
2846 strdup_or_goto(pev->args[i].type,
2847 nomem_out);
2848 }
2849 arch__fix_tev_from_maps(pev, tev, map, sym);
2850 }
2851 if (ret == skipped) {
2852 ret = -ENOENT;
2853 goto err_out;
2854 }
2855
2856 out:
2857 put_target_map(map, pev->uprobes);
2858 free(syms);
2859 return ret;
2860
2861 nomem_out:
2862 ret = -ENOMEM;
2863 err_out:
2864 clear_probe_trace_events(*tevs, num_matched_functions);
2865 zfree(tevs);
2866 goto out;
2867 }
2868
2869 static int try_to_find_absolute_address(struct perf_probe_event *pev,
2870 struct probe_trace_event **tevs)
2871 {
2872 struct perf_probe_point *pp = &pev->point;
2873 struct probe_trace_event *tev;
2874 struct probe_trace_point *tp;
2875 int i, err;
2876
2877 if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
2878 return -EINVAL;
2879 if (perf_probe_event_need_dwarf(pev))
2880 return -EINVAL;
2881
2882 /*
2883 * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
2884 * absolute address.
2885 *
2886 * Only one tev can be generated by this.
2887 */
2888 *tevs = zalloc(sizeof(*tev));
2889 if (!*tevs)
2890 return -ENOMEM;
2891
2892 tev = *tevs;
2893 tp = &tev->point;
2894
2895 /*
2896 * Don't use tp->offset, use address directly, because
2897 * in synthesize_probe_trace_command() address cannot be
2898 * zero.
2899 */
2900 tp->address = pev->point.abs_address;
2901 tp->retprobe = pp->retprobe;
2902 tev->uprobes = pev->uprobes;
2903
2904 err = -ENOMEM;
2905 /*
2906 * Give it a '0x' leading symbol name.
2907 * In __add_probe_trace_events, a NULL symbol is interpreted as
2908 * invalud.
2909 */
2910 if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0)
2911 goto errout;
2912
2913 /* For kprobe, check range */
2914 if ((!tev->uprobes) &&
2915 (kprobe_warn_out_range(tev->point.symbol,
2916 tev->point.address))) {
2917 err = -EACCES;
2918 goto errout;
2919 }
2920
2921 if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0)
2922 goto errout;
2923
2924 if (pev->target) {
2925 tp->module = strdup(pev->target);
2926 if (!tp->module)
2927 goto errout;
2928 }
2929
2930 if (tev->group) {
2931 tev->group = strdup(pev->group);
2932 if (!tev->group)
2933 goto errout;
2934 }
2935
2936 if (pev->event) {
2937 tev->event = strdup(pev->event);
2938 if (!tev->event)
2939 goto errout;
2940 }
2941
2942 tev->nargs = pev->nargs;
2943 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
2944 if (!tev->args) {
2945 err = -ENOMEM;
2946 goto errout;
2947 }
2948 for (i = 0; i < tev->nargs; i++)
2949 copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);
2950
2951 return 1;
2952
2953 errout:
2954 if (*tevs) {
2955 clear_probe_trace_events(*tevs, 1);
2956 *tevs = NULL;
2957 }
2958 return err;
2959 }
2960
2961 /* Concatinate two arrays */
2962 static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
2963 {
2964 void *ret;
2965
2966 ret = malloc(sz_a + sz_b);
2967 if (ret) {
2968 memcpy(ret, a, sz_a);
2969 memcpy(ret + sz_a, b, sz_b);
2970 }
2971 return ret;
2972 }
2973
2974 static int
2975 concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
2976 struct probe_trace_event **tevs2, int ntevs2)
2977 {
2978 struct probe_trace_event *new_tevs;
2979 int ret = 0;
2980
2981 if (ntevs == 0) {
2982 *tevs = *tevs2;
2983 *ntevs = ntevs2;
2984 *tevs2 = NULL;
2985 return 0;
2986 }
2987
2988 if (*ntevs + ntevs2 > probe_conf.max_probes)
2989 ret = -E2BIG;
2990 else {
2991 /* Concatinate the array of probe_trace_event */
2992 new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
2993 *tevs2, ntevs2 * sizeof(**tevs2));
2994 if (!new_tevs)
2995 ret = -ENOMEM;
2996 else {
2997 free(*tevs);
2998 *tevs = new_tevs;
2999 *ntevs += ntevs2;
3000 }
3001 }
3002 if (ret < 0)
3003 clear_probe_trace_events(*tevs2, ntevs2);
3004 zfree(tevs2);
3005
3006 return ret;
3007 }
3008
3009 /*
3010 * Try to find probe_trace_event from given probe caches. Return the number
3011 * of cached events found, if an error occurs return the error.
3012 */
3013 static int find_cached_events(struct perf_probe_event *pev,
3014 struct probe_trace_event **tevs,
3015 const char *target)
3016 {
3017 struct probe_cache *cache;
3018 struct probe_cache_entry *entry;
3019 struct probe_trace_event *tmp_tevs = NULL;
3020 int ntevs = 0;
3021 int ret = 0;
3022
3023 cache = probe_cache__new(target);
3024 /* Return 0 ("not found") if the target has no probe cache. */
3025 if (!cache)
3026 return 0;
3027
3028 for_each_probe_cache_entry(entry, cache) {
3029 /* Skip the cache entry which has no name */
3030 if (!entry->pev.event || !entry->pev.group)
3031 continue;
3032 if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
3033 strglobmatch(entry->pev.event, pev->event)) {
3034 ret = probe_cache_entry__get_event(entry, &tmp_tevs);
3035 if (ret > 0)
3036 ret = concat_probe_trace_events(tevs, &ntevs,
3037 &tmp_tevs, ret);
3038 if (ret < 0)
3039 break;
3040 }
3041 }
3042 probe_cache__delete(cache);
3043 if (ret < 0) {
3044 clear_probe_trace_events(*tevs, ntevs);
3045 zfree(tevs);
3046 } else {
3047 ret = ntevs;
3048 if (ntevs > 0 && target && target[0] == '/')
3049 pev->uprobes = true;
3050 }
3051
3052 return ret;
3053 }
3054
3055 /* Try to find probe_trace_event from all probe caches */
3056 static int find_cached_events_all(struct perf_probe_event *pev,
3057 struct probe_trace_event **tevs)
3058 {
3059 struct probe_trace_event *tmp_tevs = NULL;
3060 struct strlist *bidlist;
3061 struct str_node *nd;
3062 char *pathname;
3063 int ntevs = 0;
3064 int ret;
3065
3066 /* Get the buildid list of all valid caches */
3067 bidlist = build_id_cache__list_all(true);
3068 if (!bidlist) {
3069 ret = -errno;
3070 pr_debug("Failed to get buildids: %d\n", ret);
3071 return ret;
3072 }
3073
3074 ret = 0;
3075 strlist__for_each_entry(nd, bidlist) {
3076 pathname = build_id_cache__origname(nd->s);
3077 ret = find_cached_events(pev, &tmp_tevs, pathname);
3078 /* In the case of cnt == 0, we just skip it */
3079 if (ret > 0)
3080 ret = concat_probe_trace_events(tevs, &ntevs,
3081 &tmp_tevs, ret);
3082 free(pathname);
3083 if (ret < 0)
3084 break;
3085 }
3086 strlist__delete(bidlist);
3087
3088 if (ret < 0) {
3089 clear_probe_trace_events(*tevs, ntevs);
3090 zfree(tevs);
3091 } else
3092 ret = ntevs;
3093
3094 return ret;
3095 }
3096
3097 static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
3098 struct probe_trace_event **tevs)
3099 {
3100 struct probe_cache *cache;
3101 struct probe_cache_entry *entry;
3102 struct probe_trace_event *tev;
3103 struct str_node *node;
3104 int ret, i;
3105
3106 if (pev->sdt) {
3107 /* For SDT/cached events, we use special search functions */
3108 if (!pev->target)
3109 return find_cached_events_all(pev, tevs);
3110 else
3111 return find_cached_events(pev, tevs, pev->target);
3112 }
3113 cache = probe_cache__new(pev->target);
3114 if (!cache)
3115 return 0;
3116
3117 entry = probe_cache__find(cache, pev);
3118 if (!entry) {
3119 /* SDT must be in the cache */
3120 ret = pev->sdt ? -ENOENT : 0;
3121 goto out;
3122 }
3123
3124 ret = strlist__nr_entries(entry->tevlist);
3125 if (ret > probe_conf.max_probes) {
3126 pr_debug("Too many entries matched in the cache of %s\n",
3127 pev->target ? : "kernel");
3128 ret = -E2BIG;
3129 goto out;
3130 }
3131
3132 *tevs = zalloc(ret * sizeof(*tev));
3133 if (!*tevs) {
3134 ret = -ENOMEM;
3135 goto out;
3136 }
3137
3138 i = 0;
3139 strlist__for_each_entry(node, entry->tevlist) {
3140 tev = &(*tevs)[i++];
3141 ret = parse_probe_trace_command(node->s, tev);
3142 if (ret < 0)
3143 goto out;
3144 /* Set the uprobes attribute as same as original */
3145 tev->uprobes = pev->uprobes;
3146 }
3147 ret = i;
3148
3149 out:
3150 probe_cache__delete(cache);
3151 return ret;
3152 }
3153
3154 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3155 struct probe_trace_event **tevs)
3156 {
3157 int ret;
3158
3159 if (!pev->group && !pev->sdt) {
3160 /* Set group name if not given */
3161 if (!pev->uprobes) {
3162 pev->group = strdup(PERFPROBE_GROUP);
3163 ret = pev->group ? 0 : -ENOMEM;
3164 } else
3165 ret = convert_exec_to_group(pev->target, &pev->group);
3166 if (ret != 0) {
3167 pr_warning("Failed to make a group name.\n");
3168 return ret;
3169 }
3170 }
3171
3172 ret = try_to_find_absolute_address(pev, tevs);
3173 if (ret > 0)
3174 return ret;
3175
3176 /* At first, we need to lookup cache entry */
3177 ret = find_probe_trace_events_from_cache(pev, tevs);
3178 if (ret > 0 || pev->sdt) /* SDT can be found only in the cache */
3179 return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3180
3181 /* Convert perf_probe_event with debuginfo */
3182 ret = try_to_find_probe_trace_events(pev, tevs);
3183 if (ret != 0)
3184 return ret; /* Found in debuginfo or got an error */
3185
3186 return find_probe_trace_events_from_map(pev, tevs);
3187 }
3188
3189 int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3190 {
3191 int i, ret;
3192
3193 /* Loop 1: convert all events */
3194 for (i = 0; i < npevs; i++) {
3195 /* Init kprobe blacklist if needed */
3196 if (!pevs[i].uprobes)
3197 kprobe_blacklist__init();
3198 /* Convert with or without debuginfo */
3199 ret = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3200 if (ret < 0)
3201 return ret;
3202 pevs[i].ntevs = ret;
3203 }
3204 /* This just release blacklist only if allocated */
3205 kprobe_blacklist__release();
3206
3207 return 0;
3208 }
3209
3210 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3211 {
3212 int i, ret = 0;
3213
3214 /* Loop 2: add all events */
3215 for (i = 0; i < npevs; i++) {
3216 ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
3217 pevs[i].ntevs,
3218 probe_conf.force_add);
3219 if (ret < 0)
3220 break;
3221 }
3222 return ret;
3223 }
3224
3225 void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3226 {
3227 int i, j;
3228
3229 /* Loop 3: cleanup and free trace events */
3230 for (i = 0; i < npevs; i++) {
3231 for (j = 0; j < pevs[i].ntevs; j++)
3232 clear_probe_trace_event(&pevs[i].tevs[j]);
3233 zfree(&pevs[i].tevs);
3234 pevs[i].ntevs = 0;
3235 clear_perf_probe_event(&pevs[i]);
3236 }
3237 }
3238
3239 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3240 {
3241 int ret;
3242
3243 ret = init_probe_symbol_maps(pevs->uprobes);
3244 if (ret < 0)
3245 return ret;
3246
3247 ret = convert_perf_probe_events(pevs, npevs);
3248 if (ret == 0)
3249 ret = apply_perf_probe_events(pevs, npevs);
3250
3251 cleanup_perf_probe_events(pevs, npevs);
3252
3253 exit_probe_symbol_maps();
3254 return ret;
3255 }
3256
3257 int del_perf_probe_events(struct strfilter *filter)
3258 {
3259 int ret, ret2, ufd = -1, kfd = -1;
3260 char *str = strfilter__string(filter);
3261
3262 if (!str)
3263 return -EINVAL;
3264
3265 /* Get current event names */
3266 ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
3267 if (ret < 0)
3268 goto out;
3269
3270 ret = probe_file__del_events(kfd, filter);
3271 if (ret < 0 && ret != -ENOENT)
3272 goto error;
3273
3274 ret2 = probe_file__del_events(ufd, filter);
3275 if (ret2 < 0 && ret2 != -ENOENT) {
3276 ret = ret2;
3277 goto error;
3278 }
3279 ret = 0;
3280
3281 error:
3282 if (kfd >= 0)
3283 close(kfd);
3284 if (ufd >= 0)
3285 close(ufd);
3286 out:
3287 free(str);
3288
3289 return ret;
3290 }
3291
3292 /* TODO: don't use a global variable for filter ... */
3293 static struct strfilter *available_func_filter;
3294
3295 /*
3296 * If a symbol corresponds to a function with global binding and
3297 * matches filter return 0. For all others return 1.
3298 */
3299 static int filter_available_functions(struct map *map __maybe_unused,
3300 struct symbol *sym)
3301 {
3302 if (strfilter__compare(available_func_filter, sym->name))
3303 return 0;
3304 return 1;
3305 }
3306
3307 int show_available_funcs(const char *target, struct strfilter *_filter,
3308 bool user)
3309 {
3310 struct map *map;
3311 int ret;
3312
3313 ret = init_probe_symbol_maps(user);
3314 if (ret < 0)
3315 return ret;
3316
3317 /* Get a symbol map */
3318 if (user)
3319 map = dso__new_map(target);
3320 else
3321 map = kernel_get_module_map(target);
3322 if (!map) {
3323 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3324 return -EINVAL;
3325 }
3326
3327 /* Load symbols with given filter */
3328 available_func_filter = _filter;
3329 ret = map__load(map, filter_available_functions);
3330 if (ret) {
3331 if (ret == -2) {
3332 char *str = strfilter__string(_filter);
3333 pr_err("Failed to find symbols matched to \"%s\"\n",
3334 str);
3335 free(str);
3336 } else
3337 pr_err("Failed to load symbols in %s\n",
3338 (target) ? : "kernel");
3339 goto end;
3340 }
3341 if (!dso__sorted_by_name(map->dso, map->type))
3342 dso__sort_by_name(map->dso, map->type);
3343
3344 /* Show all (filtered) symbols */
3345 setup_pager();
3346 dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
3347 end:
3348 if (user) {
3349 map__put(map);
3350 }
3351 exit_probe_symbol_maps();
3352
3353 return ret;
3354 }
3355
3356 int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
3357 struct perf_probe_arg *pvar)
3358 {
3359 tvar->value = strdup(pvar->var);
3360 if (tvar->value == NULL)
3361 return -ENOMEM;
3362 if (pvar->type) {
3363 tvar->type = strdup(pvar->type);
3364 if (tvar->type == NULL)
3365 return -ENOMEM;
3366 }
3367 if (pvar->name) {
3368 tvar->name = strdup(pvar->name);
3369 if (tvar->name == NULL)
3370 return -ENOMEM;
3371 } else
3372 tvar->name = NULL;
3373 return 0;
3374 }
Linux with added FPC-III support