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
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
/* If there is no space to write, returns -E2BIG. */
59 60 61
static int e_snprintf(char *str, size_t size, const char *format, ...)
	__attribute__((format(printf, 3, 4)));

62 63 64 65 66 67 68 69 70 71 72 73
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;
}

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

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

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

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

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

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

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

125 126 127 128 129 130 131 132 133 134 135 136 137 138
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]);
139 140
	if (!kmap)
		return NULL;
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
	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 已提交
158
				((reloc) ? 0 : map->reloc);
159 160 161 162
	}
	return 0;
}

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

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

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

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

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 */
		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
			/* 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);
596 597 598 599 600
			tevs[i].point.symbol = tmp;
			tevs[i].point.offset = tevs[i].point.address -
					       reloc_sym->unrelocated_addr;
		}
	}
601
	return skipped;
602 603
}

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

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

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

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

638
	debuginfo__delete(dinfo);
639

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

654
	if (ntevs == 0)	{	/* No error but failed to find probe point. */
655
		pr_warning("Probe point '%s' not found.\n",
656
			   synthesize_perf_probe_point(&pev->point));
657
		return -ENOENT;
658 659
	}
	/* Error path : ntevs < 0 */
660 661 662 663 664
	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 已提交
665
			pr_debug("Trying to use symbols.\n");
666 667
			return 0;
		}
668
	}
669
	return ntevs;
670 671 672 673 674
}

#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

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

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

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

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

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

714 715 716 717 718
#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)

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

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

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

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

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

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

767 768 769
	setup_pager();

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

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

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

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

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

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

	return ret;
}

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

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

840
	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
841
	if (!ret) {  /* Not found, retry with an alternative */
842
		ret = get_alternative_probe_event(dinfo, pev, &tmp);
843 844
		if (!ret) {
			ret = debuginfo__find_available_vars_at(dinfo, pev,
845
								&vls);
846 847 848 849
			/* 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
			struct strfilter *_filter)
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
	for (i = 0; i < npevs && ret >= 0; i++)
910
		ret = show_available_vars_at(dinfo, &pevs[i], _filter);
911 912

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

918
#else	/* !HAVE_DWARF_SUPPORT */
919

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

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

936 937 938
	return 0;
}

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

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

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

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

976 977 978 979 980 981 982 983 984 985 986 987 988
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;
}

989 990 991 992 993 994 995 996 997 998 999 1000
/* 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;
}

1001 1002 1003 1004 1005
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
1006
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
1007
 */
1008
int parse_line_range_desc(const char *arg, struct line_range *lr)
1009
{
1010
	char *range, *file, *name = strdup(arg);
1011 1012 1013 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
	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--;
			}
		}
1045

1046
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1047 1048

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

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

	return 0;
1080 1081 1082
err:
	free(name);
	return err;
1083 1084
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return ret;
1397 1398
}

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

	return false;
}

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

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

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

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

1463 1464 1465 1466 1467 1468 1469
	/* 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];
1470
	fmt1_str = strtok_r(p, "+", &fmt);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
	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);
1485
	}
1486

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

1514 1515 1516 1517 1518 1519 1520
/* 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;

1521 1522 1523 1524
	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);
1525 1526 1527 1528 1529 1530
	if (ret <= 0)
		goto error;
	tmp += ret;
	len -= ret;

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

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

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

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

1564 1565 1566 1567 1568
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL) {
		ret = -ENOMEM;
		goto error;
	}
1569
	if (pp->offset) {
1570
		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1571 1572 1573 1574
		if (ret <= 0)
			goto error;
	}
	if (pp->line) {
1575 1576 1577 1578 1579
		ret = e_snprintf(line, 32, ":%d", pp->line);
		if (ret <= 0)
			goto error;
	}
	if (pp->file) {
1580 1581 1582 1583 1584 1585 1586
		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);
1587 1588 1589 1590 1591
		if (ret <= 0)
			goto error;
	}

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

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

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

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

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

1628 1629 1630 1631
	return buf;
}
#endif

1632
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1633 1634 1635 1636 1637
					     char **buf, size_t *buflen,
					     int depth)
{
	int ret;
	if (ref->next) {
1638
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
							 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;
1653 1654 1655

}

1656
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1657
				       char *buf, size_t buflen)
1658
{
1659
	struct probe_trace_arg_ref *ref = arg->ref;
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
	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;

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

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

	/* Print argument value */
1686 1687 1688 1689 1690
	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);
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
	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;
	}
1704 1705 1706 1707 1708 1709 1710
	/* Print argument type */
	if (arg->type) {
		ret = e_snprintf(buf, buflen, ":%s", arg->type);
		if (ret <= 0)
			return ret;
		buf += ret;
	}
1711 1712 1713 1714

	return buf - tmp;
}

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

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

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
	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 */
1735
	if (tev->uprobes)
1736 1737
		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
				 tp->module, tp->address);
1738
	else
1739
		ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1740 1741 1742
				 tp->module ?: "", tp->module ? ":" : "",
				 tp->symbol, tp->offset);

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

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

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

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

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

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

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

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

	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
1871 1872 1873 1874
}

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

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

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

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

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

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

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

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

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

1947 1948 1949 1950
static void print_both_open_warning(int kerr, int uerr)
{
	/* Both kprobes and uprobes are disabled, warn it. */
	if (kerr == -ENOTSUP && uerr == -ENOTSUP)
1951
		pr_warning("Tracefs or debugfs is not mounted.\n");
1952 1953 1954 1955
	else if (kerr == -ENOENT && uerr == -ENOENT)
		pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
			   "or/and CONFIG_UPROBE_EVENTS.\n");
	else {
1956
		char sbuf[STRERR_BUFSIZE];
1957 1958 1959 1960 1961 1962 1963
		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)));
	}
}

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

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

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

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

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

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

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

/* Get raw string list of current kprobe_events  or uprobe_events */
2006
static struct strlist *get_probe_trace_command_rawlist(int fd)
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
{
	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);
2026
		if (ret < 0) {
2027
			pr_debug("strlist__add failed (%d)\n", ret);
2028 2029 2030
			strlist__delete(sl);
			return NULL;
		}
2031 2032 2033 2034 2035 2036
	}
	fclose(fp);

	return sl;
}

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 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
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;
}

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

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

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

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

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

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

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

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

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

	return ret;
2213 2214
}

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

	setup_pager();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return ret;
2351 2352
}

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

2374 2375
static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
2376
				     int ntevs, bool allow_suffix)
2377
{
2378
	int i, fd, ret;
2379
	struct probe_trace_event *tev = NULL;
2380 2381
	char buf[64];
	const char *event, *group;
2382
	struct strlist *namelist;
2383 2384
	LIST_HEAD(blacklist);
	struct kprobe_blacklist_node *node;
2385
	bool safename;
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
	safename = (pev->point.function && !strisglob(pev->point.function));
2412
	ret = 0;
2413
	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2414
	for (i = 0; i < ntevs; i++) {
2415
		tev = &tevs[i];
2416 2417 2418
		/* Skip if the symbol is out of .text (marked previously) */
		if (!tev->point.symbol)
			continue;
2419 2420 2421 2422 2423 2424 2425 2426
		/* 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;
		}

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

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

2446 2447 2448 2449 2450 2451
		tev->event = strdup(event);
		tev->group = strdup(group);
		if (tev->event == NULL || tev->group == NULL) {
			ret = -ENOMEM;
			break;
		}
2452
		ret = write_probe_trace_event(fd, tev);
2453 2454
		if (ret < 0)
			break;
2455 2456 2457 2458 2459 2460 2461 2462
		/* 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;
2463
		show_perf_probe_event(pev, tev->point.module);
2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
		/* 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;
2475
	}
2476 2477
	if (ret == -EINVAL && pev->uprobes)
		warn_uprobe_event_compat(tev);
2478

2479 2480
	/* Note that it is possible to skip all events because of blacklist */
	if (ret >= 0 && tev->event) {
2481
		/* Show how to use the event. */
2482 2483
		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,
2484 2485
			 tev->event);
	}
2486

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

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

2500 2501 2502
	if (map__load(map, NULL) < 0)
		return 0;

2503 2504 2505
	map__for_each_symbol(map, sym, tmp) {
		if (strglobmatch(sym->name, name))
			found++;
2506
	}
2507 2508

	return found;
2509 2510 2511 2512 2513
}

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

2514 2515 2516 2517
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) { }

2518 2519 2520 2521 2522
/*
 * 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,
2523
					    struct probe_trace_event **tevs)
2524
{
2525 2526
	struct map *map = NULL;
	struct ref_reloc_sym *reloc_sym = NULL;
2527
	struct symbol *sym;
2528
	struct probe_trace_event *tev;
2529 2530
	struct perf_probe_point *pp = &pev->point;
	struct probe_trace_point *tp;
2531
	int num_matched_functions;
2532
	int ret, i;
2533

2534
	map = get_target_map(pev->target, pev->uprobes);
2535 2536 2537
	if (!map) {
		ret = -EINVAL;
		goto out;
2538 2539
	}

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

2557
	if (!pev->uprobes && !pp->retprobe) {
2558
		reloc_sym = kernel_get_ref_reloc_sym();
2559 2560 2561 2562 2563 2564
		if (!reloc_sym) {
			pr_warning("Relocated base symbol is not found!\n");
			ret = -EINVAL;
			goto out;
		}
	}
2565

2566 2567 2568
	/* Setup result trace-probe-events */
	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
	if (!*tevs) {
2569
		ret = -ENOMEM;
2570
		goto out;
2571
	}
2572

2573
	ret = 0;
2574

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

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

2627
out:
2628
	put_target_map(map, pev->uprobes);
2629
	return ret;
2630

2631 2632 2633 2634 2635 2636 2637
nomem_out:
	ret = -ENOMEM;
err_out:
	clear_probe_trace_events(*tevs, num_matched_functions);
	zfree(tevs);
	goto out;
}
2638

2639 2640
bool __weak arch__prefers_symtab(void) { return false; }

2641
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2642
					 struct probe_trace_event **tevs)
2643 2644 2645 2646 2647
{
	int ret;

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

2655
	if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
2656
		ret = find_probe_trace_events_from_map(pev, tevs);
2657 2658 2659 2660
		if (ret > 0)
			return ret; /* Found in symbol table */
	}

2661
	/* Convert perf_probe_event with debuginfo */
2662
	ret = try_to_find_probe_trace_events(pev, tevs);
2663 2664 2665
	if (ret != 0)
		return ret;	/* Found in debuginfo or got an error */

2666
	return find_probe_trace_events_from_map(pev, tevs);
2667 2668 2669 2670
}

struct __event_package {
	struct perf_probe_event		*pev;
2671
	struct probe_trace_event	*tevs;
2672 2673 2674
	int				ntevs;
};

2675
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
2676
{
2677
	int i, j, ret;
2678 2679
	struct __event_package *pkgs;

2680
	ret = 0;
2681
	pkgs = zalloc(sizeof(struct __event_package) * npevs);
2682

2683 2684
	if (pkgs == NULL)
		return -ENOMEM;
2685

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

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

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

	return ret;
2722 2723
}

2724
static int __del_trace_probe_event(int fd, struct str_node *ent)
2725 2726 2727
{
	char *p;
	char buf[128];
2728
	int ret;
2729

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

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

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

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

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

2766 2767 2768 2769 2770 2771 2772
	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)) {
2773
			ret = __del_trace_probe_event(fd, ent);
2774 2775
			if (ret < 0)
				break;
2776 2777
		}
	}
2778 2779

	return ret;
2780 2781
}

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

	if (!str)
		return -EINVAL;

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

2793
	/* Get current event names */
2794
	kfd = open_kprobe_events(true);
2795 2796
	if (kfd >= 0)
		namelist = get_probe_trace_event_names(kfd, true);
2797 2798

	ufd = open_uprobe_events(true);
2799
	if (ufd >= 0)
2800 2801
		unamelist = get_probe_trace_event_names(ufd, true);

2802 2803
	if (kfd < 0 && ufd < 0) {
		print_both_open_warning(kfd, ufd);
2804
		ret = kfd;
2805 2806 2807
		goto error;
	}

2808 2809
	ret = del_trace_probe_events(kfd, filter, namelist);
	if (ret < 0 && ret != -ENOENT)
2810 2811
		goto error;

2812 2813 2814 2815 2816 2817 2818
	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;
2819
	}
2820 2821 2822

error:
	if (kfd >= 0) {
2823
		strlist__delete(namelist);
2824 2825 2826 2827
		close(kfd);
	}

	if (ufd >= 0) {
2828
		strlist__delete(unamelist);
2829 2830
		close(ufd);
	}
2831
	free(str);
2832 2833

	return ret;
2834
}
2835

2836 2837
/* TODO: don't use a global variable for filter ... */
static struct strfilter *available_func_filter;
2838

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

2851 2852
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
2853 2854 2855 2856
{
	struct map *map;
	int ret;

2857
	ret = init_symbol_maps(user);
2858 2859 2860
	if (ret < 0)
		return ret;

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

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

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

2889
	return ret;
2890 2891
}