probe-event.c 68.6 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 char *synthesize_perf_probe_point(struct perf_probe_point *pp);
71
static struct machine *host_machine;
72

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

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

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

89 90 91 92 93 94 95 96
	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;
97
	}
98 99 100 101
out:
	if (ret < 0)
		pr_warning("Failed to init vmlinux path.\n");
	return ret;
102 103
}

104
void exit_probe_symbol_maps(void)
105 106 107 108 109 110 111 112
{
	if (host_machine) {
		machine__delete(host_machine);
		host_machine = NULL;
	}
	symbol__exit();
}

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

120 121 122 123 124 125 126 127 128
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;
129
	struct map *map = machine__kernel_map(host_machine);
130

131
	if (map__load(map, NULL) < 0)
132 133
		return NULL;

134
	kmap = map__kmap(map);
135 136
	if (!kmap)
		return NULL;
137 138 139
	return kmap->ref_reloc_sym;
}

140 141
static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
					     bool reloc, bool reladdr)
142 143 144 145 146 147 148 149
{
	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)
150
		*addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
151 152
	else {
		sym = __find_kernel_function_by_name(name, &map);
153 154 155 156 157
		if (!sym)
			return -ENOENT;
		*addr = map->unmap_ip(map, sym->start) -
			((reloc) ? 0 : map->reloc) -
			((reladdr) ? map->start : 0);
158 159 160 161
	}
	return 0;
}

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

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

172 173 174
	if (!module)
		module = "kernel";

175
	for (pos = maps__first(maps); pos; pos = map__next(pos)) {
176 177 178 179 180 181 182 183
		if (strncmp(pos->dso->short_name + 1, module,
			    pos->dso->short_name_len - 2) == 0) {
			return pos;
		}
	}
	return NULL;
}

184 185 186 187 188 189 190 191 192 193 194 195 196
static struct map *get_target_map(const char *target, bool user)
{
	/* 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 */
197
		map__put(map);
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 232
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;
}

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

240 241 242 243 244 245 246 247
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);
}

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

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

258
	if (ret == 0 && etext_addr < address)
259 260 261 262 263 264 265 266 267
		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;
}

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 326
/*
 * 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;
}

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

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) {
337 338 339 340 341 342 343
		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;
344 345 346 347 348
		}
		pr_debug("Failed to find module %s.\n", module);
		return -ENOENT;
	}

349
	map = machine__kernel_map(host_machine);
350 351 352 353 354 355 356 357 358 359 360 361 362
	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;
}

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
/*
 * 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) {
388 389 390 391
		if (uprobes)
			address = sym->start;
		else
			address = map->unmap_ip(map, sym->start);
392
		break;
393 394 395 396 397
	}
	if (!address) {
		ret = -ENOENT;
		goto out;
	}
W
Wang Nan 已提交
398 399
	pr_debug("Symbol %s address found : %" PRIx64 "\n",
			pp->function, address);
400 401 402 403 404 405 406 407

	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;
408
		result->retprobe = pp->retprobe;
409 410 411 412 413 414 415 416 417 418 419
		ret = 0;
	}

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

}

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

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

	return ret;
}
433

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

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

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
	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;
}

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

470
	if (!module || !strchr(module, '/')) {
471 472 473 474 475 476 477
		err = kernel_get_module_dso(module, &dso);
		if (err < 0) {
			if (!dso || dso->load_errno == 0) {
				if (!strerror_r(-err, reason, STRERR_BUFSIZE))
					strcpy(reason, "(unknown)");
			} else
				dso__strerror_load(dso, reason, STRERR_BUFSIZE);
478
			if (!silent)
479 480
				pr_err("Failed to find the path for %s: %s\n",
					module ?: "kernel", reason);
481 482
			return NULL;
		}
483
		path = dso->long_name;
484
	}
485 486 487 488 489 490 491 492 493 494
	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;
495
}
496

497 498 499 500 501 502
/* 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)
{
503 504 505 506 507 508 509
	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))
510 511 512 513
		goto out;

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

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

535

536 537 538 539 540 541 542 543 544 545 546 547
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);
548 549 550 551
	if (elf == NULL) {
		ret = -EINVAL;
		goto out_close;
	}
552 553 554 555 556 557 558 559 560 561 562

	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);
563 564 565
out_close:
	close(fd);

566 567 568
	return ret;
}

569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
/*
 * 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;
591
	} else if (tp->symbol) {
592 593 594 595
		/* 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)
596 597 598 599 600 601 602
			goto error;
		addr += tp->offset;
	}

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

603 604
	dinfo = debuginfo_cache__open(tp->module, verbose == 0);
	if (dinfo)
605 606
		ret = debuginfo__find_probe_point(dinfo,
						 (unsigned long)addr, pp);
607
	else
608 609 610 611 612 613 614 615 616 617 618
		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;
}

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

	if (!exec)
		return 0;

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

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

	return ret;
}

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

	if (!module)
		return 0;

655
	mod_name = find_module_name(module);
656

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

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

670 671 672 673 674 675 676
/* Post processing the probe events */
static int post_process_probe_trace_events(struct probe_trace_event *tevs,
					   int ntevs, const char *module,
					   bool uprobe)
{
	struct ref_reloc_sym *reloc_sym;
	char *tmp;
677
	int i, skipped = 0;
678 679 680 681 682 683 684 685

	if (uprobe)
		return add_exec_to_probe_trace_events(tevs, ntevs, module);

	/* Note that currently ref_reloc_sym based probe is not for drivers */
	if (module)
		return add_module_to_probe_trace_events(tevs, ntevs, module);

686
	reloc_sym = kernel_get_ref_reloc_sym();
687 688 689 690 691 692
	if (!reloc_sym) {
		pr_warning("Relocated base symbol is not found!\n");
		return -EINVAL;
	}

	for (i = 0; i < ntevs; i++) {
693 694 695 696 697 698 699 700 701 702 703
		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;
704
		}
705 706 707 708 709 710 711 712
		/* 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;
713
	}
714
	return skipped;
715 716
}

717
/* Try to find perf_probe_event with debuginfo */
718
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
719
					  struct probe_trace_event **tevs)
720 721
{
	bool need_dwarf = perf_probe_event_need_dwarf(pev);
722
	struct perf_probe_point tmp;
723
	struct debuginfo *dinfo;
724
	int ntevs, ret = 0;
725

726
	dinfo = open_debuginfo(pev->target, !need_dwarf);
727
	if (!dinfo) {
728
		if (need_dwarf)
729 730
			return -ENOENT;
		pr_debug("Could not open debuginfo. Try to use symbols.\n");
731 732 733
		return 0;
	}

734
	pr_debug("Try to find probe point from debuginfo.\n");
735
	/* Searching trace events corresponding to a probe event */
736
	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
737

738
	if (ntevs == 0)	{  /* Not found, retry with an alternative */
739
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
740
		if (!ret) {
741
			ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
742 743 744 745 746 747 748 749 750
			/*
			 * 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));
		}
	}

751
	debuginfo__delete(dinfo);
752

753
	if (ntevs > 0) {	/* Succeeded to find trace events */
754 755
		pr_debug("Found %d probe_trace_events.\n", ntevs);
		ret = post_process_probe_trace_events(*tevs, ntevs,
756
						pev->target, pev->uprobes);
757
		if (ret < 0 || ret == ntevs) {
758 759 760
			clear_probe_trace_events(*tevs, ntevs);
			zfree(tevs);
		}
761 762 763 764
		if (ret != ntevs)
			return ret < 0 ? ret : ntevs;
		ntevs = 0;
		/* Fall through */
765
	}
766

767
	if (ntevs == 0)	{	/* No error but failed to find probe point. */
768
		pr_warning("Probe point '%s' not found.\n",
769
			   synthesize_perf_probe_point(&pev->point));
770
		return -ENOENT;
771 772
	}
	/* Error path : ntevs < 0 */
773
	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
774 775 776 777
	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");
778
		if (!need_dwarf) {
M
Masami Hiramatsu 已提交
779
			pr_debug("Trying to use symbols.\n");
780 781
			return 0;
		}
782
	}
783
	return ntevs;
784 785 786 787 788
}

#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

789
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
790
{
791
	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
792 793
	const char *color = show_num ? "" : PERF_COLOR_BLUE;
	const char *prefix = NULL;
794

795
	do {
796 797
		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
			goto error;
798 799 800 801 802
		if (skip)
			continue;
		if (!prefix) {
			prefix = show_num ? "%7d  " : "         ";
			color_fprintf(stdout, color, prefix, l);
803
		}
804 805 806
		color_fprintf(stdout, color, "%s", buf);

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

808
	return 1;
809
error:
810
	if (ferror(fp)) {
811 812
		pr_warning("File read error: %s\n",
			   strerror_r(errno, sbuf, sizeof(sbuf)));
813 814 815 816
		return -1;
	}
	return 0;
}
817

818 819 820 821 822 823 824 825
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;
826 827
}

828 829 830 831 832
#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)

833 834 835 836
/*
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
837 838
static int __show_line_range(struct line_range *lr, const char *module,
			     bool user)
839
{
840
	int l = 1;
841
	struct int_node *ln;
842
	struct debuginfo *dinfo;
843
	FILE *fp;
844
	int ret;
845
	char *tmp;
846
	char sbuf[STRERR_BUFSIZE];
847 848

	/* Search a line range */
849 850
	dinfo = open_debuginfo(module, false);
	if (!dinfo)
851
		return -ENOENT;
852

853
	ret = debuginfo__find_line_range(dinfo, lr);
854 855 856 857 858
	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);
	}
859
	debuginfo__delete(dinfo);
860
	if (ret == 0 || ret == -ENOENT) {
861 862 863
		pr_warning("Specified source line is not found.\n");
		return -ENOENT;
	} else if (ret < 0) {
864
		pr_warning("Debuginfo analysis failed.\n");
865 866
		return ret;
	}
867

868 869
	/* Convert source file path */
	tmp = lr->path;
870
	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
871 872 873 874 875

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

876
	if (ret < 0) {
877
		pr_warning("Failed to find source file path.\n");
878 879 880
		return ret;
	}

881 882 883
	setup_pager();

	if (lr->function)
884
		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
885 886
			lr->start - lr->offset);
	else
887
		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
888 889

	fp = fopen(lr->path, "r");
890 891
	if (fp == NULL) {
		pr_warning("Failed to open %s: %s\n", lr->path,
892
			   strerror_r(errno, sbuf, sizeof(sbuf)));
893 894
		return -errno;
	}
895
	/* Skip to starting line number */
896
	while (l < lr->start) {
897
		ret = skip_one_line(fp, l++);
898 899 900
		if (ret < 0)
			goto end;
	}
901

902 903
	intlist__for_each(ln, lr->line_list) {
		for (; ln->i > l; l++) {
904
			ret = show_one_line(fp, l - lr->offset);
905 906 907
			if (ret < 0)
				goto end;
		}
908
		ret = show_one_line_with_num(fp, l++ - lr->offset);
909 910
		if (ret < 0)
			goto end;
911 912 913 914
	}

	if (lr->end == INT_MAX)
		lr->end = l + NR_ADDITIONAL_LINES;
915 916 917
	while (l <= lr->end) {
		ret = show_one_line_or_eof(fp, l++ - lr->offset);
		if (ret <= 0)
918 919
			break;
	}
920
end:
921
	fclose(fp);
922
	return ret;
923 924
}

925
int show_line_range(struct line_range *lr, const char *module, bool user)
926 927 928
{
	int ret;

929
	ret = init_probe_symbol_maps(user);
930 931
	if (ret < 0)
		return ret;
932
	ret = __show_line_range(lr, module, user);
933
	exit_probe_symbol_maps();
934 935 936 937

	return ret;
}

938 939
static int show_available_vars_at(struct debuginfo *dinfo,
				  struct perf_probe_event *pev,
940
				  struct strfilter *_filter)
941 942
{
	char *buf;
943
	int ret, i, nvars;
944 945
	struct str_node *node;
	struct variable_list *vls = NULL, *vl;
946
	struct perf_probe_point tmp;
947
	const char *var;
948 949 950 951 952 953

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

954
	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
955
	if (!ret) {  /* Not found, retry with an alternative */
956
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
957 958
		if (!ret) {
			ret = debuginfo__find_available_vars_at(dinfo, pev,
959
								&vls);
960 961 962 963
			/* Release the old probe_point */
			clear_perf_probe_point(&tmp);
		}
	}
964
	if (ret <= 0) {
965 966 967 968 969
		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");
970 971
		goto end;
	}
972

973 974 975 976 977 978 979 980 981 982
	/* 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);
983
		zfree(&vl->point.symbol);
984 985 986 987 988
		nvars = 0;
		if (vl->vars) {
			strlist__for_each(node, vl->vars) {
				var = strchr(node->s, '\t') + 1;
				if (strfilter__compare(_filter, var)) {
989
					fprintf(stdout, "\t\t%s\n", node->s);
990 991 992 993
					nvars++;
				}
			}
			strlist__delete(vl->vars);
994
		}
995 996 997 998 999
		if (nvars == 0)
			fprintf(stdout, "\t\t(No matched variables)\n");
	}
	free(vls);
end:
1000 1001 1002 1003 1004 1005
	free(buf);
	return ret;
}

/* Show available variables on given probe point */
int show_available_vars(struct perf_probe_event *pevs, int npevs,
1006
			struct strfilter *_filter)
1007
{
1008 1009
	int i, ret = 0;
	struct debuginfo *dinfo;
1010

1011
	ret = init_probe_symbol_maps(pevs->uprobes);
1012 1013 1014
	if (ret < 0)
		return ret;

1015
	dinfo = open_debuginfo(pevs->target, false);
1016
	if (!dinfo) {
1017 1018
		ret = -ENOENT;
		goto out;
1019 1020
	}

1021 1022
	setup_pager();

1023
	for (i = 0; i < npevs && ret >= 0; i++)
1024
		ret = show_available_vars_at(dinfo, &pevs[i], _filter);
1025 1026

	debuginfo__delete(dinfo);
1027
out:
1028
	exit_probe_symbol_maps();
1029 1030 1031
	return ret;
}

1032
#else	/* !HAVE_DWARF_SUPPORT */
1033

1034 1035 1036 1037
static void debuginfo_cache__exit(void)
{
}

1038 1039 1040 1041
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)
1042
{
1043
	return -ENOSYS;
1044 1045
}

1046
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
1047
				struct probe_trace_event **tevs __maybe_unused)
1048
{
1049 1050 1051 1052
	if (perf_probe_event_need_dwarf(pev)) {
		pr_warning("Debuginfo-analysis is not supported.\n");
		return -ENOSYS;
	}
1053

1054 1055 1056
	return 0;
}

1057
int show_line_range(struct line_range *lr __maybe_unused,
1058 1059
		    const char *module __maybe_unused,
		    bool user __maybe_unused)
1060
{
1061 1062
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
1063 1064
}

1065
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1066 1067
			int npevs __maybe_unused,
			struct strfilter *filter __maybe_unused)
1068 1069 1070 1071
{
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
}
1072 1073
#endif

1074 1075 1076 1077 1078 1079
void line_range__clear(struct line_range *lr)
{
	free(lr->function);
	free(lr->file);
	free(lr->path);
	free(lr->comp_dir);
1080
	intlist__delete(lr->line_list);
1081 1082 1083
	memset(lr, 0, sizeof(*lr));
}

1084
int line_range__init(struct line_range *lr)
1085 1086
{
	memset(lr, 0, sizeof(*lr));
1087 1088 1089 1090 1091
	lr->line_list = intlist__new(NULL);
	if (!lr->line_list)
		return -ENOMEM;
	else
		return 0;
1092 1093
}

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
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;
}

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
/* 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;
}

1119 1120 1121 1122 1123
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
1124
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
1125
 */
1126
int parse_line_range_desc(const char *arg, struct line_range *lr)
1127
{
1128
	char *range, *file, *name = strdup(arg);
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	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--;
			}
		}
1163

1164
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1165 1166

		err = -EINVAL;
1167
		if (lr->start > lr->end) {
1168
			semantic_error("Start line must be smaller"
1169
				       " than end line.\n");
1170
			goto err;
1171
		}
1172 1173 1174
		if (*range != '\0') {
			semantic_error("Tailing with invalid str '%s'.\n", range);
			goto err;
1175
		}
1176
	}
1177

1178 1179 1180 1181 1182 1183 1184 1185 1186
	file = strchr(name, '@');
	if (file) {
		*file = '\0';
		lr->file = strdup(++file);
		if (lr->file == NULL) {
			err = -ENOMEM;
			goto err;
		}
		lr->function = name;
1187
	} else if (strchr(name, '/') || strchr(name, '.'))
1188
		lr->file = name;
1189
	else if (is_c_func_name(name))/* We reuse it for checking funcname */
1190
		lr->function = name;
1191 1192 1193 1194 1195
	else {	/* Invalid name */
		semantic_error("'%s' is not a valid function name.\n", name);
		err = -EINVAL;
		goto err;
	}
1196 1197

	return 0;
1198 1199 1200
err:
	free(name);
	return err;
1201 1202
}

1203
/* Parse probepoint definition. */
1204
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1205
{
1206
	struct perf_probe_point *pp = &pev->point;
1207 1208
	char *ptr, *tmp;
	char c, nc = 0;
1209
	bool file_spec = false;
1210 1211
	/*
	 * <Syntax>
1212 1213
	 * perf probe [EVENT=]SRC[:LN|;PTN]
	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1214 1215
	 *
	 * TODO:Group name support
1216
	 */
1217 1218
	if (!arg)
		return -EINVAL;
1219

1220 1221
	ptr = strpbrk(arg, ";=@+%");
	if (ptr && *ptr == '=') {	/* Event name */
1222 1223
		*ptr = '\0';
		tmp = ptr + 1;
1224 1225 1226 1227
		if (strchr(arg, ':')) {
			semantic_error("Group name is not supported yet.\n");
			return -ENOTSUP;
		}
1228
		if (!is_c_func_name(arg)) {
1229
			semantic_error("%s is bad for event name -it must "
1230 1231 1232
				       "follow C symbol-naming rule.\n", arg);
			return -EINVAL;
		}
1233 1234 1235
		pev->event = strdup(arg);
		if (pev->event == NULL)
			return -ENOMEM;
1236
		pev->group = NULL;
1237 1238 1239
		arg = tmp;
	}

1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
	/*
	 * 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;
	}

1257
	ptr = strpbrk(arg, ";:+@%");
1258 1259 1260 1261 1262
	if (ptr) {
		nc = *ptr;
		*ptr++ = '\0';
	}

1263 1264 1265 1266 1267 1268 1269
	if (arg[0] == '\0')
		tmp = NULL;
	else {
		tmp = strdup(arg);
		if (tmp == NULL)
			return -ENOMEM;
	}
1270

1271
	if (file_spec)
1272
		pp->file = tmp;
1273
	else {
1274
		pp->function = tmp;
1275

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
		/*
		 * 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;
			}
		}
	}

1294 1295 1296 1297
	/* Parse other options */
	while (ptr) {
		arg = ptr;
		c = nc;
1298
		if (c == ';') {	/* Lazy pattern must be the last part */
1299 1300 1301
			pp->lazy_line = strdup(arg);
			if (pp->lazy_line == NULL)
				return -ENOMEM;
1302 1303 1304
			break;
		}
		ptr = strpbrk(arg, ";:+@%");
1305 1306 1307 1308 1309 1310 1311
		if (ptr) {
			nc = *ptr;
			*ptr++ = '\0';
		}
		switch (c) {
		case ':':	/* Line number */
			pp->line = strtoul(arg, &tmp, 0);
1312
			if (*tmp != '\0') {
1313
				semantic_error("There is non-digit char"
1314 1315 1316
					       " in line number.\n");
				return -EINVAL;
			}
1317 1318 1319
			break;
		case '+':	/* Byte offset from a symbol */
			pp->offset = strtoul(arg, &tmp, 0);
1320
			if (*tmp != '\0') {
1321
				semantic_error("There is non-digit character"
1322 1323 1324
						" in offset.\n");
				return -EINVAL;
			}
1325 1326
			break;
		case '@':	/* File name */
1327 1328 1329 1330
			if (pp->file) {
				semantic_error("SRC@SRC is not allowed.\n");
				return -EINVAL;
			}
1331 1332 1333
			pp->file = strdup(arg);
			if (pp->file == NULL)
				return -ENOMEM;
1334 1335 1336 1337
			break;
		case '%':	/* Probe places */
			if (strcmp(arg, "return") == 0) {
				pp->retprobe = 1;
1338 1339 1340 1341
			} else {	/* Others not supported yet */
				semantic_error("%%%s is not supported.\n", arg);
				return -ENOTSUP;
			}
1342
			break;
1343 1344 1345 1346
		default:	/* Buggy case */
			pr_err("This program has a bug at %s:%d.\n",
				__FILE__, __LINE__);
			return -ENOTSUP;
1347 1348 1349 1350 1351
			break;
		}
	}

	/* Exclusion check */
1352
	if (pp->lazy_line && pp->line) {
M
Masami Hiramatsu 已提交
1353 1354
		semantic_error("Lazy pattern can't be used with"
			       " line number.\n");
1355 1356
		return -EINVAL;
	}
1357

1358
	if (pp->lazy_line && pp->offset) {
M
Masami Hiramatsu 已提交
1359
		semantic_error("Lazy pattern can't be used with offset.\n");
1360 1361
		return -EINVAL;
	}
1362

1363
	if (pp->line && pp->offset) {
M
Masami Hiramatsu 已提交
1364
		semantic_error("Offset can't be used with line number.\n");
1365 1366
		return -EINVAL;
	}
1367

1368
	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1369
		semantic_error("File always requires line number or "
M
Masami Hiramatsu 已提交
1370
			       "lazy pattern.\n");
1371 1372
		return -EINVAL;
	}
1373

1374
	if (pp->offset && !pp->function) {
M
Masami Hiramatsu 已提交
1375
		semantic_error("Offset requires an entry function.\n");
1376 1377
		return -EINVAL;
	}
1378

1379
	if (pp->retprobe && !pp->function) {
M
Masami Hiramatsu 已提交
1380
		semantic_error("Return probe requires an entry function.\n");
1381 1382
		return -EINVAL;
	}
1383

1384
	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1385
		semantic_error("Offset/Line/Lazy pattern can't be used with "
M
Masami Hiramatsu 已提交
1386
			       "return probe.\n");
1387 1388
		return -EINVAL;
	}
1389

1390
	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1391 1392
		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
		 pp->lazy_line);
1393
	return 0;
1394 1395
}

1396
/* Parse perf-probe event argument */
1397
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1398
{
1399
	char *tmp, *goodname;
1400 1401 1402 1403
	struct perf_probe_arg_field **fieldp;

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

1404 1405
	tmp = strchr(str, '=');
	if (tmp) {
1406 1407 1408
		arg->name = strndup(str, tmp - str);
		if (arg->name == NULL)
			return -ENOMEM;
1409
		pr_debug("name:%s ", arg->name);
1410 1411 1412
		str = tmp + 1;
	}

1413 1414 1415
	tmp = strchr(str, ':');
	if (tmp) {	/* Type setting */
		*tmp = '\0';
1416 1417 1418
		arg->type = strdup(tmp + 1);
		if (arg->type == NULL)
			return -ENOMEM;
1419 1420 1421
		pr_debug("type:%s ", arg->type);
	}

1422
	tmp = strpbrk(str, "-.[");
1423 1424
	if (!is_c_varname(str) || !tmp) {
		/* A variable, register, symbol or special value */
1425 1426 1427
		arg->var = strdup(str);
		if (arg->var == NULL)
			return -ENOMEM;
1428
		pr_debug("%s\n", arg->var);
1429
		return 0;
1430 1431
	}

1432
	/* Structure fields or array element */
1433 1434 1435
	arg->var = strndup(str, tmp - str);
	if (arg->var == NULL)
		return -ENOMEM;
1436
	goodname = arg->var;
1437
	pr_debug("%s, ", arg->var);
1438 1439 1440
	fieldp = &arg->field;

	do {
1441 1442 1443
		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
		if (*fieldp == NULL)
			return -ENOMEM;
1444 1445 1446
		if (*tmp == '[') {	/* Array */
			str = tmp;
			(*fieldp)->index = strtol(str + 1, &tmp, 0);
1447
			(*fieldp)->ref = true;
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
			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, "-.[");
1469
		}
1470
		if (tmp) {
1471 1472 1473
			(*fieldp)->name = strndup(str, tmp - str);
			if ((*fieldp)->name == NULL)
				return -ENOMEM;
1474 1475
			if (*str != '[')
				goodname = (*fieldp)->name;
1476 1477 1478 1479
			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
			fieldp = &(*fieldp)->next;
		}
	} while (tmp);
1480 1481 1482
	(*fieldp)->name = strdup(str);
	if ((*fieldp)->name == NULL)
		return -ENOMEM;
1483 1484
	if (*str != '[')
		goodname = (*fieldp)->name;
1485
	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1486

1487
	/* If no name is specified, set the last field name (not array index)*/
1488
	if (!arg->name) {
1489
		arg->name = strdup(goodname);
1490 1491 1492
		if (arg->name == NULL)
			return -ENOMEM;
	}
1493
	return 0;
1494 1495
}

1496
/* Parse perf-probe event command */
1497
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1498
{
1499
	char **argv;
1500
	int argc, i, ret = 0;
1501

1502
	argv = argv_split(cmd, &argc);
1503 1504 1505 1506 1507 1508 1509 1510 1511
	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;
	}
1512
	/* Parse probe point */
1513 1514 1515
	ret = parse_perf_probe_point(argv[0], pev);
	if (ret < 0)
		goto out;
1516

1517
	/* Copy arguments and ensure return probe has no C argument */
1518
	pev->nargs = argc - 1;
1519 1520 1521 1522 1523
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1524 1525 1526 1527
	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) {
1528
			semantic_error("You can't specify local variable for"
1529 1530 1531
				       " kretprobe.\n");
			ret = -EINVAL;
		}
1532
	}
1533
out:
1534
	argv_free(argv);
1535 1536

	return ret;
1537 1538
}

1539 1540 1541 1542 1543 1544 1545 1546 1547
/* Return true if this perf_probe_event requires debuginfo */
bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
{
	int i;

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

	for (i = 0; i < pev->nargs; i++)
1548
		if (is_c_varname(pev->args[i].var))
1549 1550 1551 1552 1553
			return true;

	return false;
}

1554
/* Parse probe_events event into struct probe_point */
1555
int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1556
{
1557
	struct probe_trace_point *tp = &tev->point;
1558 1559
	char pr;
	char *p;
1560
	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1561 1562 1563
	int ret, i, argc;
	char **argv;

1564
	pr_debug("Parsing probe_events: %s\n", cmd);
1565
	argv = argv_split(cmd, &argc);
1566 1567 1568 1569 1570 1571 1572 1573 1574
	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;
	}
1575 1576

	/* Scan event and group name. */
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
	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) {
1587 1588 1589 1590
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1591 1592 1593 1594 1595 1596 1597
	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;
	}
1598
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1599

1600
	tp->retprobe = (pr == 'r');
1601

1602 1603 1604 1605
	/* Scan module name(if there), function name and offset */
	p = strchr(argv[1], ':');
	if (p) {
		tp->module = strndup(argv[1], p - argv[1]);
1606 1607 1608 1609
		if (!tp->module) {
			ret = -ENOMEM;
			goto out;
		}
1610 1611 1612
		p++;
	} else
		p = argv[1];
1613
	fmt1_str = strtok_r(p, "+", &fmt);
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
	/* 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 {
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
		/* 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);
1650
	}
1651

1652
	tev->nargs = argc - 2;
1653
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1654 1655 1656 1657
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1658
	for (i = 0; i < tev->nargs; i++) {
1659 1660
		p = strchr(argv[i + 2], '=');
		if (p)	/* We don't need which register is assigned. */
1661 1662 1663
			*p++ = '\0';
		else
			p = argv[i + 2];
1664
		tev->args[i].name = strdup(argv[i + 2]);
1665
		/* TODO: parse regs and offset */
1666 1667 1668 1669 1670
		tev->args[i].value = strdup(p);
		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
			ret = -ENOMEM;
			goto out;
		}
1671
	}
1672 1673
	ret = 0;
out:
1674
	free(argv0_str);
1675
	argv_free(argv);
1676
	return ret;
1677 1678
}

1679
/* Compose only probe arg */
1680
char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1681 1682
{
	struct perf_probe_arg_field *field = pa->field;
1683
	struct strbuf buf;
1684 1685 1686 1687 1688
	char *ret = NULL;
	int err;

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

1690
	if (pa->name && pa->var)
1691
		err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1692
	else
1693 1694 1695
		err = strbuf_addstr(&buf, pa->name ?: pa->var);
	if (err)
		goto out;
1696 1697

	while (field) {
1698
		if (field->name[0] == '[')
1699
			err = strbuf_addstr(&buf, field->name);
1700
		else
1701 1702
			err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
					  field->name);
1703
		field = field->next;
1704 1705
		if (err)
			goto out;
1706
	}
1707

1708
	if (pa->type)
1709 1710
		if (strbuf_addf(&buf, ":%s", pa->type) < 0)
			goto out;
1711 1712

	ret = strbuf_detach(&buf, NULL);
1713 1714
out:
	strbuf_release(&buf);
1715
	return ret;
1716 1717
}

1718 1719
/* Compose only probe point (not argument) */
static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1720
{
1721
	struct strbuf buf;
1722 1723 1724 1725 1726
	char *tmp, *ret = NULL;
	int len, err = 0;

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

	if (pp->function) {
1729 1730
		if (strbuf_addstr(&buf, pp->function) < 0)
			goto out;
1731
		if (pp->offset)
1732
			err = strbuf_addf(&buf, "+%lu", pp->offset);
1733
		else if (pp->line)
1734
			err = strbuf_addf(&buf, ":%d", pp->line);
1735
		else if (pp->retprobe)
1736 1737 1738
			err = strbuf_addstr(&buf, "%return");
		if (err)
			goto out;
1739 1740
	}
	if (pp->file) {
1741 1742 1743 1744 1745 1746
		tmp = pp->file;
		len = strlen(tmp);
		if (len > 30) {
			tmp = strchr(pp->file + len - 30, '/');
			tmp = tmp ? tmp + 1 : pp->file + len - 30;
		}
1747 1748 1749
		err = strbuf_addf(&buf, "@%s", tmp);
		if (!err && !pp->function && pp->line)
			err = strbuf_addf(&buf, ":%d", pp->line);
1750
	}
1751 1752 1753 1754 1755
	if (!err)
		ret = strbuf_detach(&buf, NULL);
out:
	strbuf_release(&buf);
	return ret;
1756 1757
}

1758 1759
#if 0
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1760 1761 1762 1763
{
	char *buf;
	int i, len, ret;

1764 1765 1766
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return NULL;
1767

1768 1769
	len = strlen(buf);
	for (i = 0; i < pev->nargs; i++) {
1770
		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1771 1772 1773 1774 1775
				 pev->args[i].name);
		if (ret <= 0) {
			free(buf);
			return NULL;
		}
1776 1777 1778
		len += ret;
	}

1779 1780 1781 1782
	return buf;
}
#endif

1783
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1784
					    struct strbuf *buf, int depth)
1785
{
1786
	int err;
1787
	if (ref->next) {
1788
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1789
							 depth + 1);
1790
		if (depth < 0)
1791
			return depth;
1792
	}
1793 1794
	err = strbuf_addf(buf, "%+ld(", ref->offset);
	return (err < 0) ? err : depth;
1795 1796
}

1797
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1798
				      struct strbuf *buf)
1799
{
1800
	struct probe_trace_arg_ref *ref = arg->ref;
1801
	int depth = 0, err;
1802 1803 1804

	/* Argument name or separator */
	if (arg->name)
1805
		err = strbuf_addf(buf, " %s=", arg->name);
1806
	else
1807 1808 1809
		err = strbuf_addch(buf, ' ');
	if (err)
		return err;
1810

1811 1812 1813 1814
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1815
	/* Dereferencing arguments */
1816
	if (ref) {
1817
		depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
1818 1819 1820 1821 1822
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1823
	if (arg->value[0] == '@' && arg->ref)
1824
		err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
1825
	else
1826
		err = strbuf_addstr(buf, arg->value);
1827 1828

	/* Closing */
1829 1830 1831
	while (!err && depth--)
		err = strbuf_addch(buf, ')');

1832
	/* Print argument type */
1833 1834
	if (!err && arg->type)
		err = strbuf_addf(buf, ":%s", arg->type);
1835

1836
	return err;
1837 1838
}

1839
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1840
{
1841
	struct probe_trace_point *tp = &tev->point;
1842 1843
	struct strbuf buf;
	char *ret = NULL;
1844
	int i, err;
1845

1846 1847
	/* Uprobes must have tp->module */
	if (tev->uprobes && !tp->module)
1848 1849
		return NULL;

1850 1851 1852 1853 1854 1855
	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;
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
	/*
	 * 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;
	}
1866 1867

	/* Use the tp->address for uprobes */
1868
	if (tev->uprobes)
1869
		err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address);
1870 1871
	else if (!strncmp(tp->symbol, "0x", 2))
		/* Absolute address. See try_to_find_absolute_address() */
1872 1873
		err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
				  tp->module ? ":" : "", tp->address);
1874
	else
1875 1876 1877 1878
		err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
				tp->module ? ":" : "", tp->symbol, tp->offset);
	if (err)
		goto error;
1879

1880 1881
	for (i = 0; i < tev->nargs; i++)
		if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
1882 1883
			goto error;

1884
	ret = strbuf_detach(&buf, NULL);
1885
error:
1886 1887
	strbuf_release(&buf);
	return ret;
1888
}
1889

1890 1891 1892 1893 1894 1895
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;
1896
	u64 addr = tp->address;
1897 1898 1899 1900 1901 1902 1903 1904
	int ret = -ENOENT;

	if (!is_kprobe) {
		map = dso__new_map(tp->module);
		if (!map)
			goto out;
		sym = map__find_symbol(map, addr, NULL);
	} else {
1905
		if (tp->symbol && !addr) {
1906 1907
			if (kernel_get_symbol_address_by_name(tp->symbol,
						&addr, true, false) < 0)
1908 1909
				goto out;
		}
1910 1911 1912 1913 1914
		if (addr) {
			addr += tp->offset;
			sym = __find_kernel_function(addr, &map);
		}
	}
1915

1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
	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) {
1926
		map__put(map);
1927 1928 1929 1930 1931 1932
	}

	return ret;
}

static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1933 1934
				       struct perf_probe_point *pp,
				       bool is_kprobe)
1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
{
	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;
1951
	} else {
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
		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;
}

1966
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1967
			       struct perf_probe_event *pev, bool is_kprobe)
1968
{
1969
	struct strbuf buf = STRBUF_INIT;
1970
	int i, ret;
1971

1972
	/* Convert event/group name */
1973 1974 1975 1976
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
1977

1978
	/* Convert trace_point to probe_point */
1979
	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1980 1981
	if (ret < 0)
		return ret;
1982

1983 1984
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
1985 1986 1987
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
1988
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
1989
		if (tev->args[i].name)
1990
			pev->args[i].name = strdup(tev->args[i].name);
1991
		else {
1992 1993
			if ((ret = strbuf_init(&buf, 32)) < 0)
				goto error;
1994 1995
			ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
			pev->args[i].name = strbuf_detach(&buf, NULL);
1996
		}
1997 1998 1999
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
2000
error:
2001 2002 2003 2004
	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
2005 2006 2007 2008
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
2009
	struct perf_probe_arg_field *field, *next;
2010 2011
	int i;

2012 2013
	free(pev->event);
	free(pev->group);
2014
	free(pev->target);
2015
	clear_perf_probe_point(&pev->point);
2016

2017
	for (i = 0; i < pev->nargs; i++) {
2018 2019 2020
		free(pev->args[i].name);
		free(pev->args[i].var);
		free(pev->args[i].type);
2021 2022 2023
		field = pev->args[i].field;
		while (field) {
			next = field->next;
2024
			zfree(&field->name);
2025 2026 2027 2028
			free(field);
			field = next;
		}
	}
2029
	free(pev->args);
2030 2031 2032
	memset(pev, 0, sizeof(*pev));
}

2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105
#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;
}

2106
void clear_probe_trace_event(struct probe_trace_event *tev)
2107
{
2108
	struct probe_trace_arg_ref *ref, *next;
2109 2110
	int i;

2111 2112 2113
	free(tev->event);
	free(tev->group);
	free(tev->point.symbol);
2114
	free(tev->point.realname);
2115
	free(tev->point.module);
2116
	for (i = 0; i < tev->nargs; i++) {
2117 2118 2119
		free(tev->args[i].name);
		free(tev->args[i].value);
		free(tev->args[i].type);
2120 2121 2122 2123 2124 2125 2126
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
2127
	free(tev->args);
2128
	memset(tev, 0, sizeof(*tev));
2129 2130
}

2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
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;
2154
	const char *__debugfs = debugfs__mountpoint();
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 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
	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;
}

2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
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);
}

2241 2242
static int perf_probe_event__sprintf(const char *group, const char *event,
				     struct perf_probe_event *pev,
2243 2244
				     const char *module,
				     struct strbuf *result)
2245
{
2246
	int i, ret;
2247
	char *buf;
2248

2249 2250
	if (asprintf(&buf, "%s:%s", group, event) < 0)
		return -errno;
2251
	ret = strbuf_addf(result, "  %-20s (on ", buf);
2252
	free(buf);
2253 2254
	if (ret)
		return ret;
2255

2256 2257 2258 2259
	/* Synthesize only event probe point */
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return -ENOMEM;
2260
	ret = strbuf_addstr(result, buf);
2261
	free(buf);
2262

2263 2264
	if (!ret && module)
		ret = strbuf_addf(result, " in %s", module);
2265

2266 2267 2268
	if (!ret && pev->nargs > 0) {
		ret = strbuf_add(result, " with", 5);
		for (i = 0; !ret && i < pev->nargs; i++) {
2269 2270 2271
			buf = synthesize_perf_probe_arg(&pev->args[i]);
			if (!buf)
				return -ENOMEM;
2272
			ret = strbuf_addf(result, " %s", buf);
2273
			free(buf);
2274
		}
2275
	}
2276 2277
	if (!ret)
		ret = strbuf_addch(result, ')');
2278

2279
	return ret;
2280 2281
}

2282
/* Show an event */
2283 2284 2285
int show_perf_probe_event(const char *group, const char *event,
			  struct perf_probe_event *pev,
			  const char *module, bool use_stdout)
2286 2287 2288 2289
{
	struct strbuf buf = STRBUF_INIT;
	int ret;

2290
	ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301
	if (ret >= 0) {
		if (use_stdout)
			printf("%s\n", buf.buf);
		else
			pr_info("%s\n", buf.buf);
	}
	strbuf_release(&buf);

	return ret;
}

2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
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)
2319
{
2320
	int ret = 0;
2321
	struct probe_trace_event tev;
2322
	struct perf_probe_event pev;
2323 2324 2325
	struct strlist *rawlist;
	struct str_node *ent;

2326 2327
	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
2328

2329
	rawlist = probe_file__get_rawlist(fd);
2330
	if (!rawlist)
2331
		return -ENOMEM;
2332

2333
	strlist__for_each(ent, rawlist) {
2334
		ret = parse_probe_trace_command(ent->s, &tev);
2335
		if (ret >= 0) {
2336 2337
			if (!filter_probe_trace_event(&tev, filter))
				goto next;
2338 2339
			ret = convert_to_perf_probe_event(&tev, &pev,
								is_kprobe);
2340 2341
			if (ret < 0)
				goto next;
2342 2343
			ret = show_perf_probe_event(pev.group, pev.event,
						    &pev, tev.point.module,
2344
						    true);
2345
		}
2346
next:
2347
		clear_perf_probe_event(&pev);
2348
		clear_probe_trace_event(&tev);
2349 2350
		if (ret < 0)
			break;
2351 2352
	}
	strlist__delete(rawlist);
2353 2354
	/* Cleanup cached debuginfo if needed */
	debuginfo_cache__exit();
2355 2356

	return ret;
2357 2358
}

2359
/* List up current perf-probe events */
2360
int show_perf_probe_events(struct strfilter *filter)
2361
{
2362
	int kp_fd, up_fd, ret;
2363 2364 2365

	setup_pager();

2366
	ret = init_probe_symbol_maps(false);
2367 2368 2369
	if (ret < 0)
		return ret;

2370 2371 2372
	ret = probe_file__open_both(&kp_fd, &up_fd, 0);
	if (ret < 0)
		return ret;
2373

2374 2375 2376
	if (kp_fd >= 0)
		ret = __show_perf_probe_events(kp_fd, true, filter);
	if (up_fd >= 0 && ret >= 0)
2377
		ret = __show_perf_probe_events(up_fd, false, filter);
2378 2379 2380
	if (kp_fd > 0)
		close(kp_fd);
	if (up_fd > 0)
2381
		close(up_fd);
2382
	exit_probe_symbol_maps();
2383

2384
	return ret;
2385 2386
}

2387 2388
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
2389 2390
{
	int i, ret;
2391
	char *p, *nbase;
2392

2393 2394
	if (*base == '.')
		base++;
2395 2396 2397 2398 2399 2400 2401 2402
	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';
2403

2404 2405
	/* Try no suffix number */
	ret = e_snprintf(buf, len, "%s", nbase);
2406
	if (ret < 0) {
2407
		pr_debug("snprintf() failed: %d\n", ret);
2408
		goto out;
2409
	}
2410
	if (!strlist__has_entry(namelist, buf))
2411
		goto out;
2412

2413
	if (!allow_suffix) {
2414 2415 2416 2417 2418
		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);
2419 2420
		ret = -EEXIST;
		goto out;
2421 2422
	}

2423 2424
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2425
		ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2426
		if (ret < 0) {
2427
			pr_debug("snprintf() failed: %d\n", ret);
2428
			goto out;
2429
		}
2430 2431 2432
		if (!strlist__has_entry(namelist, buf))
			break;
	}
2433 2434 2435 2436 2437
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

2438 2439
out:
	free(nbase);
2440
	return ret;
2441 2442
}

2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
/* 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);
}

2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
/* 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;

	if (pev->event)
		event = pev->event;
	else
2477 2478 2479
		if (pev->point.function &&
			(strncmp(pev->point.function, "0x", 2) != 0) &&
			!strisglob(pev->point.function))
2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
			event = pev->point.function;
		else
			event = tev->point.realname;
	if (pev->group)
		group = pev->group;
	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;
}

2506 2507
static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
2508
				     int ntevs, bool allow_suffix)
2509
{
2510
	int i, fd, ret;
2511
	struct probe_trace_event *tev = NULL;
2512
	struct strlist *namelist;
2513

2514 2515
	fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0));
	if (fd < 0)
2516
		return fd;
2517

2518
	/* Get current event names */
2519
	namelist = probe_file__get_namelist(fd);
2520 2521
	if (!namelist) {
		pr_debug("Failed to get current event list.\n");
2522 2523
		ret = -ENOMEM;
		goto close_out;
2524
	}
2525

2526
	ret = 0;
2527
	for (i = 0; i < ntevs; i++) {
2528
		tev = &tevs[i];
2529
		/* Skip if the symbol is out of .text or blacklisted */
2530 2531
		if (!tev->point.symbol)
			continue;
2532

2533 2534 2535
		/* Set new name for tev (and update namelist) */
		ret = probe_trace_event__set_name(tev, pev, namelist,
						  allow_suffix);
2536 2537
		if (ret < 0)
			break;
2538

2539
		ret = probe_file__add_event(fd, tev);
2540 2541
		if (ret < 0)
			break;
2542 2543 2544 2545 2546 2547 2548 2549

		/*
		 * 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;
2550
	}
2551 2552
	if (ret == -EINVAL && pev->uprobes)
		warn_uprobe_event_compat(tev);
2553

2554
	strlist__delete(namelist);
2555
close_out:
2556
	close(fd);
2557
	return ret;
2558
}
2559

2560 2561
static int find_probe_functions(struct map *map, char *name,
				struct symbol **syms)
2562
{
2563
	int found = 0;
2564
	struct symbol *sym;
2565
	struct rb_node *tmp;
2566

2567 2568 2569
	if (map__load(map, NULL) < 0)
		return 0;

2570
	map__for_each_symbol(map, sym, tmp) {
2571
		if (strglobmatch(sym->name, name)) {
2572
			found++;
2573 2574 2575
			if (syms && found < probe_conf.max_probes)
				syms[found - 1] = sym;
		}
2576
	}
2577 2578

	return found;
2579 2580
}

2581 2582
void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
				struct probe_trace_event *tev __maybe_unused,
2583 2584
				struct map *map __maybe_unused,
				struct symbol *sym __maybe_unused) { }
2585

2586 2587 2588 2589 2590
/*
 * 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,
2591
					    struct probe_trace_event **tevs)
2592
{
2593 2594
	struct map *map = NULL;
	struct ref_reloc_sym *reloc_sym = NULL;
2595
	struct symbol *sym;
2596
	struct symbol **syms = NULL;
2597
	struct probe_trace_event *tev;
2598 2599
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_point *tp;
2600
	int num_matched_functions;
2601
	int ret, i, j, skipped = 0;
2602
	char *mod_name;
2603

2604
	map = get_target_map(pev->target, pev->uprobes);
2605 2606 2607
	if (!map) {
		ret = -EINVAL;
		goto out;
2608 2609
	}

2610 2611 2612 2613 2614 2615
	syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
	if (!syms) {
		ret = -ENOMEM;
		goto out;
	}

2616 2617 2618 2619
	/*
	 * Load matched symbols: Since the different local symbols may have
	 * same name but different addresses, this lists all the symbols.
	 */
2620
	num_matched_functions = find_probe_functions(map, pp->function, syms);
2621
	if (num_matched_functions == 0) {
2622
		pr_err("Failed to find symbol %s in %s\n", pp->function,
2623
			pev->target ? : "kernel");
2624 2625
		ret = -ENOENT;
		goto out;
2626
	} else if (num_matched_functions > probe_conf.max_probes) {
2627
		pr_err("Too many functions matched in %s\n",
2628
			pev->target ? : "kernel");
2629 2630
		ret = -E2BIG;
		goto out;
2631 2632
	}

2633 2634
	/* Note that the symbols in the kmodule are not relocated */
	if (!pev->uprobes && !pp->retprobe && !pev->target) {
2635
		reloc_sym = kernel_get_ref_reloc_sym();
2636 2637 2638 2639 2640 2641
		if (!reloc_sym) {
			pr_warning("Relocated base symbol is not found!\n");
			ret = -EINVAL;
			goto out;
		}
	}
2642

2643 2644 2645
	/* Setup result trace-probe-events */
	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
	if (!*tevs) {
2646
		ret = -ENOMEM;
2647
		goto out;
2648
	}
2649

2650
	ret = 0;
2651

2652 2653 2654
	for (j = 0; j < num_matched_functions; j++) {
		sym = syms[j];

2655 2656 2657 2658 2659
		tev = (*tevs) + ret;
		tp = &tev->point;
		if (ret == num_matched_functions) {
			pr_warning("Too many symbols are listed. Skip it.\n");
			break;
2660
		}
2661
		ret++;
2662

2663 2664 2665 2666 2667 2668 2669 2670
		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;
2671 2672 2673

		/* Check the kprobe (not in module) is within .text  */
		if (!pev->uprobes && !pev->target &&
2674 2675 2676 2677
		    kprobe_warn_out_range(sym->name, tp->address)) {
			tp->symbol = NULL;	/* Skip it */
			skipped++;
		} else if (reloc_sym) {
2678 2679 2680 2681 2682 2683
			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;
		}
2684 2685
		tp->realname = strdup_or_goto(sym->name, nomem_out);

2686
		tp->retprobe = pp->retprobe;
2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699
		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;
			}
		}
2700 2701 2702 2703 2704 2705 2706
		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;
2707
		}
2708
		for (i = 0; i < tev->nargs; i++) {
2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719
			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);
2720
		}
2721
		arch__fix_tev_from_maps(pev, tev, map, sym);
2722
	}
2723 2724 2725 2726
	if (ret == skipped) {
		ret = -ENOENT;
		goto err_out;
	}
2727

2728
out:
2729
	put_target_map(map, pev->uprobes);
2730
	free(syms);
2731
	return ret;
2732

2733 2734 2735 2736 2737 2738 2739
nomem_out:
	ret = -ENOMEM;
err_out:
	clear_probe_trace_events(*tevs, num_matched_functions);
	zfree(tevs);
	goto out;
}
2740

2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
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;
}

2833 2834
bool __weak arch__prefers_symtab(void) { return false; }

2835
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2836
					 struct probe_trace_event **tevs)
2837 2838 2839
{
	int ret;

2840 2841 2842 2843 2844 2845 2846
	if (!pev->group) {
		/* 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);
2847 2848 2849 2850
		if (ret != 0) {
			pr_warning("Failed to make a group name.\n");
			return ret;
		}
2851
	}
2852

2853 2854 2855 2856
	ret = try_to_find_absolute_address(pev, tevs);
	if (ret > 0)
		return ret;

2857
	if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
2858
		ret = find_probe_trace_events_from_map(pev, tevs);
2859 2860 2861 2862
		if (ret > 0)
			return ret; /* Found in symbol table */
	}

2863
	/* Convert perf_probe_event with debuginfo */
2864
	ret = try_to_find_probe_trace_events(pev, tevs);
2865 2866 2867
	if (ret != 0)
		return ret;	/* Found in debuginfo or got an error */

2868
	return find_probe_trace_events_from_map(pev, tevs);
2869 2870
}

2871
int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
2872
{
2873
	int i, ret;
2874 2875 2876

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
2877
		/* Init kprobe blacklist if needed */
2878
		if (!pevs[i].uprobes)
2879
			kprobe_blacklist__init();
2880
		/* Convert with or without debuginfo */
2881
		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
2882
		if (ret < 0)
2883
			return ret;
2884
		pevs[i].ntevs = ret;
2885
	}
2886 2887
	/* This just release blacklist only if allocated */
	kprobe_blacklist__release();
2888

2889 2890 2891
	return 0;
}

2892
int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
2893 2894 2895
{
	int i, ret = 0;

2896
	/* Loop 2: add all events */
2897
	for (i = 0; i < npevs; i++) {
2898 2899
		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
					       pevs[i].ntevs,
2900
					       probe_conf.force_add);
2901 2902 2903
		if (ret < 0)
			break;
	}
2904 2905 2906
	return ret;
}

2907
void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
2908 2909 2910
{
	int i, j;

2911 2912
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
2913 2914 2915 2916
		for (j = 0; j < pevs[i].ntevs; j++)
			clear_probe_trace_event(&pevs[i].tevs[j]);
		zfree(&pevs[i].tevs);
		pevs[i].ntevs = 0;
2917
		clear_perf_probe_event(&pevs[i]);
2918
	}
2919 2920 2921 2922 2923 2924
}

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

2925 2926 2927 2928
	ret = init_probe_symbol_maps(pevs->uprobes);
	if (ret < 0)
		return ret;

2929
	ret = convert_perf_probe_events(pevs, npevs);
2930
	if (ret == 0)
2931
		ret = apply_perf_probe_events(pevs, npevs);
2932

2933
	cleanup_perf_probe_events(pevs, npevs);
2934

2935
	exit_probe_symbol_maps();
2936
	return ret;
2937 2938
}

2939
int del_perf_probe_events(struct strfilter *filter)
2940
{
2941 2942 2943 2944 2945 2946
	int ret, ret2, ufd = -1, kfd = -1;
	char *str = strfilter__string(filter);

	if (!str)
		return -EINVAL;

2947
	/* Get current event names */
2948 2949 2950
	ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
	if (ret < 0)
		goto out;
2951

2952
	ret = probe_file__del_events(kfd, filter);
2953
	if (ret < 0 && ret != -ENOENT)
2954 2955
		goto error;

2956
	ret2 = probe_file__del_events(ufd, filter);
2957
	if (ret2 < 0 && ret2 != -ENOENT) {
2958
		ret = ret2;
2959 2960 2961
		goto error;
	}
	ret = 0;
2962 2963

error:
2964
	if (kfd >= 0)
2965
		close(kfd);
2966
	if (ufd >= 0)
2967
		close(ufd);
2968
out:
2969
	free(str);
2970 2971

	return ret;
2972
}
2973

2974 2975
/* TODO: don't use a global variable for filter ... */
static struct strfilter *available_func_filter;
2976

2977
/*
2978 2979
 * If a symbol corresponds to a function with global binding and
 * matches filter return 0. For all others return 1.
2980
 */
2981
static int filter_available_functions(struct map *map __maybe_unused,
2982
				      struct symbol *sym)
2983
{
2984
	if (strfilter__compare(available_func_filter, sym->name))
2985 2986
		return 0;
	return 1;
2987 2988
}

2989 2990
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
2991 2992 2993 2994
{
	struct map *map;
	int ret;

2995
	ret = init_probe_symbol_maps(user);
2996 2997 2998
	if (ret < 0)
		return ret;

2999 3000 3001 3002 3003
	/* Get a symbol map */
	if (user)
		map = dso__new_map(target);
	else
		map = kernel_get_module_map(target);
3004
	if (!map) {
3005
		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3006 3007
		return -EINVAL;
	}
3008

3009
	/* Load symbols with given filter */
3010
	available_func_filter = _filter;
3011 3012 3013 3014 3015 3016
	if (map__load(map, filter_available_functions)) {
		pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
		goto end;
	}
	if (!dso__sorted_by_name(map->dso, map->type))
		dso__sort_by_name(map->dso, map->type);
3017

3018 3019 3020 3021 3022
	/* Show all (filtered) symbols */
	setup_pager();
	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
end:
	if (user) {
3023
		map__put(map);
3024
	}
3025
	exit_probe_symbol_maps();
3026

3027
	return ret;
3028 3029
}

3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
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;
}