projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf probe: Warn user to rebuild target with debuginfo
[deliverable/linux.git] / tools / perf / util / probe-event.c
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/debugfs.h>
44 #include "trace-event.h" /* For __maybe_unused */
45 #include "probe-event.h"
46 #include "probe-finder.h"
47 #include "session.h"
48
49 #define MAX_CMDLEN 256
50 #define PERFPROBE_GROUP "probe"
51
52 bool probe_event_dry_run; /* Dry run flag */
53
54 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
55
56 /* If there is no space to write, returns -E2BIG. */
57 static int e_snprintf(char *str, size_t size, const char *format, ...)
58 __attribute__((format(printf, 3, 4)));
59
60 static int e_snprintf(char *str, size_t size, const char *format, ...)
61 {
62 int ret;
63 va_list ap;
64 va_start(ap, format);
65 ret = vsnprintf(str, size, format, ap);
66 va_end(ap);
67 if (ret >= (int)size)
68 ret = -E2BIG;
69 return ret;
70 }
71
72 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
73 static void clear_probe_trace_event(struct probe_trace_event *tev);
74 static struct machine *host_machine;
75
76 /* Initialize symbol maps and path of vmlinux/modules */
77 static int init_symbol_maps(bool user_only)
78 {
79 int ret;
80
81 symbol_conf.sort_by_name = true;
82 ret = symbol__init(NULL);
83 if (ret < 0) {
84 pr_debug("Failed to init symbol map.\n");
85 goto out;
86 }
87
88 if (host_machine || user_only) /* already initialized */
89 return 0;
90
91 if (symbol_conf.vmlinux_name)
92 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
93
94 host_machine = machine__new_host();
95 if (!host_machine) {
96 pr_debug("machine__new_host() failed.\n");
97 symbol__exit();
98 ret = -1;
99 }
100 out:
101 if (ret < 0)
102 pr_warning("Failed to init vmlinux path.\n");
103 return ret;
104 }
105
106 static void exit_symbol_maps(void)
107 {
108 if (host_machine) {
109 machine__delete(host_machine);
110 host_machine = NULL;
111 }
112 symbol__exit();
113 }
114
115 static struct symbol *__find_kernel_function_by_name(const char *name,
116 struct map **mapp)
117 {
118 return machine__find_kernel_function_by_name(host_machine, name, mapp,
119 NULL);
120 }
121
122 static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
123 {
124 return machine__find_kernel_function(host_machine, addr, mapp, NULL);
125 }
126
127 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
128 {
129 /* kmap->ref_reloc_sym should be set if host_machine is initialized */
130 struct kmap *kmap;
131
132 if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
133 return NULL;
134
135 kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
136 return kmap->ref_reloc_sym;
137 }
138
139 static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
140 {
141 struct ref_reloc_sym *reloc_sym;
142 struct symbol *sym;
143 struct map *map;
144
145 /* ref_reloc_sym is just a label. Need a special fix*/
146 reloc_sym = kernel_get_ref_reloc_sym();
147 if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
148 return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
149 else {
150 sym = __find_kernel_function_by_name(name, &map);
151 if (sym)
152 return map->unmap_ip(map, sym->start) -
153 (reloc) ? 0 : map->reloc;
154 }
155 return 0;
156 }
157
158 static struct map *kernel_get_module_map(const char *module)
159 {
160 struct rb_node *nd;
161 struct map_groups *grp = &host_machine->kmaps;
162
163 /* A file path -- this is an offline module */
164 if (module && strchr(module, '/'))
165 return machine__new_module(host_machine, 0, module);
166
167 if (!module)
168 module = "kernel";
169
170 for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
171 struct map *pos = rb_entry(nd, struct map, rb_node);
172 if (strncmp(pos->dso->short_name + 1, module,
173 pos->dso->short_name_len - 2) == 0) {
174 return pos;
175 }
176 }
177 return NULL;
178 }
179
180 static struct dso *kernel_get_module_dso(const char *module)
181 {
182 struct dso *dso;
183 struct map *map;
184 const char *vmlinux_name;
185
186 if (module) {
187 list_for_each_entry(dso, &host_machine->kernel_dsos, node) {
188 if (strncmp(dso->short_name + 1, module,
189 dso->short_name_len - 2) == 0)
190 goto found;
191 }
192 pr_debug("Failed to find module %s.\n", module);
193 return NULL;
194 }
195
196 map = host_machine->vmlinux_maps[MAP__FUNCTION];
197 dso = map->dso;
198
199 vmlinux_name = symbol_conf.vmlinux_name;
200 if (vmlinux_name) {
201 if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
202 return NULL;
203 } else {
204 if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
205 pr_debug("Failed to load kernel map.\n");
206 return NULL;
207 }
208 }
209 found:
210 return dso;
211 }
212
213 const char *kernel_get_module_path(const char *module)
214 {
215 struct dso *dso = kernel_get_module_dso(module);
216 return (dso) ? dso->long_name : NULL;
217 }
218
219 static int convert_exec_to_group(const char *exec, char **result)
220 {
221 char *ptr1, *ptr2, *exec_copy;
222 char buf[64];
223 int ret;
224
225 exec_copy = strdup(exec);
226 if (!exec_copy)
227 return -ENOMEM;
228
229 ptr1 = basename(exec_copy);
230 if (!ptr1) {
231 ret = -EINVAL;
232 goto out;
233 }
234
235 ptr2 = strpbrk(ptr1, "-._");
236 if (ptr2)
237 *ptr2 = '\0';
238 ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
239 if (ret < 0)
240 goto out;
241
242 *result = strdup(buf);
243 ret = *result ? 0 : -ENOMEM;
244
245 out:
246 free(exec_copy);
247 return ret;
248 }
249
250 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
251 {
252 int i;
253
254 for (i = 0; i < ntevs; i++)
255 clear_probe_trace_event(tevs + i);
256 }
257
258 #ifdef HAVE_DWARF_SUPPORT
259
260 /* Open new debuginfo of given module */
261 static struct debuginfo *open_debuginfo(const char *module, bool silent)
262 {
263 const char *path = module;
264 struct debuginfo *ret;
265
266 if (!module || !strchr(module, '/')) {
267 path = kernel_get_module_path(module);
268 if (!path) {
269 if (!silent)
270 pr_err("Failed to find path of %s module.\n",
271 module ?: "kernel");
272 return NULL;
273 }
274 }
275 ret = debuginfo__new(path);
276 if (!ret && !silent) {
277 pr_warning("The %s file has no debug information.\n", path);
278 if (!module || !strtailcmp(path, ".ko"))
279 pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
280 else
281 pr_warning("Rebuild with -g, ");
282 pr_warning("or install an appropriate debuginfo package.\n");
283 }
284 return ret;
285 }
286
287
288 static int get_text_start_address(const char *exec, unsigned long *address)
289 {
290 Elf *elf;
291 GElf_Ehdr ehdr;
292 GElf_Shdr shdr;
293 int fd, ret = -ENOENT;
294
295 fd = open(exec, O_RDONLY);
296 if (fd < 0)
297 return -errno;
298
299 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
300 if (elf == NULL)
301 return -EINVAL;
302
303 if (gelf_getehdr(elf, &ehdr) == NULL)
304 goto out;
305
306 if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
307 goto out;
308
309 *address = shdr.sh_addr - shdr.sh_offset;
310 ret = 0;
311 out:
312 elf_end(elf);
313 return ret;
314 }
315
316 /*
317 * Convert trace point to probe point with debuginfo
318 */
319 static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
320 struct perf_probe_point *pp,
321 bool is_kprobe)
322 {
323 struct debuginfo *dinfo = NULL;
324 unsigned long stext = 0;
325 u64 addr = tp->address;
326 int ret = -ENOENT;
327
328 /* convert the address to dwarf address */
329 if (!is_kprobe) {
330 if (!addr) {
331 ret = -EINVAL;
332 goto error;
333 }
334 ret = get_text_start_address(tp->module, &stext);
335 if (ret < 0)
336 goto error;
337 addr += stext;
338 } else {
339 addr = kernel_get_symbol_address_by_name(tp->symbol, false);
340 if (addr == 0)
341 goto error;
342 addr += tp->offset;
343 }
344
345 pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
346 tp->module ? : "kernel");
347
348 dinfo = open_debuginfo(tp->module, verbose == 0);
349 if (dinfo) {
350 ret = debuginfo__find_probe_point(dinfo,
351 (unsigned long)addr, pp);
352 debuginfo__delete(dinfo);
353 } else
354 ret = -ENOENT;
355
356 if (ret > 0) {
357 pp->retprobe = tp->retprobe;
358 return 0;
359 }
360 error:
361 pr_debug("Failed to find corresponding probes from debuginfo.\n");
362 return ret ? : -ENOENT;
363 }
364
365 static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
366 int ntevs, const char *exec)
367 {
368 int i, ret = 0;
369 unsigned long stext = 0;
370
371 if (!exec)
372 return 0;
373
374 ret = get_text_start_address(exec, &stext);
375 if (ret < 0)
376 return ret;
377
378 for (i = 0; i < ntevs && ret >= 0; i++) {
379 /* point.address is the addres of point.symbol + point.offset */
380 tevs[i].point.address -= stext;
381 tevs[i].point.module = strdup(exec);
382 if (!tevs[i].point.module) {
383 ret = -ENOMEM;
384 break;
385 }
386 tevs[i].uprobes = true;
387 }
388
389 return ret;
390 }
391
392 static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
393 int ntevs, const char *module)
394 {
395 int i, ret = 0;
396 char *tmp;
397
398 if (!module)
399 return 0;
400
401 tmp = strrchr(module, '/');
402 if (tmp) {
403 /* This is a module path -- get the module name */
404 module = strdup(tmp + 1);
405 if (!module)
406 return -ENOMEM;
407 tmp = strchr(module, '.');
408 if (tmp)
409 *tmp = '\0';
410 tmp = (char *)module; /* For free() */
411 }
412
413 for (i = 0; i < ntevs; i++) {
414 tevs[i].point.module = strdup(module);
415 if (!tevs[i].point.module) {
416 ret = -ENOMEM;
417 break;
418 }
419 }
420
421 free(tmp);
422 return ret;
423 }
424
425 /* Post processing the probe events */
426 static int post_process_probe_trace_events(struct probe_trace_event *tevs,
427 int ntevs, const char *module,
428 bool uprobe)
429 {
430 struct ref_reloc_sym *reloc_sym;
431 char *tmp;
432 int i;
433
434 if (uprobe)
435 return add_exec_to_probe_trace_events(tevs, ntevs, module);
436
437 /* Note that currently ref_reloc_sym based probe is not for drivers */
438 if (module)
439 return add_module_to_probe_trace_events(tevs, ntevs, module);
440
441 reloc_sym = kernel_get_ref_reloc_sym();
442 if (!reloc_sym) {
443 pr_warning("Relocated base symbol is not found!\n");
444 return -EINVAL;
445 }
446
447 for (i = 0; i < ntevs; i++) {
448 if (tevs[i].point.address) {
449 tmp = strdup(reloc_sym->name);
450 if (!tmp)
451 return -ENOMEM;
452 free(tevs[i].point.symbol);
453 tevs[i].point.symbol = tmp;
454 tevs[i].point.offset = tevs[i].point.address -
455 reloc_sym->unrelocated_addr;
456 }
457 }
458 return 0;
459 }
460
461 /* Try to find perf_probe_event with debuginfo */
462 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
463 struct probe_trace_event **tevs,
464 int max_tevs, const char *target)
465 {
466 bool need_dwarf = perf_probe_event_need_dwarf(pev);
467 struct debuginfo *dinfo;
468 int ntevs, ret = 0;
469
470 dinfo = open_debuginfo(target, !need_dwarf);
471
472 if (!dinfo) {
473 if (need_dwarf)
474 return -ENOENT;
475 pr_debug("Could not open debuginfo. Try to use symbols.\n");
476 return 0;
477 }
478
479 pr_debug("Try to find probe point from debuginfo.\n");
480 /* Searching trace events corresponding to a probe event */
481 ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
482
483 debuginfo__delete(dinfo);
484
485 if (ntevs > 0) { /* Succeeded to find trace events */
486 pr_debug("Found %d probe_trace_events.\n", ntevs);
487 ret = post_process_probe_trace_events(*tevs, ntevs,
488 target, pev->uprobes);
489 if (ret < 0) {
490 clear_probe_trace_events(*tevs, ntevs);
491 zfree(tevs);
492 }
493 return ret < 0 ? ret : ntevs;
494 }
495
496 if (ntevs == 0) { /* No error but failed to find probe point. */
497 pr_warning("Probe point '%s' not found.\n",
498 synthesize_perf_probe_point(&pev->point));
499 return -ENOENT;
500 }
501 /* Error path : ntevs < 0 */
502 pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
503 if (ntevs == -EBADF) {
504 pr_warning("Warning: No dwarf info found in the vmlinux - "
505 "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
506 if (!need_dwarf) {
507 pr_debug("Trying to use symbols.\n");
508 return 0;
509 }
510 }
511 return ntevs;
512 }
513
514 /*
515 * Find a src file from a DWARF tag path. Prepend optional source path prefix
516 * and chop off leading directories that do not exist. Result is passed back as
517 * a newly allocated path on success.
518 * Return 0 if file was found and readable, -errno otherwise.
519 */
520 static int get_real_path(const char *raw_path, const char *comp_dir,
521 char **new_path)
522 {
523 const char *prefix = symbol_conf.source_prefix;
524
525 if (!prefix) {
526 if (raw_path[0] != '/' && comp_dir)
527 /* If not an absolute path, try to use comp_dir */
528 prefix = comp_dir;
529 else {
530 if (access(raw_path, R_OK) == 0) {
531 *new_path = strdup(raw_path);
532 return 0;
533 } else
534 return -errno;
535 }
536 }
537
538 *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
539 if (!*new_path)
540 return -ENOMEM;
541
542 for (;;) {
543 sprintf(*new_path, "%s/%s", prefix, raw_path);
544
545 if (access(*new_path, R_OK) == 0)
546 return 0;
547
548 if (!symbol_conf.source_prefix)
549 /* In case of searching comp_dir, don't retry */
550 return -errno;
551
552 switch (errno) {
553 case ENAMETOOLONG:
554 case ENOENT:
555 case EROFS:
556 case EFAULT:
557 raw_path = strchr(++raw_path, '/');
558 if (!raw_path) {
559 zfree(new_path);
560 return -ENOENT;
561 }
562 continue;
563
564 default:
565 zfree(new_path);
566 return -errno;
567 }
568 }
569 }
570
571 #define LINEBUF_SIZE 256
572 #define NR_ADDITIONAL_LINES 2
573
574 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
575 {
576 char buf[LINEBUF_SIZE];
577 const char *color = show_num ? "" : PERF_COLOR_BLUE;
578 const char *prefix = NULL;
579
580 do {
581 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
582 goto error;
583 if (skip)
584 continue;
585 if (!prefix) {
586 prefix = show_num ? "%7d " : " ";
587 color_fprintf(stdout, color, prefix, l);
588 }
589 color_fprintf(stdout, color, "%s", buf);
590
591 } while (strchr(buf, '\n') == NULL);
592
593 return 1;
594 error:
595 if (ferror(fp)) {
596 pr_warning("File read error: %s\n", strerror(errno));
597 return -1;
598 }
599 return 0;
600 }
601
602 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
603 {
604 int rv = __show_one_line(fp, l, skip, show_num);
605 if (rv == 0) {
606 pr_warning("Source file is shorter than expected.\n");
607 rv = -1;
608 }
609 return rv;
610 }
611
612 #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)
613 #define show_one_line(f,l) _show_one_line(f,l,false,false)
614 #define skip_one_line(f,l) _show_one_line(f,l,true,false)
615 #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)
616
617 /*
618 * Show line-range always requires debuginfo to find source file and
619 * line number.
620 */
621 static int __show_line_range(struct line_range *lr, const char *module)
622 {
623 int l = 1;
624 struct int_node *ln;
625 struct debuginfo *dinfo;
626 FILE *fp;
627 int ret;
628 char *tmp;
629
630 /* Search a line range */
631 dinfo = open_debuginfo(module, false);
632 if (!dinfo)
633 return -ENOENT;
634
635 ret = debuginfo__find_line_range(dinfo, lr);
636 debuginfo__delete(dinfo);
637 if (ret == 0 || ret == -ENOENT) {
638 pr_warning("Specified source line is not found.\n");
639 return -ENOENT;
640 } else if (ret < 0) {
641 pr_warning("Debuginfo analysis failed.\n");
642 return ret;
643 }
644
645 /* Convert source file path */
646 tmp = lr->path;
647 ret = get_real_path(tmp, lr->comp_dir, &lr->path);
648 free(tmp); /* Free old path */
649 if (ret < 0) {
650 pr_warning("Failed to find source file path.\n");
651 return ret;
652 }
653
654 setup_pager();
655
656 if (lr->function)
657 fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
658 lr->start - lr->offset);
659 else
660 fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
661
662 fp = fopen(lr->path, "r");
663 if (fp == NULL) {
664 pr_warning("Failed to open %s: %s\n", lr->path,
665 strerror(errno));
666 return -errno;
667 }
668 /* Skip to starting line number */
669 while (l < lr->start) {
670 ret = skip_one_line(fp, l++);
671 if (ret < 0)
672 goto end;
673 }
674
675 intlist__for_each(ln, lr->line_list) {
676 for (; ln->i > l; l++) {
677 ret = show_one_line(fp, l - lr->offset);
678 if (ret < 0)
679 goto end;
680 }
681 ret = show_one_line_with_num(fp, l++ - lr->offset);
682 if (ret < 0)
683 goto end;
684 }
685
686 if (lr->end == INT_MAX)
687 lr->end = l + NR_ADDITIONAL_LINES;
688 while (l <= lr->end) {
689 ret = show_one_line_or_eof(fp, l++ - lr->offset);
690 if (ret <= 0)
691 break;
692 }
693 end:
694 fclose(fp);
695 return ret;
696 }
697
698 int show_line_range(struct line_range *lr, const char *module)
699 {
700 int ret;
701
702 ret = init_symbol_maps(false);
703 if (ret < 0)
704 return ret;
705 ret = __show_line_range(lr, module);
706 exit_symbol_maps();
707
708 return ret;
709 }
710
711 static int show_available_vars_at(struct debuginfo *dinfo,
712 struct perf_probe_event *pev,
713 int max_vls, struct strfilter *_filter,
714 bool externs)
715 {
716 char *buf;
717 int ret, i, nvars;
718 struct str_node *node;
719 struct variable_list *vls = NULL, *vl;
720 const char *var;
721
722 buf = synthesize_perf_probe_point(&pev->point);
723 if (!buf)
724 return -EINVAL;
725 pr_debug("Searching variables at %s\n", buf);
726
727 ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
728 max_vls, externs);
729 if (ret <= 0) {
730 if (ret == 0 || ret == -ENOENT) {
731 pr_err("Failed to find the address of %s\n", buf);
732 ret = -ENOENT;
733 } else
734 pr_warning("Debuginfo analysis failed.\n");
735 goto end;
736 }
737
738 /* Some variables are found */
739 fprintf(stdout, "Available variables at %s\n", buf);
740 for (i = 0; i < ret; i++) {
741 vl = &vls[i];
742 /*
743 * A probe point might be converted to
744 * several trace points.
745 */
746 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
747 vl->point.offset);
748 zfree(&vl->point.symbol);
749 nvars = 0;
750 if (vl->vars) {
751 strlist__for_each(node, vl->vars) {
752 var = strchr(node->s, '\t') + 1;
753 if (strfilter__compare(_filter, var)) {
754 fprintf(stdout, "\t\t%s\n", node->s);
755 nvars++;
756 }
757 }
758 strlist__delete(vl->vars);
759 }
760 if (nvars == 0)
761 fprintf(stdout, "\t\t(No matched variables)\n");
762 }
763 free(vls);
764 end:
765 free(buf);
766 return ret;
767 }
768
769 /* Show available variables on given probe point */
770 int show_available_vars(struct perf_probe_event *pevs, int npevs,
771 int max_vls, const char *module,
772 struct strfilter *_filter, bool externs)
773 {
774 int i, ret = 0;
775 struct debuginfo *dinfo;
776
777 ret = init_symbol_maps(false);
778 if (ret < 0)
779 return ret;
780
781 dinfo = open_debuginfo(module, false);
782 if (!dinfo) {
783 ret = -ENOENT;
784 goto out;
785 }
786
787 setup_pager();
788
789 for (i = 0; i < npevs && ret >= 0; i++)
790 ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
791 externs);
792
793 debuginfo__delete(dinfo);
794 out:
795 exit_symbol_maps();
796 return ret;
797 }
798
799 #else /* !HAVE_DWARF_SUPPORT */
800
801 static int
802 find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
803 struct perf_probe_point *pp __maybe_unused,
804 bool is_kprobe __maybe_unused)
805 {
806 return -ENOSYS;
807 }
808
809 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
810 struct probe_trace_event **tevs __maybe_unused,
811 int max_tevs __maybe_unused,
812 const char *target __maybe_unused)
813 {
814 if (perf_probe_event_need_dwarf(pev)) {
815 pr_warning("Debuginfo-analysis is not supported.\n");
816 return -ENOSYS;
817 }
818
819 return 0;
820 }
821
822 int show_line_range(struct line_range *lr __maybe_unused,
823 const char *module __maybe_unused)
824 {
825 pr_warning("Debuginfo-analysis is not supported.\n");
826 return -ENOSYS;
827 }
828
829 int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
830 int npevs __maybe_unused, int max_vls __maybe_unused,
831 const char *module __maybe_unused,
832 struct strfilter *filter __maybe_unused,
833 bool externs __maybe_unused)
834 {
835 pr_warning("Debuginfo-analysis is not supported.\n");
836 return -ENOSYS;
837 }
838 #endif
839
840 void line_range__clear(struct line_range *lr)
841 {
842 free(lr->function);
843 free(lr->file);
844 free(lr->path);
845 free(lr->comp_dir);
846 intlist__delete(lr->line_list);
847 memset(lr, 0, sizeof(*lr));
848 }
849
850 int line_range__init(struct line_range *lr)
851 {
852 memset(lr, 0, sizeof(*lr));
853 lr->line_list = intlist__new(NULL);
854 if (!lr->line_list)
855 return -ENOMEM;
856 else
857 return 0;
858 }
859
860 static int parse_line_num(char **ptr, int *val, const char *what)
861 {
862 const char *start = *ptr;
863
864 errno = 0;
865 *val = strtol(*ptr, ptr, 0);
866 if (errno || *ptr == start) {
867 semantic_error("'%s' is not a valid number.\n", what);
868 return -EINVAL;
869 }
870 return 0;
871 }
872
873 /*
874 * Stuff 'lr' according to the line range described by 'arg'.
875 * The line range syntax is described by:
876 *
877 * SRC[:SLN[+NUM|-ELN]]
878 * FNC[@SRC][:SLN[+NUM|-ELN]]
879 */
880 int parse_line_range_desc(const char *arg, struct line_range *lr)
881 {
882 char *range, *file, *name = strdup(arg);
883 int err;
884
885 if (!name)
886 return -ENOMEM;
887
888 lr->start = 0;
889 lr->end = INT_MAX;
890
891 range = strchr(name, ':');
892 if (range) {
893 *range++ = '\0';
894
895 err = parse_line_num(&range, &lr->start, "start line");
896 if (err)
897 goto err;
898
899 if (*range == '+' || *range == '-') {
900 const char c = *range++;
901
902 err = parse_line_num(&range, &lr->end, "end line");
903 if (err)
904 goto err;
905
906 if (c == '+') {
907 lr->end += lr->start;
908 /*
909 * Adjust the number of lines here.
910 * If the number of lines == 1, the
911 * the end of line should be equal to
912 * the start of line.
913 */
914 lr->end--;
915 }
916 }
917
918 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
919
920 err = -EINVAL;
921 if (lr->start > lr->end) {
922 semantic_error("Start line must be smaller"
923 " than end line.\n");
924 goto err;
925 }
926 if (*range != '\0') {
927 semantic_error("Tailing with invalid str '%s'.\n", range);
928 goto err;
929 }
930 }
931
932 file = strchr(name, '@');
933 if (file) {
934 *file = '\0';
935 lr->file = strdup(++file);
936 if (lr->file == NULL) {
937 err = -ENOMEM;
938 goto err;
939 }
940 lr->function = name;
941 } else if (strchr(name, '.'))
942 lr->file = name;
943 else
944 lr->function = name;
945
946 return 0;
947 err:
948 free(name);
949 return err;
950 }
951
952 /* Check the name is good for event/group */
953 static bool check_event_name(const char *name)
954 {
955 if (!isalpha(*name) && *name != '_')
956 return false;
957 while (*++name != '\0') {
958 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
959 return false;
960 }
961 return true;
962 }
963
964 /* Parse probepoint definition. */
965 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
966 {
967 struct perf_probe_point *pp = &pev->point;
968 char *ptr, *tmp;
969 char c, nc = 0;
970 /*
971 * <Syntax>
972 * perf probe [EVENT=]SRC[:LN|;PTN]
973 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
974 *
975 * TODO:Group name support
976 */
977
978 ptr = strpbrk(arg, ";=@+%");
979 if (ptr && *ptr == '=') { /* Event name */
980 *ptr = '\0';
981 tmp = ptr + 1;
982 if (strchr(arg, ':')) {
983 semantic_error("Group name is not supported yet.\n");
984 return -ENOTSUP;
985 }
986 if (!check_event_name(arg)) {
987 semantic_error("%s is bad for event name -it must "
988 "follow C symbol-naming rule.\n", arg);
989 return -EINVAL;
990 }
991 pev->event = strdup(arg);
992 if (pev->event == NULL)
993 return -ENOMEM;
994 pev->group = NULL;
995 arg = tmp;
996 }
997
998 ptr = strpbrk(arg, ";:+@%");
999 if (ptr) {
1000 nc = *ptr;
1001 *ptr++ = '\0';
1002 }
1003
1004 tmp = strdup(arg);
1005 if (tmp == NULL)
1006 return -ENOMEM;
1007
1008 /* Check arg is function or file and copy it */
1009 if (strchr(tmp, '.')) /* File */
1010 pp->file = tmp;
1011 else /* Function */
1012 pp->function = tmp;
1013
1014 /* Parse other options */
1015 while (ptr) {
1016 arg = ptr;
1017 c = nc;
1018 if (c == ';') { /* Lazy pattern must be the last part */
1019 pp->lazy_line = strdup(arg);
1020 if (pp->lazy_line == NULL)
1021 return -ENOMEM;
1022 break;
1023 }
1024 ptr = strpbrk(arg, ";:+@%");
1025 if (ptr) {
1026 nc = *ptr;
1027 *ptr++ = '\0';
1028 }
1029 switch (c) {
1030 case ':': /* Line number */
1031 pp->line = strtoul(arg, &tmp, 0);
1032 if (*tmp != '\0') {
1033 semantic_error("There is non-digit char"
1034 " in line number.\n");
1035 return -EINVAL;
1036 }
1037 break;
1038 case '+': /* Byte offset from a symbol */
1039 pp->offset = strtoul(arg, &tmp, 0);
1040 if (*tmp != '\0') {
1041 semantic_error("There is non-digit character"
1042 " in offset.\n");
1043 return -EINVAL;
1044 }
1045 break;
1046 case '@': /* File name */
1047 if (pp->file) {
1048 semantic_error("SRC@SRC is not allowed.\n");
1049 return -EINVAL;
1050 }
1051 pp->file = strdup(arg);
1052 if (pp->file == NULL)
1053 return -ENOMEM;
1054 break;
1055 case '%': /* Probe places */
1056 if (strcmp(arg, "return") == 0) {
1057 pp->retprobe = 1;
1058 } else { /* Others not supported yet */
1059 semantic_error("%%%s is not supported.\n", arg);
1060 return -ENOTSUP;
1061 }
1062 break;
1063 default: /* Buggy case */
1064 pr_err("This program has a bug at %s:%d.\n",
1065 __FILE__, __LINE__);
1066 return -ENOTSUP;
1067 break;
1068 }
1069 }
1070
1071 /* Exclusion check */
1072 if (pp->lazy_line && pp->line) {
1073 semantic_error("Lazy pattern can't be used with"
1074 " line number.\n");
1075 return -EINVAL;
1076 }
1077
1078 if (pp->lazy_line && pp->offset) {
1079 semantic_error("Lazy pattern can't be used with offset.\n");
1080 return -EINVAL;
1081 }
1082
1083 if (pp->line && pp->offset) {
1084 semantic_error("Offset can't be used with line number.\n");
1085 return -EINVAL;
1086 }
1087
1088 if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1089 semantic_error("File always requires line number or "
1090 "lazy pattern.\n");
1091 return -EINVAL;
1092 }
1093
1094 if (pp->offset && !pp->function) {
1095 semantic_error("Offset requires an entry function.\n");
1096 return -EINVAL;
1097 }
1098
1099 if (pp->retprobe && !pp->function) {
1100 semantic_error("Return probe requires an entry function.\n");
1101 return -EINVAL;
1102 }
1103
1104 if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1105 semantic_error("Offset/Line/Lazy pattern can't be used with "
1106 "return probe.\n");
1107 return -EINVAL;
1108 }
1109
1110 pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1111 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1112 pp->lazy_line);
1113 return 0;
1114 }
1115
1116 /* Parse perf-probe event argument */
1117 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1118 {
1119 char *tmp, *goodname;
1120 struct perf_probe_arg_field **fieldp;
1121
1122 pr_debug("parsing arg: %s into ", str);
1123
1124 tmp = strchr(str, '=');
1125 if (tmp) {
1126 arg->name = strndup(str, tmp - str);
1127 if (arg->name == NULL)
1128 return -ENOMEM;
1129 pr_debug("name:%s ", arg->name);
1130 str = tmp + 1;
1131 }
1132
1133 tmp = strchr(str, ':');
1134 if (tmp) { /* Type setting */
1135 *tmp = '\0';
1136 arg->type = strdup(tmp + 1);
1137 if (arg->type == NULL)
1138 return -ENOMEM;
1139 pr_debug("type:%s ", arg->type);
1140 }
1141
1142 tmp = strpbrk(str, "-.[");
1143 if (!is_c_varname(str) || !tmp) {
1144 /* A variable, register, symbol or special value */
1145 arg->var = strdup(str);
1146 if (arg->var == NULL)
1147 return -ENOMEM;
1148 pr_debug("%s\n", arg->var);
1149 return 0;
1150 }
1151
1152 /* Structure fields or array element */
1153 arg->var = strndup(str, tmp - str);
1154 if (arg->var == NULL)
1155 return -ENOMEM;
1156 goodname = arg->var;
1157 pr_debug("%s, ", arg->var);
1158 fieldp = &arg->field;
1159
1160 do {
1161 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1162 if (*fieldp == NULL)
1163 return -ENOMEM;
1164 if (*tmp == '[') { /* Array */
1165 str = tmp;
1166 (*fieldp)->index = strtol(str + 1, &tmp, 0);
1167 (*fieldp)->ref = true;
1168 if (*tmp != ']' || tmp == str + 1) {
1169 semantic_error("Array index must be a"
1170 " number.\n");
1171 return -EINVAL;
1172 }
1173 tmp++;
1174 if (*tmp == '\0')
1175 tmp = NULL;
1176 } else { /* Structure */
1177 if (*tmp == '.') {
1178 str = tmp + 1;
1179 (*fieldp)->ref = false;
1180 } else if (tmp[1] == '>') {
1181 str = tmp + 2;
1182 (*fieldp)->ref = true;
1183 } else {
1184 semantic_error("Argument parse error: %s\n",
1185 str);
1186 return -EINVAL;
1187 }
1188 tmp = strpbrk(str, "-.[");
1189 }
1190 if (tmp) {
1191 (*fieldp)->name = strndup(str, tmp - str);
1192 if ((*fieldp)->name == NULL)
1193 return -ENOMEM;
1194 if (*str != '[')
1195 goodname = (*fieldp)->name;
1196 pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1197 fieldp = &(*fieldp)->next;
1198 }
1199 } while (tmp);
1200 (*fieldp)->name = strdup(str);
1201 if ((*fieldp)->name == NULL)
1202 return -ENOMEM;
1203 if (*str != '[')
1204 goodname = (*fieldp)->name;
1205 pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1206
1207 /* If no name is specified, set the last field name (not array index)*/
1208 if (!arg->name) {
1209 arg->name = strdup(goodname);
1210 if (arg->name == NULL)
1211 return -ENOMEM;
1212 }
1213 return 0;
1214 }
1215
1216 /* Parse perf-probe event command */
1217 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1218 {
1219 char **argv;
1220 int argc, i, ret = 0;
1221
1222 argv = argv_split(cmd, &argc);
1223 if (!argv) {
1224 pr_debug("Failed to split arguments.\n");
1225 return -ENOMEM;
1226 }
1227 if (argc - 1 > MAX_PROBE_ARGS) {
1228 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1229 ret = -ERANGE;
1230 goto out;
1231 }
1232 /* Parse probe point */
1233 ret = parse_perf_probe_point(argv[0], pev);
1234 if (ret < 0)
1235 goto out;
1236
1237 /* Copy arguments and ensure return probe has no C argument */
1238 pev->nargs = argc - 1;
1239 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1240 if (pev->args == NULL) {
1241 ret = -ENOMEM;
1242 goto out;
1243 }
1244 for (i = 0; i < pev->nargs && ret >= 0; i++) {
1245 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1246 if (ret >= 0 &&
1247 is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1248 semantic_error("You can't specify local variable for"
1249 " kretprobe.\n");
1250 ret = -EINVAL;
1251 }
1252 }
1253 out:
1254 argv_free(argv);
1255
1256 return ret;
1257 }
1258
1259 /* Return true if this perf_probe_event requires debuginfo */
1260 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1261 {
1262 int i;
1263
1264 if (pev->point.file || pev->point.line || pev->point.lazy_line)
1265 return true;
1266
1267 for (i = 0; i < pev->nargs; i++)
1268 if (is_c_varname(pev->args[i].var))
1269 return true;
1270
1271 return false;
1272 }
1273
1274 /* Parse probe_events event into struct probe_point */
1275 static int parse_probe_trace_command(const char *cmd,
1276 struct probe_trace_event *tev)
1277 {
1278 struct probe_trace_point *tp = &tev->point;
1279 char pr;
1280 char *p;
1281 char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1282 int ret, i, argc;
1283 char **argv;
1284
1285 pr_debug("Parsing probe_events: %s\n", cmd);
1286 argv = argv_split(cmd, &argc);
1287 if (!argv) {
1288 pr_debug("Failed to split arguments.\n");
1289 return -ENOMEM;
1290 }
1291 if (argc < 2) {
1292 semantic_error("Too few probe arguments.\n");
1293 ret = -ERANGE;
1294 goto out;
1295 }
1296
1297 /* Scan event and group name. */
1298 argv0_str = strdup(argv[0]);
1299 if (argv0_str == NULL) {
1300 ret = -ENOMEM;
1301 goto out;
1302 }
1303 fmt1_str = strtok_r(argv0_str, ":", &fmt);
1304 fmt2_str = strtok_r(NULL, "/", &fmt);
1305 fmt3_str = strtok_r(NULL, " \t", &fmt);
1306 if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1307 || fmt3_str == NULL) {
1308 semantic_error("Failed to parse event name: %s\n", argv[0]);
1309 ret = -EINVAL;
1310 goto out;
1311 }
1312 pr = fmt1_str[0];
1313 tev->group = strdup(fmt2_str);
1314 tev->event = strdup(fmt3_str);
1315 if (tev->group == NULL || tev->event == NULL) {
1316 ret = -ENOMEM;
1317 goto out;
1318 }
1319 pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1320
1321 tp->retprobe = (pr == 'r');
1322
1323 /* Scan module name(if there), function name and offset */
1324 p = strchr(argv[1], ':');
1325 if (p) {
1326 tp->module = strndup(argv[1], p - argv[1]);
1327 p++;
1328 } else
1329 p = argv[1];
1330 fmt1_str = strtok_r(p, "+", &fmt);
1331 if (fmt1_str[0] == '0') /* only the address started with 0x */
1332 tp->address = strtoul(fmt1_str, NULL, 0);
1333 else {
1334 /* Only the symbol-based probe has offset */
1335 tp->symbol = strdup(fmt1_str);
1336 if (tp->symbol == NULL) {
1337 ret = -ENOMEM;
1338 goto out;
1339 }
1340 fmt2_str = strtok_r(NULL, "", &fmt);
1341 if (fmt2_str == NULL)
1342 tp->offset = 0;
1343 else
1344 tp->offset = strtoul(fmt2_str, NULL, 10);
1345 }
1346
1347 tev->nargs = argc - 2;
1348 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1349 if (tev->args == NULL) {
1350 ret = -ENOMEM;
1351 goto out;
1352 }
1353 for (i = 0; i < tev->nargs; i++) {
1354 p = strchr(argv[i + 2], '=');
1355 if (p) /* We don't need which register is assigned. */
1356 *p++ = '\0';
1357 else
1358 p = argv[i + 2];
1359 tev->args[i].name = strdup(argv[i + 2]);
1360 /* TODO: parse regs and offset */
1361 tev->args[i].value = strdup(p);
1362 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1363 ret = -ENOMEM;
1364 goto out;
1365 }
1366 }
1367 ret = 0;
1368 out:
1369 free(argv0_str);
1370 argv_free(argv);
1371 return ret;
1372 }
1373
1374 /* Compose only probe arg */
1375 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
1376 {
1377 struct perf_probe_arg_field *field = pa->field;
1378 int ret;
1379 char *tmp = buf;
1380
1381 if (pa->name && pa->var)
1382 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
1383 else
1384 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
1385 if (ret <= 0)
1386 goto error;
1387 tmp += ret;
1388 len -= ret;
1389
1390 while (field) {
1391 if (field->name[0] == '[')
1392 ret = e_snprintf(tmp, len, "%s", field->name);
1393 else
1394 ret = e_snprintf(tmp, len, "%s%s",
1395 field->ref ? "->" : ".", field->name);
1396 if (ret <= 0)
1397 goto error;
1398 tmp += ret;
1399 len -= ret;
1400 field = field->next;
1401 }
1402
1403 if (pa->type) {
1404 ret = e_snprintf(tmp, len, ":%s", pa->type);
1405 if (ret <= 0)
1406 goto error;
1407 tmp += ret;
1408 len -= ret;
1409 }
1410
1411 return tmp - buf;
1412 error:
1413 pr_debug("Failed to synthesize perf probe argument: %s\n",
1414 strerror(-ret));
1415 return ret;
1416 }
1417
1418 /* Compose only probe point (not argument) */
1419 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1420 {
1421 char *buf, *tmp;
1422 char offs[32] = "", line[32] = "", file[32] = "";
1423 int ret, len;
1424
1425 buf = zalloc(MAX_CMDLEN);
1426 if (buf == NULL) {
1427 ret = -ENOMEM;
1428 goto error;
1429 }
1430 if (pp->offset) {
1431 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1432 if (ret <= 0)
1433 goto error;
1434 }
1435 if (pp->line) {
1436 ret = e_snprintf(line, 32, ":%d", pp->line);
1437 if (ret <= 0)
1438 goto error;
1439 }
1440 if (pp->file) {
1441 tmp = pp->file;
1442 len = strlen(tmp);
1443 if (len > 30) {
1444 tmp = strchr(pp->file + len - 30, '/');
1445 tmp = tmp ? tmp + 1 : pp->file + len - 30;
1446 }
1447 ret = e_snprintf(file, 32, "@%s", tmp);
1448 if (ret <= 0)
1449 goto error;
1450 }
1451
1452 if (pp->function)
1453 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
1454 offs, pp->retprobe ? "%return" : "", line,
1455 file);
1456 else
1457 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1458 if (ret <= 0)
1459 goto error;
1460
1461 return buf;
1462 error:
1463 pr_debug("Failed to synthesize perf probe point: %s\n",
1464 strerror(-ret));
1465 free(buf);
1466 return NULL;
1467 }
1468
1469 #if 0
1470 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1471 {
1472 char *buf;
1473 int i, len, ret;
1474
1475 buf = synthesize_perf_probe_point(&pev->point);
1476 if (!buf)
1477 return NULL;
1478
1479 len = strlen(buf);
1480 for (i = 0; i < pev->nargs; i++) {
1481 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1482 pev->args[i].name);
1483 if (ret <= 0) {
1484 free(buf);
1485 return NULL;
1486 }
1487 len += ret;
1488 }
1489
1490 return buf;
1491 }
1492 #endif
1493
1494 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1495 char **buf, size_t *buflen,
1496 int depth)
1497 {
1498 int ret;
1499 if (ref->next) {
1500 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1501 buflen, depth + 1);
1502 if (depth < 0)
1503 goto out;
1504 }
1505
1506 ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
1507 if (ret < 0)
1508 depth = ret;
1509 else {
1510 *buf += ret;
1511 *buflen -= ret;
1512 }
1513 out:
1514 return depth;
1515
1516 }
1517
1518 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1519 char *buf, size_t buflen)
1520 {
1521 struct probe_trace_arg_ref *ref = arg->ref;
1522 int ret, depth = 0;
1523 char *tmp = buf;
1524
1525 /* Argument name or separator */
1526 if (arg->name)
1527 ret = e_snprintf(buf, buflen, " %s=", arg->name);
1528 else
1529 ret = e_snprintf(buf, buflen, " ");
1530 if (ret < 0)
1531 return ret;
1532 buf += ret;
1533 buflen -= ret;
1534
1535 /* Special case: @XXX */
1536 if (arg->value[0] == '@' && arg->ref)
1537 ref = ref->next;
1538
1539 /* Dereferencing arguments */
1540 if (ref) {
1541 depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1542 &buflen, 1);
1543 if (depth < 0)
1544 return depth;
1545 }
1546
1547 /* Print argument value */
1548 if (arg->value[0] == '@' && arg->ref)
1549 ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
1550 arg->ref->offset);
1551 else
1552 ret = e_snprintf(buf, buflen, "%s", arg->value);
1553 if (ret < 0)
1554 return ret;
1555 buf += ret;
1556 buflen -= ret;
1557
1558 /* Closing */
1559 while (depth--) {
1560 ret = e_snprintf(buf, buflen, ")");
1561 if (ret < 0)
1562 return ret;
1563 buf += ret;
1564 buflen -= ret;
1565 }
1566 /* Print argument type */
1567 if (arg->type) {
1568 ret = e_snprintf(buf, buflen, ":%s", arg->type);
1569 if (ret <= 0)
1570 return ret;
1571 buf += ret;
1572 }
1573
1574 return buf - tmp;
1575 }
1576
1577 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1578 {
1579 struct probe_trace_point *tp = &tev->point;
1580 char *buf;
1581 int i, len, ret;
1582
1583 buf = zalloc(MAX_CMDLEN);
1584 if (buf == NULL)
1585 return NULL;
1586
1587 len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1588 tev->group, tev->event);
1589 if (len <= 0)
1590 goto error;
1591
1592 /* Uprobes must have tp->address and tp->module */
1593 if (tev->uprobes && (!tp->address || !tp->module))
1594 goto error;
1595
1596 /* Use the tp->address for uprobes */
1597 if (tev->uprobes)
1598 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
1599 tp->module, tp->address);
1600 else
1601 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1602 tp->module ?: "", tp->module ? ":" : "",
1603 tp->symbol, tp->offset);
1604
1605 if (ret <= 0)
1606 goto error;
1607 len += ret;
1608
1609 for (i = 0; i < tev->nargs; i++) {
1610 ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1611 MAX_CMDLEN - len);
1612 if (ret <= 0)
1613 goto error;
1614 len += ret;
1615 }
1616
1617 return buf;
1618 error:
1619 free(buf);
1620 return NULL;
1621 }
1622
1623 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1624 struct perf_probe_point *pp,
1625 bool is_kprobe)
1626 {
1627 struct symbol *sym = NULL;
1628 struct map *map;
1629 u64 addr;
1630 int ret = -ENOENT;
1631
1632 if (!is_kprobe) {
1633 map = dso__new_map(tp->module);
1634 if (!map)
1635 goto out;
1636 addr = tp->address;
1637 sym = map__find_symbol(map, addr, NULL);
1638 } else {
1639 addr = kernel_get_symbol_address_by_name(tp->symbol, true);
1640 if (addr) {
1641 addr += tp->offset;
1642 sym = __find_kernel_function(addr, &map);
1643 }
1644 }
1645 if (!sym)
1646 goto out;
1647
1648 pp->retprobe = tp->retprobe;
1649 pp->offset = addr - map->unmap_ip(map, sym->start);
1650 pp->function = strdup(sym->name);
1651 ret = pp->function ? 0 : -ENOMEM;
1652
1653 out:
1654 if (map && !is_kprobe) {
1655 dso__delete(map->dso);
1656 map__delete(map);
1657 }
1658
1659 return ret;
1660 }
1661
1662 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1663 struct perf_probe_point *pp,
1664 bool is_kprobe)
1665 {
1666 char buf[128];
1667 int ret;
1668
1669 ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
1670 if (!ret)
1671 return 0;
1672 ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
1673 if (!ret)
1674 return 0;
1675
1676 pr_debug("Failed to find probe point from both of dwarf and map.\n");
1677
1678 if (tp->symbol) {
1679 pp->function = strdup(tp->symbol);
1680 pp->offset = tp->offset;
1681 } else if (!tp->module && !is_kprobe) {
1682 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
1683 if (ret < 0)
1684 return ret;
1685 pp->function = strdup(buf);
1686 pp->offset = 0;
1687 }
1688 if (pp->function == NULL)
1689 return -ENOMEM;
1690
1691 pp->retprobe = tp->retprobe;
1692
1693 return 0;
1694 }
1695
1696 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1697 struct perf_probe_event *pev, bool is_kprobe)
1698 {
1699 char buf[64] = "";
1700 int i, ret;
1701
1702 /* Convert event/group name */
1703 pev->event = strdup(tev->event);
1704 pev->group = strdup(tev->group);
1705 if (pev->event == NULL || pev->group == NULL)
1706 return -ENOMEM;
1707
1708 /* Convert trace_point to probe_point */
1709 ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1710 if (ret < 0)
1711 return ret;
1712
1713 /* Convert trace_arg to probe_arg */
1714 pev->nargs = tev->nargs;
1715 pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1716 if (pev->args == NULL)
1717 return -ENOMEM;
1718 for (i = 0; i < tev->nargs && ret >= 0; i++) {
1719 if (tev->args[i].name)
1720 pev->args[i].name = strdup(tev->args[i].name);
1721 else {
1722 ret = synthesize_probe_trace_arg(&tev->args[i],
1723 buf, 64);
1724 pev->args[i].name = strdup(buf);
1725 }
1726 if (pev->args[i].name == NULL && ret >= 0)
1727 ret = -ENOMEM;
1728 }
1729
1730 if (ret < 0)
1731 clear_perf_probe_event(pev);
1732
1733 return ret;
1734 }
1735
1736 void clear_perf_probe_event(struct perf_probe_event *pev)
1737 {
1738 struct perf_probe_point *pp = &pev->point;
1739 struct perf_probe_arg_field *field, *next;
1740 int i;
1741
1742 free(pev->event);
1743 free(pev->group);
1744 free(pp->file);
1745 free(pp->function);
1746 free(pp->lazy_line);
1747
1748 for (i = 0; i < pev->nargs; i++) {
1749 free(pev->args[i].name);
1750 free(pev->args[i].var);
1751 free(pev->args[i].type);
1752 field = pev->args[i].field;
1753 while (field) {
1754 next = field->next;
1755 zfree(&field->name);
1756 free(field);
1757 field = next;
1758 }
1759 }
1760 free(pev->args);
1761 memset(pev, 0, sizeof(*pev));
1762 }
1763
1764 static void clear_probe_trace_event(struct probe_trace_event *tev)
1765 {
1766 struct probe_trace_arg_ref *ref, *next;
1767 int i;
1768
1769 free(tev->event);
1770 free(tev->group);
1771 free(tev->point.symbol);
1772 free(tev->point.module);
1773 for (i = 0; i < tev->nargs; i++) {
1774 free(tev->args[i].name);
1775 free(tev->args[i].value);
1776 free(tev->args[i].type);
1777 ref = tev->args[i].ref;
1778 while (ref) {
1779 next = ref->next;
1780 free(ref);
1781 ref = next;
1782 }
1783 }
1784 free(tev->args);
1785 memset(tev, 0, sizeof(*tev));
1786 }
1787
1788 static void print_open_warning(int err, bool is_kprobe)
1789 {
1790 char sbuf[128];
1791
1792 if (err == -ENOENT) {
1793 const char *config;
1794
1795 if (!is_kprobe)
1796 config = "CONFIG_UPROBE_EVENTS";
1797 else
1798 config = "CONFIG_KPROBE_EVENTS";
1799
1800 pr_warning("%cprobe_events file does not exist"
1801 " - please rebuild kernel with %s.\n",
1802 is_kprobe ? 'k' : 'u', config);
1803 } else if (err == -ENOTSUP)
1804 pr_warning("Debugfs is not mounted.\n");
1805 else
1806 pr_warning("Failed to open %cprobe_events: %s\n",
1807 is_kprobe ? 'k' : 'u',
1808 strerror_r(-err, sbuf, sizeof(sbuf)));
1809 }
1810
1811 static void print_both_open_warning(int kerr, int uerr)
1812 {
1813 /* Both kprobes and uprobes are disabled, warn it. */
1814 if (kerr == -ENOTSUP && uerr == -ENOTSUP)
1815 pr_warning("Debugfs is not mounted.\n");
1816 else if (kerr == -ENOENT && uerr == -ENOENT)
1817 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
1818 "or/and CONFIG_UPROBE_EVENTS.\n");
1819 else {
1820 char sbuf[128];
1821 pr_warning("Failed to open kprobe events: %s.\n",
1822 strerror_r(-kerr, sbuf, sizeof(sbuf)));
1823 pr_warning("Failed to open uprobe events: %s.\n",
1824 strerror_r(-uerr, sbuf, sizeof(sbuf)));
1825 }
1826 }
1827
1828 static int open_probe_events(const char *trace_file, bool readwrite)
1829 {
1830 char buf[PATH_MAX];
1831 const char *__debugfs;
1832 int ret;
1833
1834 __debugfs = debugfs_find_mountpoint();
1835 if (__debugfs == NULL)
1836 return -ENOTSUP;
1837
1838 ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
1839 if (ret >= 0) {
1840 pr_debug("Opening %s write=%d\n", buf, readwrite);
1841 if (readwrite && !probe_event_dry_run)
1842 ret = open(buf, O_RDWR, O_APPEND);
1843 else
1844 ret = open(buf, O_RDONLY, 0);
1845
1846 if (ret < 0)
1847 ret = -errno;
1848 }
1849 return ret;
1850 }
1851
1852 static int open_kprobe_events(bool readwrite)
1853 {
1854 return open_probe_events("tracing/kprobe_events", readwrite);
1855 }
1856
1857 static int open_uprobe_events(bool readwrite)
1858 {
1859 return open_probe_events("tracing/uprobe_events", readwrite);
1860 }
1861
1862 /* Get raw string list of current kprobe_events or uprobe_events */
1863 static struct strlist *get_probe_trace_command_rawlist(int fd)
1864 {
1865 int ret, idx;
1866 FILE *fp;
1867 char buf[MAX_CMDLEN];
1868 char *p;
1869 struct strlist *sl;
1870
1871 sl = strlist__new(true, NULL);
1872
1873 fp = fdopen(dup(fd), "r");
1874 while (!feof(fp)) {
1875 p = fgets(buf, MAX_CMDLEN, fp);
1876 if (!p)
1877 break;
1878
1879 idx = strlen(p) - 1;
1880 if (p[idx] == '\n')
1881 p[idx] = '\0';
1882 ret = strlist__add(sl, buf);
1883 if (ret < 0) {
1884 pr_debug("strlist__add failed: %s\n", strerror(-ret));
1885 strlist__delete(sl);
1886 return NULL;
1887 }
1888 }
1889 fclose(fp);
1890
1891 return sl;
1892 }
1893
1894 /* Show an event */
1895 static int show_perf_probe_event(struct perf_probe_event *pev,
1896 const char *module)
1897 {
1898 int i, ret;
1899 char buf[128];
1900 char *place;
1901
1902 /* Synthesize only event probe point */
1903 place = synthesize_perf_probe_point(&pev->point);
1904 if (!place)
1905 return -EINVAL;
1906
1907 ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
1908 if (ret < 0)
1909 return ret;
1910
1911 printf(" %-20s (on %s", buf, place);
1912 if (module)
1913 printf(" in %s", module);
1914
1915 if (pev->nargs > 0) {
1916 printf(" with");
1917 for (i = 0; i < pev->nargs; i++) {
1918 ret = synthesize_perf_probe_arg(&pev->args[i],
1919 buf, 128);
1920 if (ret < 0)
1921 break;
1922 printf(" %s", buf);
1923 }
1924 }
1925 printf(")\n");
1926 free(place);
1927 return ret;
1928 }
1929
1930 static int __show_perf_probe_events(int fd, bool is_kprobe)
1931 {
1932 int ret = 0;
1933 struct probe_trace_event tev;
1934 struct perf_probe_event pev;
1935 struct strlist *rawlist;
1936 struct str_node *ent;
1937
1938 memset(&tev, 0, sizeof(tev));
1939 memset(&pev, 0, sizeof(pev));
1940
1941 rawlist = get_probe_trace_command_rawlist(fd);
1942 if (!rawlist)
1943 return -ENOENT;
1944
1945 strlist__for_each(ent, rawlist) {
1946 ret = parse_probe_trace_command(ent->s, &tev);
1947 if (ret >= 0) {
1948 ret = convert_to_perf_probe_event(&tev, &pev,
1949 is_kprobe);
1950 if (ret >= 0)
1951 ret = show_perf_probe_event(&pev,
1952 tev.point.module);
1953 }
1954 clear_perf_probe_event(&pev);
1955 clear_probe_trace_event(&tev);
1956 if (ret < 0)
1957 break;
1958 }
1959 strlist__delete(rawlist);
1960
1961 return ret;
1962 }
1963
1964 /* List up current perf-probe events */
1965 int show_perf_probe_events(void)
1966 {
1967 int kp_fd, up_fd, ret;
1968
1969 setup_pager();
1970
1971 ret = init_symbol_maps(false);
1972 if (ret < 0)
1973 return ret;
1974
1975 kp_fd = open_kprobe_events(false);
1976 if (kp_fd >= 0) {
1977 ret = __show_perf_probe_events(kp_fd, true);
1978 close(kp_fd);
1979 if (ret < 0)
1980 goto out;
1981 }
1982
1983 up_fd = open_uprobe_events(false);
1984 if (kp_fd < 0 && up_fd < 0) {
1985 print_both_open_warning(kp_fd, up_fd);
1986 ret = kp_fd;
1987 goto out;
1988 }
1989
1990 if (up_fd >= 0) {
1991 ret = __show_perf_probe_events(up_fd, false);
1992 close(up_fd);
1993 }
1994 out:
1995 exit_symbol_maps();
1996 return ret;
1997 }
1998
1999 /* Get current perf-probe event names */
2000 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
2001 {
2002 char buf[128];
2003 struct strlist *sl, *rawlist;
2004 struct str_node *ent;
2005 struct probe_trace_event tev;
2006 int ret = 0;
2007
2008 memset(&tev, 0, sizeof(tev));
2009 rawlist = get_probe_trace_command_rawlist(fd);
2010 sl = strlist__new(true, NULL);
2011 strlist__for_each(ent, rawlist) {
2012 ret = parse_probe_trace_command(ent->s, &tev);
2013 if (ret < 0)
2014 break;
2015 if (include_group) {
2016 ret = e_snprintf(buf, 128, "%s:%s", tev.group,
2017 tev.event);
2018 if (ret >= 0)
2019 ret = strlist__add(sl, buf);
2020 } else
2021 ret = strlist__add(sl, tev.event);
2022 clear_probe_trace_event(&tev);
2023 if (ret < 0)
2024 break;
2025 }
2026 strlist__delete(rawlist);
2027
2028 if (ret < 0) {
2029 strlist__delete(sl);
2030 return NULL;
2031 }
2032 return sl;
2033 }
2034
2035 static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2036 {
2037 int ret = 0;
2038 char *buf = synthesize_probe_trace_command(tev);
2039
2040 if (!buf) {
2041 pr_debug("Failed to synthesize probe trace event.\n");
2042 return -EINVAL;
2043 }
2044
2045 pr_debug("Writing event: %s\n", buf);
2046 if (!probe_event_dry_run) {
2047 ret = write(fd, buf, strlen(buf));
2048 if (ret <= 0)
2049 pr_warning("Failed to write event: %s\n",
2050 strerror(errno));
2051 }
2052 free(buf);
2053 return ret;
2054 }
2055
2056 static int get_new_event_name(char *buf, size_t len, const char *base,
2057 struct strlist *namelist, bool allow_suffix)
2058 {
2059 int i, ret;
2060
2061 /* Try no suffix */
2062 ret = e_snprintf(buf, len, "%s", base);
2063 if (ret < 0) {
2064 pr_debug("snprintf() failed: %s\n", strerror(-ret));
2065 return ret;
2066 }
2067 if (!strlist__has_entry(namelist, buf))
2068 return 0;
2069
2070 if (!allow_suffix) {
2071 pr_warning("Error: event \"%s\" already exists. "
2072 "(Use -f to force duplicates.)\n", base);
2073 return -EEXIST;
2074 }
2075
2076 /* Try to add suffix */
2077 for (i = 1; i < MAX_EVENT_INDEX; i++) {
2078 ret = e_snprintf(buf, len, "%s_%d", base, i);
2079 if (ret < 0) {
2080 pr_debug("snprintf() failed: %s\n", strerror(-ret));
2081 return ret;
2082 }
2083 if (!strlist__has_entry(namelist, buf))
2084 break;
2085 }
2086 if (i == MAX_EVENT_INDEX) {
2087 pr_warning("Too many events are on the same function.\n");
2088 ret = -ERANGE;
2089 }
2090
2091 return ret;
2092 }
2093
2094 static int __add_probe_trace_events(struct perf_probe_event *pev,
2095 struct probe_trace_event *tevs,
2096 int ntevs, bool allow_suffix)
2097 {
2098 int i, fd, ret;
2099 struct probe_trace_event *tev = NULL;
2100 char buf[64];
2101 const char *event, *group;
2102 struct strlist *namelist;
2103
2104 if (pev->uprobes)
2105 fd = open_uprobe_events(true);
2106 else
2107 fd = open_kprobe_events(true);
2108
2109 if (fd < 0) {
2110 print_open_warning(fd, !pev->uprobes);
2111 return fd;
2112 }
2113
2114 /* Get current event names */
2115 namelist = get_probe_trace_event_names(fd, false);
2116 if (!namelist) {
2117 pr_debug("Failed to get current event list.\n");
2118 return -EIO;
2119 }
2120
2121 ret = 0;
2122 printf("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2123 for (i = 0; i < ntevs; i++) {
2124 tev = &tevs[i];
2125 if (pev->event)
2126 event = pev->event;
2127 else
2128 if (pev->point.function)
2129 event = pev->point.function;
2130 else
2131 event = tev->point.symbol;
2132 if (pev->group)
2133 group = pev->group;
2134 else
2135 group = PERFPROBE_GROUP;
2136
2137 /* Get an unused new event name */
2138 ret = get_new_event_name(buf, 64, event,
2139 namelist, allow_suffix);
2140 if (ret < 0)
2141 break;
2142 event = buf;
2143
2144 tev->event = strdup(event);
2145 tev->group = strdup(group);
2146 if (tev->event == NULL || tev->group == NULL) {
2147 ret = -ENOMEM;
2148 break;
2149 }
2150 ret = write_probe_trace_event(fd, tev);
2151 if (ret < 0)
2152 break;
2153 /* Add added event name to namelist */
2154 strlist__add(namelist, event);
2155
2156 /* Trick here - save current event/group */
2157 event = pev->event;
2158 group = pev->group;
2159 pev->event = tev->event;
2160 pev->group = tev->group;
2161 show_perf_probe_event(pev, tev->point.module);
2162 /* Trick here - restore current event/group */
2163 pev->event = (char *)event;
2164 pev->group = (char *)group;
2165
2166 /*
2167 * Probes after the first probe which comes from same
2168 * user input are always allowed to add suffix, because
2169 * there might be several addresses corresponding to
2170 * one code line.
2171 */
2172 allow_suffix = true;
2173 }
2174
2175 if (ret >= 0) {
2176 /* Show how to use the event. */
2177 printf("\nYou can now use it in all perf tools, such as:\n\n");
2178 printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
2179 tev->event);
2180 }
2181
2182 strlist__delete(namelist);
2183 close(fd);
2184 return ret;
2185 }
2186
2187 static char *looking_function_name;
2188 static int num_matched_functions;
2189
2190 static int probe_function_filter(struct map *map __maybe_unused,
2191 struct symbol *sym)
2192 {
2193 if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
2194 strcmp(looking_function_name, sym->name) == 0) {
2195 num_matched_functions++;
2196 return 0;
2197 }
2198 return 1;
2199 }
2200
2201 #define strdup_or_goto(str, label) \
2202 ({ char *__p = strdup(str); if (!__p) goto label; __p; })
2203
2204 /*
2205 * Find probe function addresses from map.
2206 * Return an error or the number of found probe_trace_event
2207 */
2208 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2209 struct probe_trace_event **tevs,
2210 int max_tevs, const char *target)
2211 {
2212 struct map *map = NULL;
2213 struct kmap *kmap = NULL;
2214 struct ref_reloc_sym *reloc_sym = NULL;
2215 struct symbol *sym;
2216 struct rb_node *nd;
2217 struct probe_trace_event *tev;
2218 struct perf_probe_point *pp = &pev->point;
2219 struct probe_trace_point *tp;
2220 int ret, i;
2221
2222 /* Init maps of given executable or kernel */
2223 if (pev->uprobes)
2224 map = dso__new_map(target);
2225 else
2226 map = kernel_get_module_map(target);
2227 if (!map) {
2228 ret = -EINVAL;
2229 goto out;
2230 }
2231
2232 /*
2233 * Load matched symbols: Since the different local symbols may have
2234 * same name but different addresses, this lists all the symbols.
2235 */
2236 num_matched_functions = 0;
2237 looking_function_name = pp->function;
2238 ret = map__load(map, probe_function_filter);
2239 if (ret || num_matched_functions == 0) {
2240 pr_err("Failed to find symbol %s in %s\n", pp->function,
2241 target ? : "kernel");
2242 ret = -ENOENT;
2243 goto out;
2244 } else if (num_matched_functions > max_tevs) {
2245 pr_err("Too many functions matched in %s\n",
2246 target ? : "kernel");
2247 ret = -E2BIG;
2248 goto out;
2249 }
2250
2251 if (!pev->uprobes) {
2252 kmap = map__kmap(map);
2253 reloc_sym = kmap->ref_reloc_sym;
2254 if (!reloc_sym) {
2255 pr_warning("Relocated base symbol is not found!\n");
2256 ret = -EINVAL;
2257 goto out;
2258 }
2259 }
2260
2261 /* Setup result trace-probe-events */
2262 *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2263 if (!*tevs) {
2264 ret = -ENOMEM;
2265 goto out;
2266 }
2267
2268 ret = 0;
2269 map__for_each_symbol(map, sym, nd) {
2270 tev = (*tevs) + ret;
2271 tp = &tev->point;
2272 if (ret == num_matched_functions) {
2273 pr_warning("Too many symbols are listed. Skip it.\n");
2274 break;
2275 }
2276 ret++;
2277
2278 if (pp->offset > sym->end - sym->start) {
2279 pr_warning("Offset %ld is bigger than the size of %s\n",
2280 pp->offset, sym->name);
2281 ret = -ENOENT;
2282 goto err_out;
2283 }
2284 /* Add one probe point */
2285 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2286 if (reloc_sym) {
2287 tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2288 tp->offset = tp->address - reloc_sym->addr;
2289 } else {
2290 tp->symbol = strdup_or_goto(sym->name, nomem_out);
2291 tp->offset = pp->offset;
2292 }
2293 tp->retprobe = pp->retprobe;
2294 if (target)
2295 tev->point.module = strdup_or_goto(target, nomem_out);
2296 tev->uprobes = pev->uprobes;
2297 tev->nargs = pev->nargs;
2298 if (tev->nargs) {
2299 tev->args = zalloc(sizeof(struct probe_trace_arg) *
2300 tev->nargs);
2301 if (tev->args == NULL)
2302 goto nomem_out;
2303 }
2304 for (i = 0; i < tev->nargs; i++) {
2305 if (pev->args[i].name)
2306 tev->args[i].name =
2307 strdup_or_goto(pev->args[i].name,
2308 nomem_out);
2309
2310 tev->args[i].value = strdup_or_goto(pev->args[i].var,
2311 nomem_out);
2312 if (pev->args[i].type)
2313 tev->args[i].type =
2314 strdup_or_goto(pev->args[i].type,
2315 nomem_out);
2316 }
2317 }
2318
2319 out:
2320 if (map && pev->uprobes) {
2321 /* Only when using uprobe(exec) map needs to be released */
2322 dso__delete(map->dso);
2323 map__delete(map);
2324 }
2325 return ret;
2326
2327 nomem_out:
2328 ret = -ENOMEM;
2329 err_out:
2330 clear_probe_trace_events(*tevs, num_matched_functions);
2331 zfree(tevs);
2332 goto out;
2333 }
2334
2335 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2336 struct probe_trace_event **tevs,
2337 int max_tevs, const char *target)
2338 {
2339 int ret;
2340
2341 if (pev->uprobes && !pev->group) {
2342 /* Replace group name if not given */
2343 ret = convert_exec_to_group(target, &pev->group);
2344 if (ret != 0) {
2345 pr_warning("Failed to make a group name.\n");
2346 return ret;
2347 }
2348 }
2349
2350 /* Convert perf_probe_event with debuginfo */
2351 ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
2352 if (ret != 0)
2353 return ret; /* Found in debuginfo or got an error */
2354
2355 return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
2356 }
2357
2358 struct __event_package {
2359 struct perf_probe_event *pev;
2360 struct probe_trace_event *tevs;
2361 int ntevs;
2362 };
2363
2364 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
2365 int max_tevs, const char *target, bool force_add)
2366 {
2367 int i, j, ret;
2368 struct __event_package *pkgs;
2369
2370 ret = 0;
2371 pkgs = zalloc(sizeof(struct __event_package) * npevs);
2372
2373 if (pkgs == NULL)
2374 return -ENOMEM;
2375
2376 ret = init_symbol_maps(pevs->uprobes);
2377 if (ret < 0) {
2378 free(pkgs);
2379 return ret;
2380 }
2381
2382 /* Loop 1: convert all events */
2383 for (i = 0; i < npevs; i++) {
2384 pkgs[i].pev = &pevs[i];
2385 /* Convert with or without debuginfo */
2386 ret = convert_to_probe_trace_events(pkgs[i].pev,
2387 &pkgs[i].tevs,
2388 max_tevs,
2389 target);
2390 if (ret < 0)
2391 goto end;
2392 pkgs[i].ntevs = ret;
2393 }
2394
2395 /* Loop 2: add all events */
2396 for (i = 0; i < npevs; i++) {
2397 ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2398 pkgs[i].ntevs, force_add);
2399 if (ret < 0)
2400 break;
2401 }
2402 end:
2403 /* Loop 3: cleanup and free trace events */
2404 for (i = 0; i < npevs; i++) {
2405 for (j = 0; j < pkgs[i].ntevs; j++)
2406 clear_probe_trace_event(&pkgs[i].tevs[j]);
2407 zfree(&pkgs[i].tevs);
2408 }
2409 free(pkgs);
2410 exit_symbol_maps();
2411
2412 return ret;
2413 }
2414
2415 static int __del_trace_probe_event(int fd, struct str_node *ent)
2416 {
2417 char *p;
2418 char buf[128];
2419 int ret;
2420
2421 /* Convert from perf-probe event to trace-probe event */
2422 ret = e_snprintf(buf, 128, "-:%s", ent->s);
2423 if (ret < 0)
2424 goto error;
2425
2426 p = strchr(buf + 2, ':');
2427 if (!p) {
2428 pr_debug("Internal error: %s should have ':' but not.\n",
2429 ent->s);
2430 ret = -ENOTSUP;
2431 goto error;
2432 }
2433 *p = '/';
2434
2435 pr_debug("Writing event: %s\n", buf);
2436 ret = write(fd, buf, strlen(buf));
2437 if (ret < 0) {
2438 ret = -errno;
2439 goto error;
2440 }
2441
2442 printf("Removed event: %s\n", ent->s);
2443 return 0;
2444 error:
2445 pr_warning("Failed to delete event: %s\n", strerror(-ret));
2446 return ret;
2447 }
2448
2449 static int del_trace_probe_event(int fd, const char *buf,
2450 struct strlist *namelist)
2451 {
2452 struct str_node *ent, *n;
2453 int ret = -1;
2454
2455 if (strpbrk(buf, "*?")) { /* Glob-exp */
2456 strlist__for_each_safe(ent, n, namelist)
2457 if (strglobmatch(ent->s, buf)) {
2458 ret = __del_trace_probe_event(fd, ent);
2459 if (ret < 0)
2460 break;
2461 strlist__remove(namelist, ent);
2462 }
2463 } else {
2464 ent = strlist__find(namelist, buf);
2465 if (ent) {
2466 ret = __del_trace_probe_event(fd, ent);
2467 if (ret >= 0)
2468 strlist__remove(namelist, ent);
2469 }
2470 }
2471
2472 return ret;
2473 }
2474
2475 int del_perf_probe_events(struct strlist *dellist)
2476 {
2477 int ret = -1, ufd = -1, kfd = -1;
2478 char buf[128];
2479 const char *group, *event;
2480 char *p, *str;
2481 struct str_node *ent;
2482 struct strlist *namelist = NULL, *unamelist = NULL;
2483
2484 /* Get current event names */
2485 kfd = open_kprobe_events(true);
2486 if (kfd >= 0)
2487 namelist = get_probe_trace_event_names(kfd, true);
2488
2489 ufd = open_uprobe_events(true);
2490 if (ufd >= 0)
2491 unamelist = get_probe_trace_event_names(ufd, true);
2492
2493 if (kfd < 0 && ufd < 0) {
2494 print_both_open_warning(kfd, ufd);
2495 goto error;
2496 }
2497
2498 if (namelist == NULL && unamelist == NULL)
2499 goto error;
2500
2501 strlist__for_each(ent, dellist) {
2502 str = strdup(ent->s);
2503 if (str == NULL) {
2504 ret = -ENOMEM;
2505 goto error;
2506 }
2507 pr_debug("Parsing: %s\n", str);
2508 p = strchr(str, ':');
2509 if (p) {
2510 group = str;
2511 *p = '\0';
2512 event = p + 1;
2513 } else {
2514 group = "*";
2515 event = str;
2516 }
2517
2518 ret = e_snprintf(buf, 128, "%s:%s", group, event);
2519 if (ret < 0) {
2520 pr_err("Failed to copy event.");
2521 free(str);
2522 goto error;
2523 }
2524
2525 pr_debug("Group: %s, Event: %s\n", group, event);
2526
2527 if (namelist)
2528 ret = del_trace_probe_event(kfd, buf, namelist);
2529
2530 if (unamelist && ret != 0)
2531 ret = del_trace_probe_event(ufd, buf, unamelist);
2532
2533 if (ret != 0)
2534 pr_info("Info: Event \"%s\" does not exist.\n", buf);
2535
2536 free(str);
2537 }
2538
2539 error:
2540 if (kfd >= 0) {
2541 strlist__delete(namelist);
2542 close(kfd);
2543 }
2544
2545 if (ufd >= 0) {
2546 strlist__delete(unamelist);
2547 close(ufd);
2548 }
2549
2550 return ret;
2551 }
2552
2553 /* TODO: don't use a global variable for filter ... */
2554 static struct strfilter *available_func_filter;
2555
2556 /*
2557 * If a symbol corresponds to a function with global binding and
2558 * matches filter return 0. For all others return 1.
2559 */
2560 static int filter_available_functions(struct map *map __maybe_unused,
2561 struct symbol *sym)
2562 {
2563 if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
2564 strfilter__compare(available_func_filter, sym->name))
2565 return 0;
2566 return 1;
2567 }
2568
2569 int show_available_funcs(const char *target, struct strfilter *_filter,
2570 bool user)
2571 {
2572 struct map *map;
2573 int ret;
2574
2575 ret = init_symbol_maps(user);
2576 if (ret < 0)
2577 return ret;
2578
2579 /* Get a symbol map */
2580 if (user)
2581 map = dso__new_map(target);
2582 else
2583 map = kernel_get_module_map(target);
2584 if (!map) {
2585 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2586 return -EINVAL;
2587 }
2588
2589 /* Load symbols with given filter */
2590 available_func_filter = _filter;
2591 if (map__load(map, filter_available_functions)) {
2592 pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
2593 goto end;
2594 }
2595 if (!dso__sorted_by_name(map->dso, map->type))
2596 dso__sort_by_name(map->dso, map->type);
2597
2598 /* Show all (filtered) symbols */
2599 setup_pager();
2600 dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
2601 end:
2602 if (user) {
2603 dso__delete(map->dso);
2604 map__delete(map);
2605 }
2606 exit_symbol_maps();
2607
2608 return ret;
2609 }
2610
Linux kernel - Deliverables
This page took 0.126094 seconds and 5 git commands to generate.