probe-event.c 64.7 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/debugfs.h>
44
#include <api/fs/tracefs.h>
45
#include "trace-event.h"	/* For __maybe_unused */
46
#include "probe-event.h"
47
#include "probe-finder.h"
48
#include "session.h"
49 50 51 52

#define MAX_CMDLEN 256
#define PERFPROBE_GROUP "probe"

53 54
bool probe_event_dry_run;	/* Dry run flag */

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

57
/* If there is no space to write, returns -E2BIG. */
58 59 60
static int e_snprintf(char *str, size_t size, const char *format, ...)
	__attribute__((format(printf, 3, 4)));

61 62 63 64 65 66 67 68 69 70 71 72
static int e_snprintf(char *str, size_t size, const char *format, ...)
{
	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;
}

73
static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
74
static void clear_probe_trace_event(struct probe_trace_event *tev);
75
static struct machine *host_machine;
76

77
/* Initialize symbol maps and path of vmlinux/modules */
78
static int init_symbol_maps(bool user_only)
79
{
80 81
	int ret;

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

90 91
	if (host_machine || user_only)	/* already initialized */
		return 0;
92

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

108 109 110 111 112 113 114 115 116
static void exit_symbol_maps(void)
{
	if (host_machine) {
		machine__delete(host_machine);
		host_machine = NULL;
	}
	symbol__exit();
}

117 118 119
static struct symbol *__find_kernel_function_by_name(const char *name,
						     struct map **mapp)
{
120
	return machine__find_kernel_function_by_name(host_machine, name, mapp,
121 122 123
						     NULL);
}

124 125 126 127 128 129 130 131 132 133 134 135 136 137
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;

	if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
		return NULL;

	kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
138 139
	if (!kmap)
		return NULL;
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	return kmap->ref_reloc_sym;
}

static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
{
	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)
		return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
	else {
		sym = __find_kernel_function_by_name(name, &map);
		if (sym)
			return map->unmap_ip(map, sym->start) -
H
He Kuang 已提交
157
				((reloc) ? 0 : map->reloc);
158 159 160 161
	}
	return 0;
}

162 163 164
static struct map *kernel_get_module_map(const char *module)
{
	struct rb_node *nd;
165
	struct map_groups *grp = &host_machine->kmaps;
166

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

171 172 173 174 175 176 177 178 179 180 181 182 183
	if (!module)
		module = "kernel";

	for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
		struct map *pos = rb_entry(nd, struct map, rb_node);
		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 197 198 199 200 201 202
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 */
		dso__delete(map->dso);
		map__delete(map);
	}
}


203
static struct dso *kernel_get_module_dso(const char *module)
204 205
{
	struct dso *dso;
206 207
	struct map *map;
	const char *vmlinux_name;
208 209

	if (module) {
210 211
		list_for_each_entry(dso, &host_machine->kernel_dsos.head,
				    node) {
212 213 214 215 216 217
			if (strncmp(dso->short_name + 1, module,
				    dso->short_name_len - 2) == 0)
				goto found;
		}
		pr_debug("Failed to find module %s.\n", module);
		return NULL;
218 219
	}

220
	map = host_machine->vmlinux_maps[MAP__FUNCTION];
221 222 223 224
	dso = map->dso;

	vmlinux_name = symbol_conf.vmlinux_name;
	if (vmlinux_name) {
225
		if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
226
			return NULL;
227
	} else {
228
		if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
229 230 231 232 233
			pr_debug("Failed to load kernel map.\n");
			return NULL;
		}
	}
found:
234 235 236 237 238 239 240
	return dso;
}

const char *kernel_get_module_path(const char *module)
{
	struct dso *dso = kernel_get_module_dso(module);
	return (dso) ? dso->long_name : NULL;
241 242
}

243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
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;
}

274 275 276 277 278 279 280
static void clear_perf_probe_point(struct perf_probe_point *pp)
{
	free(pp->file);
	free(pp->function);
	free(pp->lazy_line);
}

281 282 283 284 285 286 287 288
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);
}

289
#ifdef HAVE_DWARF_SUPPORT
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
/*
 * 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) {
315 316 317 318
		if (uprobes)
			address = sym->start;
		else
			address = map->unmap_ip(map, sym->start);
319
		break;
320 321 322 323 324
	}
	if (!address) {
		ret = -ENOENT;
		goto out;
	}
W
Wang Nan 已提交
325 326
	pr_debug("Symbol %s address found : %" PRIx64 "\n",
			pp->function, address);
327 328 329 330 331 332 333 334

	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;
335
		result->retprobe = pp->retprobe;
336 337 338 339 340 341 342 343 344 345 346
		ret = 0;
	}

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

}

static int get_alternative_probe_event(struct debuginfo *dinfo,
				       struct perf_probe_event *pev,
347
				       struct perf_probe_point *tmp)
348 349 350 351 352 353
{
	int ret;

	memcpy(tmp, &pev->point, sizeof(*tmp));
	memset(&pev->point, 0, sizeof(pev->point));
	ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
354
					   pev->target, pev->uprobes);
355 356 357 358 359
	if (ret < 0)
		memcpy(&pev->point, tmp, sizeof(*tmp));

	return ret;
}
360

361 362 363 364
static int get_alternative_line_range(struct debuginfo *dinfo,
				      struct line_range *lr,
				      const char *target, bool user)
{
365 366 367 368
	struct perf_probe_point pp = { .function = lr->function,
				       .file = lr->file,
				       .line = lr->start };
	struct perf_probe_point result;
369 370
	int ret, len = 0;

371 372
	memset(&result, 0, sizeof(result));

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	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;
}

388
/* Open new debuginfo of given module */
389
static struct debuginfo *open_debuginfo(const char *module, bool silent)
390
{
391
	const char *path = module;
392
	struct debuginfo *ret;
393

394
	if (!module || !strchr(module, '/')) {
395 396
		path = kernel_get_module_path(module);
		if (!path) {
397 398 399
			if (!silent)
				pr_err("Failed to find path of %s module.\n",
				       module ?: "kernel");
400 401
			return NULL;
		}
402
	}
403 404 405 406 407 408 409 410 411 412
	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;
413
}
414

415

416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
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);
	if (elf == NULL)
		return -EINVAL;

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

444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
/*
 * 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;
	} else {
		addr = kernel_get_symbol_address_by_name(tp->symbol, false);
		if (addr == 0)
			goto error;
		addr += tp->offset;
	}

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

476
	dinfo = open_debuginfo(tp->module, verbose == 0);
477 478 479 480
	if (dinfo) {
		ret = debuginfo__find_probe_point(dinfo,
						 (unsigned long)addr, pp);
		debuginfo__delete(dinfo);
481
	} else
482 483 484 485 486 487 488 489 490 491 492
		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;
}

493 494 495 496
static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
					  int ntevs, const char *exec)
{
	int i, ret = 0;
497
	unsigned long stext = 0;
498 499 500 501 502 503 504 505 506

	if (!exec)
		return 0;

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

	for (i = 0; i < ntevs && ret >= 0; i++) {
507
		/* point.address is the addres of point.symbol + point.offset */
508
		tevs[i].point.address -= stext;
509
		tevs[i].point.module = strdup(exec);
510
		if (!tevs[i].point.module) {
511 512 513 514 515 516 517 518 519
			ret = -ENOMEM;
			break;
		}
		tevs[i].uprobes = true;
	}

	return ret;
}

520 521 522
static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
					    int ntevs, const char *module)
{
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	int i, ret = 0;
	char *tmp;

	if (!module)
		return 0;

	tmp = strrchr(module, '/');
	if (tmp) {
		/* This is a module path -- get the module name */
		module = strdup(tmp + 1);
		if (!module)
			return -ENOMEM;
		tmp = strchr(module, '.');
		if (tmp)
			*tmp = '\0';
		tmp = (char *)module;	/* For free() */
	}

541 542
	for (i = 0; i < ntevs; i++) {
		tevs[i].point.module = strdup(module);
543 544 545 546
		if (!tevs[i].point.module) {
			ret = -ENOMEM;
			break;
		}
547
	}
548

549
	free(tmp);
550
	return ret;
551 552
}

553 554 555 556 557 558
/* 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;
559
	u64 etext_addr;
560
	char *tmp;
561
	int i, skipped = 0;
562 563 564 565 566 567 568 569

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

570
	reloc_sym = kernel_get_ref_reloc_sym();
571 572 573 574
	if (!reloc_sym) {
		pr_warning("Relocated base symbol is not found!\n");
		return -EINVAL;
	}
575 576
	/* Get the address of _etext for checking non-probable text symbol */
	etext_addr = kernel_get_symbol_address_by_name("_etext", false);
577 578

	for (i = 0; i < ntevs; i++) {
579
		if (tevs[i].point.address && !tevs[i].point.retprobe) {
580 581 582 583 584 585 586 587 588 589 590
			/* If we found a wrong one, mark it by NULL symbol */
			if (etext_addr < tevs[i].point.address) {
				pr_warning("%s+%lu is out of .text, skip it.\n",
				   tevs[i].point.symbol, tevs[i].point.offset);
				tmp = NULL;
				skipped++;
			} else {
				tmp = strdup(reloc_sym->name);
				if (!tmp)
					return -ENOMEM;
			}
591 592 593 594 595 596
			free(tevs[i].point.symbol);
			tevs[i].point.symbol = tmp;
			tevs[i].point.offset = tevs[i].point.address -
					       reloc_sym->unrelocated_addr;
		}
	}
597
	return skipped;
598 599
}

600
/* Try to find perf_probe_event with debuginfo */
601
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
602
					  struct probe_trace_event **tevs,
603
					  int max_tevs)
604 605
{
	bool need_dwarf = perf_probe_event_need_dwarf(pev);
606
	struct perf_probe_point tmp;
607
	struct debuginfo *dinfo;
608
	int ntevs, ret = 0;
609

610
	dinfo = open_debuginfo(pev->target, !need_dwarf);
611
	if (!dinfo) {
612
		if (need_dwarf)
613 614
			return -ENOENT;
		pr_debug("Could not open debuginfo. Try to use symbols.\n");
615 616 617
		return 0;
	}

618
	pr_debug("Try to find probe point from debuginfo.\n");
619 620 621
	/* Searching trace events corresponding to a probe event */
	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);

622
	if (ntevs == 0)	{  /* Not found, retry with an alternative */
623
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
624 625 626 627 628 629 630 631 632 633 634 635
		if (!ret) {
			ntevs = debuginfo__find_trace_events(dinfo, pev,
							     tevs, max_tevs);
			/*
			 * 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));
		}
	}

636
	debuginfo__delete(dinfo);
637

638
	if (ntevs > 0) {	/* Succeeded to find trace events */
639 640
		pr_debug("Found %d probe_trace_events.\n", ntevs);
		ret = post_process_probe_trace_events(*tevs, ntevs,
641
						pev->target, pev->uprobes);
642
		if (ret < 0 || ret == ntevs) {
643 644 645
			clear_probe_trace_events(*tevs, ntevs);
			zfree(tevs);
		}
646 647 648 649
		if (ret != ntevs)
			return ret < 0 ? ret : ntevs;
		ntevs = 0;
		/* Fall through */
650
	}
651

652
	if (ntevs == 0)	{	/* No error but failed to find probe point. */
653
		pr_warning("Probe point '%s' not found.\n",
654
			   synthesize_perf_probe_point(&pev->point));
655
		return -ENOENT;
656 657
	}
	/* Error path : ntevs < 0 */
658 659 660 661 662
	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
	if (ntevs == -EBADF) {
		pr_warning("Warning: No dwarf info found in the vmlinux - "
			"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
		if (!need_dwarf) {
M
Masami Hiramatsu 已提交
663
			pr_debug("Trying to use symbols.\n");
664 665
			return 0;
		}
666
	}
667
	return ntevs;
668 669 670 671 672
}

#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

673
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
674
{
675
	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
676 677
	const char *color = show_num ? "" : PERF_COLOR_BLUE;
	const char *prefix = NULL;
678

679
	do {
680 681
		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
			goto error;
682 683 684 685 686
		if (skip)
			continue;
		if (!prefix) {
			prefix = show_num ? "%7d  " : "         ";
			color_fprintf(stdout, color, prefix, l);
687
		}
688 689 690
		color_fprintf(stdout, color, "%s", buf);

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

692
	return 1;
693
error:
694
	if (ferror(fp)) {
695 696
		pr_warning("File read error: %s\n",
			   strerror_r(errno, sbuf, sizeof(sbuf)));
697 698 699 700
		return -1;
	}
	return 0;
}
701

702 703 704 705 706 707 708 709
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;
710 711
}

712 713 714 715 716
#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)

717 718 719 720
/*
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
721 722
static int __show_line_range(struct line_range *lr, const char *module,
			     bool user)
723
{
724
	int l = 1;
725
	struct int_node *ln;
726
	struct debuginfo *dinfo;
727
	FILE *fp;
728
	int ret;
729
	char *tmp;
730
	char sbuf[STRERR_BUFSIZE];
731 732

	/* Search a line range */
733 734
	dinfo = open_debuginfo(module, false);
	if (!dinfo)
735
		return -ENOENT;
736

737
	ret = debuginfo__find_line_range(dinfo, lr);
738 739 740 741 742
	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);
	}
743
	debuginfo__delete(dinfo);
744
	if (ret == 0 || ret == -ENOENT) {
745 746 747
		pr_warning("Specified source line is not found.\n");
		return -ENOENT;
	} else if (ret < 0) {
748
		pr_warning("Debuginfo analysis failed.\n");
749 750
		return ret;
	}
751

752 753
	/* Convert source file path */
	tmp = lr->path;
754
	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
755 756 757 758 759

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

760
	if (ret < 0) {
761
		pr_warning("Failed to find source file path.\n");
762 763 764
		return ret;
	}

765 766 767
	setup_pager();

	if (lr->function)
768
		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
769 770
			lr->start - lr->offset);
	else
771
		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
772 773

	fp = fopen(lr->path, "r");
774 775
	if (fp == NULL) {
		pr_warning("Failed to open %s: %s\n", lr->path,
776
			   strerror_r(errno, sbuf, sizeof(sbuf)));
777 778
		return -errno;
	}
779
	/* Skip to starting line number */
780
	while (l < lr->start) {
781
		ret = skip_one_line(fp, l++);
782 783 784
		if (ret < 0)
			goto end;
	}
785

786 787
	intlist__for_each(ln, lr->line_list) {
		for (; ln->i > l; l++) {
788
			ret = show_one_line(fp, l - lr->offset);
789 790 791
			if (ret < 0)
				goto end;
		}
792
		ret = show_one_line_with_num(fp, l++ - lr->offset);
793 794
		if (ret < 0)
			goto end;
795 796 797 798
	}

	if (lr->end == INT_MAX)
		lr->end = l + NR_ADDITIONAL_LINES;
799 800 801
	while (l <= lr->end) {
		ret = show_one_line_or_eof(fp, l++ - lr->offset);
		if (ret <= 0)
802 803
			break;
	}
804
end:
805
	fclose(fp);
806
	return ret;
807 808
}

809
int show_line_range(struct line_range *lr, const char *module, bool user)
810 811 812
{
	int ret;

813
	ret = init_symbol_maps(user);
814 815
	if (ret < 0)
		return ret;
816
	ret = __show_line_range(lr, module, user);
817 818 819 820 821
	exit_symbol_maps();

	return ret;
}

822 823
static int show_available_vars_at(struct debuginfo *dinfo,
				  struct perf_probe_event *pev,
824
				  int max_vls, struct strfilter *_filter,
825
				  bool externs)
826 827
{
	char *buf;
828
	int ret, i, nvars;
829 830
	struct str_node *node;
	struct variable_list *vls = NULL, *vl;
831
	struct perf_probe_point tmp;
832
	const char *var;
833 834 835 836 837 838

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

839 840
	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
						max_vls, externs);
841
	if (!ret) {  /* Not found, retry with an alternative */
842
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
843 844 845 846 847 848 849
		if (!ret) {
			ret = debuginfo__find_available_vars_at(dinfo, pev,
						&vls, max_vls, externs);
			/* Release the old probe_point */
			clear_perf_probe_point(&tmp);
		}
	}
850
	if (ret <= 0) {
851 852 853 854 855
		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");
856 857
		goto end;
	}
858

859 860 861 862 863 864 865 866 867 868
	/* 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);
869
		zfree(&vl->point.symbol);
870 871 872 873 874
		nvars = 0;
		if (vl->vars) {
			strlist__for_each(node, vl->vars) {
				var = strchr(node->s, '\t') + 1;
				if (strfilter__compare(_filter, var)) {
875
					fprintf(stdout, "\t\t%s\n", node->s);
876 877 878 879
					nvars++;
				}
			}
			strlist__delete(vl->vars);
880
		}
881 882 883 884 885
		if (nvars == 0)
			fprintf(stdout, "\t\t(No matched variables)\n");
	}
	free(vls);
end:
886 887 888 889 890 891
	free(buf);
	return ret;
}

/* Show available variables on given probe point */
int show_available_vars(struct perf_probe_event *pevs, int npevs,
892
			int max_vls, struct strfilter *_filter, bool externs)
893
{
894 895
	int i, ret = 0;
	struct debuginfo *dinfo;
896

897
	ret = init_symbol_maps(pevs->uprobes);
898 899 900
	if (ret < 0)
		return ret;

901
	dinfo = open_debuginfo(pevs->target, false);
902
	if (!dinfo) {
903 904
		ret = -ENOENT;
		goto out;
905 906
	}

907 908
	setup_pager();

909 910
	for (i = 0; i < npevs && ret >= 0; i++)
		ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
911
					     externs);
912 913

	debuginfo__delete(dinfo);
914 915
out:
	exit_symbol_maps();
916 917 918
	return ret;
}

919
#else	/* !HAVE_DWARF_SUPPORT */
920

921 922 923 924
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)
925
{
926
	return -ENOSYS;
927 928
}

929
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
930
				struct probe_trace_event **tevs __maybe_unused,
931
				int max_tevs __maybe_unused)
932
{
933 934 935 936
	if (perf_probe_event_need_dwarf(pev)) {
		pr_warning("Debuginfo-analysis is not supported.\n");
		return -ENOSYS;
	}
937

938 939 940
	return 0;
}

941
int show_line_range(struct line_range *lr __maybe_unused,
942 943
		    const char *module __maybe_unused,
		    bool user __maybe_unused)
944
{
945 946
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
947 948
}

949 950 951 952
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
			int npevs __maybe_unused, int max_vls __maybe_unused,
			struct strfilter *filter __maybe_unused,
			bool externs __maybe_unused)
953 954 955 956
{
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
}
957 958
#endif

959 960 961 962 963 964
void line_range__clear(struct line_range *lr)
{
	free(lr->function);
	free(lr->file);
	free(lr->path);
	free(lr->comp_dir);
965
	intlist__delete(lr->line_list);
966 967 968
	memset(lr, 0, sizeof(*lr));
}

969
int line_range__init(struct line_range *lr)
970 971
{
	memset(lr, 0, sizeof(*lr));
972 973 974 975 976
	lr->line_list = intlist__new(NULL);
	if (!lr->line_list)
		return -ENOMEM;
	else
		return 0;
977 978
}

979 980 981 982 983 984 985 986 987 988 989 990 991
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;
}

992 993 994 995 996 997 998 999 1000 1001 1002 1003
/* 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;
}

1004 1005 1006 1007 1008
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
1009
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
1010
 */
1011
int parse_line_range_desc(const char *arg, struct line_range *lr)
1012
{
1013
	char *range, *file, *name = strdup(arg);
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	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--;
			}
		}
1048

1049
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1050 1051

		err = -EINVAL;
1052
		if (lr->start > lr->end) {
1053
			semantic_error("Start line must be smaller"
1054
				       " than end line.\n");
1055
			goto err;
1056
		}
1057 1058 1059
		if (*range != '\0') {
			semantic_error("Tailing with invalid str '%s'.\n", range);
			goto err;
1060
		}
1061
	}
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071
	file = strchr(name, '@');
	if (file) {
		*file = '\0';
		lr->file = strdup(++file);
		if (lr->file == NULL) {
			err = -ENOMEM;
			goto err;
		}
		lr->function = name;
1072
	} else if (strchr(name, '/') || strchr(name, '.'))
1073
		lr->file = name;
1074
	else if (is_c_func_name(name))/* We reuse it for checking funcname */
1075
		lr->function = name;
1076 1077 1078 1079 1080
	else {	/* Invalid name */
		semantic_error("'%s' is not a valid function name.\n", name);
		err = -EINVAL;
		goto err;
	}
1081 1082

	return 0;
1083 1084 1085
err:
	free(name);
	return err;
1086 1087
}

1088
/* Parse probepoint definition. */
1089
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1090
{
1091
	struct perf_probe_point *pp = &pev->point;
1092 1093
	char *ptr, *tmp;
	char c, nc = 0;
1094
	bool file_spec = false;
1095 1096
	/*
	 * <Syntax>
1097 1098
	 * perf probe [EVENT=]SRC[:LN|;PTN]
	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1099 1100
	 *
	 * TODO:Group name support
1101 1102
	 */

1103 1104
	ptr = strpbrk(arg, ";=@+%");
	if (ptr && *ptr == '=') {	/* Event name */
1105 1106
		*ptr = '\0';
		tmp = ptr + 1;
1107 1108 1109 1110
		if (strchr(arg, ':')) {
			semantic_error("Group name is not supported yet.\n");
			return -ENOTSUP;
		}
1111
		if (!is_c_func_name(arg)) {
1112
			semantic_error("%s is bad for event name -it must "
1113 1114 1115
				       "follow C symbol-naming rule.\n", arg);
			return -EINVAL;
		}
1116 1117 1118
		pev->event = strdup(arg);
		if (pev->event == NULL)
			return -ENOMEM;
1119
		pev->group = NULL;
1120 1121 1122
		arg = tmp;
	}

1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	/*
	 * 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;
	}

1140
	ptr = strpbrk(arg, ";:+@%");
1141 1142 1143 1144 1145
	if (ptr) {
		nc = *ptr;
		*ptr++ = '\0';
	}

1146 1147 1148 1149
	tmp = strdup(arg);
	if (tmp == NULL)
		return -ENOMEM;

1150
	if (file_spec)
1151
		pp->file = tmp;
1152
	else
1153
		pp->function = tmp;
1154 1155 1156 1157 1158

	/* Parse other options */
	while (ptr) {
		arg = ptr;
		c = nc;
1159
		if (c == ';') {	/* Lazy pattern must be the last part */
1160 1161 1162
			pp->lazy_line = strdup(arg);
			if (pp->lazy_line == NULL)
				return -ENOMEM;
1163 1164 1165
			break;
		}
		ptr = strpbrk(arg, ";:+@%");
1166 1167 1168 1169 1170 1171 1172
		if (ptr) {
			nc = *ptr;
			*ptr++ = '\0';
		}
		switch (c) {
		case ':':	/* Line number */
			pp->line = strtoul(arg, &tmp, 0);
1173
			if (*tmp != '\0') {
1174
				semantic_error("There is non-digit char"
1175 1176 1177
					       " in line number.\n");
				return -EINVAL;
			}
1178 1179 1180
			break;
		case '+':	/* Byte offset from a symbol */
			pp->offset = strtoul(arg, &tmp, 0);
1181
			if (*tmp != '\0') {
1182
				semantic_error("There is non-digit character"
1183 1184 1185
						" in offset.\n");
				return -EINVAL;
			}
1186 1187
			break;
		case '@':	/* File name */
1188 1189 1190 1191
			if (pp->file) {
				semantic_error("SRC@SRC is not allowed.\n");
				return -EINVAL;
			}
1192 1193 1194
			pp->file = strdup(arg);
			if (pp->file == NULL)
				return -ENOMEM;
1195 1196 1197 1198
			break;
		case '%':	/* Probe places */
			if (strcmp(arg, "return") == 0) {
				pp->retprobe = 1;
1199 1200 1201 1202
			} else {	/* Others not supported yet */
				semantic_error("%%%s is not supported.\n", arg);
				return -ENOTSUP;
			}
1203
			break;
1204 1205 1206 1207
		default:	/* Buggy case */
			pr_err("This program has a bug at %s:%d.\n",
				__FILE__, __LINE__);
			return -ENOTSUP;
1208 1209 1210 1211 1212
			break;
		}
	}

	/* Exclusion check */
1213
	if (pp->lazy_line && pp->line) {
M
Masami Hiramatsu 已提交
1214 1215
		semantic_error("Lazy pattern can't be used with"
			       " line number.\n");
1216 1217
		return -EINVAL;
	}
1218

1219
	if (pp->lazy_line && pp->offset) {
M
Masami Hiramatsu 已提交
1220
		semantic_error("Lazy pattern can't be used with offset.\n");
1221 1222
		return -EINVAL;
	}
1223

1224
	if (pp->line && pp->offset) {
M
Masami Hiramatsu 已提交
1225
		semantic_error("Offset can't be used with line number.\n");
1226 1227
		return -EINVAL;
	}
1228

1229
	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1230
		semantic_error("File always requires line number or "
M
Masami Hiramatsu 已提交
1231
			       "lazy pattern.\n");
1232 1233
		return -EINVAL;
	}
1234

1235
	if (pp->offset && !pp->function) {
M
Masami Hiramatsu 已提交
1236
		semantic_error("Offset requires an entry function.\n");
1237 1238
		return -EINVAL;
	}
1239

1240
	if (pp->retprobe && !pp->function) {
M
Masami Hiramatsu 已提交
1241
		semantic_error("Return probe requires an entry function.\n");
1242 1243
		return -EINVAL;
	}
1244

1245
	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1246
		semantic_error("Offset/Line/Lazy pattern can't be used with "
M
Masami Hiramatsu 已提交
1247
			       "return probe.\n");
1248 1249
		return -EINVAL;
	}
1250

1251
	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1252 1253
		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
		 pp->lazy_line);
1254
	return 0;
1255 1256
}

1257
/* Parse perf-probe event argument */
1258
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1259
{
1260
	char *tmp, *goodname;
1261 1262 1263 1264
	struct perf_probe_arg_field **fieldp;

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

1265 1266
	tmp = strchr(str, '=');
	if (tmp) {
1267 1268 1269
		arg->name = strndup(str, tmp - str);
		if (arg->name == NULL)
			return -ENOMEM;
1270
		pr_debug("name:%s ", arg->name);
1271 1272 1273
		str = tmp + 1;
	}

1274 1275 1276
	tmp = strchr(str, ':');
	if (tmp) {	/* Type setting */
		*tmp = '\0';
1277 1278 1279
		arg->type = strdup(tmp + 1);
		if (arg->type == NULL)
			return -ENOMEM;
1280 1281 1282
		pr_debug("type:%s ", arg->type);
	}

1283
	tmp = strpbrk(str, "-.[");
1284 1285
	if (!is_c_varname(str) || !tmp) {
		/* A variable, register, symbol or special value */
1286 1287 1288
		arg->var = strdup(str);
		if (arg->var == NULL)
			return -ENOMEM;
1289
		pr_debug("%s\n", arg->var);
1290
		return 0;
1291 1292
	}

1293
	/* Structure fields or array element */
1294 1295 1296
	arg->var = strndup(str, tmp - str);
	if (arg->var == NULL)
		return -ENOMEM;
1297
	goodname = arg->var;
1298
	pr_debug("%s, ", arg->var);
1299 1300 1301
	fieldp = &arg->field;

	do {
1302 1303 1304
		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
		if (*fieldp == NULL)
			return -ENOMEM;
1305 1306 1307
		if (*tmp == '[') {	/* Array */
			str = tmp;
			(*fieldp)->index = strtol(str + 1, &tmp, 0);
1308
			(*fieldp)->ref = true;
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
			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, "-.[");
1330
		}
1331
		if (tmp) {
1332 1333 1334
			(*fieldp)->name = strndup(str, tmp - str);
			if ((*fieldp)->name == NULL)
				return -ENOMEM;
1335 1336
			if (*str != '[')
				goodname = (*fieldp)->name;
1337 1338 1339 1340
			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
			fieldp = &(*fieldp)->next;
		}
	} while (tmp);
1341 1342 1343
	(*fieldp)->name = strdup(str);
	if ((*fieldp)->name == NULL)
		return -ENOMEM;
1344 1345
	if (*str != '[')
		goodname = (*fieldp)->name;
1346
	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1347

1348
	/* If no name is specified, set the last field name (not array index)*/
1349
	if (!arg->name) {
1350
		arg->name = strdup(goodname);
1351 1352 1353
		if (arg->name == NULL)
			return -ENOMEM;
	}
1354
	return 0;
1355 1356
}

1357
/* Parse perf-probe event command */
1358
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1359
{
1360
	char **argv;
1361
	int argc, i, ret = 0;
1362

1363
	argv = argv_split(cmd, &argc);
1364 1365 1366 1367 1368 1369 1370 1371 1372
	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;
	}
1373
	/* Parse probe point */
1374 1375 1376
	ret = parse_perf_probe_point(argv[0], pev);
	if (ret < 0)
		goto out;
1377

1378
	/* Copy arguments and ensure return probe has no C argument */
1379
	pev->nargs = argc - 1;
1380 1381 1382 1383 1384
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1385 1386 1387 1388
	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) {
1389
			semantic_error("You can't specify local variable for"
1390 1391 1392
				       " kretprobe.\n");
			ret = -EINVAL;
		}
1393
	}
1394
out:
1395
	argv_free(argv);
1396 1397

	return ret;
1398 1399
}

1400 1401 1402 1403 1404 1405 1406 1407 1408
/* 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++)
1409
		if (is_c_varname(pev->args[i].var))
1410 1411 1412 1413 1414
			return true;

	return false;
}

1415 1416
/* Parse probe_events event into struct probe_point */
static int parse_probe_trace_command(const char *cmd,
1417
				     struct probe_trace_event *tev)
1418
{
1419
	struct probe_trace_point *tp = &tev->point;
1420 1421
	char pr;
	char *p;
1422
	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1423 1424 1425
	int ret, i, argc;
	char **argv;

1426
	pr_debug("Parsing probe_events: %s\n", cmd);
1427
	argv = argv_split(cmd, &argc);
1428 1429 1430 1431 1432 1433 1434 1435 1436
	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;
	}
1437 1438

	/* Scan event and group name. */
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
	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) {
1449 1450 1451 1452
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1453 1454 1455 1456 1457 1458 1459
	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;
	}
1460
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1461

1462
	tp->retprobe = (pr == 'r');
1463

1464 1465 1466 1467 1468 1469 1470
	/* Scan module name(if there), function name and offset */
	p = strchr(argv[1], ':');
	if (p) {
		tp->module = strndup(argv[1], p - argv[1]);
		p++;
	} else
		p = argv[1];
1471
	fmt1_str = strtok_r(p, "+", &fmt);
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	if (fmt1_str[0] == '0')	/* only the address started with 0x */
		tp->address = strtoul(fmt1_str, NULL, 0);
	else {
		/* 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);
1486
	}
1487

1488
	tev->nargs = argc - 2;
1489
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1490 1491 1492 1493
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1494
	for (i = 0; i < tev->nargs; i++) {
1495 1496
		p = strchr(argv[i + 2], '=');
		if (p)	/* We don't need which register is assigned. */
1497 1498 1499
			*p++ = '\0';
		else
			p = argv[i + 2];
1500
		tev->args[i].name = strdup(argv[i + 2]);
1501
		/* TODO: parse regs and offset */
1502 1503 1504 1505 1506
		tev->args[i].value = strdup(p);
		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
			ret = -ENOMEM;
			goto out;
		}
1507
	}
1508 1509
	ret = 0;
out:
1510
	free(argv0_str);
1511
	argv_free(argv);
1512
	return ret;
1513 1514
}

1515 1516 1517 1518 1519 1520 1521
/* Compose only probe arg */
int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
{
	struct perf_probe_arg_field *field = pa->field;
	int ret;
	char *tmp = buf;

1522 1523 1524 1525
	if (pa->name && pa->var)
		ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
	else
		ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
1526 1527 1528 1529 1530 1531
	if (ret <= 0)
		goto error;
	tmp += ret;
	len -= ret;

	while (field) {
1532 1533 1534 1535 1536
		if (field->name[0] == '[')
			ret = e_snprintf(tmp, len, "%s", field->name);
		else
			ret = e_snprintf(tmp, len, "%s%s",
					 field->ref ? "->" : ".", field->name);
1537 1538 1539 1540 1541 1542
		if (ret <= 0)
			goto error;
		tmp += ret;
		len -= ret;
		field = field->next;
	}
1543 1544 1545 1546 1547 1548 1549 1550 1551

	if (pa->type) {
		ret = e_snprintf(tmp, len, ":%s", pa->type);
		if (ret <= 0)
			goto error;
		tmp += ret;
		len -= ret;
	}

1552 1553
	return tmp - buf;
error:
1554
	pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
1555
	return ret;
1556 1557
}

1558 1559
/* Compose only probe point (not argument) */
static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1560
{
1561 1562 1563
	char *buf, *tmp;
	char offs[32] = "", line[32] = "", file[32] = "";
	int ret, len;
1564

1565 1566 1567 1568 1569
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL) {
		ret = -ENOMEM;
		goto error;
	}
1570
	if (pp->offset) {
1571
		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1572 1573 1574 1575
		if (ret <= 0)
			goto error;
	}
	if (pp->line) {
1576 1577 1578 1579 1580
		ret = e_snprintf(line, 32, ":%d", pp->line);
		if (ret <= 0)
			goto error;
	}
	if (pp->file) {
1581 1582 1583 1584 1585 1586 1587
		tmp = pp->file;
		len = strlen(tmp);
		if (len > 30) {
			tmp = strchr(pp->file + len - 30, '/');
			tmp = tmp ? tmp + 1 : pp->file + len - 30;
		}
		ret = e_snprintf(file, 32, "@%s", tmp);
1588 1589 1590 1591 1592
		if (ret <= 0)
			goto error;
	}

	if (pp->function)
1593 1594 1595
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
				 offs, pp->retprobe ? "%return" : "", line,
				 file);
1596
	else
1597
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1598 1599 1600 1601
	if (ret <= 0)
		goto error;

	return buf;
1602
error:
1603
	pr_debug("Failed to synthesize perf probe point: %d\n", ret);
1604
	free(buf);
1605
	return NULL;
1606 1607
}

1608 1609
#if 0
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1610 1611 1612 1613
{
	char *buf;
	int i, len, ret;

1614 1615 1616
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return NULL;
1617

1618 1619
	len = strlen(buf);
	for (i = 0; i < pev->nargs; i++) {
1620
		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1621 1622 1623 1624 1625
				 pev->args[i].name);
		if (ret <= 0) {
			free(buf);
			return NULL;
		}
1626 1627 1628
		len += ret;
	}

1629 1630 1631 1632
	return buf;
}
#endif

1633
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1634 1635 1636 1637 1638
					     char **buf, size_t *buflen,
					     int depth)
{
	int ret;
	if (ref->next) {
1639
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
							 buflen, depth + 1);
		if (depth < 0)
			goto out;
	}

	ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
	if (ret < 0)
		depth = ret;
	else {
		*buf += ret;
		*buflen -= ret;
	}
out:
	return depth;
1654 1655 1656

}

1657
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1658
				       char *buf, size_t buflen)
1659
{
1660
	struct probe_trace_arg_ref *ref = arg->ref;
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
	int ret, depth = 0;
	char *tmp = buf;

	/* Argument name or separator */
	if (arg->name)
		ret = e_snprintf(buf, buflen, " %s=", arg->name);
	else
		ret = e_snprintf(buf, buflen, " ");
	if (ret < 0)
		return ret;
	buf += ret;
	buflen -= ret;

1674 1675 1676 1677
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1678
	/* Dereferencing arguments */
1679
	if (ref) {
1680
		depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1681 1682 1683 1684 1685 1686
							  &buflen, 1);
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1687 1688 1689 1690 1691
	if (arg->value[0] == '@' && arg->ref)
		ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
				 arg->ref->offset);
	else
		ret = e_snprintf(buf, buflen, "%s", arg->value);
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
	if (ret < 0)
		return ret;
	buf += ret;
	buflen -= ret;

	/* Closing */
	while (depth--) {
		ret = e_snprintf(buf, buflen, ")");
		if (ret < 0)
			return ret;
		buf += ret;
		buflen -= ret;
	}
1705 1706 1707 1708 1709 1710 1711
	/* Print argument type */
	if (arg->type) {
		ret = e_snprintf(buf, buflen, ":%s", arg->type);
		if (ret <= 0)
			return ret;
		buf += ret;
	}
1712 1713 1714 1715

	return buf - tmp;
}

1716
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1717
{
1718
	struct probe_trace_point *tp = &tev->point;
1719 1720 1721
	char *buf;
	int i, len, ret;

1722 1723 1724 1725
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL)
		return NULL;

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
			 tev->group, tev->event);
	if (len <= 0)
		goto error;

	/* Uprobes must have tp->address and tp->module */
	if (tev->uprobes && (!tp->address || !tp->module))
		goto error;

	/* Use the tp->address for uprobes */
1736
	if (tev->uprobes)
1737 1738
		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
				 tp->module, tp->address);
1739
	else
1740
		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1741 1742 1743
				 tp->module ?: "", tp->module ? ":" : "",
				 tp->symbol, tp->offset);

1744
	if (ret <= 0)
1745
		goto error;
1746
	len += ret;
1747

1748
	for (i = 0; i < tev->nargs; i++) {
1749
		ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1750
						  MAX_CMDLEN - len);
1751
		if (ret <= 0)
1752 1753 1754 1755
			goto error;
		len += ret;
	}

1756
	return buf;
1757
error:
1758 1759 1760
	free(buf);
	return NULL;
}
1761

1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
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;
	u64 addr;
	int ret = -ENOENT;

	if (!is_kprobe) {
		map = dso__new_map(tp->module);
		if (!map)
			goto out;
		addr = tp->address;
		sym = map__find_symbol(map, addr, NULL);
	} else {
		addr = kernel_get_symbol_address_by_name(tp->symbol, true);
		if (addr) {
			addr += tp->offset;
			sym = __find_kernel_function(addr, &map);
		}
	}
	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) {
		dso__delete(map->dso);
		map__delete(map);
	}

	return ret;
}

static int convert_to_perf_probe_point(struct probe_trace_point *tp,
					struct perf_probe_point *pp,
					bool is_kprobe)
{
	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;
	} else if (!tp->module && !is_kprobe) {
		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;
}

1835
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1836
			       struct perf_probe_event *pev, bool is_kprobe)
1837
{
1838
	char buf[64] = "";
1839
	int i, ret;
1840

1841
	/* Convert event/group name */
1842 1843 1844 1845
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
1846

1847
	/* Convert trace_point to probe_point */
1848
	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1849 1850
	if (ret < 0)
		return ret;
1851

1852 1853
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
1854 1855 1856
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
1857
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
1858
		if (tev->args[i].name)
1859
			pev->args[i].name = strdup(tev->args[i].name);
1860
		else {
1861
			ret = synthesize_probe_trace_arg(&tev->args[i],
1862
							  buf, 64);
1863
			pev->args[i].name = strdup(buf);
1864
		}
1865 1866 1867
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
1868 1869 1870 1871 1872

	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
1873 1874 1875 1876
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
1877
	struct perf_probe_arg_field *field, *next;
1878 1879
	int i;

1880 1881
	free(pev->event);
	free(pev->group);
1882
	free(pev->target);
1883
	clear_perf_probe_point(&pev->point);
1884

1885
	for (i = 0; i < pev->nargs; i++) {
1886 1887 1888
		free(pev->args[i].name);
		free(pev->args[i].var);
		free(pev->args[i].type);
1889 1890 1891
		field = pev->args[i].field;
		while (field) {
			next = field->next;
1892
			zfree(&field->name);
1893 1894 1895 1896
			free(field);
			field = next;
		}
	}
1897
	free(pev->args);
1898 1899 1900
	memset(pev, 0, sizeof(*pev));
}

1901
static void clear_probe_trace_event(struct probe_trace_event *tev)
1902
{
1903
	struct probe_trace_arg_ref *ref, *next;
1904 1905
	int i;

1906 1907 1908 1909
	free(tev->event);
	free(tev->group);
	free(tev->point.symbol);
	free(tev->point.module);
1910
	for (i = 0; i < tev->nargs; i++) {
1911 1912 1913
		free(tev->args[i].name);
		free(tev->args[i].value);
		free(tev->args[i].type);
1914 1915 1916 1917 1918 1919 1920
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
1921
	free(tev->args);
1922
	memset(tev, 0, sizeof(*tev));
1923 1924
}

1925
static void print_open_warning(int err, bool is_kprobe)
1926
{
1927
	char sbuf[STRERR_BUFSIZE];
1928

1929
	if (err == -ENOENT) {
1930 1931 1932 1933 1934 1935 1936
		const char *config;

		if (!is_kprobe)
			config = "CONFIG_UPROBE_EVENTS";
		else
			config = "CONFIG_KPROBE_EVENTS";

1937 1938 1939 1940
		pr_warning("%cprobe_events file does not exist"
			   " - please rebuild kernel with %s.\n",
			   is_kprobe ? 'k' : 'u', config);
	} else if (err == -ENOTSUP)
1941
		pr_warning("Tracefs or debugfs is not mounted.\n");
1942 1943 1944 1945
	else
		pr_warning("Failed to open %cprobe_events: %s\n",
			   is_kprobe ? 'k' : 'u',
			   strerror_r(-err, sbuf, sizeof(sbuf)));
1946 1947
}

1948 1949 1950 1951
static void print_both_open_warning(int kerr, int uerr)
{
	/* Both kprobes and uprobes are disabled, warn it. */
	if (kerr == -ENOTSUP && uerr == -ENOTSUP)
1952
		pr_warning("Tracefs or debugfs is not mounted.\n");
1953 1954 1955 1956
	else if (kerr == -ENOENT && uerr == -ENOENT)
		pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
			   "or/and CONFIG_UPROBE_EVENTS.\n");
	else {
1957
		char sbuf[STRERR_BUFSIZE];
1958 1959 1960 1961 1962 1963 1964
		pr_warning("Failed to open kprobe events: %s.\n",
			   strerror_r(-kerr, sbuf, sizeof(sbuf)));
		pr_warning("Failed to open uprobe events: %s.\n",
			   strerror_r(-uerr, sbuf, sizeof(sbuf)));
	}
}

1965
static int open_probe_events(const char *trace_file, bool readwrite)
1966 1967
{
	char buf[PATH_MAX];
1968
	const char *__debugfs;
1969
	const char *tracing_dir = "";
1970 1971
	int ret;

1972 1973 1974
	__debugfs = tracefs_find_mountpoint();
	if (__debugfs == NULL) {
		tracing_dir = "tracing/";
1975

1976 1977 1978 1979 1980 1981 1982
		__debugfs = debugfs_find_mountpoint();
		if (__debugfs == NULL)
			return -ENOTSUP;
	}

	ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
			 __debugfs, tracing_dir, trace_file);
1983
	if (ret >= 0) {
1984
		pr_debug("Opening %s write=%d\n", buf, readwrite);
1985
		if (readwrite && !probe_event_dry_run)
1986
			ret = open(buf, O_RDWR | O_APPEND, 0);
1987 1988
		else
			ret = open(buf, O_RDONLY, 0);
1989

1990
		if (ret < 0)
1991
			ret = -errno;
1992 1993 1994 1995
	}
	return ret;
}

1996 1997
static int open_kprobe_events(bool readwrite)
{
1998
	return open_probe_events("kprobe_events", readwrite);
1999 2000 2001 2002
}

static int open_uprobe_events(bool readwrite)
{
2003
	return open_probe_events("uprobe_events", readwrite);
2004 2005 2006
}

/* Get raw string list of current kprobe_events  or uprobe_events */
2007
static struct strlist *get_probe_trace_command_rawlist(int fd)
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
{
	int ret, idx;
	FILE *fp;
	char buf[MAX_CMDLEN];
	char *p;
	struct strlist *sl;

	sl = strlist__new(true, NULL);

	fp = fdopen(dup(fd), "r");
	while (!feof(fp)) {
		p = fgets(buf, MAX_CMDLEN, fp);
		if (!p)
			break;

		idx = strlen(p) - 1;
		if (p[idx] == '\n')
			p[idx] = '\0';
		ret = strlist__add(sl, buf);
2027
		if (ret < 0) {
2028
			pr_debug("strlist__add failed (%d)\n", ret);
2029 2030 2031
			strlist__delete(sl);
			return NULL;
		}
2032 2033 2034 2035 2036 2037
	}
	fclose(fp);

	return sl;
}

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 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
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;
	const char *__debugfs = debugfs_find_mountpoint();
	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;
}

2127
/* Show an event */
2128 2129
static int show_perf_probe_event(struct perf_probe_event *pev,
				 const char *module)
2130
{
2131
	int i, ret;
2132
	char buf[128];
2133
	char *place;
2134

2135 2136
	/* Synthesize only event probe point */
	place = synthesize_perf_probe_point(&pev->point);
2137 2138
	if (!place)
		return -EINVAL;
2139 2140

	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
2141
	if (ret < 0)
2142 2143
		return ret;

2144
	pr_info("  %-20s (on %s", buf, place);
2145
	if (module)
2146
		pr_info(" in %s", module);
2147

2148
	if (pev->nargs > 0) {
2149
		pr_info(" with");
2150
		for (i = 0; i < pev->nargs; i++) {
2151 2152 2153 2154
			ret = synthesize_perf_probe_arg(&pev->args[i],
							buf, 128);
			if (ret < 0)
				break;
2155
			pr_info(" %s", buf);
2156
		}
2157
	}
2158
	pr_info(")\n");
2159
	free(place);
2160
	return ret;
2161 2162
}

2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
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)
2180
{
2181
	int ret = 0;
2182
	struct probe_trace_event tev;
2183
	struct perf_probe_event pev;
2184 2185 2186
	struct strlist *rawlist;
	struct str_node *ent;

2187 2188
	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
2189

2190
	rawlist = get_probe_trace_command_rawlist(fd);
2191
	if (!rawlist)
2192
		return -ENOMEM;
2193

2194
	strlist__for_each(ent, rawlist) {
2195
		ret = parse_probe_trace_command(ent->s, &tev);
2196
		if (ret >= 0) {
2197 2198
			if (!filter_probe_trace_event(&tev, filter))
				goto next;
2199 2200
			ret = convert_to_perf_probe_event(&tev, &pev,
								is_kprobe);
2201
			if (ret >= 0)
2202 2203
				ret = show_perf_probe_event(&pev,
							    tev.point.module);
2204
		}
2205
next:
2206
		clear_perf_probe_event(&pev);
2207
		clear_probe_trace_event(&tev);
2208 2209
		if (ret < 0)
			break;
2210 2211
	}
	strlist__delete(rawlist);
2212 2213

	return ret;
2214 2215
}

2216
/* List up current perf-probe events */
2217
int show_perf_probe_events(struct strfilter *filter)
2218
{
2219
	int kp_fd, up_fd, ret;
2220 2221 2222

	setup_pager();

2223
	ret = init_symbol_maps(false);
2224 2225 2226
	if (ret < 0)
		return ret;

2227 2228
	kp_fd = open_kprobe_events(false);
	if (kp_fd >= 0) {
2229
		ret = __show_perf_probe_events(kp_fd, true, filter);
2230 2231 2232 2233
		close(kp_fd);
		if (ret < 0)
			goto out;
	}
2234

2235 2236
	up_fd = open_uprobe_events(false);
	if (kp_fd < 0 && up_fd < 0) {
2237
		print_both_open_warning(kp_fd, up_fd);
2238 2239
		ret = kp_fd;
		goto out;
2240 2241
	}

2242
	if (up_fd >= 0) {
2243
		ret = __show_perf_probe_events(up_fd, false, filter);
2244 2245 2246
		close(up_fd);
	}
out:
2247
	exit_symbol_maps();
2248 2249 2250
	return ret;
}

2251
/* Get current perf-probe event names */
2252
static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
2253
{
2254
	char buf[128];
2255 2256
	struct strlist *sl, *rawlist;
	struct str_node *ent;
2257
	struct probe_trace_event tev;
2258
	int ret = 0;
2259

2260
	memset(&tev, 0, sizeof(tev));
2261
	rawlist = get_probe_trace_command_rawlist(fd);
2262 2263
	if (!rawlist)
		return NULL;
2264
	sl = strlist__new(true, NULL);
2265
	strlist__for_each(ent, rawlist) {
2266
		ret = parse_probe_trace_command(ent->s, &tev);
2267 2268
		if (ret < 0)
			break;
2269
		if (include_group) {
2270 2271 2272 2273
			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
					tev.event);
			if (ret >= 0)
				ret = strlist__add(sl, buf);
2274
		} else
2275
			ret = strlist__add(sl, tev.event);
2276
		clear_probe_trace_event(&tev);
2277 2278
		if (ret < 0)
			break;
2279 2280 2281
	}
	strlist__delete(rawlist);

2282 2283 2284 2285
	if (ret < 0) {
		strlist__delete(sl);
		return NULL;
	}
2286 2287 2288
	return sl;
}

2289
static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2290
{
2291
	int ret = 0;
2292
	char *buf = synthesize_probe_trace_command(tev);
2293
	char sbuf[STRERR_BUFSIZE];
2294

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

2300
	pr_debug("Writing event: %s\n", buf);
2301 2302
	if (!probe_event_dry_run) {
		ret = write(fd, buf, strlen(buf));
2303 2304
		if (ret <= 0) {
			ret = -errno;
2305
			pr_warning("Failed to write event: %s\n",
2306
				   strerror_r(errno, sbuf, sizeof(sbuf)));
2307
		}
2308
	}
2309
	free(buf);
2310
	return ret;
2311 2312
}

2313 2314
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
2315 2316
{
	int i, ret;
2317

2318 2319 2320
	if (*base == '.')
		base++;

2321 2322
	/* Try no suffix */
	ret = e_snprintf(buf, len, "%s", base);
2323
	if (ret < 0) {
2324
		pr_debug("snprintf() failed: %d\n", ret);
2325 2326
		return ret;
	}
2327
	if (!strlist__has_entry(namelist, buf))
2328
		return 0;
2329

2330 2331 2332
	if (!allow_suffix) {
		pr_warning("Error: event \"%s\" already exists. "
			   "(Use -f to force duplicates.)\n", base);
2333
		return -EEXIST;
2334 2335
	}

2336 2337
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2338
		ret = e_snprintf(buf, len, "%s_%d", base, i);
2339
		if (ret < 0) {
2340
			pr_debug("snprintf() failed: %d\n", ret);
2341 2342
			return ret;
		}
2343 2344 2345
		if (!strlist__has_entry(namelist, buf))
			break;
	}
2346 2347 2348 2349 2350 2351
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

	return ret;
2352 2353
}

2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
/* 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);
}

2375 2376
static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
2377
				     int ntevs, bool allow_suffix)
2378
{
2379
	int i, fd, ret;
2380
	struct probe_trace_event *tev = NULL;
2381 2382
	char buf[64];
	const char *event, *group;
2383
	struct strlist *namelist;
2384 2385
	LIST_HEAD(blacklist);
	struct kprobe_blacklist_node *node;
2386

2387 2388 2389 2390 2391
	if (pev->uprobes)
		fd = open_uprobe_events(true);
	else
		fd = open_kprobe_events(true);

2392 2393
	if (fd < 0) {
		print_open_warning(fd, !pev->uprobes);
2394
		return fd;
2395 2396
	}

2397
	/* Get current event names */
2398
	namelist = get_probe_trace_event_names(fd, false);
2399 2400
	if (!namelist) {
		pr_debug("Failed to get current event list.\n");
2401 2402
		ret = -ENOMEM;
		goto close_out;
2403
	}
2404 2405 2406 2407 2408 2409
	/* Get kprobe blacklist if exists */
	if (!pev->uprobes) {
		ret = kprobe_blacklist__load(&blacklist);
		if (ret < 0)
			pr_debug("No kprobe blacklist support, ignored\n");
	}
2410

2411
	ret = 0;
2412
	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2413
	for (i = 0; i < ntevs; i++) {
2414
		tev = &tevs[i];
2415 2416 2417
		/* Skip if the symbol is out of .text (marked previously) */
		if (!tev->point.symbol)
			continue;
2418 2419 2420 2421 2422 2423 2424 2425
		/* Ensure that the address is NOT blacklisted */
		node = kprobe_blacklist__find_by_address(&blacklist,
							 tev->point.address);
		if (node) {
			pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol);
			continue;
		}

2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
		if (pev->event)
			event = pev->event;
		else
			if (pev->point.function)
				event = pev->point.function;
			else
				event = tev->point.symbol;
		if (pev->group)
			group = pev->group;
		else
			group = PERFPROBE_GROUP;

		/* Get an unused new event name */
2439 2440 2441 2442
		ret = get_new_event_name(buf, 64, event,
					 namelist, allow_suffix);
		if (ret < 0)
			break;
2443 2444
		event = buf;

2445 2446 2447 2448 2449 2450
		tev->event = strdup(event);
		tev->group = strdup(group);
		if (tev->event == NULL || tev->group == NULL) {
			ret = -ENOMEM;
			break;
		}
2451
		ret = write_probe_trace_event(fd, tev);
2452 2453
		if (ret < 0)
			break;
2454 2455 2456 2457 2458 2459 2460 2461
		/* Add added event name to namelist */
		strlist__add(namelist, event);

		/* Trick here - save current event/group */
		event = pev->event;
		group = pev->group;
		pev->event = tev->event;
		pev->group = tev->group;
2462
		show_perf_probe_event(pev, tev->point.module);
2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
		/* Trick here - restore current event/group */
		pev->event = (char *)event;
		pev->group = (char *)group;

		/*
		 * 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;
2474
	}
2475 2476
	if (ret == -EINVAL && pev->uprobes)
		warn_uprobe_event_compat(tev);
2477

2478 2479
	/* Note that it is possible to skip all events because of blacklist */
	if (ret >= 0 && tev->event) {
2480
		/* Show how to use the event. */
2481 2482
		pr_info("\nYou can now use it in all perf tools, such as:\n\n");
		pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
2483 2484
			 tev->event);
	}
2485

2486
	kprobe_blacklist__delete(&blacklist);
2487
	strlist__delete(namelist);
2488
close_out:
2489
	close(fd);
2490
	return ret;
2491
}
2492

2493
static int find_probe_functions(struct map *map, char *name)
2494
{
2495
	int found = 0;
2496
	struct symbol *sym;
2497

2498
	map__for_each_symbol_by_name(map, name, sym) {
2499
		found++;
2500
	}
2501 2502

	return found;
2503 2504 2505 2506 2507
}

#define strdup_or_goto(str, label)	\
	({ char *__p = strdup(str); if (!__p) goto label; __p; })

2508 2509 2510 2511
void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
				struct probe_trace_event *tev __maybe_unused,
				struct map *map __maybe_unused) { }

2512 2513 2514 2515 2516 2517
/*
 * 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,
					    struct probe_trace_event **tevs,
2518
					    int max_tevs)
2519
{
2520 2521
	struct map *map = NULL;
	struct ref_reloc_sym *reloc_sym = NULL;
2522
	struct symbol *sym;
2523
	struct probe_trace_event *tev;
2524 2525
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_point *tp;
2526
	int num_matched_functions;
2527
	int ret, i;
2528

2529
	map = get_target_map(pev->target, pev->uprobes);
2530 2531 2532
	if (!map) {
		ret = -EINVAL;
		goto out;
2533 2534
	}

2535 2536 2537 2538
	/*
	 * Load matched symbols: Since the different local symbols may have
	 * same name but different addresses, this lists all the symbols.
	 */
2539 2540
	num_matched_functions = find_probe_functions(map, pp->function);
	if (num_matched_functions == 0) {
2541
		pr_err("Failed to find symbol %s in %s\n", pp->function,
2542
			pev->target ? : "kernel");
2543 2544 2545 2546
		ret = -ENOENT;
		goto out;
	} else if (num_matched_functions > max_tevs) {
		pr_err("Too many functions matched in %s\n",
2547
			pev->target ? : "kernel");
2548 2549
		ret = -E2BIG;
		goto out;
2550 2551
	}

2552
	if (!pev->uprobes && !pp->retprobe) {
2553
		reloc_sym = kernel_get_ref_reloc_sym();
2554 2555 2556 2557 2558 2559
		if (!reloc_sym) {
			pr_warning("Relocated base symbol is not found!\n");
			ret = -EINVAL;
			goto out;
		}
	}
2560

2561 2562 2563
	/* Setup result trace-probe-events */
	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
	if (!*tevs) {
2564
		ret = -ENOMEM;
2565
		goto out;
2566
	}
2567

2568
	ret = 0;
2569

2570
	map__for_each_symbol_by_name(map, pp->function, sym) {
2571 2572 2573 2574 2575
		tev = (*tevs) + ret;
		tp = &tev->point;
		if (ret == num_matched_functions) {
			pr_warning("Too many symbols are listed. Skip it.\n");
			break;
2576
		}
2577
		ret++;
2578

2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594
		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;
		if (reloc_sym) {
			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;
		}
		tp->retprobe = pp->retprobe;
2595 2596 2597
		if (pev->target)
			tev->point.module = strdup_or_goto(pev->target,
							   nomem_out);
2598 2599 2600 2601 2602 2603 2604
		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;
2605
		}
2606
		for (i = 0; i < tev->nargs; i++) {
2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
			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);
2618
		}
2619
		arch__fix_tev_from_maps(pev, tev, map);
2620 2621
	}

2622
out:
2623
	put_target_map(map, pev->uprobes);
2624
	return ret;
2625

2626 2627 2628 2629 2630 2631 2632
nomem_out:
	ret = -ENOMEM;
err_out:
	clear_probe_trace_events(*tevs, num_matched_functions);
	zfree(tevs);
	goto out;
}
2633

2634 2635
bool __weak arch__prefers_symtab(void) { return false; }

2636 2637
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
					  struct probe_trace_event **tevs,
2638
					  int max_tevs)
2639 2640 2641 2642 2643
{
	int ret;

	if (pev->uprobes && !pev->group) {
		/* Replace group name if not given */
2644
		ret = convert_exec_to_group(pev->target, &pev->group);
2645 2646 2647 2648
		if (ret != 0) {
			pr_warning("Failed to make a group name.\n");
			return ret;
		}
2649
	}
2650

2651
	if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
2652
		ret = find_probe_trace_events_from_map(pev, tevs, max_tevs);
2653 2654 2655 2656
		if (ret > 0)
			return ret; /* Found in symbol table */
	}

2657
	/* Convert perf_probe_event with debuginfo */
2658
	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs);
2659 2660 2661
	if (ret != 0)
		return ret;	/* Found in debuginfo or got an error */

2662
	return find_probe_trace_events_from_map(pev, tevs, max_tevs);
2663 2664 2665 2666
}

struct __event_package {
	struct perf_probe_event		*pev;
2667
	struct probe_trace_event	*tevs;
2668 2669 2670
	int				ntevs;
};

2671
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
2672
			  int max_tevs, bool force_add)
2673
{
2674
	int i, j, ret;
2675 2676
	struct __event_package *pkgs;

2677
	ret = 0;
2678
	pkgs = zalloc(sizeof(struct __event_package) * npevs);
2679

2680 2681
	if (pkgs == NULL)
		return -ENOMEM;
2682

2683
	ret = init_symbol_maps(pevs->uprobes);
2684 2685
	if (ret < 0) {
		free(pkgs);
2686
		return ret;
2687
	}
2688 2689 2690 2691 2692

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
		pkgs[i].pev = &pevs[i];
		/* Convert with or without debuginfo */
2693
		ret  = convert_to_probe_trace_events(pkgs[i].pev,
2694
						     &pkgs[i].tevs,
2695
						     max_tevs);
2696 2697 2698
		if (ret < 0)
			goto end;
		pkgs[i].ntevs = ret;
2699 2700
	}

2701
	/* Loop 2: add all events */
2702
	for (i = 0; i < npevs; i++) {
2703
		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2704
						pkgs[i].ntevs, force_add);
2705 2706 2707
		if (ret < 0)
			break;
	}
2708
end:
2709 2710
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
2711
		for (j = 0; j < pkgs[i].ntevs; j++)
2712
			clear_probe_trace_event(&pkgs[i].tevs[j]);
2713
		zfree(&pkgs[i].tevs);
2714 2715
	}
	free(pkgs);
2716
	exit_symbol_maps();
2717 2718

	return ret;
2719 2720
}

2721
static int __del_trace_probe_event(int fd, struct str_node *ent)
2722 2723 2724
{
	char *p;
	char buf[128];
2725
	int ret;
2726

2727
	/* Convert from perf-probe event to trace-probe event */
2728 2729 2730 2731
	ret = e_snprintf(buf, 128, "-:%s", ent->s);
	if (ret < 0)
		goto error;

2732
	p = strchr(buf + 2, ':');
2733 2734 2735 2736 2737 2738
	if (!p) {
		pr_debug("Internal error: %s should have ':' but not.\n",
			 ent->s);
		ret = -ENOTSUP;
		goto error;
	}
2739 2740
	*p = '/';

2741 2742
	pr_debug("Writing event: %s\n", buf);
	ret = write(fd, buf, strlen(buf));
2743 2744
	if (ret < 0) {
		ret = -errno;
2745
		goto error;
2746
	}
2747

2748
	pr_info("Removed event: %s\n", ent->s);
2749 2750
	return 0;
error:
2751 2752
	pr_warning("Failed to delete event: %s\n",
		   strerror_r(-ret, buf, sizeof(buf)));
2753
	return ret;
2754 2755
}

2756 2757
static int del_trace_probe_events(int fd, struct strfilter *filter,
				  struct strlist *namelist)
2758
{
2759 2760
	struct str_node *ent;
	const char *p;
2761
	int ret = -ENOENT;
2762

2763 2764 2765 2766 2767 2768 2769
	if (!namelist)
		return -ENOENT;

	strlist__for_each(ent, namelist) {
		p = strchr(ent->s, ':');
		if ((p && strfilter__compare(filter, p + 1)) ||
		    strfilter__compare(filter, ent->s)) {
2770
			ret = __del_trace_probe_event(fd, ent);
2771 2772
			if (ret < 0)
				break;
2773 2774
		}
	}
2775 2776

	return ret;
2777 2778
}

2779
int del_perf_probe_events(struct strfilter *filter)
2780
{
2781
	int ret, ret2, ufd = -1, kfd = -1;
2782
	struct strlist *namelist = NULL, *unamelist = NULL;
2783 2784 2785 2786 2787 2788
	char *str = strfilter__string(filter);

	if (!str)
		return -EINVAL;

	pr_debug("Delete filter: \'%s\'\n", str);
2789

2790
	/* Get current event names */
2791
	kfd = open_kprobe_events(true);
2792 2793
	if (kfd >= 0)
		namelist = get_probe_trace_event_names(kfd, true);
2794 2795

	ufd = open_uprobe_events(true);
2796
	if (ufd >= 0)
2797 2798
		unamelist = get_probe_trace_event_names(ufd, true);

2799 2800
	if (kfd < 0 && ufd < 0) {
		print_both_open_warning(kfd, ufd);
2801
		ret = kfd;
2802 2803 2804
		goto error;
	}

2805 2806
	ret = del_trace_probe_events(kfd, filter, namelist);
	if (ret < 0 && ret != -ENOENT)
2807 2808
		goto error;

2809 2810 2811 2812 2813 2814 2815
	ret2 = del_trace_probe_events(ufd, filter, unamelist);
	if (ret2 < 0 && ret2 != -ENOENT)
		ret = ret2;
	else if (ret == -ENOENT && ret2 == -ENOENT) {
		pr_debug("\"%s\" does not hit any event.\n", str);
		/* Note that this is silently ignored */
		ret = 0;
2816
	}
2817 2818 2819

error:
	if (kfd >= 0) {
2820
		strlist__delete(namelist);
2821 2822 2823 2824
		close(kfd);
	}

	if (ufd >= 0) {
2825
		strlist__delete(unamelist);
2826 2827
		close(ufd);
	}
2828
	free(str);
2829 2830

	return ret;
2831
}
2832

2833 2834
/* TODO: don't use a global variable for filter ... */
static struct strfilter *available_func_filter;
2835

2836
/*
2837 2838
 * If a symbol corresponds to a function with global binding and
 * matches filter return 0. For all others return 1.
2839
 */
2840
static int filter_available_functions(struct map *map __maybe_unused,
2841
				      struct symbol *sym)
2842
{
2843
	if (strfilter__compare(available_func_filter, sym->name))
2844 2845
		return 0;
	return 1;
2846 2847
}

2848 2849
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
2850 2851 2852 2853
{
	struct map *map;
	int ret;

2854
	ret = init_symbol_maps(user);
2855 2856 2857
	if (ret < 0)
		return ret;

2858 2859 2860 2861 2862
	/* Get a symbol map */
	if (user)
		map = dso__new_map(target);
	else
		map = kernel_get_module_map(target);
2863
	if (!map) {
2864
		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2865 2866
		return -EINVAL;
	}
2867

2868
	/* Load symbols with given filter */
2869
	available_func_filter = _filter;
2870 2871 2872 2873 2874 2875
	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);
2876

2877 2878 2879 2880 2881 2882 2883 2884 2885
	/* Show all (filtered) symbols */
	setup_pager();
	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
end:
	if (user) {
		dso__delete(map->dso);
		map__delete(map);
	}
	exit_symbol_maps();
2886

2887
	return ret;
2888 2889
}