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