probe-event.c 77.2 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 1630 1631 1632 1633
/* Returns true if *any* ARG is either C variable, $params or $vars. */
bool perf_probe_with_var(struct perf_probe_event *pev)
{
	int i = 0;

	for (i = 0; i < pev->nargs; i++)
		if (is_c_varname(pev->args[i].var)              ||
		    !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
		    !strcmp(pev->args[i].var, PROBE_ARG_VARS))
			return true;
	return false;
}

1634 1635 1636 1637 1638 1639
/* Return true if this perf_probe_event requires debuginfo */
bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
{
	if (pev->point.file || pev->point.line || pev->point.lazy_line)
		return true;

1640 1641
	if (perf_probe_with_var(pev))
		return true;
1642 1643 1644 1645

	return false;
}

1646
/* Parse probe_events event into struct probe_point */
1647
int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1648
{
1649
	struct probe_trace_point *tp = &tev->point;
1650 1651
	char pr;
	char *p;
1652
	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1653 1654 1655
	int ret, i, argc;
	char **argv;

1656
	pr_debug("Parsing probe_events: %s\n", cmd);
1657
	argv = argv_split(cmd, &argc);
1658 1659 1660 1661 1662 1663 1664 1665 1666
	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;
	}
1667 1668

	/* Scan event and group name. */
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
	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) {
1679 1680 1681 1682
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1683 1684 1685 1686 1687 1688 1689
	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;
	}
1690
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1691

1692
	tp->retprobe = (pr == 'r');
1693

1694 1695 1696 1697
	/* Scan module name(if there), function name and offset */
	p = strchr(argv[1], ':');
	if (p) {
		tp->module = strndup(argv[1], p - argv[1]);
1698 1699 1700 1701
		if (!tp->module) {
			ret = -ENOMEM;
			goto out;
		}
1702
		tev->uprobes = (tp->module[0] == '/');
1703 1704 1705
		p++;
	} else
		p = argv[1];
1706
	fmt1_str = strtok_r(p, "+", &fmt);
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
	/* 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 {
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
		/* 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);
1743
	}
1744

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

1772
/* Compose only probe arg */
1773
char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1774 1775
{
	struct perf_probe_arg_field *field = pa->field;
1776
	struct strbuf buf;
1777 1778 1779 1780 1781
	char *ret = NULL;
	int err;

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

1783
	if (pa->name && pa->var)
1784
		err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1785
	else
1786 1787 1788
		err = strbuf_addstr(&buf, pa->name ?: pa->var);
	if (err)
		goto out;
1789 1790

	while (field) {
1791
		if (field->name[0] == '[')
1792
			err = strbuf_addstr(&buf, field->name);
1793
		else
1794 1795
			err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
					  field->name);
1796
		field = field->next;
1797 1798
		if (err)
			goto out;
1799
	}
1800

1801
	if (pa->type)
1802 1803
		if (strbuf_addf(&buf, ":%s", pa->type) < 0)
			goto out;
1804 1805

	ret = strbuf_detach(&buf, NULL);
1806 1807
out:
	strbuf_release(&buf);
1808
	return ret;
1809 1810
}

1811
/* Compose only probe point (not argument) */
1812
char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1813
{
1814
	struct strbuf buf;
1815 1816 1817 1818 1819
	char *tmp, *ret = NULL;
	int len, err = 0;

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

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

1851
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1852
{
1853 1854 1855
	struct strbuf buf;
	char *tmp, *ret = NULL;
	int i;
1856

1857
	if (strbuf_init(&buf, 64))
1858
		return NULL;
1859 1860 1861 1862 1863 1864 1865 1866 1867
	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);
1868

1869
	for (i = 0; i < pev->nargs; i++) {
1870 1871 1872 1873
		tmp = synthesize_perf_probe_arg(pev->args + i);
		if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
			goto out;
		free(tmp);
1874 1875
	}

1876 1877 1878 1879
	ret = strbuf_detach(&buf, NULL);
out:
	strbuf_release(&buf);
	return ret;
1880 1881
}

1882
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1883
					    struct strbuf *buf, int depth)
1884
{
1885
	int err;
1886
	if (ref->next) {
1887
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1888
							 depth + 1);
1889
		if (depth < 0)
1890
			return depth;
1891
	}
1892 1893
	err = strbuf_addf(buf, "%+ld(", ref->offset);
	return (err < 0) ? err : depth;
1894 1895
}

1896
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1897
				      struct strbuf *buf)
1898
{
1899
	struct probe_trace_arg_ref *ref = arg->ref;
1900
	int depth = 0, err;
1901 1902 1903

	/* Argument name or separator */
	if (arg->name)
1904
		err = strbuf_addf(buf, " %s=", arg->name);
1905
	else
1906 1907 1908
		err = strbuf_addch(buf, ' ');
	if (err)
		return err;
1909

1910 1911 1912 1913
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1914
	/* Dereferencing arguments */
1915
	if (ref) {
1916
		depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
1917 1918 1919 1920 1921
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1922
	if (arg->value[0] == '@' && arg->ref)
1923
		err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
1924
	else
1925
		err = strbuf_addstr(buf, arg->value);
1926 1927

	/* Closing */
1928 1929 1930
	while (!err && depth--)
		err = strbuf_addch(buf, ')');

1931
	/* Print argument type */
1932 1933
	if (!err && arg->type)
		err = strbuf_addf(buf, ":%s", arg->type);
1934

1935
	return err;
1936 1937
}

1938
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1939
{
1940
	struct probe_trace_point *tp = &tev->point;
1941 1942
	struct strbuf buf;
	char *ret = NULL;
1943
	int i, err;
1944

1945 1946
	/* Uprobes must have tp->module */
	if (tev->uprobes && !tp->module)
1947 1948
		return NULL;

1949 1950 1951 1952 1953 1954
	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;
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964
	/*
	 * 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;
	}
1965 1966

	/* Use the tp->address for uprobes */
1967
	if (tev->uprobes)
1968
		err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address);
1969 1970
	else if (!strncmp(tp->symbol, "0x", 2))
		/* Absolute address. See try_to_find_absolute_address() */
1971 1972
		err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
				  tp->module ? ":" : "", tp->address);
1973
	else
1974 1975 1976 1977
		err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
				tp->module ? ":" : "", tp->symbol, tp->offset);
	if (err)
		goto error;
1978

1979 1980
	for (i = 0; i < tev->nargs; i++)
		if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
1981 1982
			goto error;

1983
	ret = strbuf_detach(&buf, NULL);
1984
error:
1985 1986
	strbuf_release(&buf);
	return ret;
1987
}
1988

1989 1990 1991 1992 1993 1994
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;
1995
	u64 addr = tp->address;
1996 1997 1998 1999 2000 2001 2002 2003
	int ret = -ENOENT;

	if (!is_kprobe) {
		map = dso__new_map(tp->module);
		if (!map)
			goto out;
		sym = map__find_symbol(map, addr, NULL);
	} else {
2004
		if (tp->symbol && !addr) {
2005 2006
			if (kernel_get_symbol_address_by_name(tp->symbol,
						&addr, true, false) < 0)
2007 2008
				goto out;
		}
2009 2010 2011 2012 2013
		if (addr) {
			addr += tp->offset;
			sym = __find_kernel_function(addr, &map);
		}
	}
2014

2015 2016 2017 2018 2019 2020 2021 2022 2023 2024
	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) {
2025
		map__put(map);
2026 2027 2028 2029 2030 2031
	}

	return ret;
}

static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2032 2033
				       struct perf_probe_point *pp,
				       bool is_kprobe)
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
{
	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;
2050
	} else {
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
		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;
}

2065
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2066
			       struct perf_probe_event *pev, bool is_kprobe)
2067
{
2068
	struct strbuf buf = STRBUF_INIT;
2069
	int i, ret;
2070

2071
	/* Convert event/group name */
2072 2073 2074 2075
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
2076

2077
	/* Convert trace_point to probe_point */
2078
	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2079 2080
	if (ret < 0)
		return ret;
2081

2082 2083
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
2084 2085 2086
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
2087
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
2088
		if (tev->args[i].name)
2089
			pev->args[i].name = strdup(tev->args[i].name);
2090
		else {
2091 2092
			if ((ret = strbuf_init(&buf, 32)) < 0)
				goto error;
2093 2094
			ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
			pev->args[i].name = strbuf_detach(&buf, NULL);
2095
		}
2096 2097 2098
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
2099
error:
2100 2101 2102 2103
	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
2104 2105 2106 2107
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
2108
	struct perf_probe_arg_field *field, *next;
2109 2110
	int i;

2111 2112
	free(pev->event);
	free(pev->group);
2113
	free(pev->target);
2114
	clear_perf_probe_point(&pev->point);
2115

2116
	for (i = 0; i < pev->nargs; i++) {
2117 2118 2119
		free(pev->args[i].name);
		free(pev->args[i].var);
		free(pev->args[i].type);
2120 2121 2122
		field = pev->args[i].field;
		while (field) {
			next = field->next;
2123
			zfree(&field->name);
2124 2125 2126 2127
			free(field);
			field = next;
		}
	}
2128
	free(pev->args);
2129 2130 2131
	memset(pev, 0, sizeof(*pev));
}

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 2197 2198 2199 2200 2201 2202 2203 2204
#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;
}

2205
void clear_probe_trace_event(struct probe_trace_event *tev)
2206
{
2207
	struct probe_trace_arg_ref *ref, *next;
2208 2209
	int i;

2210 2211 2212
	free(tev->event);
	free(tev->group);
	free(tev->point.symbol);
2213
	free(tev->point.realname);
2214
	free(tev->point.module);
2215
	for (i = 0; i < tev->nargs; i++) {
2216 2217 2218
		free(tev->args[i].name);
		free(tev->args[i].value);
		free(tev->args[i].type);
2219 2220 2221 2222 2223 2224 2225
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
2226
	free(tev->args);
2227
	memset(tev, 0, sizeof(*tev));
2228 2229
}

2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
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;
2253
	const char *__debugfs = debugfs__mountpoint();
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 2311 2312 2313 2314 2315 2316 2317 2318
	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;
}

2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
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);
}

2340 2341
static int perf_probe_event__sprintf(const char *group, const char *event,
				     struct perf_probe_event *pev,
2342 2343
				     const char *module,
				     struct strbuf *result)
2344
{
2345
	int i, ret;
2346
	char *buf;
2347

2348 2349
	if (asprintf(&buf, "%s:%s", group, event) < 0)
		return -errno;
2350
	ret = strbuf_addf(result, "  %-20s (on ", buf);
2351
	free(buf);
2352 2353
	if (ret)
		return ret;
2354

2355 2356 2357 2358
	/* Synthesize only event probe point */
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return -ENOMEM;
2359
	ret = strbuf_addstr(result, buf);
2360
	free(buf);
2361

2362 2363
	if (!ret && module)
		ret = strbuf_addf(result, " in %s", module);
2364

2365 2366 2367
	if (!ret && pev->nargs > 0) {
		ret = strbuf_add(result, " with", 5);
		for (i = 0; !ret && i < pev->nargs; i++) {
2368 2369 2370
			buf = synthesize_perf_probe_arg(&pev->args[i]);
			if (!buf)
				return -ENOMEM;
2371
			ret = strbuf_addf(result, " %s", buf);
2372
			free(buf);
2373
		}
2374
	}
2375 2376
	if (!ret)
		ret = strbuf_addch(result, ')');
2377

2378
	return ret;
2379 2380
}

2381
/* Show an event */
2382 2383 2384
int show_perf_probe_event(const char *group, const char *event,
			  struct perf_probe_event *pev,
			  const char *module, bool use_stdout)
2385 2386 2387 2388
{
	struct strbuf buf = STRBUF_INIT;
	int ret;

2389
	ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
	if (ret >= 0) {
		if (use_stdout)
			printf("%s\n", buf.buf);
		else
			pr_info("%s\n", buf.buf);
	}
	strbuf_release(&buf);

	return ret;
}

2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417
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)
2418
{
2419
	int ret = 0;
2420
	struct probe_trace_event tev;
2421
	struct perf_probe_event pev;
2422 2423 2424
	struct strlist *rawlist;
	struct str_node *ent;

2425 2426
	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
2427

2428
	rawlist = probe_file__get_rawlist(fd);
2429
	if (!rawlist)
2430
		return -ENOMEM;
2431

2432
	strlist__for_each_entry(ent, rawlist) {
2433
		ret = parse_probe_trace_command(ent->s, &tev);
2434
		if (ret >= 0) {
2435 2436
			if (!filter_probe_trace_event(&tev, filter))
				goto next;
2437 2438
			ret = convert_to_perf_probe_event(&tev, &pev,
								is_kprobe);
2439 2440
			if (ret < 0)
				goto next;
2441 2442
			ret = show_perf_probe_event(pev.group, pev.event,
						    &pev, tev.point.module,
2443
						    true);
2444
		}
2445
next:
2446
		clear_perf_probe_event(&pev);
2447
		clear_probe_trace_event(&tev);
2448 2449
		if (ret < 0)
			break;
2450 2451
	}
	strlist__delete(rawlist);
2452 2453
	/* Cleanup cached debuginfo if needed */
	debuginfo_cache__exit();
2454 2455

	return ret;
2456 2457
}

2458
/* List up current perf-probe events */
2459
int show_perf_probe_events(struct strfilter *filter)
2460
{
2461
	int kp_fd, up_fd, ret;
2462 2463 2464

	setup_pager();

2465 2466 2467
	if (probe_conf.cache)
		return probe_cache__show_all_caches(filter);

2468
	ret = init_probe_symbol_maps(false);
2469 2470 2471
	if (ret < 0)
		return ret;

2472 2473 2474
	ret = probe_file__open_both(&kp_fd, &up_fd, 0);
	if (ret < 0)
		return ret;
2475

2476 2477 2478
	if (kp_fd >= 0)
		ret = __show_perf_probe_events(kp_fd, true, filter);
	if (up_fd >= 0 && ret >= 0)
2479
		ret = __show_perf_probe_events(up_fd, false, filter);
2480 2481 2482
	if (kp_fd > 0)
		close(kp_fd);
	if (up_fd > 0)
2483
		close(up_fd);
2484
	exit_probe_symbol_maps();
2485

2486
	return ret;
2487 2488
}

2489 2490
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
2491 2492
{
	int i, ret;
2493
	char *p, *nbase;
2494

2495 2496
	if (*base == '.')
		base++;
2497 2498 2499 2500 2501 2502 2503 2504
	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';
2505

2506 2507
	/* Try no suffix number */
	ret = e_snprintf(buf, len, "%s", nbase);
2508
	if (ret < 0) {
2509
		pr_debug("snprintf() failed: %d\n", ret);
2510
		goto out;
2511
	}
2512
	if (!strlist__has_entry(namelist, buf))
2513
		goto out;
2514

2515
	if (!allow_suffix) {
2516 2517 2518 2519 2520
		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);
2521 2522
		ret = -EEXIST;
		goto out;
2523 2524
	}

2525 2526
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2527
		ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2528
		if (ret < 0) {
2529
			pr_debug("snprintf() failed: %d\n", ret);
2530
			goto out;
2531
		}
2532 2533 2534
		if (!strlist__has_entry(namelist, buf))
			break;
	}
2535 2536 2537 2538 2539
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

2540 2541
out:
	free(nbase);
2542
	return ret;
2543 2544
}

2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
/* 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);
}

2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
/* 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;

2576
	/* If probe_event or trace_event already have the name, reuse it */
2577
	if (pev->event && !pev->sdt)
2578
		event = pev->event;
2579 2580 2581 2582
	else if (tev->event)
		event = tev->event;
	else {
		/* Or generate new one from probe point */
2583 2584 2585
		if (pev->point.function &&
			(strncmp(pev->point.function, "0x", 2) != 0) &&
			!strisglob(pev->point.function))
2586 2587 2588
			event = pev->point.function;
		else
			event = tev->point.realname;
2589
	}
2590
	if (pev->group && !pev->sdt)
2591
		group = pev->group;
2592 2593
	else if (tev->group)
		group = tev->group;
2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
	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;
}

2615 2616
static int __open_probe_file_and_namelist(bool uprobe,
					  struct strlist **namelist)
2617
{
2618
	int fd;
2619

2620
	fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2621
	if (fd < 0)
2622
		return fd;
2623

2624
	/* Get current event names */
2625 2626
	*namelist = probe_file__get_namelist(fd);
	if (!(*namelist)) {
2627
		pr_debug("Failed to get current event list.\n");
2628 2629
		close(fd);
		return -ENOMEM;
2630
	}
2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
	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];
2647

2648
	ret = 0;
2649
	for (i = 0; i < ntevs; i++) {
2650
		tev = &tevs[i];
2651 2652 2653 2654 2655 2656 2657
		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;
		}
2658
		/* Skip if the symbol is out of .text or blacklisted */
2659
		if (!tev->point.symbol && !pev->uprobes)
2660
			continue;
2661

2662
		/* Set new name for tev (and update namelist) */
2663
		ret = probe_trace_event__set_name(tev, pev, namelist[up],
2664
						  allow_suffix);
2665 2666
		if (ret < 0)
			break;
2667

2668
		ret = probe_file__add_event(fd[up], tev);
2669 2670
		if (ret < 0)
			break;
2671 2672 2673 2674 2675 2676 2677 2678

		/*
		 * 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;
2679
	}
2680 2681
	if (ret == -EINVAL && pev->uprobes)
		warn_uprobe_event_compat(tev);
2682 2683 2684 2685 2686 2687 2688 2689
	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);
	}
2690

2691
close_out:
2692 2693 2694 2695 2696
	for (up = 0; up < 2; up++) {
		strlist__delete(namelist[up]);
		if (fd[up] >= 0)
			close(fd[up]);
	}
2697
	return ret;
2698
}
2699

2700 2701
static int find_probe_functions(struct map *map, char *name,
				struct symbol **syms)
2702
{
2703
	int found = 0;
2704
	struct symbol *sym;
2705
	struct rb_node *tmp;
2706

2707 2708 2709
	if (map__load(map, NULL) < 0)
		return 0;

2710
	map__for_each_symbol(map, sym, tmp) {
2711
		if (strglobmatch(sym->name, name)) {
2712
			found++;
2713 2714 2715
			if (syms && found < probe_conf.max_probes)
				syms[found - 1] = sym;
		}
2716
	}
2717 2718

	return found;
2719 2720
}

2721 2722
void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
				struct probe_trace_event *tev __maybe_unused,
2723 2724
				struct map *map __maybe_unused,
				struct symbol *sym __maybe_unused) { }
2725

2726 2727 2728 2729 2730
/*
 * 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,
2731
					    struct probe_trace_event **tevs)
2732
{
2733 2734
	struct map *map = NULL;
	struct ref_reloc_sym *reloc_sym = NULL;
2735
	struct symbol *sym;
2736
	struct symbol **syms = NULL;
2737
	struct probe_trace_event *tev;
2738 2739
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_point *tp;
2740
	int num_matched_functions;
2741
	int ret, i, j, skipped = 0;
2742
	char *mod_name;
2743

2744
	map = get_target_map(pev->target, pev->uprobes);
2745 2746 2747
	if (!map) {
		ret = -EINVAL;
		goto out;
2748 2749
	}

2750 2751 2752 2753 2754 2755
	syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
	if (!syms) {
		ret = -ENOMEM;
		goto out;
	}

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

2773 2774
	/* Note that the symbols in the kmodule are not relocated */
	if (!pev->uprobes && !pp->retprobe && !pev->target) {
2775
		reloc_sym = kernel_get_ref_reloc_sym();
2776 2777 2778 2779 2780 2781
		if (!reloc_sym) {
			pr_warning("Relocated base symbol is not found!\n");
			ret = -EINVAL;
			goto out;
		}
	}
2782

2783 2784 2785
	/* Setup result trace-probe-events */
	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
	if (!*tevs) {
2786
		ret = -ENOMEM;
2787
		goto out;
2788
	}
2789

2790
	ret = 0;
2791

2792 2793 2794
	for (j = 0; j < num_matched_functions; j++) {
		sym = syms[j];

2795 2796 2797 2798 2799
		tev = (*tevs) + ret;
		tp = &tev->point;
		if (ret == num_matched_functions) {
			pr_warning("Too many symbols are listed. Skip it.\n");
			break;
2800
		}
2801
		ret++;
2802

2803 2804 2805 2806 2807 2808 2809 2810
		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;
2811 2812 2813

		/* Check the kprobe (not in module) is within .text  */
		if (!pev->uprobes && !pev->target &&
2814 2815 2816 2817
		    kprobe_warn_out_range(sym->name, tp->address)) {
			tp->symbol = NULL;	/* Skip it */
			skipped++;
		} else if (reloc_sym) {
2818 2819 2820 2821 2822 2823
			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;
		}
2824 2825
		tp->realname = strdup_or_goto(sym->name, nomem_out);

2826
		tp->retprobe = pp->retprobe;
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
		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;
			}
		}
2840 2841 2842 2843 2844 2845 2846
		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;
2847
		}
2848
		for (i = 0; i < tev->nargs; i++) {
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
			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);
2860
		}
2861
		arch__fix_tev_from_maps(pev, tev, map, sym);
2862
	}
2863 2864 2865 2866
	if (ret == skipped) {
		ret = -ENOENT;
		goto err_out;
	}
2867

2868
out:
2869
	put_target_map(map, pev->uprobes);
2870
	free(syms);
2871
	return ret;
2872

2873 2874 2875 2876 2877 2878 2879
nomem_out:
	ret = -ENOMEM;
err_out:
	clear_probe_trace_events(*tevs, num_matched_functions);
	zfree(tevs);
	goto out;
}
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 2965 2966 2967 2968 2969 2970 2971 2972
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;
}

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 3059 3060 3061 3062 3063 3064 3065 3066
/* 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;
}

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 3101 3102 3103 3104 3105 3106 3107 3108
/* 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;
}

3109 3110 3111 3112 3113 3114 3115 3116 3117
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;

3118
	if (pev->sdt) {
3119
		/* For SDT/cached events, we use special search functions */
3120 3121 3122 3123 3124
		if (!pev->target)
			return find_cached_events_all(pev, tevs);
		else
			return find_cached_events(pev, tevs, pev->target);
	}
3125 3126 3127 3128 3129 3130
	cache = probe_cache__new(pev->target);
	if (!cache)
		return 0;

	entry = probe_cache__find(cache, pev);
	if (!entry) {
3131 3132
		/* SDT must be in the cache */
		ret = pev->sdt ? -ENOENT : 0;
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 3158 3159 3160 3161 3162 3163 3164 3165
		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;
}

3166
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3167
					 struct probe_trace_event **tevs)
3168 3169 3170
{
	int ret;

3171
	if (!pev->group && !pev->sdt) {
3172 3173 3174 3175 3176 3177
		/* 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);
3178 3179 3180 3181
		if (ret != 0) {
			pr_warning("Failed to make a group name.\n");
			return ret;
		}
3182
	}
3183

3184 3185 3186 3187
	ret = try_to_find_absolute_address(pev, tevs);
	if (ret > 0)
		return ret;

3188 3189
	/* At first, we need to lookup cache entry */
	ret = find_probe_trace_events_from_cache(pev, tevs);
3190 3191
	if (ret > 0 || pev->sdt)	/* SDT can be found only in the cache */
		return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3192

3193
	/* Convert perf_probe_event with debuginfo */
3194
	ret = try_to_find_probe_trace_events(pev, tevs);
3195 3196 3197
	if (ret != 0)
		return ret;	/* Found in debuginfo or got an error */

3198
	return find_probe_trace_events_from_map(pev, tevs);
3199 3200
}

3201
int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3202
{
3203
	int i, ret;
3204 3205 3206

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
3207
		/* Init kprobe blacklist if needed */
3208
		if (!pevs[i].uprobes)
3209
			kprobe_blacklist__init();
3210
		/* Convert with or without debuginfo */
3211
		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3212
		if (ret < 0)
3213
			return ret;
3214
		pevs[i].ntevs = ret;
3215
	}
3216 3217
	/* This just release blacklist only if allocated */
	kprobe_blacklist__release();
3218

3219 3220 3221
	return 0;
}

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 3260 3261 3262 3263 3264 3265 3266 3267
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;
}

3268
int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3269 3270 3271
{
	int i, ret = 0;

3272
	/* Loop 2: add all events */
3273
	for (i = 0; i < npevs; i++) {
3274 3275
		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
					       pevs[i].ntevs,
3276
					       probe_conf.force_add);
3277 3278 3279
		if (ret < 0)
			break;
	}
3280 3281 3282
	return ret;
}

3283
void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3284 3285 3286
{
	int i, j;

3287 3288
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
3289 3290 3291 3292
		for (j = 0; j < pevs[i].ntevs; j++)
			clear_probe_trace_event(&pevs[i].tevs[j]);
		zfree(&pevs[i].tevs);
		pevs[i].ntevs = 0;
3293
		clear_perf_probe_event(&pevs[i]);
3294
	}
3295 3296 3297 3298 3299 3300
}

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

3301 3302 3303 3304
	ret = init_probe_symbol_maps(pevs->uprobes);
	if (ret < 0)
		return ret;

3305
	ret = convert_perf_probe_events(pevs, npevs);
3306
	if (ret == 0)
3307
		ret = apply_perf_probe_events(pevs, npevs);
3308

3309
	cleanup_perf_probe_events(pevs, npevs);
3310

3311
	exit_probe_symbol_maps();
3312
	return ret;
3313 3314
}

3315
int del_perf_probe_events(struct strfilter *filter)
3316
{
3317 3318 3319 3320 3321 3322
	int ret, ret2, ufd = -1, kfd = -1;
	char *str = strfilter__string(filter);

	if (!str)
		return -EINVAL;

3323
	/* Get current event names */
3324 3325 3326
	ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
	if (ret < 0)
		goto out;
3327

3328
	ret = probe_file__del_events(kfd, filter);
3329
	if (ret < 0 && ret != -ENOENT)
3330 3331
		goto error;

3332
	ret2 = probe_file__del_events(ufd, filter);
3333
	if (ret2 < 0 && ret2 != -ENOENT) {
3334
		ret = ret2;
3335 3336 3337
		goto error;
	}
	ret = 0;
3338 3339

error:
3340
	if (kfd >= 0)
3341
		close(kfd);
3342
	if (ufd >= 0)
3343
		close(ufd);
3344
out:
3345
	free(str);
3346 3347

	return ret;
3348
}
3349

3350 3351
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
3352
{
3353
        struct rb_node *nd;
3354 3355 3356
	struct map *map;
	int ret;

3357
	ret = init_probe_symbol_maps(user);
3358 3359 3360
	if (ret < 0)
		return ret;

3361 3362 3363 3364 3365
	/* Get a symbol map */
	if (user)
		map = dso__new_map(target);
	else
		map = kernel_get_module_map(target);
3366
	if (!map) {
3367
		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3368 3369
		return -EINVAL;
	}
3370

3371
	ret = map__load(map, NULL);
3372 3373 3374 3375 3376 3377 3378 3379 3380
	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");
3381 3382 3383 3384
		goto end;
	}
	if (!dso__sorted_by_name(map->dso, map->type))
		dso__sort_by_name(map->dso, map->type);
3385

3386 3387
	/* Show all (filtered) symbols */
	setup_pager();
3388 3389 3390 3391 3392 3393 3394 3395

        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);
        }

3396 3397
end:
	if (user) {
3398
		map__put(map);
3399
	}
3400
	exit_probe_symbol_maps();
3401

3402
	return ret;
3403 3404
}

3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423
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;
}