probe-event.c 77.0 KB
Newer Older
1
/*
2
 * probe-event.c : perf-probe definition to probe_events format converter
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Written by Masami Hiramatsu <mhiramat@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#include <sys/utsname.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
31 32
#include <stdarg.h>
#include <limits.h>
33
#include <elf.h>
34

35
#include "util.h"
36
#include "event.h"
37
#include "strlist.h"
38
#include "debug.h"
39
#include "cache.h"
40
#include "color.h"
41 42
#include "symbol.h"
#include "thread.h"
43
#include <api/fs/fs.h>
44
#include "trace-event.h"	/* For __maybe_unused */
45
#include "probe-event.h"
46
#include "probe-finder.h"
47
#include "probe-file.h"
48
#include "session.h"
49 50 51 52

#define MAX_CMDLEN 256
#define PERFPROBE_GROUP "probe"

53
bool probe_event_dry_run;	/* Dry run flag */
54
struct probe_conf probe_conf;
55

56
#define semantic_error(msg ...) pr_err("Semantic error :" msg)
57

58
int e_snprintf(char *str, size_t size, const char *format, ...)
59 60 61 62 63 64 65 66 67 68 69
{
	int ret;
	va_list ap;
	va_start(ap, format);
	ret = vsnprintf(str, size, format, ap);
	va_end(ap);
	if (ret >= (int)size)
		ret = -E2BIG;
	return ret;
}

70
static struct machine *host_machine;
71

72
/* Initialize symbol maps and path of vmlinux/modules */
73
int init_probe_symbol_maps(bool user_only)
74
{
75 76
	int ret;

77
	symbol_conf.sort_by_name = true;
78
	symbol_conf.allow_aliases = true;
79
	ret = symbol__init(NULL);
80 81 82 83
	if (ret < 0) {
		pr_debug("Failed to init symbol map.\n");
		goto out;
	}
84

85 86
	if (host_machine || user_only)	/* already initialized */
		return 0;
87

88 89 90 91 92 93 94 95
	if (symbol_conf.vmlinux_name)
		pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);

	host_machine = machine__new_host();
	if (!host_machine) {
		pr_debug("machine__new_host() failed.\n");
		symbol__exit();
		ret = -1;
96
	}
97 98 99 100
out:
	if (ret < 0)
		pr_warning("Failed to init vmlinux path.\n");
	return ret;
101 102
}

103
void exit_probe_symbol_maps(void)
104
{
105 106
	machine__delete(host_machine);
	host_machine = NULL;
107 108 109
	symbol__exit();
}

110 111 112
static struct symbol *__find_kernel_function_by_name(const char *name,
						     struct map **mapp)
{
113
	return machine__find_kernel_function_by_name(host_machine, name, mapp,
114 115 116
						     NULL);
}

117 118 119 120 121 122 123 124 125
static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
{
	return machine__find_kernel_function(host_machine, addr, mapp, NULL);
}

static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
{
	/* kmap->ref_reloc_sym should be set if host_machine is initialized */
	struct kmap *kmap;
126
	struct map *map = machine__kernel_map(host_machine);
127

128
	if (map__load(map, NULL) < 0)
129 130
		return NULL;

131
	kmap = map__kmap(map);
132 133
	if (!kmap)
		return NULL;
134 135 136
	return kmap->ref_reloc_sym;
}

137 138
static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
					     bool reloc, bool reladdr)
139 140 141 142 143 144 145 146
{
	struct ref_reloc_sym *reloc_sym;
	struct symbol *sym;
	struct map *map;

	/* ref_reloc_sym is just a label. Need a special fix*/
	reloc_sym = kernel_get_ref_reloc_sym();
	if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
147
		*addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
148 149
	else {
		sym = __find_kernel_function_by_name(name, &map);
150 151 152 153 154
		if (!sym)
			return -ENOENT;
		*addr = map->unmap_ip(map, sym->start) -
			((reloc) ? 0 : map->reloc) -
			((reladdr) ? map->start : 0);
155 156 157 158
	}
	return 0;
}

159 160
static struct map *kernel_get_module_map(const char *module)
{
161
	struct map_groups *grp = &host_machine->kmaps;
162
	struct maps *maps = &grp->maps[MAP__FUNCTION];
163
	struct map *pos;
164

165 166
	/* A file path -- this is an offline module */
	if (module && strchr(module, '/'))
167
		return machine__findnew_module_map(host_machine, 0, module);
168

169 170 171
	if (!module)
		module = "kernel";

172
	for (pos = maps__first(maps); pos; pos = map__next(pos)) {
173
		/* short_name is "[module]" */
174
		if (strncmp(pos->dso->short_name + 1, module,
175 176
			    pos->dso->short_name_len - 2) == 0 &&
		    module[pos->dso->short_name_len - 2] == '\0') {
177 178 179 180 181 182
			return pos;
		}
	}
	return NULL;
}

183
struct map *get_target_map(const char *target, bool user)
184 185 186 187 188 189 190 191 192 193 194 195
{
	/* Init maps of given executable or kernel */
	if (user)
		return dso__new_map(target);
	else
		return kernel_get_module_map(target);
}

static void put_target_map(struct map *map, bool user)
{
	if (map && user) {
		/* Only the user map needs to be released */
196
		map__put(map);
197 198 199 200
	}
}


201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
static int convert_exec_to_group(const char *exec, char **result)
{
	char *ptr1, *ptr2, *exec_copy;
	char buf[64];
	int ret;

	exec_copy = strdup(exec);
	if (!exec_copy)
		return -ENOMEM;

	ptr1 = basename(exec_copy);
	if (!ptr1) {
		ret = -EINVAL;
		goto out;
	}

	ptr2 = strpbrk(ptr1, "-._");
	if (ptr2)
		*ptr2 = '\0';
	ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
	if (ret < 0)
		goto out;

	*result = strdup(buf);
	ret = *result ? 0 : -ENOMEM;

out:
	free(exec_copy);
	return ret;
}

232 233 234 235 236 237 238
static void clear_perf_probe_point(struct perf_probe_point *pp)
{
	free(pp->file);
	free(pp->function);
	free(pp->lazy_line);
}

239 240 241 242 243 244 245 246
static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
{
	int i;

	for (i = 0; i < ntevs; i++)
		clear_probe_trace_event(tevs + i);
}

247 248 249
static bool kprobe_blacklist__listed(unsigned long address);
static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
{
250 251
	u64 etext_addr = 0;
	int ret;
252

253
	/* Get the address of _etext for checking non-probable text symbol */
254 255
	ret = kernel_get_symbol_address_by_name("_etext", &etext_addr,
						false, false);
256

257
	if (ret == 0 && etext_addr < address)
258 259 260 261 262 263 264 265 266
		pr_warning("%s is out of .text, skip it.\n", symbol);
	else if (kprobe_blacklist__listed(address))
		pr_warning("%s is blacklisted function, skip it.\n", symbol);
	else
		return false;

	return true;
}

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
/*
 * NOTE:
 * '.gnu.linkonce.this_module' section of kernel module elf directly
 * maps to 'struct module' from linux/module.h. This section contains
 * actual module name which will be used by kernel after loading it.
 * But, we cannot use 'struct module' here since linux/module.h is not
 * exposed to user-space. Offset of 'name' has remained same from long
 * time, so hardcoding it here.
 */
#ifdef __LP64__
#define MOD_NAME_OFFSET 24
#else
#define MOD_NAME_OFFSET 12
#endif

/*
 * @module can be module name of module file path. In case of path,
 * inspect elf and find out what is actual module name.
 * Caller has to free mod_name after using it.
 */
static char *find_module_name(const char *module)
{
	int fd;
	Elf *elf;
	GElf_Ehdr ehdr;
	GElf_Shdr shdr;
	Elf_Data *data;
	Elf_Scn *sec;
	char *mod_name = NULL;

	fd = open(module, O_RDONLY);
	if (fd < 0)
		return NULL;

	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
	if (elf == NULL)
		goto elf_err;

	if (gelf_getehdr(elf, &ehdr) == NULL)
		goto ret_err;

	sec = elf_section_by_name(elf, &ehdr, &shdr,
			".gnu.linkonce.this_module", NULL);
	if (!sec)
		goto ret_err;

	data = elf_getdata(sec, NULL);
	if (!data || !data->d_buf)
		goto ret_err;

	mod_name = strdup((char *)data->d_buf + MOD_NAME_OFFSET);

ret_err:
	elf_end(elf);
elf_err:
	close(fd);
	return mod_name;
}

326
#ifdef HAVE_DWARF_SUPPORT
327 328 329 330 331 332 333 334 335

static int kernel_get_module_dso(const char *module, struct dso **pdso)
{
	struct dso *dso;
	struct map *map;
	const char *vmlinux_name;
	int ret = 0;

	if (module) {
336 337 338 339 340 341 342
		char module_name[128];

		snprintf(module_name, sizeof(module_name), "[%s]", module);
		map = map_groups__find_by_name(&host_machine->kmaps, MAP__FUNCTION, module_name);
		if (map) {
			dso = map->dso;
			goto found;
343 344 345 346 347
		}
		pr_debug("Failed to find module %s.\n", module);
		return -ENOENT;
	}

348
	map = machine__kernel_map(host_machine);
349 350 351 352 353 354 355 356 357 358 359 360 361
	dso = map->dso;

	vmlinux_name = symbol_conf.vmlinux_name;
	dso->load_errno = 0;
	if (vmlinux_name)
		ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL);
	else
		ret = dso__load_vmlinux_path(dso, map, NULL);
found:
	*pdso = dso;
	return ret;
}

362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
/*
 * Some binaries like glibc have special symbols which are on the symbol
 * table, but not in the debuginfo. If we can find the address of the
 * symbol from map, we can translate the address back to the probe point.
 */
static int find_alternative_probe_point(struct debuginfo *dinfo,
					struct perf_probe_point *pp,
					struct perf_probe_point *result,
					const char *target, bool uprobes)
{
	struct map *map = NULL;
	struct symbol *sym;
	u64 address = 0;
	int ret = -ENOENT;

	/* This can work only for function-name based one */
	if (!pp->function || pp->file)
		return -ENOTSUP;

	map = get_target_map(target, uprobes);
	if (!map)
		return -EINVAL;

	/* Find the address of given function */
	map__for_each_symbol_by_name(map, pp->function, sym) {
387 388 389
		if (uprobes)
			address = sym->start;
		else
390
			address = map->unmap_ip(map, sym->start) - map->reloc;
391
		break;
392 393 394 395 396
	}
	if (!address) {
		ret = -ENOENT;
		goto out;
	}
W
Wang Nan 已提交
397 398
	pr_debug("Symbol %s address found : %" PRIx64 "\n",
			pp->function, address);
399 400 401 402 403 404 405 406

	ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
					  result);
	if (ret <= 0)
		ret = (!ret) ? -ENOENT : ret;
	else {
		result->offset += pp->offset;
		result->line += pp->line;
407
		result->retprobe = pp->retprobe;
408 409 410 411 412 413 414 415 416 417 418
		ret = 0;
	}

out:
	put_target_map(map, uprobes);
	return ret;

}

static int get_alternative_probe_event(struct debuginfo *dinfo,
				       struct perf_probe_event *pev,
419
				       struct perf_probe_point *tmp)
420 421 422 423 424 425
{
	int ret;

	memcpy(tmp, &pev->point, sizeof(*tmp));
	memset(&pev->point, 0, sizeof(pev->point));
	ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
426
					   pev->target, pev->uprobes);
427 428 429 430 431
	if (ret < 0)
		memcpy(&pev->point, tmp, sizeof(*tmp));

	return ret;
}
432

433 434 435 436
static int get_alternative_line_range(struct debuginfo *dinfo,
				      struct line_range *lr,
				      const char *target, bool user)
{
437 438 439 440
	struct perf_probe_point pp = { .function = lr->function,
				       .file = lr->file,
				       .line = lr->start };
	struct perf_probe_point result;
441 442
	int ret, len = 0;

443 444
	memset(&result, 0, sizeof(result));

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
	if (lr->end != INT_MAX)
		len = lr->end - lr->start;
	ret = find_alternative_probe_point(dinfo, &pp, &result,
					   target, user);
	if (!ret) {
		lr->function = result.function;
		lr->file = result.file;
		lr->start = result.line;
		if (lr->end != INT_MAX)
			lr->end = lr->start + len;
		clear_perf_probe_point(&pp);
	}
	return ret;
}

460
/* Open new debuginfo of given module */
461
static struct debuginfo *open_debuginfo(const char *module, bool silent)
462
{
463
	const char *path = module;
464 465 466 467
	char reason[STRERR_BUFSIZE];
	struct debuginfo *ret = NULL;
	struct dso *dso = NULL;
	int err;
468

469
	if (!module || !strchr(module, '/')) {
470 471 472
		err = kernel_get_module_dso(module, &dso);
		if (err < 0) {
			if (!dso || dso->load_errno == 0) {
473
				if (!str_error_r(-err, reason, STRERR_BUFSIZE))
474 475 476
					strcpy(reason, "(unknown)");
			} else
				dso__strerror_load(dso, reason, STRERR_BUFSIZE);
477
			if (!silent)
478 479
				pr_err("Failed to find the path for %s: %s\n",
					module ?: "kernel", reason);
480 481
			return NULL;
		}
482
		path = dso->long_name;
483
	}
484 485 486 487 488 489 490 491 492 493
	ret = debuginfo__new(path);
	if (!ret && !silent) {
		pr_warning("The %s file has no debug information.\n", path);
		if (!module || !strtailcmp(path, ".ko"))
			pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
		else
			pr_warning("Rebuild with -g, ");
		pr_warning("or install an appropriate debuginfo package.\n");
	}
	return ret;
494
}
495

496 497 498 499 500 501
/* For caching the last debuginfo */
static struct debuginfo *debuginfo_cache;
static char *debuginfo_cache_path;

static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
{
502 503 504 505 506 507 508
	const char *path = module;

	/* If the module is NULL, it should be the kernel. */
	if (!module)
		path = "kernel";

	if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path))
509 510 511 512
		goto out;

	/* Copy module path */
	free(debuginfo_cache_path);
513 514 515 516 517
	debuginfo_cache_path = strdup(path);
	if (!debuginfo_cache_path) {
		debuginfo__delete(debuginfo_cache);
		debuginfo_cache = NULL;
		goto out;
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
	}

	debuginfo_cache = open_debuginfo(module, silent);
	if (!debuginfo_cache)
		zfree(&debuginfo_cache_path);
out:
	return debuginfo_cache;
}

static void debuginfo_cache__exit(void)
{
	debuginfo__delete(debuginfo_cache);
	debuginfo_cache = NULL;
	zfree(&debuginfo_cache_path);
}

534

535 536 537 538 539 540 541 542 543 544 545 546
static int get_text_start_address(const char *exec, unsigned long *address)
{
	Elf *elf;
	GElf_Ehdr ehdr;
	GElf_Shdr shdr;
	int fd, ret = -ENOENT;

	fd = open(exec, O_RDONLY);
	if (fd < 0)
		return -errno;

	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
547 548 549 550
	if (elf == NULL) {
		ret = -EINVAL;
		goto out_close;
	}
551 552 553 554 555 556 557 558 559 560 561

	if (gelf_getehdr(elf, &ehdr) == NULL)
		goto out;

	if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
		goto out;

	*address = shdr.sh_addr - shdr.sh_offset;
	ret = 0;
out:
	elf_end(elf);
562 563 564
out_close:
	close(fd);

565 566 567
	return ret;
}

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
/*
 * Convert trace point to probe point with debuginfo
 */
static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
					    struct perf_probe_point *pp,
					    bool is_kprobe)
{
	struct debuginfo *dinfo = NULL;
	unsigned long stext = 0;
	u64 addr = tp->address;
	int ret = -ENOENT;

	/* convert the address to dwarf address */
	if (!is_kprobe) {
		if (!addr) {
			ret = -EINVAL;
			goto error;
		}
		ret = get_text_start_address(tp->module, &stext);
		if (ret < 0)
			goto error;
		addr += stext;
590
	} else if (tp->symbol) {
591 592 593 594
		/* If the module is given, this returns relative address */
		ret = kernel_get_symbol_address_by_name(tp->symbol, &addr,
							false, !!tp->module);
		if (ret != 0)
595 596 597 598 599 600 601
			goto error;
		addr += tp->offset;
	}

	pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
		 tp->module ? : "kernel");

602 603
	dinfo = debuginfo_cache__open(tp->module, verbose == 0);
	if (dinfo)
604 605
		ret = debuginfo__find_probe_point(dinfo,
						 (unsigned long)addr, pp);
606
	else
607 608 609 610 611 612 613 614 615 616 617
		ret = -ENOENT;

	if (ret > 0) {
		pp->retprobe = tp->retprobe;
		return 0;
	}
error:
	pr_debug("Failed to find corresponding probes from debuginfo.\n");
	return ret ? : -ENOENT;
}

618 619 620 621
static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
					  int ntevs, const char *exec)
{
	int i, ret = 0;
622
	unsigned long stext = 0;
623 624 625 626 627 628 629 630 631

	if (!exec)
		return 0;

	ret = get_text_start_address(exec, &stext);
	if (ret < 0)
		return ret;

	for (i = 0; i < ntevs && ret >= 0; i++) {
632
		/* point.address is the addres of point.symbol + point.offset */
633
		tevs[i].point.address -= stext;
634
		tevs[i].point.module = strdup(exec);
635
		if (!tevs[i].point.module) {
636 637 638 639 640 641 642 643 644
			ret = -ENOMEM;
			break;
		}
		tevs[i].uprobes = true;
	}

	return ret;
}

645 646 647
static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
					    int ntevs, const char *module)
{
648
	int i, ret = 0;
649
	char *mod_name = NULL;
650 651 652 653

	if (!module)
		return 0;

654
	mod_name = find_module_name(module);
655

656
	for (i = 0; i < ntevs; i++) {
657 658
		tevs[i].point.module =
			strdup(mod_name ? mod_name : module);
659 660 661 662
		if (!tevs[i].point.module) {
			ret = -ENOMEM;
			break;
		}
663
	}
664

665
	free(mod_name);
666
	return ret;
667 668
}

669 670 671
static int
post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
				       int ntevs)
672 673 674
{
	struct ref_reloc_sym *reloc_sym;
	char *tmp;
675
	int i, skipped = 0;
676

677 678 679 680
	/* Skip post process if the target is an offline kernel */
	if (symbol_conf.ignore_vmlinux_buildid)
		return 0;

681
	reloc_sym = kernel_get_ref_reloc_sym();
682 683 684 685 686 687
	if (!reloc_sym) {
		pr_warning("Relocated base symbol is not found!\n");
		return -EINVAL;
	}

	for (i = 0; i < ntevs; i++) {
688 689 690 691 692 693 694 695 696 697 698
		if (!tevs[i].point.address || tevs[i].point.retprobe)
			continue;
		/* If we found a wrong one, mark it by NULL symbol */
		if (kprobe_warn_out_range(tevs[i].point.symbol,
					  tevs[i].point.address)) {
			tmp = NULL;
			skipped++;
		} else {
			tmp = strdup(reloc_sym->name);
			if (!tmp)
				return -ENOMEM;
699
		}
700 701 702 703 704 705 706 707
		/* If we have no realname, use symbol for it */
		if (!tevs[i].point.realname)
			tevs[i].point.realname = tevs[i].point.symbol;
		else
			free(tevs[i].point.symbol);
		tevs[i].point.symbol = tmp;
		tevs[i].point.offset = tevs[i].point.address -
				       reloc_sym->unrelocated_addr;
708
	}
709
	return skipped;
710 711
}

712 713 714 715 716 717
void __weak
arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
				      int ntevs __maybe_unused)
{
}

718
/* Post processing the probe events */
719 720
static int post_process_probe_trace_events(struct perf_probe_event *pev,
					   struct probe_trace_event *tevs,
721 722 723
					   int ntevs, const char *module,
					   bool uprobe)
{
724
	int ret;
725

726 727 728
	if (uprobe)
		ret = add_exec_to_probe_trace_events(tevs, ntevs, module);
	else if (module)
729
		/* Currently ref_reloc_sym based probe is not for drivers */
730 731 732
		ret = add_module_to_probe_trace_events(tevs, ntevs, module);
	else
		ret = post_process_kernel_probe_trace_events(tevs, ntevs);
733

734 735 736 737
	if (ret >= 0)
		arch__post_process_probe_trace_events(pev, ntevs);

	return ret;
738 739
}

740
/* Try to find perf_probe_event with debuginfo */
741
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
742
					  struct probe_trace_event **tevs)
743 744
{
	bool need_dwarf = perf_probe_event_need_dwarf(pev);
745
	struct perf_probe_point tmp;
746
	struct debuginfo *dinfo;
747
	int ntevs, ret = 0;
748

749
	dinfo = open_debuginfo(pev->target, !need_dwarf);
750
	if (!dinfo) {
751
		if (need_dwarf)
752 753
			return -ENOENT;
		pr_debug("Could not open debuginfo. Try to use symbols.\n");
754 755 756
		return 0;
	}

757
	pr_debug("Try to find probe point from debuginfo.\n");
758
	/* Searching trace events corresponding to a probe event */
759
	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
760

761
	if (ntevs == 0)	{  /* Not found, retry with an alternative */
762
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
763
		if (!ret) {
764
			ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
765 766 767 768 769 770 771 772 773
			/*
			 * Write back to the original probe_event for
			 * setting appropriate (user given) event name
			 */
			clear_perf_probe_point(&pev->point);
			memcpy(&pev->point, &tmp, sizeof(tmp));
		}
	}

774
	debuginfo__delete(dinfo);
775

776
	if (ntevs > 0) {	/* Succeeded to find trace events */
777
		pr_debug("Found %d probe_trace_events.\n", ntevs);
778
		ret = post_process_probe_trace_events(pev, *tevs, ntevs,
779
						pev->target, pev->uprobes);
780
		if (ret < 0 || ret == ntevs) {
781 782 783
			clear_probe_trace_events(*tevs, ntevs);
			zfree(tevs);
		}
784 785 786 787
		if (ret != ntevs)
			return ret < 0 ? ret : ntevs;
		ntevs = 0;
		/* Fall through */
788
	}
789

790
	if (ntevs == 0)	{	/* No error but failed to find probe point. */
791
		pr_warning("Probe point '%s' not found.\n",
792
			   synthesize_perf_probe_point(&pev->point));
793
		return -ENOENT;
794 795
	}
	/* Error path : ntevs < 0 */
796
	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
797 798 799 800
	if (ntevs < 0) {
		if (ntevs == -EBADF)
			pr_warning("Warning: No dwarf info found in the vmlinux - "
				"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
801
		if (!need_dwarf) {
M
Masami Hiramatsu 已提交
802
			pr_debug("Trying to use symbols.\n");
803 804
			return 0;
		}
805
	}
806
	return ntevs;
807 808 809 810 811
}

#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

812
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
813
{
814
	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
815 816
	const char *color = show_num ? "" : PERF_COLOR_BLUE;
	const char *prefix = NULL;
817

818
	do {
819 820
		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
			goto error;
821 822 823 824 825
		if (skip)
			continue;
		if (!prefix) {
			prefix = show_num ? "%7d  " : "         ";
			color_fprintf(stdout, color, prefix, l);
826
		}
827 828 829
		color_fprintf(stdout, color, "%s", buf);

	} while (strchr(buf, '\n') == NULL);
830

831
	return 1;
832
error:
833
	if (ferror(fp)) {
834
		pr_warning("File read error: %s\n",
835
			   str_error_r(errno, sbuf, sizeof(sbuf)));
836 837 838 839
		return -1;
	}
	return 0;
}
840

841 842 843 844 845 846 847 848
static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
{
	int rv = __show_one_line(fp, l, skip, show_num);
	if (rv == 0) {
		pr_warning("Source file is shorter than expected.\n");
		rv = -1;
	}
	return rv;
849 850
}

851 852 853 854 855
#define show_one_line_with_num(f,l)	_show_one_line(f,l,false,true)
#define show_one_line(f,l)		_show_one_line(f,l,false,false)
#define skip_one_line(f,l)		_show_one_line(f,l,true,false)
#define show_one_line_or_eof(f,l)	__show_one_line(f,l,false,false)

856 857 858 859
/*
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
860 861
static int __show_line_range(struct line_range *lr, const char *module,
			     bool user)
862
{
863
	int l = 1;
864
	struct int_node *ln;
865
	struct debuginfo *dinfo;
866
	FILE *fp;
867
	int ret;
868
	char *tmp;
869
	char sbuf[STRERR_BUFSIZE];
870 871

	/* Search a line range */
872 873
	dinfo = open_debuginfo(module, false);
	if (!dinfo)
874
		return -ENOENT;
875

876
	ret = debuginfo__find_line_range(dinfo, lr);
877 878 879 880 881
	if (!ret) {	/* Not found, retry with an alternative */
		ret = get_alternative_line_range(dinfo, lr, module, user);
		if (!ret)
			ret = debuginfo__find_line_range(dinfo, lr);
	}
882
	debuginfo__delete(dinfo);
883
	if (ret == 0 || ret == -ENOENT) {
884 885 886
		pr_warning("Specified source line is not found.\n");
		return -ENOENT;
	} else if (ret < 0) {
887
		pr_warning("Debuginfo analysis failed.\n");
888 889
		return ret;
	}
890

891 892
	/* Convert source file path */
	tmp = lr->path;
893
	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
894 895 896 897 898

	/* Free old path when new path is assigned */
	if (tmp != lr->path)
		free(tmp);

899
	if (ret < 0) {
900
		pr_warning("Failed to find source file path.\n");
901 902 903
		return ret;
	}

904 905 906
	setup_pager();

	if (lr->function)
907
		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
908 909
			lr->start - lr->offset);
	else
910
		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
911 912

	fp = fopen(lr->path, "r");
913 914
	if (fp == NULL) {
		pr_warning("Failed to open %s: %s\n", lr->path,
915
			   str_error_r(errno, sbuf, sizeof(sbuf)));
916 917
		return -errno;
	}
918
	/* Skip to starting line number */
919
	while (l < lr->start) {
920
		ret = skip_one_line(fp, l++);
921 922 923
		if (ret < 0)
			goto end;
	}
924

925
	intlist__for_each_entry(ln, lr->line_list) {
926
		for (; ln->i > l; l++) {
927
			ret = show_one_line(fp, l - lr->offset);
928 929 930
			if (ret < 0)
				goto end;
		}
931
		ret = show_one_line_with_num(fp, l++ - lr->offset);
932 933
		if (ret < 0)
			goto end;
934 935 936 937
	}

	if (lr->end == INT_MAX)
		lr->end = l + NR_ADDITIONAL_LINES;
938 939 940
	while (l <= lr->end) {
		ret = show_one_line_or_eof(fp, l++ - lr->offset);
		if (ret <= 0)
941 942
			break;
	}
943
end:
944
	fclose(fp);
945
	return ret;
946 947
}

948
int show_line_range(struct line_range *lr, const char *module, bool user)
949 950 951
{
	int ret;

952
	ret = init_probe_symbol_maps(user);
953 954
	if (ret < 0)
		return ret;
955
	ret = __show_line_range(lr, module, user);
956
	exit_probe_symbol_maps();
957 958 959 960

	return ret;
}

961 962
static int show_available_vars_at(struct debuginfo *dinfo,
				  struct perf_probe_event *pev,
963
				  struct strfilter *_filter)
964 965
{
	char *buf;
966
	int ret, i, nvars;
967 968
	struct str_node *node;
	struct variable_list *vls = NULL, *vl;
969
	struct perf_probe_point tmp;
970
	const char *var;
971 972 973 974 975 976

	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return -EINVAL;
	pr_debug("Searching variables at %s\n", buf);

977
	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
978
	if (!ret) {  /* Not found, retry with an alternative */
979
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
980 981
		if (!ret) {
			ret = debuginfo__find_available_vars_at(dinfo, pev,
982
								&vls);
983 984 985 986
			/* Release the old probe_point */
			clear_perf_probe_point(&tmp);
		}
	}
987
	if (ret <= 0) {
988 989 990 991 992
		if (ret == 0 || ret == -ENOENT) {
			pr_err("Failed to find the address of %s\n", buf);
			ret = -ENOENT;
		} else
			pr_warning("Debuginfo analysis failed.\n");
993 994
		goto end;
	}
995

996 997 998 999 1000 1001 1002 1003 1004 1005
	/* Some variables are found */
	fprintf(stdout, "Available variables at %s\n", buf);
	for (i = 0; i < ret; i++) {
		vl = &vls[i];
		/*
		 * A probe point might be converted to
		 * several trace points.
		 */
		fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
			vl->point.offset);
1006
		zfree(&vl->point.symbol);
1007 1008
		nvars = 0;
		if (vl->vars) {
1009
			strlist__for_each_entry(node, vl->vars) {
1010 1011
				var = strchr(node->s, '\t') + 1;
				if (strfilter__compare(_filter, var)) {
1012
					fprintf(stdout, "\t\t%s\n", node->s);
1013 1014 1015 1016
					nvars++;
				}
			}
			strlist__delete(vl->vars);
1017
		}
1018 1019 1020 1021 1022
		if (nvars == 0)
			fprintf(stdout, "\t\t(No matched variables)\n");
	}
	free(vls);
end:
1023 1024 1025 1026 1027 1028
	free(buf);
	return ret;
}

/* Show available variables on given probe point */
int show_available_vars(struct perf_probe_event *pevs, int npevs,
1029
			struct strfilter *_filter)
1030
{
1031 1032
	int i, ret = 0;
	struct debuginfo *dinfo;
1033

1034
	ret = init_probe_symbol_maps(pevs->uprobes);
1035 1036 1037
	if (ret < 0)
		return ret;

1038
	dinfo = open_debuginfo(pevs->target, false);
1039
	if (!dinfo) {
1040 1041
		ret = -ENOENT;
		goto out;
1042 1043
	}

1044 1045
	setup_pager();

1046
	for (i = 0; i < npevs && ret >= 0; i++)
1047
		ret = show_available_vars_at(dinfo, &pevs[i], _filter);
1048 1049

	debuginfo__delete(dinfo);
1050
out:
1051
	exit_probe_symbol_maps();
1052 1053 1054
	return ret;
}

1055
#else	/* !HAVE_DWARF_SUPPORT */
1056

1057 1058 1059 1060
static void debuginfo_cache__exit(void)
{
}

1061 1062 1063 1064
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)
1065
{
1066
	return -ENOSYS;
1067 1068
}

1069
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
1070
				struct probe_trace_event **tevs __maybe_unused)
1071
{
1072 1073 1074 1075
	if (perf_probe_event_need_dwarf(pev)) {
		pr_warning("Debuginfo-analysis is not supported.\n");
		return -ENOSYS;
	}
1076

1077 1078 1079
	return 0;
}

1080
int show_line_range(struct line_range *lr __maybe_unused,
1081 1082
		    const char *module __maybe_unused,
		    bool user __maybe_unused)
1083
{
1084 1085
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
1086 1087
}

1088
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1089 1090
			int npevs __maybe_unused,
			struct strfilter *filter __maybe_unused)
1091 1092 1093 1094
{
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
}
1095 1096
#endif

1097 1098 1099 1100 1101 1102
void line_range__clear(struct line_range *lr)
{
	free(lr->function);
	free(lr->file);
	free(lr->path);
	free(lr->comp_dir);
1103
	intlist__delete(lr->line_list);
1104 1105 1106
	memset(lr, 0, sizeof(*lr));
}

1107
int line_range__init(struct line_range *lr)
1108 1109
{
	memset(lr, 0, sizeof(*lr));
1110 1111 1112 1113 1114
	lr->line_list = intlist__new(NULL);
	if (!lr->line_list)
		return -ENOMEM;
	else
		return 0;
1115 1116
}

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
static int parse_line_num(char **ptr, int *val, const char *what)
{
	const char *start = *ptr;

	errno = 0;
	*val = strtol(*ptr, ptr, 0);
	if (errno || *ptr == start) {
		semantic_error("'%s' is not a valid number.\n", what);
		return -EINVAL;
	}
	return 0;
}

1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
/* Check the name is good for event, group or function */
static bool is_c_func_name(const char *name)
{
	if (!isalpha(*name) && *name != '_')
		return false;
	while (*++name != '\0') {
		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
			return false;
	}
	return true;
}

1142 1143 1144 1145 1146
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
1147
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
1148
 */
1149
int parse_line_range_desc(const char *arg, struct line_range *lr)
1150
{
1151
	char *range, *file, *name = strdup(arg);
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
	int err;

	if (!name)
		return -ENOMEM;

	lr->start = 0;
	lr->end = INT_MAX;

	range = strchr(name, ':');
	if (range) {
		*range++ = '\0';

		err = parse_line_num(&range, &lr->start, "start line");
		if (err)
			goto err;

		if (*range == '+' || *range == '-') {
			const char c = *range++;

			err = parse_line_num(&range, &lr->end, "end line");
			if (err)
				goto err;

			if (c == '+') {
				lr->end += lr->start;
				/*
				 * Adjust the number of lines here.
				 * If the number of lines == 1, the
				 * the end of line should be equal to
				 * the start of line.
				 */
				lr->end--;
			}
		}
1186

1187
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1188 1189

		err = -EINVAL;
1190
		if (lr->start > lr->end) {
1191
			semantic_error("Start line must be smaller"
1192
				       " than end line.\n");
1193
			goto err;
1194
		}
1195 1196 1197
		if (*range != '\0') {
			semantic_error("Tailing with invalid str '%s'.\n", range);
			goto err;
1198
		}
1199
	}
1200

1201 1202 1203 1204 1205 1206 1207 1208 1209
	file = strchr(name, '@');
	if (file) {
		*file = '\0';
		lr->file = strdup(++file);
		if (lr->file == NULL) {
			err = -ENOMEM;
			goto err;
		}
		lr->function = name;
1210
	} else if (strchr(name, '/') || strchr(name, '.'))
1211
		lr->file = name;
1212
	else if (is_c_func_name(name))/* We reuse it for checking funcname */
1213
		lr->function = name;
1214 1215 1216 1217 1218
	else {	/* Invalid name */
		semantic_error("'%s' is not a valid function name.\n", name);
		err = -EINVAL;
		goto err;
	}
1219 1220

	return 0;
1221 1222 1223
err:
	free(name);
	return err;
1224 1225
}

1226 1227 1228 1229 1230 1231 1232
static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
{
	char *ptr;

	ptr = strchr(*arg, ':');
	if (ptr) {
		*ptr = '\0';
1233
		if (!pev->sdt && !is_c_func_name(*arg))
1234 1235 1236 1237 1238 1239 1240
			goto ng_name;
		pev->group = strdup(*arg);
		if (!pev->group)
			return -ENOMEM;
		*arg = ptr + 1;
	} else
		pev->group = NULL;
1241
	if (!pev->sdt && !is_c_func_name(*arg)) {
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
ng_name:
		semantic_error("%s is bad for event name -it must "
			       "follow C symbol-naming rule.\n", *arg);
		return -EINVAL;
	}
	pev->event = strdup(*arg);
	if (pev->event == NULL)
		return -ENOMEM;

	return 0;
}

1254
/* Parse probepoint definition. */
1255
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1256
{
1257
	struct perf_probe_point *pp = &pev->point;
1258 1259
	char *ptr, *tmp;
	char c, nc = 0;
1260
	bool file_spec = false;
1261 1262
	int ret;

1263 1264
	/*
	 * <Syntax>
1265 1266
	 * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
	 * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1267
	 * perf probe %[GRP:]SDT_EVENT
1268
	 */
1269 1270
	if (!arg)
		return -EINVAL;
1271

1272 1273 1274 1275 1276 1277 1278 1279
	/*
	 * If the probe point starts with '%',
	 * or starts with "sdt_" and has a ':' but no '=',
	 * then it should be a SDT/cached probe point.
	 */
	if (arg[0] == '%' ||
	    (!strncmp(arg, "sdt_", 4) &&
	     !!strchr(arg, ':') && !strchr(arg, '='))) {
1280
		pev->sdt = true;
1281 1282
		if (arg[0] == '%')
			arg++;
1283 1284
	}

1285
	ptr = strpbrk(arg, ";=@+%");
1286
	if (pev->sdt) {
1287
		if (ptr) {
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
			if (*ptr != '@') {
				semantic_error("%s must be an SDT name.\n",
					       arg);
				return -EINVAL;
			}
			/* This must be a target file name or build id */
			tmp = build_id_cache__complement(ptr + 1);
			if (tmp) {
				pev->target = build_id_cache__origname(tmp);
				free(tmp);
			} else
				pev->target = strdup(ptr + 1);
			if (!pev->target)
				return -ENOMEM;
			*ptr = '\0';
1303
		}
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
		ret = parse_perf_probe_event_name(&arg, pev);
		if (ret == 0) {
			if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
				ret = -errno;
		}
		return ret;
	}

	if (ptr && *ptr == '=') {	/* Event name */
		*ptr = '\0';
		tmp = ptr + 1;
		ret = parse_perf_probe_event_name(&arg, pev);
		if (ret < 0)
			return ret;

1319 1320 1321
		arg = tmp;
	}

1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
	/*
	 * Check arg is function or file name and copy it.
	 *
	 * We consider arg to be a file spec if and only if it satisfies
	 * all of the below criteria::
	 * - it does not include any of "+@%",
	 * - it includes one of ":;", and
	 * - it has a period '.' in the name.
	 *
	 * Otherwise, we consider arg to be a function specification.
	 */
	if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) {
		/* This is a file spec if it includes a '.' before ; or : */
		if (memchr(arg, '.', ptr - arg))
			file_spec = true;
	}

1339
	ptr = strpbrk(arg, ";:+@%");
1340 1341 1342 1343 1344
	if (ptr) {
		nc = *ptr;
		*ptr++ = '\0';
	}

1345 1346 1347 1348 1349 1350 1351
	if (arg[0] == '\0')
		tmp = NULL;
	else {
		tmp = strdup(arg);
		if (tmp == NULL)
			return -ENOMEM;
	}
1352

1353
	if (file_spec)
1354
		pp->file = tmp;
1355
	else {
1356
		pp->function = tmp;
1357

1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
		/*
		 * Keep pp->function even if this is absolute address,
		 * so it can mark whether abs_address is valid.
		 * Which make 'perf probe lib.bin 0x0' possible.
		 *
		 * Note that checking length of tmp is not needed
		 * because when we access tmp[1] we know tmp[0] is '0',
		 * so tmp[1] should always valid (but could be '\0').
		 */
		if (tmp && !strncmp(tmp, "0x", 2)) {
			pp->abs_address = strtoul(pp->function, &tmp, 0);
			if (*tmp != '\0') {
				semantic_error("Invalid absolute address.\n");
				return -EINVAL;
			}
		}
	}

1376 1377 1378 1379
	/* Parse other options */
	while (ptr) {
		arg = ptr;
		c = nc;
1380
		if (c == ';') {	/* Lazy pattern must be the last part */
1381 1382 1383
			pp->lazy_line = strdup(arg);
			if (pp->lazy_line == NULL)
				return -ENOMEM;
1384 1385 1386
			break;
		}
		ptr = strpbrk(arg, ";:+@%");
1387 1388 1389 1390 1391 1392 1393
		if (ptr) {
			nc = *ptr;
			*ptr++ = '\0';
		}
		switch (c) {
		case ':':	/* Line number */
			pp->line = strtoul(arg, &tmp, 0);
1394
			if (*tmp != '\0') {
1395
				semantic_error("There is non-digit char"
1396 1397 1398
					       " in line number.\n");
				return -EINVAL;
			}
1399 1400 1401
			break;
		case '+':	/* Byte offset from a symbol */
			pp->offset = strtoul(arg, &tmp, 0);
1402
			if (*tmp != '\0') {
1403
				semantic_error("There is non-digit character"
1404 1405 1406
						" in offset.\n");
				return -EINVAL;
			}
1407 1408
			break;
		case '@':	/* File name */
1409 1410 1411 1412
			if (pp->file) {
				semantic_error("SRC@SRC is not allowed.\n");
				return -EINVAL;
			}
1413 1414 1415
			pp->file = strdup(arg);
			if (pp->file == NULL)
				return -ENOMEM;
1416 1417 1418 1419
			break;
		case '%':	/* Probe places */
			if (strcmp(arg, "return") == 0) {
				pp->retprobe = 1;
1420 1421 1422 1423
			} else {	/* Others not supported yet */
				semantic_error("%%%s is not supported.\n", arg);
				return -ENOTSUP;
			}
1424
			break;
1425 1426 1427 1428
		default:	/* Buggy case */
			pr_err("This program has a bug at %s:%d.\n",
				__FILE__, __LINE__);
			return -ENOTSUP;
1429 1430 1431 1432 1433
			break;
		}
	}

	/* Exclusion check */
1434
	if (pp->lazy_line && pp->line) {
M
Masami Hiramatsu 已提交
1435 1436
		semantic_error("Lazy pattern can't be used with"
			       " line number.\n");
1437 1438
		return -EINVAL;
	}
1439

1440
	if (pp->lazy_line && pp->offset) {
M
Masami Hiramatsu 已提交
1441
		semantic_error("Lazy pattern can't be used with offset.\n");
1442 1443
		return -EINVAL;
	}
1444

1445
	if (pp->line && pp->offset) {
M
Masami Hiramatsu 已提交
1446
		semantic_error("Offset can't be used with line number.\n");
1447 1448
		return -EINVAL;
	}
1449

1450
	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1451
		semantic_error("File always requires line number or "
M
Masami Hiramatsu 已提交
1452
			       "lazy pattern.\n");
1453 1454
		return -EINVAL;
	}
1455

1456
	if (pp->offset && !pp->function) {
M
Masami Hiramatsu 已提交
1457
		semantic_error("Offset requires an entry function.\n");
1458 1459
		return -EINVAL;
	}
1460

1461
	if (pp->retprobe && !pp->function) {
M
Masami Hiramatsu 已提交
1462
		semantic_error("Return probe requires an entry function.\n");
1463 1464
		return -EINVAL;
	}
1465

1466
	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1467
		semantic_error("Offset/Line/Lazy pattern can't be used with "
M
Masami Hiramatsu 已提交
1468
			       "return probe.\n");
1469 1470
		return -EINVAL;
	}
1471

1472
	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1473 1474
		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
		 pp->lazy_line);
1475
	return 0;
1476 1477
}

1478
/* Parse perf-probe event argument */
1479
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1480
{
1481
	char *tmp, *goodname;
1482 1483 1484 1485
	struct perf_probe_arg_field **fieldp;

	pr_debug("parsing arg: %s into ", str);

1486 1487
	tmp = strchr(str, '=');
	if (tmp) {
1488 1489 1490
		arg->name = strndup(str, tmp - str);
		if (arg->name == NULL)
			return -ENOMEM;
1491
		pr_debug("name:%s ", arg->name);
1492 1493 1494
		str = tmp + 1;
	}

1495 1496 1497
	tmp = strchr(str, ':');
	if (tmp) {	/* Type setting */
		*tmp = '\0';
1498 1499 1500
		arg->type = strdup(tmp + 1);
		if (arg->type == NULL)
			return -ENOMEM;
1501 1502 1503
		pr_debug("type:%s ", arg->type);
	}

1504
	tmp = strpbrk(str, "-.[");
1505 1506
	if (!is_c_varname(str) || !tmp) {
		/* A variable, register, symbol or special value */
1507 1508 1509
		arg->var = strdup(str);
		if (arg->var == NULL)
			return -ENOMEM;
1510
		pr_debug("%s\n", arg->var);
1511
		return 0;
1512 1513
	}

1514
	/* Structure fields or array element */
1515 1516 1517
	arg->var = strndup(str, tmp - str);
	if (arg->var == NULL)
		return -ENOMEM;
1518
	goodname = arg->var;
1519
	pr_debug("%s, ", arg->var);
1520 1521 1522
	fieldp = &arg->field;

	do {
1523 1524 1525
		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
		if (*fieldp == NULL)
			return -ENOMEM;
1526 1527 1528
		if (*tmp == '[') {	/* Array */
			str = tmp;
			(*fieldp)->index = strtol(str + 1, &tmp, 0);
1529
			(*fieldp)->ref = true;
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
			if (*tmp != ']' || tmp == str + 1) {
				semantic_error("Array index must be a"
						" number.\n");
				return -EINVAL;
			}
			tmp++;
			if (*tmp == '\0')
				tmp = NULL;
		} else {		/* Structure */
			if (*tmp == '.') {
				str = tmp + 1;
				(*fieldp)->ref = false;
			} else if (tmp[1] == '>') {
				str = tmp + 2;
				(*fieldp)->ref = true;
			} else {
				semantic_error("Argument parse error: %s\n",
					       str);
				return -EINVAL;
			}
			tmp = strpbrk(str, "-.[");
1551
		}
1552
		if (tmp) {
1553 1554 1555
			(*fieldp)->name = strndup(str, tmp - str);
			if ((*fieldp)->name == NULL)
				return -ENOMEM;
1556 1557
			if (*str != '[')
				goodname = (*fieldp)->name;
1558 1559 1560 1561
			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
			fieldp = &(*fieldp)->next;
		}
	} while (tmp);
1562 1563 1564
	(*fieldp)->name = strdup(str);
	if ((*fieldp)->name == NULL)
		return -ENOMEM;
1565 1566
	if (*str != '[')
		goodname = (*fieldp)->name;
1567
	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1568

1569
	/* If no name is specified, set the last field name (not array index)*/
1570
	if (!arg->name) {
1571
		arg->name = strdup(goodname);
1572 1573 1574
		if (arg->name == NULL)
			return -ENOMEM;
	}
1575
	return 0;
1576 1577
}

1578
/* Parse perf-probe event command */
1579
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1580
{
1581
	char **argv;
1582
	int argc, i, ret = 0;
1583

1584
	argv = argv_split(cmd, &argc);
1585 1586 1587 1588 1589 1590 1591 1592 1593
	if (!argv) {
		pr_debug("Failed to split arguments.\n");
		return -ENOMEM;
	}
	if (argc - 1 > MAX_PROBE_ARGS) {
		semantic_error("Too many probe arguments (%d).\n", argc - 1);
		ret = -ERANGE;
		goto out;
	}
1594
	/* Parse probe point */
1595 1596 1597
	ret = parse_perf_probe_point(argv[0], pev);
	if (ret < 0)
		goto out;
1598

1599
	/* Copy arguments and ensure return probe has no C argument */
1600
	pev->nargs = argc - 1;
1601 1602 1603 1604 1605
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1606 1607 1608 1609
	for (i = 0; i < pev->nargs && ret >= 0; i++) {
		ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
		if (ret >= 0 &&
		    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1610
			semantic_error("You can't specify local variable for"
1611 1612 1613
				       " kretprobe.\n");
			ret = -EINVAL;
		}
1614
	}
1615
out:
1616
	argv_free(argv);
1617 1618

	return ret;
1619 1620
}

1621 1622 1623 1624 1625 1626 1627 1628 1629
/* Return true if this perf_probe_event requires debuginfo */
bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
{
	int i;

	if (pev->point.file || pev->point.line || pev->point.lazy_line)
		return true;

	for (i = 0; i < pev->nargs; i++)
1630 1631 1632
		if (is_c_varname(pev->args[i].var) ||
		    !strcmp(pev->args[i].var, "$params") ||
		    !strcmp(pev->args[i].var, "$vars"))
1633 1634 1635 1636 1637
			return true;

	return false;
}

1638
/* Parse probe_events event into struct probe_point */
1639
int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1640
{
1641
	struct probe_trace_point *tp = &tev->point;
1642 1643
	char pr;
	char *p;
1644
	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1645 1646 1647
	int ret, i, argc;
	char **argv;

1648
	pr_debug("Parsing probe_events: %s\n", cmd);
1649
	argv = argv_split(cmd, &argc);
1650 1651 1652 1653 1654 1655 1656 1657 1658
	if (!argv) {
		pr_debug("Failed to split arguments.\n");
		return -ENOMEM;
	}
	if (argc < 2) {
		semantic_error("Too few probe arguments.\n");
		ret = -ERANGE;
		goto out;
	}
1659 1660

	/* Scan event and group name. */
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
	argv0_str = strdup(argv[0]);
	if (argv0_str == NULL) {
		ret = -ENOMEM;
		goto out;
	}
	fmt1_str = strtok_r(argv0_str, ":", &fmt);
	fmt2_str = strtok_r(NULL, "/", &fmt);
	fmt3_str = strtok_r(NULL, " \t", &fmt);
	if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
	    || fmt3_str == NULL) {
1671 1672 1673 1674
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1675 1676 1677 1678 1679 1680 1681
	pr = fmt1_str[0];
	tev->group = strdup(fmt2_str);
	tev->event = strdup(fmt3_str);
	if (tev->group == NULL || tev->event == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1682
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1683

1684
	tp->retprobe = (pr == 'r');
1685

1686 1687 1688 1689
	/* Scan module name(if there), function name and offset */
	p = strchr(argv[1], ':');
	if (p) {
		tp->module = strndup(argv[1], p - argv[1]);
1690 1691 1692 1693
		if (!tp->module) {
			ret = -ENOMEM;
			goto out;
		}
1694
		tev->uprobes = (tp->module[0] == '/');
1695 1696 1697
		p++;
	} else
		p = argv[1];
1698
	fmt1_str = strtok_r(p, "+", &fmt);
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
	/* only the address started with 0x */
	if (fmt1_str[0] == '0')	{
		/*
		 * Fix a special case:
		 * if address == 0, kernel reports something like:
		 * p:probe_libc/abs_0 /lib/libc-2.18.so:0x          (null) arg1=%ax
		 * Newer kernel may fix that, but we want to
		 * support old kernel also.
		 */
		if (strcmp(fmt1_str, "0x") == 0) {
			if (!argv[2] || strcmp(argv[2], "(null)")) {
				ret = -EINVAL;
				goto out;
			}
			tp->address = 0;

			free(argv[2]);
			for (i = 2; argv[i + 1] != NULL; i++)
				argv[i] = argv[i + 1];

			argv[i] = NULL;
			argc -= 1;
		} else
			tp->address = strtoul(fmt1_str, NULL, 0);
	} else {
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
		/* Only the symbol-based probe has offset */
		tp->symbol = strdup(fmt1_str);
		if (tp->symbol == NULL) {
			ret = -ENOMEM;
			goto out;
		}
		fmt2_str = strtok_r(NULL, "", &fmt);
		if (fmt2_str == NULL)
			tp->offset = 0;
		else
			tp->offset = strtoul(fmt2_str, NULL, 10);
1735
	}
1736

1737
	tev->nargs = argc - 2;
1738
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1739 1740 1741 1742
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1743
	for (i = 0; i < tev->nargs; i++) {
1744 1745
		p = strchr(argv[i + 2], '=');
		if (p)	/* We don't need which register is assigned. */
1746 1747 1748
			*p++ = '\0';
		else
			p = argv[i + 2];
1749
		tev->args[i].name = strdup(argv[i + 2]);
1750
		/* TODO: parse regs and offset */
1751 1752 1753 1754 1755
		tev->args[i].value = strdup(p);
		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
			ret = -ENOMEM;
			goto out;
		}
1756
	}
1757 1758
	ret = 0;
out:
1759
	free(argv0_str);
1760
	argv_free(argv);
1761
	return ret;
1762 1763
}

1764
/* Compose only probe arg */
1765
char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1766 1767
{
	struct perf_probe_arg_field *field = pa->field;
1768
	struct strbuf buf;
1769 1770 1771 1772 1773
	char *ret = NULL;
	int err;

	if (strbuf_init(&buf, 64) < 0)
		return NULL;
1774

1775
	if (pa->name && pa->var)
1776
		err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1777
	else
1778 1779 1780
		err = strbuf_addstr(&buf, pa->name ?: pa->var);
	if (err)
		goto out;
1781 1782

	while (field) {
1783
		if (field->name[0] == '[')
1784
			err = strbuf_addstr(&buf, field->name);
1785
		else
1786 1787
			err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
					  field->name);
1788
		field = field->next;
1789 1790
		if (err)
			goto out;
1791
	}
1792

1793
	if (pa->type)
1794 1795
		if (strbuf_addf(&buf, ":%s", pa->type) < 0)
			goto out;
1796 1797

	ret = strbuf_detach(&buf, NULL);
1798 1799
out:
	strbuf_release(&buf);
1800
	return ret;
1801 1802
}

1803
/* Compose only probe point (not argument) */
1804
char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1805
{
1806
	struct strbuf buf;
1807 1808 1809 1810 1811
	char *tmp, *ret = NULL;
	int len, err = 0;

	if (strbuf_init(&buf, 64) < 0)
		return NULL;
1812 1813

	if (pp->function) {
1814 1815
		if (strbuf_addstr(&buf, pp->function) < 0)
			goto out;
1816
		if (pp->offset)
1817
			err = strbuf_addf(&buf, "+%lu", pp->offset);
1818
		else if (pp->line)
1819
			err = strbuf_addf(&buf, ":%d", pp->line);
1820
		else if (pp->retprobe)
1821 1822 1823
			err = strbuf_addstr(&buf, "%return");
		if (err)
			goto out;
1824 1825
	}
	if (pp->file) {
1826 1827 1828 1829 1830 1831
		tmp = pp->file;
		len = strlen(tmp);
		if (len > 30) {
			tmp = strchr(pp->file + len - 30, '/');
			tmp = tmp ? tmp + 1 : pp->file + len - 30;
		}
1832 1833 1834
		err = strbuf_addf(&buf, "@%s", tmp);
		if (!err && !pp->function && pp->line)
			err = strbuf_addf(&buf, ":%d", pp->line);
1835
	}
1836 1837 1838 1839 1840
	if (!err)
		ret = strbuf_detach(&buf, NULL);
out:
	strbuf_release(&buf);
	return ret;
1841 1842
}

1843
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1844
{
1845 1846 1847
	struct strbuf buf;
	char *tmp, *ret = NULL;
	int i;
1848

1849
	if (strbuf_init(&buf, 64))
1850
		return NULL;
1851 1852 1853 1854 1855 1856 1857 1858 1859
	if (pev->event)
		if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
				pev->event) < 0)
			goto out;

	tmp = synthesize_perf_probe_point(&pev->point);
	if (!tmp || strbuf_addstr(&buf, tmp) < 0)
		goto out;
	free(tmp);
1860

1861
	for (i = 0; i < pev->nargs; i++) {
1862 1863 1864 1865
		tmp = synthesize_perf_probe_arg(pev->args + i);
		if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
			goto out;
		free(tmp);
1866 1867
	}

1868 1869 1870 1871
	ret = strbuf_detach(&buf, NULL);
out:
	strbuf_release(&buf);
	return ret;
1872 1873
}

1874
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1875
					    struct strbuf *buf, int depth)
1876
{
1877
	int err;
1878
	if (ref->next) {
1879
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1880
							 depth + 1);
1881
		if (depth < 0)
1882
			return depth;
1883
	}
1884 1885
	err = strbuf_addf(buf, "%+ld(", ref->offset);
	return (err < 0) ? err : depth;
1886 1887
}

1888
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1889
				      struct strbuf *buf)
1890
{
1891
	struct probe_trace_arg_ref *ref = arg->ref;
1892
	int depth = 0, err;
1893 1894 1895

	/* Argument name or separator */
	if (arg->name)
1896
		err = strbuf_addf(buf, " %s=", arg->name);
1897
	else
1898 1899 1900
		err = strbuf_addch(buf, ' ');
	if (err)
		return err;
1901

1902 1903 1904 1905
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1906
	/* Dereferencing arguments */
1907
	if (ref) {
1908
		depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
1909 1910 1911 1912 1913
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1914
	if (arg->value[0] == '@' && arg->ref)
1915
		err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
1916
	else
1917
		err = strbuf_addstr(buf, arg->value);
1918 1919

	/* Closing */
1920 1921 1922
	while (!err && depth--)
		err = strbuf_addch(buf, ')');

1923
	/* Print argument type */
1924 1925
	if (!err && arg->type)
		err = strbuf_addf(buf, ":%s", arg->type);
1926

1927
	return err;
1928 1929
}

1930
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1931
{
1932
	struct probe_trace_point *tp = &tev->point;
1933 1934
	struct strbuf buf;
	char *ret = NULL;
1935
	int i, err;
1936

1937 1938
	/* Uprobes must have tp->module */
	if (tev->uprobes && !tp->module)
1939 1940
		return NULL;

1941 1942 1943 1944 1945 1946
	if (strbuf_init(&buf, 32) < 0)
		return NULL;

	if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
			tev->group, tev->event) < 0)
		goto error;
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
	/*
	 * If tp->address == 0, then this point must be a
	 * absolute address uprobe.
	 * try_to_find_absolute_address() should have made
	 * tp->symbol to "0x0".
	 */
	if (tev->uprobes && !tp->address) {
		if (!tp->symbol || strcmp(tp->symbol, "0x0"))
			goto error;
	}
1957 1958

	/* Use the tp->address for uprobes */
1959
	if (tev->uprobes)
1960
		err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address);
1961 1962
	else if (!strncmp(tp->symbol, "0x", 2))
		/* Absolute address. See try_to_find_absolute_address() */
1963 1964
		err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
				  tp->module ? ":" : "", tp->address);
1965
	else
1966 1967 1968 1969
		err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
				tp->module ? ":" : "", tp->symbol, tp->offset);
	if (err)
		goto error;
1970

1971 1972
	for (i = 0; i < tev->nargs; i++)
		if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
1973 1974
			goto error;

1975
	ret = strbuf_detach(&buf, NULL);
1976
error:
1977 1978
	strbuf_release(&buf);
	return ret;
1979
}
1980

1981 1982 1983 1984 1985 1986
static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
					  struct perf_probe_point *pp,
					  bool is_kprobe)
{
	struct symbol *sym = NULL;
	struct map *map;
1987
	u64 addr = tp->address;
1988 1989 1990 1991 1992 1993 1994 1995
	int ret = -ENOENT;

	if (!is_kprobe) {
		map = dso__new_map(tp->module);
		if (!map)
			goto out;
		sym = map__find_symbol(map, addr, NULL);
	} else {
1996
		if (tp->symbol && !addr) {
1997 1998
			if (kernel_get_symbol_address_by_name(tp->symbol,
						&addr, true, false) < 0)
1999 2000
				goto out;
		}
2001 2002 2003 2004 2005
		if (addr) {
			addr += tp->offset;
			sym = __find_kernel_function(addr, &map);
		}
	}
2006

2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
	if (!sym)
		goto out;

	pp->retprobe = tp->retprobe;
	pp->offset = addr - map->unmap_ip(map, sym->start);
	pp->function = strdup(sym->name);
	ret = pp->function ? 0 : -ENOMEM;

out:
	if (map && !is_kprobe) {
2017
		map__put(map);
2018 2019 2020 2021 2022 2023
	}

	return ret;
}

static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2024 2025
				       struct perf_probe_point *pp,
				       bool is_kprobe)
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
{
	char buf[128];
	int ret;

	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
	if (!ret)
		return 0;
	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
	if (!ret)
		return 0;

	pr_debug("Failed to find probe point from both of dwarf and map.\n");

	if (tp->symbol) {
		pp->function = strdup(tp->symbol);
		pp->offset = tp->offset;
2042
	} else {
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
		ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
		if (ret < 0)
			return ret;
		pp->function = strdup(buf);
		pp->offset = 0;
	}
	if (pp->function == NULL)
		return -ENOMEM;

	pp->retprobe = tp->retprobe;

	return 0;
}

2057
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2058
			       struct perf_probe_event *pev, bool is_kprobe)
2059
{
2060
	struct strbuf buf = STRBUF_INIT;
2061
	int i, ret;
2062

2063
	/* Convert event/group name */
2064 2065 2066 2067
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
2068

2069
	/* Convert trace_point to probe_point */
2070
	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2071 2072
	if (ret < 0)
		return ret;
2073

2074 2075
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
2076 2077 2078
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
2079
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
2080
		if (tev->args[i].name)
2081
			pev->args[i].name = strdup(tev->args[i].name);
2082
		else {
2083 2084
			if ((ret = strbuf_init(&buf, 32)) < 0)
				goto error;
2085 2086
			ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
			pev->args[i].name = strbuf_detach(&buf, NULL);
2087
		}
2088 2089 2090
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
2091
error:
2092 2093 2094 2095
	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
2096 2097 2098 2099
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
2100
	struct perf_probe_arg_field *field, *next;
2101 2102
	int i;

2103 2104
	free(pev->event);
	free(pev->group);
2105
	free(pev->target);
2106
	clear_perf_probe_point(&pev->point);
2107

2108
	for (i = 0; i < pev->nargs; i++) {
2109 2110 2111
		free(pev->args[i].name);
		free(pev->args[i].var);
		free(pev->args[i].type);
2112 2113 2114
		field = pev->args[i].field;
		while (field) {
			next = field->next;
2115
			zfree(&field->name);
2116 2117 2118 2119
			free(field);
			field = next;
		}
	}
2120
	free(pev->args);
2121 2122 2123
	memset(pev, 0, sizeof(*pev));
}

2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196
#define strdup_or_goto(str, label)	\
({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })

static int perf_probe_point__copy(struct perf_probe_point *dst,
				  struct perf_probe_point *src)
{
	dst->file = strdup_or_goto(src->file, out_err);
	dst->function = strdup_or_goto(src->function, out_err);
	dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
	dst->line = src->line;
	dst->retprobe = src->retprobe;
	dst->offset = src->offset;
	return 0;

out_err:
	clear_perf_probe_point(dst);
	return -ENOMEM;
}

static int perf_probe_arg__copy(struct perf_probe_arg *dst,
				struct perf_probe_arg *src)
{
	struct perf_probe_arg_field *field, **ppfield;

	dst->name = strdup_or_goto(src->name, out_err);
	dst->var = strdup_or_goto(src->var, out_err);
	dst->type = strdup_or_goto(src->type, out_err);

	field = src->field;
	ppfield = &(dst->field);
	while (field) {
		*ppfield = zalloc(sizeof(*field));
		if (!*ppfield)
			goto out_err;
		(*ppfield)->name = strdup_or_goto(field->name, out_err);
		(*ppfield)->index = field->index;
		(*ppfield)->ref = field->ref;
		field = field->next;
		ppfield = &((*ppfield)->next);
	}
	return 0;
out_err:
	return -ENOMEM;
}

int perf_probe_event__copy(struct perf_probe_event *dst,
			   struct perf_probe_event *src)
{
	int i;

	dst->event = strdup_or_goto(src->event, out_err);
	dst->group = strdup_or_goto(src->group, out_err);
	dst->target = strdup_or_goto(src->target, out_err);
	dst->uprobes = src->uprobes;

	if (perf_probe_point__copy(&dst->point, &src->point) < 0)
		goto out_err;

	dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
	if (!dst->args)
		goto out_err;
	dst->nargs = src->nargs;

	for (i = 0; i < src->nargs; i++)
		if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
			goto out_err;
	return 0;

out_err:
	clear_perf_probe_event(dst);
	return -ENOMEM;
}

2197
void clear_probe_trace_event(struct probe_trace_event *tev)
2198
{
2199
	struct probe_trace_arg_ref *ref, *next;
2200 2201
	int i;

2202 2203 2204
	free(tev->event);
	free(tev->group);
	free(tev->point.symbol);
2205
	free(tev->point.realname);
2206
	free(tev->point.module);
2207
	for (i = 0; i < tev->nargs; i++) {
2208 2209 2210
		free(tev->args[i].name);
		free(tev->args[i].value);
		free(tev->args[i].type);
2211 2212 2213 2214 2215 2216 2217
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
2218
	free(tev->args);
2219
	memset(tev, 0, sizeof(*tev));
2220 2221
}

2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
struct kprobe_blacklist_node {
	struct list_head list;
	unsigned long start;
	unsigned long end;
	char *symbol;
};

static void kprobe_blacklist__delete(struct list_head *blacklist)
{
	struct kprobe_blacklist_node *node;

	while (!list_empty(blacklist)) {
		node = list_first_entry(blacklist,
					struct kprobe_blacklist_node, list);
		list_del(&node->list);
		free(node->symbol);
		free(node);
	}
}

static int kprobe_blacklist__load(struct list_head *blacklist)
{
	struct kprobe_blacklist_node *node;
2245
	const char *__debugfs = debugfs__mountpoint();
2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
	char buf[PATH_MAX], *p;
	FILE *fp;
	int ret;

	if (__debugfs == NULL)
		return -ENOTSUP;

	ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
	if (ret < 0)
		return ret;

	fp = fopen(buf, "r");
	if (!fp)
		return -errno;

	ret = 0;
	while (fgets(buf, PATH_MAX, fp)) {
		node = zalloc(sizeof(*node));
		if (!node) {
			ret = -ENOMEM;
			break;
		}
		INIT_LIST_HEAD(&node->list);
		list_add_tail(&node->list, blacklist);
		if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
			ret = -EINVAL;
			break;
		}
		p = strchr(buf, '\t');
		if (p) {
			p++;
			if (p[strlen(p) - 1] == '\n')
				p[strlen(p) - 1] = '\0';
		} else
			p = (char *)"unknown";
		node->symbol = strdup(p);
		if (!node->symbol) {
			ret = -ENOMEM;
			break;
		}
		pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
			  node->start, node->end, node->symbol);
		ret++;
	}
	if (ret < 0)
		kprobe_blacklist__delete(blacklist);
	fclose(fp);

	return ret;
}

static struct kprobe_blacklist_node *
kprobe_blacklist__find_by_address(struct list_head *blacklist,
				  unsigned long address)
{
	struct kprobe_blacklist_node *node;

	list_for_each_entry(node, blacklist, list) {
		if (node->start <= address && address <= node->end)
			return node;
	}

	return NULL;
}

2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
static LIST_HEAD(kprobe_blacklist);

static void kprobe_blacklist__init(void)
{
	if (!list_empty(&kprobe_blacklist))
		return;

	if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
		pr_debug("No kprobe blacklist support, ignored\n");
}

static void kprobe_blacklist__release(void)
{
	kprobe_blacklist__delete(&kprobe_blacklist);
}

static bool kprobe_blacklist__listed(unsigned long address)
{
	return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
}

2332 2333
static int perf_probe_event__sprintf(const char *group, const char *event,
				     struct perf_probe_event *pev,
2334 2335
				     const char *module,
				     struct strbuf *result)
2336
{
2337
	int i, ret;
2338
	char *buf;
2339

2340 2341
	if (asprintf(&buf, "%s:%s", group, event) < 0)
		return -errno;
2342
	ret = strbuf_addf(result, "  %-20s (on ", buf);
2343
	free(buf);
2344 2345
	if (ret)
		return ret;
2346

2347 2348 2349 2350
	/* Synthesize only event probe point */
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return -ENOMEM;
2351
	ret = strbuf_addstr(result, buf);
2352
	free(buf);
2353

2354 2355
	if (!ret && module)
		ret = strbuf_addf(result, " in %s", module);
2356

2357 2358 2359
	if (!ret && pev->nargs > 0) {
		ret = strbuf_add(result, " with", 5);
		for (i = 0; !ret && i < pev->nargs; i++) {
2360 2361 2362
			buf = synthesize_perf_probe_arg(&pev->args[i]);
			if (!buf)
				return -ENOMEM;
2363
			ret = strbuf_addf(result, " %s", buf);
2364
			free(buf);
2365
		}
2366
	}
2367 2368
	if (!ret)
		ret = strbuf_addch(result, ')');
2369

2370
	return ret;
2371 2372
}

2373
/* Show an event */
2374 2375 2376
int show_perf_probe_event(const char *group, const char *event,
			  struct perf_probe_event *pev,
			  const char *module, bool use_stdout)
2377 2378 2379 2380
{
	struct strbuf buf = STRBUF_INIT;
	int ret;

2381
	ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392
	if (ret >= 0) {
		if (use_stdout)
			printf("%s\n", buf.buf);
		else
			pr_info("%s\n", buf.buf);
	}
	strbuf_release(&buf);

	return ret;
}

2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
static bool filter_probe_trace_event(struct probe_trace_event *tev,
				     struct strfilter *filter)
{
	char tmp[128];

	/* At first, check the event name itself */
	if (strfilter__compare(filter, tev->event))
		return true;

	/* Next, check the combination of name and group */
	if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
		return false;
	return strfilter__compare(filter, tmp);
}

static int __show_perf_probe_events(int fd, bool is_kprobe,
				    struct strfilter *filter)
2410
{
2411
	int ret = 0;
2412
	struct probe_trace_event tev;
2413
	struct perf_probe_event pev;
2414 2415 2416
	struct strlist *rawlist;
	struct str_node *ent;

2417 2418
	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
2419

2420
	rawlist = probe_file__get_rawlist(fd);
2421
	if (!rawlist)
2422
		return -ENOMEM;
2423

2424
	strlist__for_each_entry(ent, rawlist) {
2425
		ret = parse_probe_trace_command(ent->s, &tev);
2426
		if (ret >= 0) {
2427 2428
			if (!filter_probe_trace_event(&tev, filter))
				goto next;
2429 2430
			ret = convert_to_perf_probe_event(&tev, &pev,
								is_kprobe);
2431 2432
			if (ret < 0)
				goto next;
2433 2434
			ret = show_perf_probe_event(pev.group, pev.event,
						    &pev, tev.point.module,
2435
						    true);
2436
		}
2437
next:
2438
		clear_perf_probe_event(&pev);
2439
		clear_probe_trace_event(&tev);
2440 2441
		if (ret < 0)
			break;
2442 2443
	}
	strlist__delete(rawlist);
2444 2445
	/* Cleanup cached debuginfo if needed */
	debuginfo_cache__exit();
2446 2447

	return ret;
2448 2449
}

2450
/* List up current perf-probe events */
2451
int show_perf_probe_events(struct strfilter *filter)
2452
{
2453
	int kp_fd, up_fd, ret;
2454 2455 2456

	setup_pager();

2457 2458 2459
	if (probe_conf.cache)
		return probe_cache__show_all_caches(filter);

2460
	ret = init_probe_symbol_maps(false);
2461 2462 2463
	if (ret < 0)
		return ret;

2464 2465 2466
	ret = probe_file__open_both(&kp_fd, &up_fd, 0);
	if (ret < 0)
		return ret;
2467

2468 2469 2470
	if (kp_fd >= 0)
		ret = __show_perf_probe_events(kp_fd, true, filter);
	if (up_fd >= 0 && ret >= 0)
2471
		ret = __show_perf_probe_events(up_fd, false, filter);
2472 2473 2474
	if (kp_fd > 0)
		close(kp_fd);
	if (up_fd > 0)
2475
		close(up_fd);
2476
	exit_probe_symbol_maps();
2477

2478
	return ret;
2479 2480
}

2481 2482
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
2483 2484
{
	int i, ret;
2485
	char *p, *nbase;
2486

2487 2488
	if (*base == '.')
		base++;
2489 2490 2491 2492 2493 2494 2495 2496
	nbase = strdup(base);
	if (!nbase)
		return -ENOMEM;

	/* Cut off the dot suffixes (e.g. .const, .isra)*/
	p = strchr(nbase, '.');
	if (p && p != nbase)
		*p = '\0';
2497

2498 2499
	/* Try no suffix number */
	ret = e_snprintf(buf, len, "%s", nbase);
2500
	if (ret < 0) {
2501
		pr_debug("snprintf() failed: %d\n", ret);
2502
		goto out;
2503
	}
2504
	if (!strlist__has_entry(namelist, buf))
2505
		goto out;
2506

2507
	if (!allow_suffix) {
2508 2509 2510 2511 2512
		pr_warning("Error: event \"%s\" already exists.\n"
			   " Hint: Remove existing event by 'perf probe -d'\n"
			   "       or force duplicates by 'perf probe -f'\n"
			   "       or set 'force=yes' in BPF source.\n",
			   buf);
2513 2514
		ret = -EEXIST;
		goto out;
2515 2516
	}

2517 2518
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2519
		ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2520
		if (ret < 0) {
2521
			pr_debug("snprintf() failed: %d\n", ret);
2522
			goto out;
2523
		}
2524 2525 2526
		if (!strlist__has_entry(namelist, buf))
			break;
	}
2527 2528 2529 2530 2531
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

2532 2533
out:
	free(nbase);
2534
	return ret;
2535 2536
}

2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
/* Warn if the current kernel's uprobe implementation is old */
static void warn_uprobe_event_compat(struct probe_trace_event *tev)
{
	int i;
	char *buf = synthesize_probe_trace_command(tev);

	/* Old uprobe event doesn't support memory dereference */
	if (!tev->uprobes || tev->nargs == 0 || !buf)
		goto out;

	for (i = 0; i < tev->nargs; i++)
		if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
			pr_warning("Please upgrade your kernel to at least "
				   "3.14 to have access to feature %s\n",
				   tev->args[i].value);
			break;
		}
out:
	free(buf);
}

2558 2559 2560 2561 2562 2563 2564 2565 2566 2567
/* Set new name from original perf_probe_event and namelist */
static int probe_trace_event__set_name(struct probe_trace_event *tev,
				       struct perf_probe_event *pev,
				       struct strlist *namelist,
				       bool allow_suffix)
{
	const char *event, *group;
	char buf[64];
	int ret;

2568
	/* If probe_event or trace_event already have the name, reuse it */
2569
	if (pev->event && !pev->sdt)
2570
		event = pev->event;
2571 2572 2573 2574
	else if (tev->event)
		event = tev->event;
	else {
		/* Or generate new one from probe point */
2575 2576 2577
		if (pev->point.function &&
			(strncmp(pev->point.function, "0x", 2) != 0) &&
			!strisglob(pev->point.function))
2578 2579 2580
			event = pev->point.function;
		else
			event = tev->point.realname;
2581
	}
2582
	if (pev->group && !pev->sdt)
2583
		group = pev->group;
2584 2585
	else if (tev->group)
		group = tev->group;
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606
	else
		group = PERFPROBE_GROUP;

	/* Get an unused new event name */
	ret = get_new_event_name(buf, 64, event,
				 namelist, allow_suffix);
	if (ret < 0)
		return ret;

	event = buf;

	tev->event = strdup(event);
	tev->group = strdup(group);
	if (tev->event == NULL || tev->group == NULL)
		return -ENOMEM;

	/* Add added event name to namelist */
	strlist__add(namelist, event);
	return 0;
}

2607 2608
static int __open_probe_file_and_namelist(bool uprobe,
					  struct strlist **namelist)
2609
{
2610
	int fd;
2611

2612
	fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2613
	if (fd < 0)
2614
		return fd;
2615

2616
	/* Get current event names */
2617 2618
	*namelist = probe_file__get_namelist(fd);
	if (!(*namelist)) {
2619
		pr_debug("Failed to get current event list.\n");
2620 2621
		close(fd);
		return -ENOMEM;
2622
	}
2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638
	return fd;
}

static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
				     int ntevs, bool allow_suffix)
{
	int i, fd[2] = {-1, -1}, up, ret;
	struct probe_trace_event *tev = NULL;
	struct probe_cache *cache = NULL;
	struct strlist *namelist[2] = {NULL, NULL};

	up = pev->uprobes ? 1 : 0;
	fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
	if (fd[up] < 0)
		return fd[up];
2639

2640
	ret = 0;
2641
	for (i = 0; i < ntevs; i++) {
2642
		tev = &tevs[i];
2643 2644 2645 2646 2647 2648 2649
		up = tev->uprobes ? 1 : 0;
		if (fd[up] == -1) {	/* Open the kprobe/uprobe_events */
			fd[up] = __open_probe_file_and_namelist(up,
								&namelist[up]);
			if (fd[up] < 0)
				goto close_out;
		}
2650
		/* Skip if the symbol is out of .text or blacklisted */
2651
		if (!tev->point.symbol && !pev->uprobes)
2652
			continue;
2653

2654
		/* Set new name for tev (and update namelist) */
2655
		ret = probe_trace_event__set_name(tev, pev, namelist[up],
2656
						  allow_suffix);
2657 2658
		if (ret < 0)
			break;
2659

2660
		ret = probe_file__add_event(fd[up], tev);
2661 2662
		if (ret < 0)
			break;
2663 2664 2665 2666 2667 2668 2669 2670

		/*
		 * Probes after the first probe which comes from same
		 * user input are always allowed to add suffix, because
		 * there might be several addresses corresponding to
		 * one code line.
		 */
		allow_suffix = true;
2671
	}
2672 2673
	if (ret == -EINVAL && pev->uprobes)
		warn_uprobe_event_compat(tev);
2674 2675 2676 2677 2678 2679 2680 2681
	if (ret == 0 && probe_conf.cache) {
		cache = probe_cache__new(pev->target);
		if (!cache ||
		    probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
		    probe_cache__commit(cache) < 0)
			pr_warning("Failed to add event to probe cache\n");
		probe_cache__delete(cache);
	}
2682

2683
close_out:
2684 2685 2686 2687 2688
	for (up = 0; up < 2; up++) {
		strlist__delete(namelist[up]);
		if (fd[up] >= 0)
			close(fd[up]);
	}
2689
	return ret;
2690
}
2691

2692 2693
static int find_probe_functions(struct map *map, char *name,
				struct symbol **syms)
2694
{
2695
	int found = 0;
2696
	struct symbol *sym;
2697
	struct rb_node *tmp;
2698

2699 2700 2701
	if (map__load(map, NULL) < 0)
		return 0;

2702
	map__for_each_symbol(map, sym, tmp) {
2703
		if (strglobmatch(sym->name, name)) {
2704
			found++;
2705 2706 2707
			if (syms && found < probe_conf.max_probes)
				syms[found - 1] = sym;
		}
2708
	}
2709 2710

	return found;
2711 2712
}

2713 2714
void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
				struct probe_trace_event *tev __maybe_unused,
2715 2716
				struct map *map __maybe_unused,
				struct symbol *sym __maybe_unused) { }
2717

2718 2719 2720 2721 2722
/*
 * Find probe function addresses from map.
 * Return an error or the number of found probe_trace_event
 */
static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2723
					    struct probe_trace_event **tevs)
2724
{
2725 2726
	struct map *map = NULL;
	struct ref_reloc_sym *reloc_sym = NULL;
2727
	struct symbol *sym;
2728
	struct symbol **syms = NULL;
2729
	struct probe_trace_event *tev;
2730 2731
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_point *tp;
2732
	int num_matched_functions;
2733
	int ret, i, j, skipped = 0;
2734
	char *mod_name;
2735

2736
	map = get_target_map(pev->target, pev->uprobes);
2737 2738 2739
	if (!map) {
		ret = -EINVAL;
		goto out;
2740 2741
	}

2742 2743 2744 2745 2746 2747
	syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
	if (!syms) {
		ret = -ENOMEM;
		goto out;
	}

2748 2749 2750 2751
	/*
	 * Load matched symbols: Since the different local symbols may have
	 * same name but different addresses, this lists all the symbols.
	 */
2752
	num_matched_functions = find_probe_functions(map, pp->function, syms);
2753
	if (num_matched_functions == 0) {
2754
		pr_err("Failed to find symbol %s in %s\n", pp->function,
2755
			pev->target ? : "kernel");
2756 2757
		ret = -ENOENT;
		goto out;
2758
	} else if (num_matched_functions > probe_conf.max_probes) {
2759
		pr_err("Too many functions matched in %s\n",
2760
			pev->target ? : "kernel");
2761 2762
		ret = -E2BIG;
		goto out;
2763 2764
	}

2765 2766
	/* Note that the symbols in the kmodule are not relocated */
	if (!pev->uprobes && !pp->retprobe && !pev->target) {
2767
		reloc_sym = kernel_get_ref_reloc_sym();
2768 2769 2770 2771 2772 2773
		if (!reloc_sym) {
			pr_warning("Relocated base symbol is not found!\n");
			ret = -EINVAL;
			goto out;
		}
	}
2774

2775 2776 2777
	/* Setup result trace-probe-events */
	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
	if (!*tevs) {
2778
		ret = -ENOMEM;
2779
		goto out;
2780
	}
2781

2782
	ret = 0;
2783

2784 2785 2786
	for (j = 0; j < num_matched_functions; j++) {
		sym = syms[j];

2787 2788 2789 2790 2791
		tev = (*tevs) + ret;
		tp = &tev->point;
		if (ret == num_matched_functions) {
			pr_warning("Too many symbols are listed. Skip it.\n");
			break;
2792
		}
2793
		ret++;
2794

2795 2796 2797 2798 2799 2800 2801 2802
		if (pp->offset > sym->end - sym->start) {
			pr_warning("Offset %ld is bigger than the size of %s\n",
				   pp->offset, sym->name);
			ret = -ENOENT;
			goto err_out;
		}
		/* Add one probe point */
		tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2803 2804 2805

		/* Check the kprobe (not in module) is within .text  */
		if (!pev->uprobes && !pev->target &&
2806 2807 2808 2809
		    kprobe_warn_out_range(sym->name, tp->address)) {
			tp->symbol = NULL;	/* Skip it */
			skipped++;
		} else if (reloc_sym) {
2810 2811 2812 2813 2814 2815
			tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
			tp->offset = tp->address - reloc_sym->addr;
		} else {
			tp->symbol = strdup_or_goto(sym->name, nomem_out);
			tp->offset = pp->offset;
		}
2816 2817
		tp->realname = strdup_or_goto(sym->name, nomem_out);

2818
		tp->retprobe = pp->retprobe;
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
		if (pev->target) {
			if (pev->uprobes) {
				tev->point.module = strdup_or_goto(pev->target,
								   nomem_out);
			} else {
				mod_name = find_module_name(pev->target);
				tev->point.module =
					strdup(mod_name ? mod_name : pev->target);
				free(mod_name);
				if (!tev->point.module)
					goto nomem_out;
			}
		}
2832 2833 2834 2835 2836 2837 2838
		tev->uprobes = pev->uprobes;
		tev->nargs = pev->nargs;
		if (tev->nargs) {
			tev->args = zalloc(sizeof(struct probe_trace_arg) *
					   tev->nargs);
			if (tev->args == NULL)
				goto nomem_out;
2839
		}
2840
		for (i = 0; i < tev->nargs; i++) {
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851
			if (pev->args[i].name)
				tev->args[i].name =
					strdup_or_goto(pev->args[i].name,
							nomem_out);

			tev->args[i].value = strdup_or_goto(pev->args[i].var,
							    nomem_out);
			if (pev->args[i].type)
				tev->args[i].type =
					strdup_or_goto(pev->args[i].type,
							nomem_out);
2852
		}
2853
		arch__fix_tev_from_maps(pev, tev, map, sym);
2854
	}
2855 2856 2857 2858
	if (ret == skipped) {
		ret = -ENOENT;
		goto err_out;
	}
2859

2860
out:
2861
	put_target_map(map, pev->uprobes);
2862
	free(syms);
2863
	return ret;
2864

2865 2866 2867 2868 2869 2870 2871
nomem_out:
	ret = -ENOMEM;
err_out:
	clear_probe_trace_events(*tevs, num_matched_functions);
	zfree(tevs);
	goto out;
}
2872

2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964
static int try_to_find_absolute_address(struct perf_probe_event *pev,
					struct probe_trace_event **tevs)
{
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_event *tev;
	struct probe_trace_point *tp;
	int i, err;

	if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
		return -EINVAL;
	if (perf_probe_event_need_dwarf(pev))
		return -EINVAL;

	/*
	 * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
	 * absolute address.
	 *
	 * Only one tev can be generated by this.
	 */
	*tevs = zalloc(sizeof(*tev));
	if (!*tevs)
		return -ENOMEM;

	tev = *tevs;
	tp = &tev->point;

	/*
	 * Don't use tp->offset, use address directly, because
	 * in synthesize_probe_trace_command() address cannot be
	 * zero.
	 */
	tp->address = pev->point.abs_address;
	tp->retprobe = pp->retprobe;
	tev->uprobes = pev->uprobes;

	err = -ENOMEM;
	/*
	 * Give it a '0x' leading symbol name.
	 * In __add_probe_trace_events, a NULL symbol is interpreted as
	 * invalud.
	 */
	if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0)
		goto errout;

	/* For kprobe, check range */
	if ((!tev->uprobes) &&
	    (kprobe_warn_out_range(tev->point.symbol,
				   tev->point.address))) {
		err = -EACCES;
		goto errout;
	}

	if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0)
		goto errout;

	if (pev->target) {
		tp->module = strdup(pev->target);
		if (!tp->module)
			goto errout;
	}

	if (tev->group) {
		tev->group = strdup(pev->group);
		if (!tev->group)
			goto errout;
	}

	if (pev->event) {
		tev->event = strdup(pev->event);
		if (!tev->event)
			goto errout;
	}

	tev->nargs = pev->nargs;
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
	if (!tev->args) {
		err = -ENOMEM;
		goto errout;
	}
	for (i = 0; i < tev->nargs; i++)
		copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);

	return 1;

errout:
	if (*tevs) {
		clear_probe_trace_events(*tevs, 1);
		*tevs = NULL;
	}
	return err;
}

2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
/* Concatinate two arrays */
static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
{
	void *ret;

	ret = malloc(sz_a + sz_b);
	if (ret) {
		memcpy(ret, a, sz_a);
		memcpy(ret + sz_a, b, sz_b);
	}
	return ret;
}

static int
concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
			  struct probe_trace_event **tevs2, int ntevs2)
{
	struct probe_trace_event *new_tevs;
	int ret = 0;

	if (ntevs == 0) {
		*tevs = *tevs2;
		*ntevs = ntevs2;
		*tevs2 = NULL;
		return 0;
	}

	if (*ntevs + ntevs2 > probe_conf.max_probes)
		ret = -E2BIG;
	else {
		/* Concatinate the array of probe_trace_event */
		new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
				  *tevs2, ntevs2 * sizeof(**tevs2));
		if (!new_tevs)
			ret = -ENOMEM;
		else {
			free(*tevs);
			*tevs = new_tevs;
			*ntevs += ntevs2;
		}
	}
	if (ret < 0)
		clear_probe_trace_events(*tevs2, ntevs2);
	zfree(tevs2);

	return ret;
}

/*
 * Try to find probe_trace_event from given probe caches. Return the number
 * of cached events found, if an error occurs return the error.
 */
static int find_cached_events(struct perf_probe_event *pev,
			      struct probe_trace_event **tevs,
			      const char *target)
{
	struct probe_cache *cache;
	struct probe_cache_entry *entry;
	struct probe_trace_event *tmp_tevs = NULL;
	int ntevs = 0;
	int ret = 0;

	cache = probe_cache__new(target);
	/* Return 0 ("not found") if the target has no probe cache. */
	if (!cache)
		return 0;

	for_each_probe_cache_entry(entry, cache) {
		/* Skip the cache entry which has no name */
		if (!entry->pev.event || !entry->pev.group)
			continue;
		if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
		    strglobmatch(entry->pev.event, pev->event)) {
			ret = probe_cache_entry__get_event(entry, &tmp_tevs);
			if (ret > 0)
				ret = concat_probe_trace_events(tevs, &ntevs,
								&tmp_tevs, ret);
			if (ret < 0)
				break;
		}
	}
	probe_cache__delete(cache);
	if (ret < 0) {
		clear_probe_trace_events(*tevs, ntevs);
		zfree(tevs);
	} else {
		ret = ntevs;
		if (ntevs > 0 && target && target[0] == '/')
			pev->uprobes = true;
	}

	return ret;
}

3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
/* Try to find probe_trace_event from all probe caches */
static int find_cached_events_all(struct perf_probe_event *pev,
				   struct probe_trace_event **tevs)
{
	struct probe_trace_event *tmp_tevs = NULL;
	struct strlist *bidlist;
	struct str_node *nd;
	char *pathname;
	int ntevs = 0;
	int ret;

	/* Get the buildid list of all valid caches */
	bidlist = build_id_cache__list_all(true);
	if (!bidlist) {
		ret = -errno;
		pr_debug("Failed to get buildids: %d\n", ret);
		return ret;
	}

	ret = 0;
	strlist__for_each_entry(nd, bidlist) {
		pathname = build_id_cache__origname(nd->s);
		ret = find_cached_events(pev, &tmp_tevs, pathname);
		/* In the case of cnt == 0, we just skip it */
		if (ret > 0)
			ret = concat_probe_trace_events(tevs, &ntevs,
							&tmp_tevs, ret);
		free(pathname);
		if (ret < 0)
			break;
	}
	strlist__delete(bidlist);

	if (ret < 0) {
		clear_probe_trace_events(*tevs, ntevs);
		zfree(tevs);
	} else
		ret = ntevs;

	return ret;
}

3101 3102 3103 3104 3105 3106 3107 3108 3109
static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
					      struct probe_trace_event **tevs)
{
	struct probe_cache *cache;
	struct probe_cache_entry *entry;
	struct probe_trace_event *tev;
	struct str_node *node;
	int ret, i;

3110
	if (pev->sdt) {
3111
		/* For SDT/cached events, we use special search functions */
3112 3113 3114 3115 3116
		if (!pev->target)
			return find_cached_events_all(pev, tevs);
		else
			return find_cached_events(pev, tevs, pev->target);
	}
3117 3118 3119 3120 3121 3122
	cache = probe_cache__new(pev->target);
	if (!cache)
		return 0;

	entry = probe_cache__find(cache, pev);
	if (!entry) {
3123 3124
		/* SDT must be in the cache */
		ret = pev->sdt ? -ENOENT : 0;
3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157
		goto out;
	}

	ret = strlist__nr_entries(entry->tevlist);
	if (ret > probe_conf.max_probes) {
		pr_debug("Too many entries matched in the cache of %s\n",
			 pev->target ? : "kernel");
		ret = -E2BIG;
		goto out;
	}

	*tevs = zalloc(ret * sizeof(*tev));
	if (!*tevs) {
		ret = -ENOMEM;
		goto out;
	}

	i = 0;
	strlist__for_each_entry(node, entry->tevlist) {
		tev = &(*tevs)[i++];
		ret = parse_probe_trace_command(node->s, tev);
		if (ret < 0)
			goto out;
		/* Set the uprobes attribute as same as original */
		tev->uprobes = pev->uprobes;
	}
	ret = i;

out:
	probe_cache__delete(cache);
	return ret;
}

3158
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3159
					 struct probe_trace_event **tevs)
3160 3161 3162
{
	int ret;

3163
	if (!pev->group && !pev->sdt) {
3164 3165 3166 3167 3168 3169
		/* Set group name if not given */
		if (!pev->uprobes) {
			pev->group = strdup(PERFPROBE_GROUP);
			ret = pev->group ? 0 : -ENOMEM;
		} else
			ret = convert_exec_to_group(pev->target, &pev->group);
3170 3171 3172 3173
		if (ret != 0) {
			pr_warning("Failed to make a group name.\n");
			return ret;
		}
3174
	}
3175

3176 3177 3178 3179
	ret = try_to_find_absolute_address(pev, tevs);
	if (ret > 0)
		return ret;

3180 3181
	/* At first, we need to lookup cache entry */
	ret = find_probe_trace_events_from_cache(pev, tevs);
3182 3183
	if (ret > 0 || pev->sdt)	/* SDT can be found only in the cache */
		return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3184

3185
	/* Convert perf_probe_event with debuginfo */
3186
	ret = try_to_find_probe_trace_events(pev, tevs);
3187 3188 3189
	if (ret != 0)
		return ret;	/* Found in debuginfo or got an error */

3190
	return find_probe_trace_events_from_map(pev, tevs);
3191 3192
}

3193
int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3194
{
3195
	int i, ret;
3196 3197 3198

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
3199
		/* Init kprobe blacklist if needed */
3200
		if (!pevs[i].uprobes)
3201
			kprobe_blacklist__init();
3202
		/* Convert with or without debuginfo */
3203
		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3204
		if (ret < 0)
3205
			return ret;
3206
		pevs[i].ntevs = ret;
3207
	}
3208 3209
	/* This just release blacklist only if allocated */
	kprobe_blacklist__release();
3210

3211 3212 3213
	return 0;
}

3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
static int show_probe_trace_event(struct probe_trace_event *tev)
{
	char *buf = synthesize_probe_trace_command(tev);

	if (!buf) {
		pr_debug("Failed to synthesize probe trace event.\n");
		return -EINVAL;
	}

	/* Showing definition always go stdout */
	printf("%s\n", buf);
	free(buf);

	return 0;
}

int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
{
	struct strlist *namelist = strlist__new(NULL, NULL);
	struct probe_trace_event *tev;
	struct perf_probe_event *pev;
	int i, j, ret = 0;

	if (!namelist)
		return -ENOMEM;

	for (j = 0; j < npevs && !ret; j++) {
		pev = &pevs[j];
		for (i = 0; i < pev->ntevs && !ret; i++) {
			tev = &pev->tevs[i];
			/* Skip if the symbol is out of .text or blacklisted */
			if (!tev->point.symbol && !pev->uprobes)
				continue;

			/* Set new name for tev (and update namelist) */
			ret = probe_trace_event__set_name(tev, pev,
							  namelist, true);
			if (!ret)
				ret = show_probe_trace_event(tev);
		}
	}
	strlist__delete(namelist);

	return ret;
}

3260
int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3261 3262 3263
{
	int i, ret = 0;

3264
	/* Loop 2: add all events */
3265
	for (i = 0; i < npevs; i++) {
3266 3267
		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
					       pevs[i].ntevs,
3268
					       probe_conf.force_add);
3269 3270 3271
		if (ret < 0)
			break;
	}
3272 3273 3274
	return ret;
}

3275
void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3276 3277 3278
{
	int i, j;

3279 3280
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
3281 3282 3283 3284
		for (j = 0; j < pevs[i].ntevs; j++)
			clear_probe_trace_event(&pevs[i].tevs[j]);
		zfree(&pevs[i].tevs);
		pevs[i].ntevs = 0;
3285
		clear_perf_probe_event(&pevs[i]);
3286
	}
3287 3288 3289 3290 3291 3292
}

int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
{
	int ret;

3293 3294 3295 3296
	ret = init_probe_symbol_maps(pevs->uprobes);
	if (ret < 0)
		return ret;

3297
	ret = convert_perf_probe_events(pevs, npevs);
3298
	if (ret == 0)
3299
		ret = apply_perf_probe_events(pevs, npevs);
3300

3301
	cleanup_perf_probe_events(pevs, npevs);
3302

3303
	exit_probe_symbol_maps();
3304
	return ret;
3305 3306
}

3307
int del_perf_probe_events(struct strfilter *filter)
3308
{
3309 3310 3311 3312 3313 3314
	int ret, ret2, ufd = -1, kfd = -1;
	char *str = strfilter__string(filter);

	if (!str)
		return -EINVAL;

3315
	/* Get current event names */
3316 3317 3318
	ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
	if (ret < 0)
		goto out;
3319

3320
	ret = probe_file__del_events(kfd, filter);
3321
	if (ret < 0 && ret != -ENOENT)
3322 3323
		goto error;

3324
	ret2 = probe_file__del_events(ufd, filter);
3325
	if (ret2 < 0 && ret2 != -ENOENT) {
3326
		ret = ret2;
3327 3328 3329
		goto error;
	}
	ret = 0;
3330 3331

error:
3332
	if (kfd >= 0)
3333
		close(kfd);
3334
	if (ufd >= 0)
3335
		close(ufd);
3336
out:
3337
	free(str);
3338 3339

	return ret;
3340
}
3341

3342 3343
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
3344
{
3345
        struct rb_node *nd;
3346 3347 3348
	struct map *map;
	int ret;

3349
	ret = init_probe_symbol_maps(user);
3350 3351 3352
	if (ret < 0)
		return ret;

3353 3354 3355 3356 3357
	/* Get a symbol map */
	if (user)
		map = dso__new_map(target);
	else
		map = kernel_get_module_map(target);
3358
	if (!map) {
3359
		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3360 3361
		return -EINVAL;
	}
3362

3363
	ret = map__load(map, NULL);
3364 3365 3366 3367 3368 3369 3370 3371 3372
	if (ret) {
		if (ret == -2) {
			char *str = strfilter__string(_filter);
			pr_err("Failed to find symbols matched to \"%s\"\n",
			       str);
			free(str);
		} else
			pr_err("Failed to load symbols in %s\n",
			       (target) ? : "kernel");
3373 3374 3375 3376
		goto end;
	}
	if (!dso__sorted_by_name(map->dso, map->type))
		dso__sort_by_name(map->dso, map->type);
3377

3378 3379
	/* Show all (filtered) symbols */
	setup_pager();
3380 3381 3382 3383 3384 3385 3386 3387

        for (nd = rb_first(&map->dso->symbol_names[map->type]); nd; nd = rb_next(nd)) {
		struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);

		if (strfilter__compare(_filter, pos->sym.name))
			printf("%s\n", pos->sym.name);
        }

3388 3389
end:
	if (user) {
3390
		map__put(map);
3391
	}
3392
	exit_probe_symbol_maps();
3393

3394
	return ret;
3395 3396
}

3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
			    struct perf_probe_arg *pvar)
{
	tvar->value = strdup(pvar->var);
	if (tvar->value == NULL)
		return -ENOMEM;
	if (pvar->type) {
		tvar->type = strdup(pvar->type);
		if (tvar->type == NULL)
			return -ENOMEM;
	}
	if (pvar->name) {
		tvar->name = strdup(pvar->name);
		if (tvar->name == NULL)
			return -ENOMEM;
	} else
		tvar->name = NULL;
	return 0;
}