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