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 
52 bool probe_event_dry_run;	/* Dry run flag */
53 struct probe_conf probe_conf = { .magic_num = DEFAULT_PROBE_MAGIC_NUM };
54 
55 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
56 
e_snprintf(char * str,size_t size,const char * format,...)57 int 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 
69 static struct machine *host_machine;
70 
71 /* Initialize symbol maps and path of vmlinux/modules */
init_probe_symbol_maps(bool user_only)72 int 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 	}
96 out:
97 	if (ret < 0)
98 		pr_warning("Failed to init vmlinux path.\n");
99 	return ret;
100 }
101 
exit_probe_symbol_maps(void)102 void exit_probe_symbol_maps(void)
103 {
104 	machine__delete(host_machine);
105 	host_machine = NULL;
106 	symbol__exit();
107 }
108 
kernel_get_ref_reloc_sym(struct map ** pmap)109 static 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 
kernel_get_symbol_address_by_name(const char * name,u64 * addr,bool reloc,bool reladdr)127 static 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 
kernel_get_module_map(const char * module)150 static 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 
get_target_map(const char * target,struct nsinfo * nsi,bool user)175 struct 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 
convert_exec_to_group(const char * exec,char ** result)192 static 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 
222 out:
223 	free(exec_copy);
224 	return ret;
225 }
226 
clear_perf_probe_point(struct perf_probe_point * pp)227 static 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 
clear_probe_trace_events(struct probe_trace_event * tevs,int ntevs)234 static 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 
242 static bool kprobe_blacklist__listed(u64 address);
kprobe_warn_out_range(const char * symbol,u64 address)243 static 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  */
find_module_name(const char * module)268 static 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 
315 ret_err:
316 	elf_end(elf);
317 elf_err:
318 	close(fd);
319 	return mod_name;
320 }
321 
322 #ifdef HAVE_DWARF_SUPPORT
323 
kernel_get_module_dso(const char * module,struct dso ** pdso)324 static 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(machine__kernel_maps(host_machine), 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);
355 found:
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  */
find_alternative_probe_point(struct debuginfo * dinfo,struct perf_probe_point * pp,struct perf_probe_point * result,const char * target,struct nsinfo * nsi,bool uprobes)365 static 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 
413 out:
414 	map__put(map);
415 	return ret;
416 
417 }
418 
get_alternative_probe_event(struct debuginfo * dinfo,struct perf_probe_event * pev,struct perf_probe_point * tmp)419 static 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 
get_alternative_line_range(struct debuginfo * dinfo,struct line_range * lr,const char * target,bool user)435 static 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
open_from_debuginfod(struct dso * dso,struct nsinfo * nsi,bool silent)463 static 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
496 static inline
open_from_debuginfod(struct dso * dso __maybe_unused,struct nsinfo * nsi __maybe_unused,bool silent __maybe_unused)497 struct 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 */
open_debuginfo(const char * module,struct nsinfo * nsi,bool silent)506 static 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 */
553 static struct debuginfo *debuginfo_cache;
554 static char *debuginfo_cache_path;
555 
debuginfo_cache__open(const char * module,bool silent)556 static 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);
579 out:
580 	return debuginfo_cache;
581 }
582 
debuginfo_cache__exit(void)583 static void debuginfo_cache__exit(void)
584 {
585 	debuginfo__delete(debuginfo_cache);
586 	debuginfo_cache = NULL;
587 	zfree(&debuginfo_cache_path);
588 }
589 
590 
get_text_start_address(const char * exec,u64 * address,struct nsinfo * nsi)591 static 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;
620 out:
621 	elf_end(elf);
622 out_close:
623 	close(fd);
624 
625 	return ret;
626 }
627 
628 /*
629  * Convert trace point to probe point with debuginfo
630  */
find_perf_probe_point_from_dwarf(struct probe_trace_point * tp,struct perf_probe_point * pp,bool is_kprobe)631 static 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 	}
672 error:
673 	pr_debug("Failed to find corresponding probes from debuginfo.\n");
674 	return ret ? : -ENOENT;
675 }
676 
677 /* Adjust symbol name and address */
post_process_probe_trace_point(struct probe_trace_point * tp,struct map * map,u64 offs)678 static 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  */
717 static int
post_process_offline_probe_trace_events(struct probe_trace_event * tevs,int ntevs,const char * pathname)718 post_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 
add_exec_to_probe_trace_events(struct probe_trace_event * tevs,int ntevs,const char * exec,struct nsinfo * nsi)743 static 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 
771 static int
post_process_module_probe_trace_events(struct probe_trace_event * tevs,int ntevs,const char * module,struct debuginfo * dinfo)772 post_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 
810 static int
post_process_kernel_probe_trace_events(struct probe_trace_event * tevs,int ntevs)811 post_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 
865 void __weak
arch__post_process_probe_trace_events(struct perf_probe_event * pev __maybe_unused,int ntevs __maybe_unused)866 arch__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 */
post_process_probe_trace_events(struct perf_probe_event * pev,struct probe_trace_event * tevs,int ntevs,const char * module,bool uprobe,struct debuginfo * dinfo)872 static 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 */
try_to_find_probe_trace_events(struct perf_probe_event * pev,struct probe_trace_event ** tevs)896 static 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 
__show_one_line(FILE * fp,int l,bool skip,bool show_num)974 static 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;
994 error:
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 
_show_one_line(FILE * fp,int l,bool skip,bool show_num)1003 static 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  */
__show_line_range(struct line_range * lr,const char * module,bool user)1022 static 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 	}
1111 end:
1112 	fclose(fp);
1113 	return ret;
1114 }
1115 
show_line_range(struct line_range * lr,const char * module,struct nsinfo * nsi,bool user)1116 int 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 
show_available_vars_at(struct debuginfo * dinfo,struct perf_probe_event * pev,struct strfilter * _filter)1133 static 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);
1194 end:
1195 	free(buf);
1196 	return ret;
1197 }
1198 
1199 /* Show available variables on given probe point */
show_available_vars(struct perf_probe_event * pevs,int npevs,struct strfilter * _filter)1200 int 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);
1222 out:
1223 	exit_probe_symbol_maps();
1224 	return ret;
1225 }
1226 
1227 #else	/* !HAVE_DWARF_SUPPORT */
1228 
debuginfo_cache__exit(void)1229 static void debuginfo_cache__exit(void)
1230 {
1231 }
1232 
1233 static int
find_perf_probe_point_from_dwarf(struct probe_trace_point * tp __maybe_unused,struct perf_probe_point * pp __maybe_unused,bool is_kprobe __maybe_unused)1234 find_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 
try_to_find_probe_trace_events(struct perf_probe_event * pev,struct probe_trace_event ** tevs __maybe_unused)1241 static 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 
show_line_range(struct line_range * lr __maybe_unused,const char * module __maybe_unused,struct nsinfo * nsi __maybe_unused,bool user __maybe_unused)1252 int 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 
show_available_vars(struct perf_probe_event * pevs __maybe_unused,int npevs __maybe_unused,struct strfilter * filter __maybe_unused)1261 int 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 
line_range__clear(struct line_range * lr)1270 void 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 
line_range__init(struct line_range * lr)1279 int 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 
parse_line_num(char ** ptr,int * val,const char * what)1289 static 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 */
is_c_func_name(const char * name)1303 static 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  */
parse_line_range_desc(const char * arg,struct line_range * lr)1321 int 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;
1393 err:
1394 	free(name);
1395 	return err;
1396 }
1397 
parse_perf_probe_event_name(char ** arg,struct perf_probe_event * pev)1398 static 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);
1420 ng_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. */
parse_perf_probe_point(char * arg,struct perf_probe_event * pev)1430 static 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 */
parse_perf_probe_arg(char * str,struct perf_probe_arg * arg)1643 static 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 */
parse_perf_probe_command(const char * cmd,struct perf_probe_event * pev)1754 int 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 			ret = -ENOMEM;
1780 			goto out;
1781 		}
1782 	}
1783 
1784 	/* Copy arguments and ensure return probe has no C argument */
1785 	pev->nargs = argc - 1;
1786 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1787 	if (pev->args == NULL) {
1788 		ret = -ENOMEM;
1789 		goto out;
1790 	}
1791 	for (i = 0; i < pev->nargs && ret >= 0; i++) {
1792 		ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1793 		if (ret >= 0 &&
1794 		    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1795 			semantic_error("You can't specify local variable for"
1796 				       " kretprobe.\n");
1797 			ret = -EINVAL;
1798 		}
1799 	}
1800 out:
1801 	argv_free(argv);
1802 
1803 	return ret;
1804 }
1805 
1806 /* Returns true if *any* ARG is either C variable, $params or $vars. */
perf_probe_with_var(struct perf_probe_event * pev)1807 bool perf_probe_with_var(struct perf_probe_event *pev)
1808 {
1809 	int i = 0;
1810 
1811 	for (i = 0; i < pev->nargs; i++)
1812 		if (is_c_varname(pev->args[i].var)              ||
1813 		    !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
1814 		    !strcmp(pev->args[i].var, PROBE_ARG_VARS))
1815 			return true;
1816 	return false;
1817 }
1818 
1819 /* Return true if this perf_probe_event requires debuginfo */
perf_probe_event_need_dwarf(struct perf_probe_event * pev)1820 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1821 {
1822 	if (pev->point.file || pev->point.line || pev->point.lazy_line)
1823 		return true;
1824 
1825 	if (perf_probe_with_var(pev))
1826 		return true;
1827 
1828 	return false;
1829 }
1830 
1831 /* Parse probe_events event into struct probe_point */
parse_probe_trace_command(const char * cmd,struct probe_trace_event * tev)1832 int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1833 {
1834 	struct probe_trace_point *tp = &tev->point;
1835 	char pr;
1836 	char *p;
1837 	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1838 	int ret, i, argc;
1839 	char **argv;
1840 
1841 	pr_debug("Parsing probe_events: %s\n", cmd);
1842 	argv = argv_split(cmd, &argc);
1843 	if (!argv) {
1844 		pr_debug("Failed to split arguments.\n");
1845 		return -ENOMEM;
1846 	}
1847 	if (argc < 2) {
1848 		semantic_error("Too few probe arguments.\n");
1849 		ret = -ERANGE;
1850 		goto out;
1851 	}
1852 
1853 	/* Scan event and group name. */
1854 	argv0_str = strdup(argv[0]);
1855 	if (argv0_str == NULL) {
1856 		ret = -ENOMEM;
1857 		goto out;
1858 	}
1859 	fmt1_str = strtok_r(argv0_str, ":", &fmt);
1860 	fmt2_str = strtok_r(NULL, "/", &fmt);
1861 	fmt3_str = strtok_r(NULL, " \t", &fmt);
1862 	if (fmt1_str == NULL || fmt2_str == NULL || fmt3_str == NULL) {
1863 		semantic_error("Failed to parse event name: %s\n", argv[0]);
1864 		ret = -EINVAL;
1865 		goto out;
1866 	}
1867 	pr = fmt1_str[0];
1868 	tev->group = strdup(fmt2_str);
1869 	tev->event = strdup(fmt3_str);
1870 	if (tev->group == NULL || tev->event == NULL) {
1871 		ret = -ENOMEM;
1872 		goto out;
1873 	}
1874 	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1875 
1876 	tp->retprobe = (pr == 'r');
1877 
1878 	/* Scan module name(if there), function name and offset */
1879 	p = strchr(argv[1], ':');
1880 	if (p) {
1881 		tp->module = strndup(argv[1], p - argv[1]);
1882 		if (!tp->module) {
1883 			ret = -ENOMEM;
1884 			goto out;
1885 		}
1886 		tev->uprobes = (tp->module[0] == '/');
1887 		p++;
1888 	} else
1889 		p = argv[1];
1890 	fmt1_str = strtok_r(p, "+", &fmt);
1891 	/* only the address started with 0x */
1892 	if (fmt1_str[0] == '0')	{
1893 		/*
1894 		 * Fix a special case:
1895 		 * if address == 0, kernel reports something like:
1896 		 * p:probe_libc/abs_0 /lib/libc-2.18.so:0x          (null) arg1=%ax
1897 		 * Newer kernel may fix that, but we want to
1898 		 * support old kernel also.
1899 		 */
1900 		if (strcmp(fmt1_str, "0x") == 0) {
1901 			if (!argv[2] || strcmp(argv[2], "(null)")) {
1902 				ret = -EINVAL;
1903 				goto out;
1904 			}
1905 			tp->address = 0;
1906 
1907 			free(argv[2]);
1908 			for (i = 2; argv[i + 1] != NULL; i++)
1909 				argv[i] = argv[i + 1];
1910 
1911 			argv[i] = NULL;
1912 			argc -= 1;
1913 		} else
1914 			tp->address = strtoull(fmt1_str, NULL, 0);
1915 	} else {
1916 		/* Only the symbol-based probe has offset */
1917 		tp->symbol = strdup(fmt1_str);
1918 		if (tp->symbol == NULL) {
1919 			ret = -ENOMEM;
1920 			goto out;
1921 		}
1922 		fmt2_str = strtok_r(NULL, "", &fmt);
1923 		if (fmt2_str == NULL)
1924 			tp->offset = 0;
1925 		else
1926 			tp->offset = strtoul(fmt2_str, NULL, 10);
1927 	}
1928 
1929 	if (tev->uprobes) {
1930 		fmt2_str = strchr(p, '(');
1931 		if (fmt2_str)
1932 			tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0);
1933 	}
1934 
1935 	tev->nargs = argc - 2;
1936 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1937 	if (tev->args == NULL) {
1938 		ret = -ENOMEM;
1939 		goto out;
1940 	}
1941 	for (i = 0; i < tev->nargs; i++) {
1942 		p = strchr(argv[i + 2], '=');
1943 		if (p)	/* We don't need which register is assigned. */
1944 			*p++ = '\0';
1945 		else
1946 			p = argv[i + 2];
1947 		tev->args[i].name = strdup(argv[i + 2]);
1948 		/* TODO: parse regs and offset */
1949 		tev->args[i].value = strdup(p);
1950 		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1951 			ret = -ENOMEM;
1952 			goto out;
1953 		}
1954 	}
1955 	ret = 0;
1956 out:
1957 	free(argv0_str);
1958 	argv_free(argv);
1959 	return ret;
1960 }
1961 
1962 /* Compose only probe arg */
synthesize_perf_probe_arg(struct perf_probe_arg * pa)1963 char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1964 {
1965 	struct perf_probe_arg_field *field = pa->field;
1966 	struct strbuf buf;
1967 	char *ret = NULL;
1968 	int err;
1969 
1970 	if (strbuf_init(&buf, 64) < 0)
1971 		return NULL;
1972 
1973 	if (pa->name && pa->var)
1974 		err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1975 	else
1976 		err = strbuf_addstr(&buf, pa->name ?: pa->var);
1977 	if (err)
1978 		goto out;
1979 
1980 	while (field) {
1981 		if (field->name[0] == '[')
1982 			err = strbuf_addstr(&buf, field->name);
1983 		else
1984 			err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
1985 					  field->name);
1986 		field = field->next;
1987 		if (err)
1988 			goto out;
1989 	}
1990 
1991 	if (pa->type)
1992 		if (strbuf_addf(&buf, ":%s", pa->type) < 0)
1993 			goto out;
1994 
1995 	ret = strbuf_detach(&buf, NULL);
1996 out:
1997 	strbuf_release(&buf);
1998 	return ret;
1999 }
2000 
2001 /* Compose only probe point (not argument) */
synthesize_perf_probe_point(struct perf_probe_point * pp)2002 char *synthesize_perf_probe_point(struct perf_probe_point *pp)
2003 {
2004 	struct strbuf buf;
2005 	char *tmp, *ret = NULL;
2006 	int len, err = 0;
2007 
2008 	if (strbuf_init(&buf, 64) < 0)
2009 		return NULL;
2010 
2011 	if (pp->function) {
2012 		if (strbuf_addstr(&buf, pp->function) < 0)
2013 			goto out;
2014 		if (pp->offset)
2015 			err = strbuf_addf(&buf, "+%lu", pp->offset);
2016 		else if (pp->line)
2017 			err = strbuf_addf(&buf, ":%d", pp->line);
2018 		else if (pp->retprobe)
2019 			err = strbuf_addstr(&buf, "%return");
2020 		if (err)
2021 			goto out;
2022 	}
2023 	if (pp->file) {
2024 		tmp = pp->file;
2025 		len = strlen(tmp);
2026 		if (len > 30) {
2027 			tmp = strchr(pp->file + len - 30, '/');
2028 			tmp = tmp ? tmp + 1 : pp->file + len - 30;
2029 		}
2030 		err = strbuf_addf(&buf, "@%s", tmp);
2031 		if (!err && !pp->function && pp->line)
2032 			err = strbuf_addf(&buf, ":%d", pp->line);
2033 	}
2034 	if (!err)
2035 		ret = strbuf_detach(&buf, NULL);
2036 out:
2037 	strbuf_release(&buf);
2038 	return ret;
2039 }
2040 
synthesize_perf_probe_command(struct perf_probe_event * pev)2041 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
2042 {
2043 	struct strbuf buf;
2044 	char *tmp, *ret = NULL;
2045 	int i;
2046 
2047 	if (strbuf_init(&buf, 64))
2048 		return NULL;
2049 	if (pev->event)
2050 		if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
2051 				pev->event) < 0)
2052 			goto out;
2053 
2054 	tmp = synthesize_perf_probe_point(&pev->point);
2055 	if (!tmp || strbuf_addstr(&buf, tmp) < 0)
2056 		goto out;
2057 	free(tmp);
2058 
2059 	for (i = 0; i < pev->nargs; i++) {
2060 		tmp = synthesize_perf_probe_arg(pev->args + i);
2061 		if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
2062 			goto out;
2063 		free(tmp);
2064 	}
2065 
2066 	ret = strbuf_detach(&buf, NULL);
2067 out:
2068 	strbuf_release(&buf);
2069 	return ret;
2070 }
2071 
__synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref * ref,struct strbuf * buf,int depth)2072 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
2073 					    struct strbuf *buf, int depth)
2074 {
2075 	int err;
2076 	if (ref->next) {
2077 		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
2078 							 depth + 1);
2079 		if (depth < 0)
2080 			return depth;
2081 	}
2082 	if (ref->user_access)
2083 		err = strbuf_addf(buf, "%s%ld(", "+u", ref->offset);
2084 	else
2085 		err = strbuf_addf(buf, "%+ld(", ref->offset);
2086 	return (err < 0) ? err : depth;
2087 }
2088 
synthesize_probe_trace_arg(struct probe_trace_arg * arg,struct strbuf * buf)2089 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
2090 				      struct strbuf *buf)
2091 {
2092 	struct probe_trace_arg_ref *ref = arg->ref;
2093 	int depth = 0, err;
2094 
2095 	/* Argument name or separator */
2096 	if (arg->name)
2097 		err = strbuf_addf(buf, " %s=", arg->name);
2098 	else
2099 		err = strbuf_addch(buf, ' ');
2100 	if (err)
2101 		return err;
2102 
2103 	/* Special case: @XXX */
2104 	if (arg->value[0] == '@' && arg->ref)
2105 			ref = ref->next;
2106 
2107 	/* Dereferencing arguments */
2108 	if (ref) {
2109 		depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
2110 		if (depth < 0)
2111 			return depth;
2112 	}
2113 
2114 	/* Print argument value */
2115 	if (arg->value[0] == '@' && arg->ref)
2116 		err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
2117 	else
2118 		err = strbuf_addstr(buf, arg->value);
2119 
2120 	/* Closing */
2121 	while (!err && depth--)
2122 		err = strbuf_addch(buf, ')');
2123 
2124 	/* Print argument type */
2125 	if (!err && arg->type)
2126 		err = strbuf_addf(buf, ":%s", arg->type);
2127 
2128 	return err;
2129 }
2130 
2131 static int
synthesize_probe_trace_args(struct probe_trace_event * tev,struct strbuf * buf)2132 synthesize_probe_trace_args(struct probe_trace_event *tev, struct strbuf *buf)
2133 {
2134 	int i, ret = 0;
2135 
2136 	for (i = 0; i < tev->nargs && ret >= 0; i++)
2137 		ret = synthesize_probe_trace_arg(&tev->args[i], buf);
2138 
2139 	return ret;
2140 }
2141 
2142 static int
synthesize_uprobe_trace_def(struct probe_trace_point * tp,struct strbuf * buf)2143 synthesize_uprobe_trace_def(struct probe_trace_point *tp, struct strbuf *buf)
2144 {
2145 	int err;
2146 
2147 	/* Uprobes must have tp->module */
2148 	if (!tp->module)
2149 		return -EINVAL;
2150 	/*
2151 	 * If tp->address == 0, then this point must be a
2152 	 * absolute address uprobe.
2153 	 * try_to_find_absolute_address() should have made
2154 	 * tp->symbol to "0x0".
2155 	 */
2156 	if (!tp->address && (!tp->symbol || strcmp(tp->symbol, "0x0")))
2157 		return -EINVAL;
2158 
2159 	/* Use the tp->address for uprobes */
2160 	err = strbuf_addf(buf, "%s:0x%" PRIx64, tp->module, tp->address);
2161 
2162 	if (err >= 0 && tp->ref_ctr_offset) {
2163 		if (!uprobe_ref_ctr_is_supported())
2164 			return -EINVAL;
2165 		err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset);
2166 	}
2167 	return err >= 0 ? 0 : err;
2168 }
2169 
2170 static int
synthesize_kprobe_trace_def(struct probe_trace_point * tp,struct strbuf * buf)2171 synthesize_kprobe_trace_def(struct probe_trace_point *tp, struct strbuf *buf)
2172 {
2173 	if (!strncmp(tp->symbol, "0x", 2)) {
2174 		/* Absolute address. See try_to_find_absolute_address() */
2175 		return strbuf_addf(buf, "%s%s0x%" PRIx64, tp->module ?: "",
2176 				  tp->module ? ":" : "", tp->address);
2177 	} else {
2178 		return strbuf_addf(buf, "%s%s%s+%lu", tp->module ?: "",
2179 				tp->module ? ":" : "", tp->symbol, tp->offset);
2180 	}
2181 }
2182 
synthesize_probe_trace_command(struct probe_trace_event * tev)2183 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
2184 {
2185 	struct probe_trace_point *tp = &tev->point;
2186 	struct strbuf buf;
2187 	char *ret = NULL;
2188 	int err;
2189 
2190 	if (strbuf_init(&buf, 32) < 0)
2191 		return NULL;
2192 
2193 	if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
2194 			tev->group, tev->event) < 0)
2195 		goto error;
2196 
2197 	if (tev->uprobes)
2198 		err = synthesize_uprobe_trace_def(tp, &buf);
2199 	else
2200 		err = synthesize_kprobe_trace_def(tp, &buf);
2201 
2202 	if (err >= 0)
2203 		err = synthesize_probe_trace_args(tev, &buf);
2204 
2205 	if (err >= 0)
2206 		ret = strbuf_detach(&buf, NULL);
2207 error:
2208 	strbuf_release(&buf);
2209 	return ret;
2210 }
2211 
find_perf_probe_point_from_map(struct probe_trace_point * tp,struct perf_probe_point * pp,bool is_kprobe)2212 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
2213 					  struct perf_probe_point *pp,
2214 					  bool is_kprobe)
2215 {
2216 	struct symbol *sym = NULL;
2217 	struct map *map = NULL;
2218 	u64 addr = tp->address;
2219 	int ret = -ENOENT;
2220 
2221 	if (!is_kprobe) {
2222 		map = dso__new_map(tp->module);
2223 		if (!map)
2224 			goto out;
2225 		sym = map__find_symbol(map, addr);
2226 	} else {
2227 		if (tp->symbol && !addr) {
2228 			if (kernel_get_symbol_address_by_name(tp->symbol,
2229 						&addr, true, false) < 0)
2230 				goto out;
2231 		}
2232 		if (addr) {
2233 			addr += tp->offset;
2234 			sym = machine__find_kernel_symbol(host_machine, addr, &map);
2235 		}
2236 	}
2237 
2238 	if (!sym)
2239 		goto out;
2240 
2241 	pp->retprobe = tp->retprobe;
2242 	pp->offset = addr - map->unmap_ip(map, sym->start);
2243 	pp->function = strdup(sym->name);
2244 	ret = pp->function ? 0 : -ENOMEM;
2245 
2246 out:
2247 	if (map && !is_kprobe) {
2248 		map__put(map);
2249 	}
2250 
2251 	return ret;
2252 }
2253 
convert_to_perf_probe_point(struct probe_trace_point * tp,struct perf_probe_point * pp,bool is_kprobe)2254 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2255 				       struct perf_probe_point *pp,
2256 				       bool is_kprobe)
2257 {
2258 	char buf[128];
2259 	int ret;
2260 
2261 	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
2262 	if (!ret)
2263 		return 0;
2264 	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
2265 	if (!ret)
2266 		return 0;
2267 
2268 	pr_debug("Failed to find probe point from both of dwarf and map.\n");
2269 
2270 	if (tp->symbol) {
2271 		pp->function = strdup(tp->symbol);
2272 		pp->offset = tp->offset;
2273 	} else {
2274 		ret = e_snprintf(buf, 128, "0x%" PRIx64, tp->address);
2275 		if (ret < 0)
2276 			return ret;
2277 		pp->function = strdup(buf);
2278 		pp->offset = 0;
2279 	}
2280 	if (pp->function == NULL)
2281 		return -ENOMEM;
2282 
2283 	pp->retprobe = tp->retprobe;
2284 
2285 	return 0;
2286 }
2287 
convert_to_perf_probe_event(struct probe_trace_event * tev,struct perf_probe_event * pev,bool is_kprobe)2288 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2289 			       struct perf_probe_event *pev, bool is_kprobe)
2290 {
2291 	struct strbuf buf = STRBUF_INIT;
2292 	int i, ret;
2293 
2294 	/* Convert event/group name */
2295 	pev->event = strdup(tev->event);
2296 	pev->group = strdup(tev->group);
2297 	if (pev->event == NULL || pev->group == NULL)
2298 		return -ENOMEM;
2299 
2300 	/* Convert trace_point to probe_point */
2301 	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2302 	if (ret < 0)
2303 		return ret;
2304 
2305 	/* Convert trace_arg to probe_arg */
2306 	pev->nargs = tev->nargs;
2307 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
2308 	if (pev->args == NULL)
2309 		return -ENOMEM;
2310 	for (i = 0; i < tev->nargs && ret >= 0; i++) {
2311 		if (tev->args[i].name)
2312 			pev->args[i].name = strdup(tev->args[i].name);
2313 		else {
2314 			if ((ret = strbuf_init(&buf, 32)) < 0)
2315 				goto error;
2316 			ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
2317 			pev->args[i].name = strbuf_detach(&buf, NULL);
2318 		}
2319 		if (pev->args[i].name == NULL && ret >= 0)
2320 			ret = -ENOMEM;
2321 	}
2322 error:
2323 	if (ret < 0)
2324 		clear_perf_probe_event(pev);
2325 
2326 	return ret;
2327 }
2328 
clear_perf_probe_event(struct perf_probe_event * pev)2329 void clear_perf_probe_event(struct perf_probe_event *pev)
2330 {
2331 	struct perf_probe_arg_field *field, *next;
2332 	int i;
2333 
2334 	zfree(&pev->event);
2335 	zfree(&pev->group);
2336 	zfree(&pev->target);
2337 	clear_perf_probe_point(&pev->point);
2338 
2339 	for (i = 0; i < pev->nargs; i++) {
2340 		zfree(&pev->args[i].name);
2341 		zfree(&pev->args[i].var);
2342 		zfree(&pev->args[i].type);
2343 		field = pev->args[i].field;
2344 		while (field) {
2345 			next = field->next;
2346 			zfree(&field->name);
2347 			free(field);
2348 			field = next;
2349 		}
2350 	}
2351 	pev->nargs = 0;
2352 	zfree(&pev->args);
2353 }
2354 
2355 #define strdup_or_goto(str, label)	\
2356 ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
2357 
perf_probe_point__copy(struct perf_probe_point * dst,struct perf_probe_point * src)2358 static int perf_probe_point__copy(struct perf_probe_point *dst,
2359 				  struct perf_probe_point *src)
2360 {
2361 	dst->file = strdup_or_goto(src->file, out_err);
2362 	dst->function = strdup_or_goto(src->function, out_err);
2363 	dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
2364 	dst->line = src->line;
2365 	dst->retprobe = src->retprobe;
2366 	dst->offset = src->offset;
2367 	return 0;
2368 
2369 out_err:
2370 	clear_perf_probe_point(dst);
2371 	return -ENOMEM;
2372 }
2373 
perf_probe_arg__copy(struct perf_probe_arg * dst,struct perf_probe_arg * src)2374 static int perf_probe_arg__copy(struct perf_probe_arg *dst,
2375 				struct perf_probe_arg *src)
2376 {
2377 	struct perf_probe_arg_field *field, **ppfield;
2378 
2379 	dst->name = strdup_or_goto(src->name, out_err);
2380 	dst->var = strdup_or_goto(src->var, out_err);
2381 	dst->type = strdup_or_goto(src->type, out_err);
2382 
2383 	field = src->field;
2384 	ppfield = &(dst->field);
2385 	while (field) {
2386 		*ppfield = zalloc(sizeof(*field));
2387 		if (!*ppfield)
2388 			goto out_err;
2389 		(*ppfield)->name = strdup_or_goto(field->name, out_err);
2390 		(*ppfield)->index = field->index;
2391 		(*ppfield)->ref = field->ref;
2392 		field = field->next;
2393 		ppfield = &((*ppfield)->next);
2394 	}
2395 	return 0;
2396 out_err:
2397 	return -ENOMEM;
2398 }
2399 
perf_probe_event__copy(struct perf_probe_event * dst,struct perf_probe_event * src)2400 int perf_probe_event__copy(struct perf_probe_event *dst,
2401 			   struct perf_probe_event *src)
2402 {
2403 	int i;
2404 
2405 	dst->event = strdup_or_goto(src->event, out_err);
2406 	dst->group = strdup_or_goto(src->group, out_err);
2407 	dst->target = strdup_or_goto(src->target, out_err);
2408 	dst->uprobes = src->uprobes;
2409 
2410 	if (perf_probe_point__copy(&dst->point, &src->point) < 0)
2411 		goto out_err;
2412 
2413 	dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
2414 	if (!dst->args)
2415 		goto out_err;
2416 	dst->nargs = src->nargs;
2417 
2418 	for (i = 0; i < src->nargs; i++)
2419 		if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
2420 			goto out_err;
2421 	return 0;
2422 
2423 out_err:
2424 	clear_perf_probe_event(dst);
2425 	return -ENOMEM;
2426 }
2427 
clear_probe_trace_event(struct probe_trace_event * tev)2428 void clear_probe_trace_event(struct probe_trace_event *tev)
2429 {
2430 	struct probe_trace_arg_ref *ref, *next;
2431 	int i;
2432 
2433 	zfree(&tev->event);
2434 	zfree(&tev->group);
2435 	zfree(&tev->point.symbol);
2436 	zfree(&tev->point.realname);
2437 	zfree(&tev->point.module);
2438 	for (i = 0; i < tev->nargs; i++) {
2439 		zfree(&tev->args[i].name);
2440 		zfree(&tev->args[i].value);
2441 		zfree(&tev->args[i].type);
2442 		ref = tev->args[i].ref;
2443 		while (ref) {
2444 			next = ref->next;
2445 			free(ref);
2446 			ref = next;
2447 		}
2448 	}
2449 	zfree(&tev->args);
2450 	tev->nargs = 0;
2451 }
2452 
2453 struct kprobe_blacklist_node {
2454 	struct list_head list;
2455 	u64 start;
2456 	u64 end;
2457 	char *symbol;
2458 };
2459 
kprobe_blacklist__delete(struct list_head * blacklist)2460 static void kprobe_blacklist__delete(struct list_head *blacklist)
2461 {
2462 	struct kprobe_blacklist_node *node;
2463 
2464 	while (!list_empty(blacklist)) {
2465 		node = list_first_entry(blacklist,
2466 					struct kprobe_blacklist_node, list);
2467 		list_del_init(&node->list);
2468 		zfree(&node->symbol);
2469 		free(node);
2470 	}
2471 }
2472 
kprobe_blacklist__load(struct list_head * blacklist)2473 static int kprobe_blacklist__load(struct list_head *blacklist)
2474 {
2475 	struct kprobe_blacklist_node *node;
2476 	const char *__debugfs = debugfs__mountpoint();
2477 	char buf[PATH_MAX], *p;
2478 	FILE *fp;
2479 	int ret;
2480 
2481 	if (__debugfs == NULL)
2482 		return -ENOTSUP;
2483 
2484 	ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2485 	if (ret < 0)
2486 		return ret;
2487 
2488 	fp = fopen(buf, "r");
2489 	if (!fp)
2490 		return -errno;
2491 
2492 	ret = 0;
2493 	while (fgets(buf, PATH_MAX, fp)) {
2494 		node = zalloc(sizeof(*node));
2495 		if (!node) {
2496 			ret = -ENOMEM;
2497 			break;
2498 		}
2499 		INIT_LIST_HEAD(&node->list);
2500 		list_add_tail(&node->list, blacklist);
2501 		if (sscanf(buf, "0x%" PRIx64 "-0x%" PRIx64, &node->start, &node->end) != 2) {
2502 			ret = -EINVAL;
2503 			break;
2504 		}
2505 		p = strchr(buf, '\t');
2506 		if (p) {
2507 			p++;
2508 			if (p[strlen(p) - 1] == '\n')
2509 				p[strlen(p) - 1] = '\0';
2510 		} else
2511 			p = (char *)"unknown";
2512 		node->symbol = strdup(p);
2513 		if (!node->symbol) {
2514 			ret = -ENOMEM;
2515 			break;
2516 		}
2517 		pr_debug2("Blacklist: 0x%" PRIx64 "-0x%" PRIx64 ", %s\n",
2518 			  node->start, node->end, node->symbol);
2519 		ret++;
2520 	}
2521 	if (ret < 0)
2522 		kprobe_blacklist__delete(blacklist);
2523 	fclose(fp);
2524 
2525 	return ret;
2526 }
2527 
2528 static struct kprobe_blacklist_node *
kprobe_blacklist__find_by_address(struct list_head * blacklist,u64 address)2529 kprobe_blacklist__find_by_address(struct list_head *blacklist, u64 address)
2530 {
2531 	struct kprobe_blacklist_node *node;
2532 
2533 	list_for_each_entry(node, blacklist, list) {
2534 		if (node->start <= address && address < node->end)
2535 			return node;
2536 	}
2537 
2538 	return NULL;
2539 }
2540 
2541 static LIST_HEAD(kprobe_blacklist);
2542 
kprobe_blacklist__init(void)2543 static void kprobe_blacklist__init(void)
2544 {
2545 	if (!list_empty(&kprobe_blacklist))
2546 		return;
2547 
2548 	if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
2549 		pr_debug("No kprobe blacklist support, ignored\n");
2550 }
2551 
kprobe_blacklist__release(void)2552 static void kprobe_blacklist__release(void)
2553 {
2554 	kprobe_blacklist__delete(&kprobe_blacklist);
2555 }
2556 
kprobe_blacklist__listed(u64 address)2557 static bool kprobe_blacklist__listed(u64 address)
2558 {
2559 	return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
2560 }
2561 
perf_probe_event__sprintf(const char * group,const char * event,struct perf_probe_event * pev,const char * module,struct strbuf * result)2562 static int perf_probe_event__sprintf(const char *group, const char *event,
2563 				     struct perf_probe_event *pev,
2564 				     const char *module,
2565 				     struct strbuf *result)
2566 {
2567 	int i, ret;
2568 	char *buf;
2569 
2570 	if (asprintf(&buf, "%s:%s", group, event) < 0)
2571 		return -errno;
2572 	ret = strbuf_addf(result, "  %-20s (on ", buf);
2573 	free(buf);
2574 	if (ret)
2575 		return ret;
2576 
2577 	/* Synthesize only event probe point */
2578 	buf = synthesize_perf_probe_point(&pev->point);
2579 	if (!buf)
2580 		return -ENOMEM;
2581 	ret = strbuf_addstr(result, buf);
2582 	free(buf);
2583 
2584 	if (!ret && module)
2585 		ret = strbuf_addf(result, " in %s", module);
2586 
2587 	if (!ret && pev->nargs > 0) {
2588 		ret = strbuf_add(result, " with", 5);
2589 		for (i = 0; !ret && i < pev->nargs; i++) {
2590 			buf = synthesize_perf_probe_arg(&pev->args[i]);
2591 			if (!buf)
2592 				return -ENOMEM;
2593 			ret = strbuf_addf(result, " %s", buf);
2594 			free(buf);
2595 		}
2596 	}
2597 	if (!ret)
2598 		ret = strbuf_addch(result, ')');
2599 
2600 	return ret;
2601 }
2602 
2603 /* Show an event */
show_perf_probe_event(const char * group,const char * event,struct perf_probe_event * pev,const char * module,bool use_stdout)2604 int show_perf_probe_event(const char *group, const char *event,
2605 			  struct perf_probe_event *pev,
2606 			  const char *module, bool use_stdout)
2607 {
2608 	struct strbuf buf = STRBUF_INIT;
2609 	int ret;
2610 
2611 	ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2612 	if (ret >= 0) {
2613 		if (use_stdout)
2614 			printf("%s\n", buf.buf);
2615 		else
2616 			pr_info("%s\n", buf.buf);
2617 	}
2618 	strbuf_release(&buf);
2619 
2620 	return ret;
2621 }
2622 
filter_probe_trace_event(struct probe_trace_event * tev,struct strfilter * filter)2623 static bool filter_probe_trace_event(struct probe_trace_event *tev,
2624 				     struct strfilter *filter)
2625 {
2626 	char tmp[128];
2627 
2628 	/* At first, check the event name itself */
2629 	if (strfilter__compare(filter, tev->event))
2630 		return true;
2631 
2632 	/* Next, check the combination of name and group */
2633 	if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2634 		return false;
2635 	return strfilter__compare(filter, tmp);
2636 }
2637 
__show_perf_probe_events(int fd,bool is_kprobe,struct strfilter * filter)2638 static int __show_perf_probe_events(int fd, bool is_kprobe,
2639 				    struct strfilter *filter)
2640 {
2641 	int ret = 0;
2642 	struct probe_trace_event tev;
2643 	struct perf_probe_event pev;
2644 	struct strlist *rawlist;
2645 	struct str_node *ent;
2646 
2647 	memset(&tev, 0, sizeof(tev));
2648 	memset(&pev, 0, sizeof(pev));
2649 
2650 	rawlist = probe_file__get_rawlist(fd);
2651 	if (!rawlist)
2652 		return -ENOMEM;
2653 
2654 	strlist__for_each_entry(ent, rawlist) {
2655 		ret = parse_probe_trace_command(ent->s, &tev);
2656 		if (ret >= 0) {
2657 			if (!filter_probe_trace_event(&tev, filter))
2658 				goto next;
2659 			ret = convert_to_perf_probe_event(&tev, &pev,
2660 								is_kprobe);
2661 			if (ret < 0)
2662 				goto next;
2663 			ret = show_perf_probe_event(pev.group, pev.event,
2664 						    &pev, tev.point.module,
2665 						    true);
2666 		}
2667 next:
2668 		clear_perf_probe_event(&pev);
2669 		clear_probe_trace_event(&tev);
2670 		if (ret < 0)
2671 			break;
2672 	}
2673 	strlist__delete(rawlist);
2674 	/* Cleanup cached debuginfo if needed */
2675 	debuginfo_cache__exit();
2676 
2677 	return ret;
2678 }
2679 
2680 /* List up current perf-probe events */
show_perf_probe_events(struct strfilter * filter)2681 int show_perf_probe_events(struct strfilter *filter)
2682 {
2683 	int kp_fd, up_fd, ret;
2684 
2685 	setup_pager();
2686 
2687 	if (probe_conf.cache)
2688 		return probe_cache__show_all_caches(filter);
2689 
2690 	ret = init_probe_symbol_maps(false);
2691 	if (ret < 0)
2692 		return ret;
2693 
2694 	ret = probe_file__open_both(&kp_fd, &up_fd, 0);
2695 	if (ret < 0)
2696 		return ret;
2697 
2698 	if (kp_fd >= 0)
2699 		ret = __show_perf_probe_events(kp_fd, true, filter);
2700 	if (up_fd >= 0 && ret >= 0)
2701 		ret = __show_perf_probe_events(up_fd, false, filter);
2702 	if (kp_fd > 0)
2703 		close(kp_fd);
2704 	if (up_fd > 0)
2705 		close(up_fd);
2706 	exit_probe_symbol_maps();
2707 
2708 	return ret;
2709 }
2710 
get_new_event_name(char * buf,size_t len,const char * base,struct strlist * namelist,bool ret_event,bool allow_suffix)2711 static int get_new_event_name(char *buf, size_t len, const char *base,
2712 			      struct strlist *namelist, bool ret_event,
2713 			      bool allow_suffix)
2714 {
2715 	int i, ret;
2716 	char *p, *nbase;
2717 
2718 	if (*base == '.')
2719 		base++;
2720 	nbase = strdup(base);
2721 	if (!nbase)
2722 		return -ENOMEM;
2723 
2724 	/* Cut off the dot suffixes (e.g. .const, .isra) and version suffixes */
2725 	p = strpbrk(nbase, ".@");
2726 	if (p && p != nbase)
2727 		*p = '\0';
2728 
2729 	/* Try no suffix number */
2730 	ret = e_snprintf(buf, len, "%s%s", nbase, ret_event ? "__return" : "");
2731 	if (ret < 0) {
2732 		pr_debug("snprintf() failed: %d\n", ret);
2733 		goto out;
2734 	}
2735 	if (!strlist__has_entry(namelist, buf))
2736 		goto out;
2737 
2738 	if (!allow_suffix) {
2739 		pr_warning("Error: event \"%s\" already exists.\n"
2740 			   " Hint: Remove existing event by 'perf probe -d'\n"
2741 			   "       or force duplicates by 'perf probe -f'\n"
2742 			   "       or set 'force=yes' in BPF source.\n",
2743 			   buf);
2744 		ret = -EEXIST;
2745 		goto out;
2746 	}
2747 
2748 	/* Try to add suffix */
2749 	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2750 		ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2751 		if (ret < 0) {
2752 			pr_debug("snprintf() failed: %d\n", ret);
2753 			goto out;
2754 		}
2755 		if (!strlist__has_entry(namelist, buf))
2756 			break;
2757 	}
2758 	if (i == MAX_EVENT_INDEX) {
2759 		pr_warning("Too many events are on the same function.\n");
2760 		ret = -ERANGE;
2761 	}
2762 
2763 out:
2764 	free(nbase);
2765 
2766 	/* Final validation */
2767 	if (ret >= 0 && !is_c_func_name(buf)) {
2768 		pr_warning("Internal error: \"%s\" is an invalid event name.\n",
2769 			   buf);
2770 		ret = -EINVAL;
2771 	}
2772 
2773 	return ret;
2774 }
2775 
2776 /* Warn if the current kernel's uprobe implementation is old */
warn_uprobe_event_compat(struct probe_trace_event * tev)2777 static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2778 {
2779 	int i;
2780 	char *buf = synthesize_probe_trace_command(tev);
2781 	struct probe_trace_point *tp = &tev->point;
2782 
2783 	if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) {
2784 		pr_warning("A semaphore is associated with %s:%s and "
2785 			   "seems your kernel doesn't support it.\n",
2786 			   tev->group, tev->event);
2787 	}
2788 
2789 	/* Old uprobe event doesn't support memory dereference */
2790 	if (!tev->uprobes || tev->nargs == 0 || !buf)
2791 		goto out;
2792 
2793 	for (i = 0; i < tev->nargs; i++)
2794 		if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2795 			pr_warning("Please upgrade your kernel to at least "
2796 				   "3.14 to have access to feature %s\n",
2797 				   tev->args[i].value);
2798 			break;
2799 		}
2800 out:
2801 	free(buf);
2802 }
2803 
2804 /* Set new name from original perf_probe_event and namelist */
probe_trace_event__set_name(struct probe_trace_event * tev,struct perf_probe_event * pev,struct strlist * namelist,bool allow_suffix)2805 static int probe_trace_event__set_name(struct probe_trace_event *tev,
2806 				       struct perf_probe_event *pev,
2807 				       struct strlist *namelist,
2808 				       bool allow_suffix)
2809 {
2810 	const char *event, *group;
2811 	char buf[64];
2812 	int ret;
2813 
2814 	/* If probe_event or trace_event already have the name, reuse it */
2815 	if (pev->event && !pev->sdt)
2816 		event = pev->event;
2817 	else if (tev->event)
2818 		event = tev->event;
2819 	else {
2820 		/* Or generate new one from probe point */
2821 		if (pev->point.function &&
2822 			(strncmp(pev->point.function, "0x", 2) != 0) &&
2823 			!strisglob(pev->point.function))
2824 			event = pev->point.function;
2825 		else
2826 			event = tev->point.realname;
2827 	}
2828 	if (pev->group && !pev->sdt)
2829 		group = pev->group;
2830 	else if (tev->group)
2831 		group = tev->group;
2832 	else
2833 		group = PERFPROBE_GROUP;
2834 
2835 	/* Get an unused new event name */
2836 	ret = get_new_event_name(buf, 64, event, namelist,
2837 				 tev->point.retprobe, allow_suffix);
2838 	if (ret < 0)
2839 		return ret;
2840 
2841 	event = buf;
2842 
2843 	tev->event = strdup(event);
2844 	tev->group = strdup(group);
2845 	if (tev->event == NULL || tev->group == NULL)
2846 		return -ENOMEM;
2847 
2848 	/*
2849 	 * Add new event name to namelist if multiprobe event is NOT
2850 	 * supported, since we have to use new event name for following
2851 	 * probes in that case.
2852 	 */
2853 	if (!multiprobe_event_is_supported())
2854 		strlist__add(namelist, event);
2855 	return 0;
2856 }
2857 
__open_probe_file_and_namelist(bool uprobe,struct strlist ** namelist)2858 static int __open_probe_file_and_namelist(bool uprobe,
2859 					  struct strlist **namelist)
2860 {
2861 	int fd;
2862 
2863 	fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2864 	if (fd < 0)
2865 		return fd;
2866 
2867 	/* Get current event names */
2868 	*namelist = probe_file__get_namelist(fd);
2869 	if (!(*namelist)) {
2870 		pr_debug("Failed to get current event list.\n");
2871 		close(fd);
2872 		return -ENOMEM;
2873 	}
2874 	return fd;
2875 }
2876 
__add_probe_trace_events(struct perf_probe_event * pev,struct probe_trace_event * tevs,int ntevs,bool allow_suffix)2877 static int __add_probe_trace_events(struct perf_probe_event *pev,
2878 				     struct probe_trace_event *tevs,
2879 				     int ntevs, bool allow_suffix)
2880 {
2881 	int i, fd[2] = {-1, -1}, up, ret;
2882 	struct probe_trace_event *tev = NULL;
2883 	struct probe_cache *cache = NULL;
2884 	struct strlist *namelist[2] = {NULL, NULL};
2885 	struct nscookie nsc;
2886 
2887 	up = pev->uprobes ? 1 : 0;
2888 	fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
2889 	if (fd[up] < 0)
2890 		return fd[up];
2891 
2892 	ret = 0;
2893 	for (i = 0; i < ntevs; i++) {
2894 		tev = &tevs[i];
2895 		up = tev->uprobes ? 1 : 0;
2896 		if (fd[up] == -1) {	/* Open the kprobe/uprobe_events */
2897 			fd[up] = __open_probe_file_and_namelist(up,
2898 								&namelist[up]);
2899 			if (fd[up] < 0)
2900 				goto close_out;
2901 		}
2902 		/* Skip if the symbol is out of .text or blacklisted */
2903 		if (!tev->point.symbol && !pev->uprobes)
2904 			continue;
2905 
2906 		/* Set new name for tev (and update namelist) */
2907 		ret = probe_trace_event__set_name(tev, pev, namelist[up],
2908 						  allow_suffix);
2909 		if (ret < 0)
2910 			break;
2911 
2912 		nsinfo__mountns_enter(pev->nsi, &nsc);
2913 		ret = probe_file__add_event(fd[up], tev);
2914 		nsinfo__mountns_exit(&nsc);
2915 		if (ret < 0)
2916 			break;
2917 
2918 		/*
2919 		 * Probes after the first probe which comes from same
2920 		 * user input are always allowed to add suffix, because
2921 		 * there might be several addresses corresponding to
2922 		 * one code line.
2923 		 */
2924 		allow_suffix = true;
2925 	}
2926 	if (ret == -EINVAL && pev->uprobes)
2927 		warn_uprobe_event_compat(tev);
2928 	if (ret == 0 && probe_conf.cache) {
2929 		cache = probe_cache__new(pev->target, pev->nsi);
2930 		if (!cache ||
2931 		    probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
2932 		    probe_cache__commit(cache) < 0)
2933 			pr_warning("Failed to add event to probe cache\n");
2934 		probe_cache__delete(cache);
2935 	}
2936 
2937 close_out:
2938 	for (up = 0; up < 2; up++) {
2939 		strlist__delete(namelist[up]);
2940 		if (fd[up] >= 0)
2941 			close(fd[up]);
2942 	}
2943 	return ret;
2944 }
2945 
find_probe_functions(struct map * map,char * name,struct symbol ** syms)2946 static int find_probe_functions(struct map *map, char *name,
2947 				struct symbol **syms)
2948 {
2949 	int found = 0;
2950 	struct symbol *sym;
2951 	struct rb_node *tmp;
2952 	const char *norm, *ver;
2953 	char *buf = NULL;
2954 	bool cut_version = true;
2955 
2956 	if (map__load(map) < 0)
2957 		return -EACCES;	/* Possible permission error to load symbols */
2958 
2959 	/* If user gives a version, don't cut off the version from symbols */
2960 	if (strchr(name, '@'))
2961 		cut_version = false;
2962 
2963 	map__for_each_symbol(map, sym, tmp) {
2964 		norm = arch__normalize_symbol_name(sym->name);
2965 		if (!norm)
2966 			continue;
2967 
2968 		if (cut_version) {
2969 			/* We don't care about default symbol or not */
2970 			ver = strchr(norm, '@');
2971 			if (ver) {
2972 				buf = strndup(norm, ver - norm);
2973 				if (!buf)
2974 					return -ENOMEM;
2975 				norm = buf;
2976 			}
2977 		}
2978 
2979 		if (strglobmatch(norm, name)) {
2980 			found++;
2981 			if (syms && found < probe_conf.max_probes)
2982 				syms[found - 1] = sym;
2983 		}
2984 		if (buf)
2985 			zfree(&buf);
2986 	}
2987 
2988 	return found;
2989 }
2990 
arch__fix_tev_from_maps(struct perf_probe_event * pev __maybe_unused,struct probe_trace_event * tev __maybe_unused,struct map * map __maybe_unused,struct symbol * sym __maybe_unused)2991 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2992 				struct probe_trace_event *tev __maybe_unused,
2993 				struct map *map __maybe_unused,
2994 				struct symbol *sym __maybe_unused) { }
2995 
2996 
pr_kallsyms_access_error(void)2997 static void pr_kallsyms_access_error(void)
2998 {
2999 	pr_err("Please ensure you can read the /proc/kallsyms symbol addresses.\n"
3000 	       "If /proc/sys/kernel/kptr_restrict is '2', you can not read\n"
3001 	       "kernel symbol addresses even if you are a superuser. Please change\n"
3002 	       "it to '1'. If kptr_restrict is '1', the superuser can read the\n"
3003 	       "symbol addresses.\n"
3004 	       "In that case, please run this command again with sudo.\n");
3005 }
3006 
3007 /*
3008  * Find probe function addresses from map.
3009  * Return an error or the number of found probe_trace_event
3010  */
find_probe_trace_events_from_map(struct perf_probe_event * pev,struct probe_trace_event ** tevs)3011 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
3012 					    struct probe_trace_event **tevs)
3013 {
3014 	struct map *map = NULL;
3015 	struct ref_reloc_sym *reloc_sym = NULL;
3016 	struct symbol *sym;
3017 	struct symbol **syms = NULL;
3018 	struct probe_trace_event *tev;
3019 	struct perf_probe_point *pp = &pev->point;
3020 	struct probe_trace_point *tp;
3021 	int num_matched_functions;
3022 	int ret, i, j, skipped = 0;
3023 	char *mod_name;
3024 
3025 	map = get_target_map(pev->target, pev->nsi, pev->uprobes);
3026 	if (!map) {
3027 		ret = -EINVAL;
3028 		goto out;
3029 	}
3030 
3031 	syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
3032 	if (!syms) {
3033 		ret = -ENOMEM;
3034 		goto out;
3035 	}
3036 
3037 	/*
3038 	 * Load matched symbols: Since the different local symbols may have
3039 	 * same name but different addresses, this lists all the symbols.
3040 	 */
3041 	num_matched_functions = find_probe_functions(map, pp->function, syms);
3042 	if (num_matched_functions <= 0) {
3043 		if (num_matched_functions == -EACCES) {
3044 			pr_err("Failed to load symbols from %s\n",
3045 			       pev->target ?: "/proc/kallsyms");
3046 			if (pev->target)
3047 				pr_err("Please ensure the file is not stripped.\n");
3048 			else
3049 				pr_kallsyms_access_error();
3050 		} else
3051 			pr_err("Failed to find symbol %s in %s\n", pp->function,
3052 				pev->target ? : "kernel");
3053 		ret = -ENOENT;
3054 		goto out;
3055 	} else if (num_matched_functions > probe_conf.max_probes) {
3056 		pr_err("Too many functions matched in %s\n",
3057 			pev->target ? : "kernel");
3058 		ret = -E2BIG;
3059 		goto out;
3060 	}
3061 
3062 	/* Note that the symbols in the kmodule are not relocated */
3063 	if (!pev->uprobes && !pev->target &&
3064 			(!pp->retprobe || kretprobe_offset_is_supported())) {
3065 		reloc_sym = kernel_get_ref_reloc_sym(NULL);
3066 		if (!reloc_sym) {
3067 			pr_warning("Relocated base symbol is not found! "
3068 				   "Check /proc/sys/kernel/kptr_restrict\n"
3069 				   "and /proc/sys/kernel/perf_event_paranoid. "
3070 				   "Or run as privileged perf user.\n\n");
3071 			ret = -EINVAL;
3072 			goto out;
3073 		}
3074 	}
3075 
3076 	/* Setup result trace-probe-events */
3077 	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
3078 	if (!*tevs) {
3079 		ret = -ENOMEM;
3080 		goto out;
3081 	}
3082 
3083 	ret = 0;
3084 
3085 	for (j = 0; j < num_matched_functions; j++) {
3086 		sym = syms[j];
3087 
3088 		if (sym->type != STT_FUNC)
3089 			continue;
3090 
3091 		/* There can be duplicated symbols in the map */
3092 		for (i = 0; i < j; i++)
3093 			if (sym->start == syms[i]->start) {
3094 				pr_debug("Found duplicated symbol %s @ %" PRIx64 "\n",
3095 					 sym->name, sym->start);
3096 				break;
3097 			}
3098 		if (i != j)
3099 			continue;
3100 
3101 		tev = (*tevs) + ret;
3102 		tp = &tev->point;
3103 		if (ret == num_matched_functions) {
3104 			pr_warning("Too many symbols are listed. Skip it.\n");
3105 			break;
3106 		}
3107 		ret++;
3108 
3109 		if (pp->offset > sym->end - sym->start) {
3110 			pr_warning("Offset %ld is bigger than the size of %s\n",
3111 				   pp->offset, sym->name);
3112 			ret = -ENOENT;
3113 			goto err_out;
3114 		}
3115 		/* Add one probe point */
3116 		tp->address = map->unmap_ip(map, sym->start) + pp->offset;
3117 
3118 		/* Check the kprobe (not in module) is within .text  */
3119 		if (!pev->uprobes && !pev->target &&
3120 		    kprobe_warn_out_range(sym->name, tp->address)) {
3121 			tp->symbol = NULL;	/* Skip it */
3122 			skipped++;
3123 		} else if (reloc_sym) {
3124 			tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
3125 			tp->offset = tp->address - reloc_sym->addr;
3126 		} else {
3127 			tp->symbol = strdup_or_goto(sym->name, nomem_out);
3128 			tp->offset = pp->offset;
3129 		}
3130 		tp->realname = strdup_or_goto(sym->name, nomem_out);
3131 
3132 		tp->retprobe = pp->retprobe;
3133 		if (pev->target) {
3134 			if (pev->uprobes) {
3135 				tev->point.module = strdup_or_goto(pev->target,
3136 								   nomem_out);
3137 			} else {
3138 				mod_name = find_module_name(pev->target);
3139 				tev->point.module =
3140 					strdup(mod_name ? mod_name : pev->target);
3141 				free(mod_name);
3142 				if (!tev->point.module)
3143 					goto nomem_out;
3144 			}
3145 		}
3146 		tev->uprobes = pev->uprobes;
3147 		tev->nargs = pev->nargs;
3148 		if (tev->nargs) {
3149 			tev->args = zalloc(sizeof(struct probe_trace_arg) *
3150 					   tev->nargs);
3151 			if (tev->args == NULL)
3152 				goto nomem_out;
3153 		}
3154 		for (i = 0; i < tev->nargs; i++) {
3155 			if (pev->args[i].name)
3156 				tev->args[i].name =
3157 					strdup_or_goto(pev->args[i].name,
3158 							nomem_out);
3159 
3160 			tev->args[i].value = strdup_or_goto(pev->args[i].var,
3161 							    nomem_out);
3162 			if (pev->args[i].type)
3163 				tev->args[i].type =
3164 					strdup_or_goto(pev->args[i].type,
3165 							nomem_out);
3166 		}
3167 		arch__fix_tev_from_maps(pev, tev, map, sym);
3168 	}
3169 	if (ret == skipped) {
3170 		ret = -ENOENT;
3171 		goto err_out;
3172 	}
3173 
3174 out:
3175 	map__put(map);
3176 	free(syms);
3177 	return ret;
3178 
3179 nomem_out:
3180 	ret = -ENOMEM;
3181 err_out:
3182 	clear_probe_trace_events(*tevs, num_matched_functions);
3183 	zfree(tevs);
3184 	goto out;
3185 }
3186 
try_to_find_absolute_address(struct perf_probe_event * pev,struct probe_trace_event ** tevs)3187 static int try_to_find_absolute_address(struct perf_probe_event *pev,
3188 					struct probe_trace_event **tevs)
3189 {
3190 	struct perf_probe_point *pp = &pev->point;
3191 	struct probe_trace_event *tev;
3192 	struct probe_trace_point *tp;
3193 	int i, err;
3194 
3195 	if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
3196 		return -EINVAL;
3197 	if (perf_probe_event_need_dwarf(pev))
3198 		return -EINVAL;
3199 
3200 	/*
3201 	 * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
3202 	 * absolute address.
3203 	 *
3204 	 * Only one tev can be generated by this.
3205 	 */
3206 	*tevs = zalloc(sizeof(*tev));
3207 	if (!*tevs)
3208 		return -ENOMEM;
3209 
3210 	tev = *tevs;
3211 	tp = &tev->point;
3212 
3213 	/*
3214 	 * Don't use tp->offset, use address directly, because
3215 	 * in synthesize_probe_trace_command() address cannot be
3216 	 * zero.
3217 	 */
3218 	tp->address = pev->point.abs_address;
3219 	tp->retprobe = pp->retprobe;
3220 	tev->uprobes = pev->uprobes;
3221 
3222 	err = -ENOMEM;
3223 	/*
3224 	 * Give it a '0x' leading symbol name.
3225 	 * In __add_probe_trace_events, a NULL symbol is interpreted as
3226 	 * invalid.
3227 	 */
3228 	if (asprintf(&tp->symbol, "0x%" PRIx64, tp->address) < 0)
3229 		goto errout;
3230 
3231 	/* For kprobe, check range */
3232 	if ((!tev->uprobes) &&
3233 	    (kprobe_warn_out_range(tev->point.symbol,
3234 				   tev->point.address))) {
3235 		err = -EACCES;
3236 		goto errout;
3237 	}
3238 
3239 	if (asprintf(&tp->realname, "abs_%" PRIx64, tp->address) < 0)
3240 		goto errout;
3241 
3242 	if (pev->target) {
3243 		tp->module = strdup(pev->target);
3244 		if (!tp->module)
3245 			goto errout;
3246 	}
3247 
3248 	if (tev->group) {
3249 		tev->group = strdup(pev->group);
3250 		if (!tev->group)
3251 			goto errout;
3252 	}
3253 
3254 	if (pev->event) {
3255 		tev->event = strdup(pev->event);
3256 		if (!tev->event)
3257 			goto errout;
3258 	}
3259 
3260 	tev->nargs = pev->nargs;
3261 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
3262 	if (!tev->args)
3263 		goto errout;
3264 
3265 	for (i = 0; i < tev->nargs; i++)
3266 		copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);
3267 
3268 	return 1;
3269 
3270 errout:
3271 	clear_probe_trace_events(*tevs, 1);
3272 	*tevs = NULL;
3273 	return err;
3274 }
3275 
3276 /* Concatenate two arrays */
memcat(void * a,size_t sz_a,void * b,size_t sz_b)3277 static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
3278 {
3279 	void *ret;
3280 
3281 	ret = malloc(sz_a + sz_b);
3282 	if (ret) {
3283 		memcpy(ret, a, sz_a);
3284 		memcpy(ret + sz_a, b, sz_b);
3285 	}
3286 	return ret;
3287 }
3288 
3289 static int
concat_probe_trace_events(struct probe_trace_event ** tevs,int * ntevs,struct probe_trace_event ** tevs2,int ntevs2)3290 concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
3291 			  struct probe_trace_event **tevs2, int ntevs2)
3292 {
3293 	struct probe_trace_event *new_tevs;
3294 	int ret = 0;
3295 
3296 	if (*ntevs == 0) {
3297 		*tevs = *tevs2;
3298 		*ntevs = ntevs2;
3299 		*tevs2 = NULL;
3300 		return 0;
3301 	}
3302 
3303 	if (*ntevs + ntevs2 > probe_conf.max_probes)
3304 		ret = -E2BIG;
3305 	else {
3306 		/* Concatenate the array of probe_trace_event */
3307 		new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
3308 				  *tevs2, ntevs2 * sizeof(**tevs2));
3309 		if (!new_tevs)
3310 			ret = -ENOMEM;
3311 		else {
3312 			free(*tevs);
3313 			*tevs = new_tevs;
3314 			*ntevs += ntevs2;
3315 		}
3316 	}
3317 	if (ret < 0)
3318 		clear_probe_trace_events(*tevs2, ntevs2);
3319 	zfree(tevs2);
3320 
3321 	return ret;
3322 }
3323 
3324 /*
3325  * Try to find probe_trace_event from given probe caches. Return the number
3326  * of cached events found, if an error occurs return the error.
3327  */
find_cached_events(struct perf_probe_event * pev,struct probe_trace_event ** tevs,const char * target)3328 static int find_cached_events(struct perf_probe_event *pev,
3329 			      struct probe_trace_event **tevs,
3330 			      const char *target)
3331 {
3332 	struct probe_cache *cache;
3333 	struct probe_cache_entry *entry;
3334 	struct probe_trace_event *tmp_tevs = NULL;
3335 	int ntevs = 0;
3336 	int ret = 0;
3337 
3338 	cache = probe_cache__new(target, pev->nsi);
3339 	/* Return 0 ("not found") if the target has no probe cache. */
3340 	if (!cache)
3341 		return 0;
3342 
3343 	for_each_probe_cache_entry(entry, cache) {
3344 		/* Skip the cache entry which has no name */
3345 		if (!entry->pev.event || !entry->pev.group)
3346 			continue;
3347 		if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
3348 		    strglobmatch(entry->pev.event, pev->event)) {
3349 			ret = probe_cache_entry__get_event(entry, &tmp_tevs);
3350 			if (ret > 0)
3351 				ret = concat_probe_trace_events(tevs, &ntevs,
3352 								&tmp_tevs, ret);
3353 			if (ret < 0)
3354 				break;
3355 		}
3356 	}
3357 	probe_cache__delete(cache);
3358 	if (ret < 0) {
3359 		clear_probe_trace_events(*tevs, ntevs);
3360 		zfree(tevs);
3361 	} else {
3362 		ret = ntevs;
3363 		if (ntevs > 0 && target && target[0] == '/')
3364 			pev->uprobes = true;
3365 	}
3366 
3367 	return ret;
3368 }
3369 
3370 /* Try to find probe_trace_event from all probe caches */
find_cached_events_all(struct perf_probe_event * pev,struct probe_trace_event ** tevs)3371 static int find_cached_events_all(struct perf_probe_event *pev,
3372 				   struct probe_trace_event **tevs)
3373 {
3374 	struct probe_trace_event *tmp_tevs = NULL;
3375 	struct strlist *bidlist;
3376 	struct str_node *nd;
3377 	char *pathname;
3378 	int ntevs = 0;
3379 	int ret;
3380 
3381 	/* Get the buildid list of all valid caches */
3382 	bidlist = build_id_cache__list_all(true);
3383 	if (!bidlist) {
3384 		ret = -errno;
3385 		pr_debug("Failed to get buildids: %d\n", ret);
3386 		return ret;
3387 	}
3388 
3389 	ret = 0;
3390 	strlist__for_each_entry(nd, bidlist) {
3391 		pathname = build_id_cache__origname(nd->s);
3392 		ret = find_cached_events(pev, &tmp_tevs, pathname);
3393 		/* In the case of cnt == 0, we just skip it */
3394 		if (ret > 0)
3395 			ret = concat_probe_trace_events(tevs, &ntevs,
3396 							&tmp_tevs, ret);
3397 		free(pathname);
3398 		if (ret < 0)
3399 			break;
3400 	}
3401 	strlist__delete(bidlist);
3402 
3403 	if (ret < 0) {
3404 		clear_probe_trace_events(*tevs, ntevs);
3405 		zfree(tevs);
3406 	} else
3407 		ret = ntevs;
3408 
3409 	return ret;
3410 }
3411 
find_probe_trace_events_from_cache(struct perf_probe_event * pev,struct probe_trace_event ** tevs)3412 static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
3413 					      struct probe_trace_event **tevs)
3414 {
3415 	struct probe_cache *cache;
3416 	struct probe_cache_entry *entry;
3417 	struct probe_trace_event *tev;
3418 	struct str_node *node;
3419 	int ret, i;
3420 
3421 	if (pev->sdt) {
3422 		/* For SDT/cached events, we use special search functions */
3423 		if (!pev->target)
3424 			return find_cached_events_all(pev, tevs);
3425 		else
3426 			return find_cached_events(pev, tevs, pev->target);
3427 	}
3428 	cache = probe_cache__new(pev->target, pev->nsi);
3429 	if (!cache)
3430 		return 0;
3431 
3432 	entry = probe_cache__find(cache, pev);
3433 	if (!entry) {
3434 		/* SDT must be in the cache */
3435 		ret = pev->sdt ? -ENOENT : 0;
3436 		goto out;
3437 	}
3438 
3439 	ret = strlist__nr_entries(entry->tevlist);
3440 	if (ret > probe_conf.max_probes) {
3441 		pr_debug("Too many entries matched in the cache of %s\n",
3442 			 pev->target ? : "kernel");
3443 		ret = -E2BIG;
3444 		goto out;
3445 	}
3446 
3447 	*tevs = zalloc(ret * sizeof(*tev));
3448 	if (!*tevs) {
3449 		ret = -ENOMEM;
3450 		goto out;
3451 	}
3452 
3453 	i = 0;
3454 	strlist__for_each_entry(node, entry->tevlist) {
3455 		tev = &(*tevs)[i++];
3456 		ret = parse_probe_trace_command(node->s, tev);
3457 		if (ret < 0)
3458 			goto out;
3459 		/* Set the uprobes attribute as same as original */
3460 		tev->uprobes = pev->uprobes;
3461 	}
3462 	ret = i;
3463 
3464 out:
3465 	probe_cache__delete(cache);
3466 	return ret;
3467 }
3468 
convert_to_probe_trace_events(struct perf_probe_event * pev,struct probe_trace_event ** tevs)3469 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3470 					 struct probe_trace_event **tevs)
3471 {
3472 	int ret;
3473 
3474 	if (!pev->group && !pev->sdt) {
3475 		/* Set group name if not given */
3476 		if (!pev->uprobes) {
3477 			pev->group = strdup(PERFPROBE_GROUP);
3478 			ret = pev->group ? 0 : -ENOMEM;
3479 		} else
3480 			ret = convert_exec_to_group(pev->target, &pev->group);
3481 		if (ret != 0) {
3482 			pr_warning("Failed to make a group name.\n");
3483 			return ret;
3484 		}
3485 	}
3486 
3487 	ret = try_to_find_absolute_address(pev, tevs);
3488 	if (ret > 0)
3489 		return ret;
3490 
3491 	/* At first, we need to lookup cache entry */
3492 	ret = find_probe_trace_events_from_cache(pev, tevs);
3493 	if (ret > 0 || pev->sdt)	/* SDT can be found only in the cache */
3494 		return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3495 
3496 	/* Convert perf_probe_event with debuginfo */
3497 	ret = try_to_find_probe_trace_events(pev, tevs);
3498 	if (ret != 0)
3499 		return ret;	/* Found in debuginfo or got an error */
3500 
3501 	return find_probe_trace_events_from_map(pev, tevs);
3502 }
3503 
convert_perf_probe_events(struct perf_probe_event * pevs,int npevs)3504 int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3505 {
3506 	int i, ret;
3507 
3508 	/* Loop 1: convert all events */
3509 	for (i = 0; i < npevs; i++) {
3510 		/* Init kprobe blacklist if needed */
3511 		if (!pevs[i].uprobes)
3512 			kprobe_blacklist__init();
3513 		/* Convert with or without debuginfo */
3514 		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3515 		if (ret < 0)
3516 			return ret;
3517 		pevs[i].ntevs = ret;
3518 	}
3519 	/* This just release blacklist only if allocated */
3520 	kprobe_blacklist__release();
3521 
3522 	return 0;
3523 }
3524 
show_probe_trace_event(struct probe_trace_event * tev)3525 static int show_probe_trace_event(struct probe_trace_event *tev)
3526 {
3527 	char *buf = synthesize_probe_trace_command(tev);
3528 
3529 	if (!buf) {
3530 		pr_debug("Failed to synthesize probe trace event.\n");
3531 		return -EINVAL;
3532 	}
3533 
3534 	/* Showing definition always go stdout */
3535 	printf("%s\n", buf);
3536 	free(buf);
3537 
3538 	return 0;
3539 }
3540 
show_probe_trace_events(struct perf_probe_event * pevs,int npevs)3541 int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
3542 {
3543 	struct strlist *namelist = strlist__new(NULL, NULL);
3544 	struct probe_trace_event *tev;
3545 	struct perf_probe_event *pev;
3546 	int i, j, ret = 0;
3547 
3548 	if (!namelist)
3549 		return -ENOMEM;
3550 
3551 	for (j = 0; j < npevs && !ret; j++) {
3552 		pev = &pevs[j];
3553 		for (i = 0; i < pev->ntevs && !ret; i++) {
3554 			tev = &pev->tevs[i];
3555 			/* Skip if the symbol is out of .text or blacklisted */
3556 			if (!tev->point.symbol && !pev->uprobes)
3557 				continue;
3558 
3559 			/* Set new name for tev (and update namelist) */
3560 			ret = probe_trace_event__set_name(tev, pev,
3561 							  namelist, true);
3562 			if (!ret)
3563 				ret = show_probe_trace_event(tev);
3564 		}
3565 	}
3566 	strlist__delete(namelist);
3567 
3568 	return ret;
3569 }
3570 
show_bootconfig_event(struct probe_trace_event * tev)3571 static int show_bootconfig_event(struct probe_trace_event *tev)
3572 {
3573 	struct probe_trace_point *tp = &tev->point;
3574 	struct strbuf buf;
3575 	char *ret = NULL;
3576 	int err;
3577 
3578 	if (strbuf_init(&buf, 32) < 0)
3579 		return -ENOMEM;
3580 
3581 	err = synthesize_kprobe_trace_def(tp, &buf);
3582 	if (err >= 0)
3583 		err = synthesize_probe_trace_args(tev, &buf);
3584 	if (err >= 0)
3585 		ret = strbuf_detach(&buf, NULL);
3586 	strbuf_release(&buf);
3587 
3588 	if (ret) {
3589 		printf("'%s'", ret);
3590 		free(ret);
3591 	}
3592 
3593 	return err;
3594 }
3595 
show_bootconfig_events(struct perf_probe_event * pevs,int npevs)3596 int show_bootconfig_events(struct perf_probe_event *pevs, int npevs)
3597 {
3598 	struct strlist *namelist = strlist__new(NULL, NULL);
3599 	struct probe_trace_event *tev;
3600 	struct perf_probe_event *pev;
3601 	char *cur_name = NULL;
3602 	int i, j, ret = 0;
3603 
3604 	if (!namelist)
3605 		return -ENOMEM;
3606 
3607 	for (j = 0; j < npevs && !ret; j++) {
3608 		pev = &pevs[j];
3609 		if (pev->group && strcmp(pev->group, "probe"))
3610 			pr_warning("WARN: Group name %s is ignored\n", pev->group);
3611 		if (pev->uprobes) {
3612 			pr_warning("ERROR: Bootconfig doesn't support uprobes\n");
3613 			ret = -EINVAL;
3614 			break;
3615 		}
3616 		for (i = 0; i < pev->ntevs && !ret; i++) {
3617 			tev = &pev->tevs[i];
3618 			/* Skip if the symbol is out of .text or blacklisted */
3619 			if (!tev->point.symbol && !pev->uprobes)
3620 				continue;
3621 
3622 			/* Set new name for tev (and update namelist) */
3623 			ret = probe_trace_event__set_name(tev, pev,
3624 							  namelist, true);
3625 			if (ret)
3626 				break;
3627 
3628 			if (!cur_name || strcmp(cur_name, tev->event)) {
3629 				printf("%sftrace.event.kprobes.%s.probe = ",
3630 					cur_name ? "\n" : "", tev->event);
3631 				cur_name = tev->event;
3632 			} else
3633 				printf(", ");
3634 			ret = show_bootconfig_event(tev);
3635 		}
3636 	}
3637 	printf("\n");
3638 	strlist__delete(namelist);
3639 
3640 	return ret;
3641 }
3642 
apply_perf_probe_events(struct perf_probe_event * pevs,int npevs)3643 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3644 {
3645 	int i, ret = 0;
3646 
3647 	/* Loop 2: add all events */
3648 	for (i = 0; i < npevs; i++) {
3649 		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
3650 					       pevs[i].ntevs,
3651 					       probe_conf.force_add);
3652 		if (ret < 0)
3653 			break;
3654 	}
3655 	return ret;
3656 }
3657 
cleanup_perf_probe_events(struct perf_probe_event * pevs,int npevs)3658 void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3659 {
3660 	int i, j;
3661 	struct perf_probe_event *pev;
3662 
3663 	/* Loop 3: cleanup and free trace events  */
3664 	for (i = 0; i < npevs; i++) {
3665 		pev = &pevs[i];
3666 		for (j = 0; j < pevs[i].ntevs; j++)
3667 			clear_probe_trace_event(&pevs[i].tevs[j]);
3668 		zfree(&pevs[i].tevs);
3669 		pevs[i].ntevs = 0;
3670 		nsinfo__zput(pev->nsi);
3671 		clear_perf_probe_event(&pevs[i]);
3672 	}
3673 }
3674 
add_perf_probe_events(struct perf_probe_event * pevs,int npevs)3675 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3676 {
3677 	int ret;
3678 
3679 	ret = init_probe_symbol_maps(pevs->uprobes);
3680 	if (ret < 0)
3681 		return ret;
3682 
3683 	ret = convert_perf_probe_events(pevs, npevs);
3684 	if (ret == 0)
3685 		ret = apply_perf_probe_events(pevs, npevs);
3686 
3687 	cleanup_perf_probe_events(pevs, npevs);
3688 
3689 	exit_probe_symbol_maps();
3690 	return ret;
3691 }
3692 
del_perf_probe_events(struct strfilter * filter)3693 int del_perf_probe_events(struct strfilter *filter)
3694 {
3695 	int ret, ret2, ufd = -1, kfd = -1;
3696 	char *str = strfilter__string(filter);
3697 
3698 	if (!str)
3699 		return -EINVAL;
3700 
3701 	/* Get current event names */
3702 	ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
3703 	if (ret < 0)
3704 		goto out;
3705 
3706 	ret = probe_file__del_events(kfd, filter);
3707 	if (ret < 0 && ret != -ENOENT)
3708 		goto error;
3709 
3710 	ret2 = probe_file__del_events(ufd, filter);
3711 	if (ret2 < 0 && ret2 != -ENOENT) {
3712 		ret = ret2;
3713 		goto error;
3714 	}
3715 	ret = 0;
3716 
3717 error:
3718 	if (kfd >= 0)
3719 		close(kfd);
3720 	if (ufd >= 0)
3721 		close(ufd);
3722 out:
3723 	free(str);
3724 
3725 	return ret;
3726 }
3727 
show_available_funcs(const char * target,struct nsinfo * nsi,struct strfilter * _filter,bool user)3728 int show_available_funcs(const char *target, struct nsinfo *nsi,
3729 			 struct strfilter *_filter, bool user)
3730 {
3731         struct rb_node *nd;
3732 	struct map *map;
3733 	int ret;
3734 
3735 	ret = init_probe_symbol_maps(user);
3736 	if (ret < 0)
3737 		return ret;
3738 
3739 	/* Get a symbol map */
3740 	map = get_target_map(target, nsi, user);
3741 	if (!map) {
3742 		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3743 		return -EINVAL;
3744 	}
3745 
3746 	ret = map__load(map);
3747 	if (ret) {
3748 		if (ret == -2) {
3749 			char *str = strfilter__string(_filter);
3750 			pr_err("Failed to find symbols matched to \"%s\"\n",
3751 			       str);
3752 			free(str);
3753 		} else
3754 			pr_err("Failed to load symbols in %s\n",
3755 			       (target) ? : "kernel");
3756 		goto end;
3757 	}
3758 	if (!dso__sorted_by_name(map->dso))
3759 		dso__sort_by_name(map->dso);
3760 
3761 	/* Show all (filtered) symbols */
3762 	setup_pager();
3763 
3764 	for (nd = rb_first_cached(&map->dso->symbol_names); nd;
3765 	     nd = rb_next(nd)) {
3766 		struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
3767 
3768 		if (strfilter__compare(_filter, pos->sym.name))
3769 			printf("%s\n", pos->sym.name);
3770 	}
3771 end:
3772 	map__put(map);
3773 	exit_probe_symbol_maps();
3774 
3775 	return ret;
3776 }
3777 
copy_to_probe_trace_arg(struct probe_trace_arg * tvar,struct perf_probe_arg * pvar)3778 int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
3779 			    struct perf_probe_arg *pvar)
3780 {
3781 	tvar->value = strdup(pvar->var);
3782 	if (tvar->value == NULL)
3783 		return -ENOMEM;
3784 	if (pvar->type) {
3785 		tvar->type = strdup(pvar->type);
3786 		if (tvar->type == NULL)
3787 			return -ENOMEM;
3788 	}
3789 	if (pvar->name) {
3790 		tvar->name = strdup(pvar->name);
3791 		if (tvar->name == NULL)
3792 			return -ENOMEM;
3793 	} else
3794 		tvar->name = NULL;
3795 	return 0;
3796 }
3797