probe-event.c 56.5 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 "trace-event.h"	/* For __maybe_unused */
45
#include "probe-event.h"
46
#include "probe-finder.h"
47
#include "session.h"
48 49 50 51

#define MAX_CMDLEN 256
#define PERFPROBE_GROUP "probe"

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

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

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

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

72
static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
73 74
static int convert_name_to_addr(struct perf_probe_event *pev,
				const char *exec);
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 85 86 87 88
	ret = symbol__init();
	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 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
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]);
	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) -
				(reloc) ? 0 : map->reloc;
	}
	return 0;
}

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

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

169 170 171 172 173 174 175 176 177 178 179 180 181 182
	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;
}

static struct dso *kernel_get_module_dso(const char *module)
183 184
{
	struct dso *dso;
185 186
	struct map *map;
	const char *vmlinux_name;
187 188

	if (module) {
189
		list_for_each_entry(dso, &host_machine->kernel_dsos, node) {
190 191 192 193 194 195
			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;
196 197
	}

198
	map = host_machine->vmlinux_maps[MAP__FUNCTION];
199 200 201 202
	dso = map->dso;

	vmlinux_name = symbol_conf.vmlinux_name;
	if (vmlinux_name) {
203
		if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
204
			return NULL;
205
	} else {
206
		if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
207 208 209 210 211
			pr_debug("Failed to load kernel map.\n");
			return NULL;
		}
	}
found:
212 213 214 215 216 217 218
	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;
219 220
}

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
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;
}

252
#ifdef HAVE_DWARF_SUPPORT
253 254
/* Open new debuginfo of given module */
static struct debuginfo *open_debuginfo(const char *module)
255
{
256
	const char *path;
257

258 259 260 261 262 263 264 265 266 267 268
	/* A file path -- this is an offline module */
	if (module && strchr(module, '/'))
		path = module;
	else {
		path = kernel_get_module_path(module);

		if (!path) {
			pr_err("Failed to find path of %s module.\n",
			       module ?: "kernel");
			return NULL;
		}
269
	}
270
	return debuginfo__new(path);
271
}
272

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
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;
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
/*
 * 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");

	dinfo = open_debuginfo(tp->module);
	if (dinfo) {
		ret = debuginfo__find_probe_point(dinfo,
						 (unsigned long)addr, pp);
		debuginfo__delete(dinfo);
	} else {
		pr_debug("Failed to open debuginfo at 0x%" PRIx64 "\n", addr);
		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;
}

352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
					  int ntevs, const char *exec)
{
	int i, ret = 0;
	unsigned long offset, stext = 0;
	char buf[32];

	if (!exec)
		return 0;

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

	for (i = 0; i < ntevs && ret >= 0; i++) {
367
		/* point.address is the addres of point.symbol + point.offset */
368 369
		offset = tevs[i].point.address - stext;
		tevs[i].point.offset = 0;
370
		zfree(&tevs[i].point.symbol);
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
		ret = e_snprintf(buf, 32, "0x%lx", offset);
		if (ret < 0)
			break;
		tevs[i].point.module = strdup(exec);
		tevs[i].point.symbol = strdup(buf);
		if (!tevs[i].point.symbol || !tevs[i].point.module) {
			ret = -ENOMEM;
			break;
		}
		tevs[i].uprobes = true;
	}

	return ret;
}

386 387 388
static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
					    int ntevs, const char *module)
{
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
	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() */
	}

407 408
	for (i = 0; i < ntevs; i++) {
		tevs[i].point.module = strdup(module);
409 410 411 412
		if (!tevs[i].point.module) {
			ret = -ENOMEM;
			break;
		}
413
	}
414

415
	free(tmp);
416
	return ret;
417 418
}

419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
/* Post processing the probe events */
static int post_process_probe_trace_events(struct probe_trace_event *tevs,
					   int ntevs, const char *module,
					   bool uprobe)
{
	struct ref_reloc_sym *reloc_sym;
	char *tmp;
	int i;

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

435
	reloc_sym = kernel_get_ref_reloc_sym();
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
	if (!reloc_sym) {
		pr_warning("Relocated base symbol is not found!\n");
		return -EINVAL;
	}

	for (i = 0; i < ntevs; i++) {
		if (tevs[i].point.address) {
			tmp = strdup(reloc_sym->name);
			if (!tmp)
				return -ENOMEM;
			free(tevs[i].point.symbol);
			tevs[i].point.symbol = tmp;
			tevs[i].point.offset = tevs[i].point.address -
					       reloc_sym->unrelocated_addr;
		}
	}
	return 0;
}

455 456 457 458 459 460 461 462
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);
}

463
/* Try to find perf_probe_event with debuginfo */
464
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
465
					  struct probe_trace_event **tevs,
466
					  int max_tevs, const char *target)
467 468
{
	bool need_dwarf = perf_probe_event_need_dwarf(pev);
469
	struct debuginfo *dinfo;
470
	int ntevs, ret = 0;
471

472 473
	dinfo = open_debuginfo(target);

474
	if (!dinfo) {
475 476
		if (need_dwarf) {
			pr_warning("Failed to open debuginfo file.\n");
477
			return -ENOENT;
478
		}
479
		pr_debug("Could not open debuginfo. Try to use symbols.\n");
480 481 482
		return 0;
	}

483
	pr_debug("Try to find probe point from debuginfo.\n");
484 485 486 487
	/* Searching trace events corresponding to a probe event */
	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);

	debuginfo__delete(dinfo);
488

489
	if (ntevs > 0) {	/* Succeeded to find trace events */
490 491 492
		pr_debug("Found %d probe_trace_events.\n", ntevs);
		ret = post_process_probe_trace_events(*tevs, ntevs,
							target, pev->uprobes);
493 494 495 496
		if (ret < 0) {
			clear_probe_trace_events(*tevs, ntevs);
			zfree(tevs);
		}
497
		return ret < 0 ? ret : ntevs;
498
	}
499

500 501 502 503 504 505
	if (ntevs == 0)	{	/* No error but failed to find probe point. */
		pr_warning("Probe point '%s' not found.\n",
			   synthesize_perf_probe_point(&pev->point));
		return -ENOENT;
	}
	/* Error path : ntevs < 0 */
506 507 508 509 510
	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 已提交
511
			pr_debug("Trying to use symbols.\n");
512 513
			return 0;
		}
514
	}
515
	return ntevs;
516 517
}

518 519 520 521 522 523
/*
 * Find a src file from a DWARF tag path. Prepend optional source path prefix
 * and chop off leading directories that do not exist. Result is passed back as
 * a newly allocated path on success.
 * Return 0 if file was found and readable, -errno otherwise.
 */
524 525
static int get_real_path(const char *raw_path, const char *comp_dir,
			 char **new_path)
526
{
527 528 529 530 531 532 533 534 535 536 537 538 539
	const char *prefix = symbol_conf.source_prefix;

	if (!prefix) {
		if (raw_path[0] != '/' && comp_dir)
			/* If not an absolute path, try to use comp_dir */
			prefix = comp_dir;
		else {
			if (access(raw_path, R_OK) == 0) {
				*new_path = strdup(raw_path);
				return 0;
			} else
				return -errno;
		}
540 541
	}

542
	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
543 544 545 546
	if (!*new_path)
		return -ENOMEM;

	for (;;) {
547
		sprintf(*new_path, "%s/%s", prefix, raw_path);
548 549 550 551

		if (access(*new_path, R_OK) == 0)
			return 0;

552 553 554 555
		if (!symbol_conf.source_prefix)
			/* In case of searching comp_dir, don't retry */
			return -errno;

556 557 558 559 560 561 562
		switch (errno) {
		case ENAMETOOLONG:
		case ENOENT:
		case EROFS:
		case EFAULT:
			raw_path = strchr(++raw_path, '/');
			if (!raw_path) {
563
				zfree(new_path);
564 565 566 567 568
				return -ENOENT;
			}
			continue;

		default:
569
			zfree(new_path);
570 571 572 573 574
			return -errno;
		}
	}
}

575 576 577
#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

578
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
579 580
{
	char buf[LINEBUF_SIZE];
581 582
	const char *color = show_num ? "" : PERF_COLOR_BLUE;
	const char *prefix = NULL;
583

584
	do {
585 586
		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
			goto error;
587 588 589 590 591
		if (skip)
			continue;
		if (!prefix) {
			prefix = show_num ? "%7d  " : "         ";
			color_fprintf(stdout, color, prefix, l);
592
		}
593 594 595
		color_fprintf(stdout, color, "%s", buf);

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

597
	return 1;
598
error:
599
	if (ferror(fp)) {
600
		pr_warning("File read error: %s\n", strerror(errno));
601 602 603 604
		return -1;
	}
	return 0;
}
605

606 607 608 609 610 611 612 613
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;
614 615
}

616 617 618 619 620
#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)

621 622 623 624
/*
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
625
static int __show_line_range(struct line_range *lr, const char *module)
626
{
627
	int l = 1;
628
	struct int_node *ln;
629
	struct debuginfo *dinfo;
630
	FILE *fp;
631
	int ret;
632
	char *tmp;
633 634

	/* Search a line range */
635 636
	dinfo = open_debuginfo(module);
	if (!dinfo) {
637
		pr_warning("Failed to open debuginfo file.\n");
638
		return -ENOENT;
639 640
	}

641 642
	ret = debuginfo__find_line_range(dinfo, lr);
	debuginfo__delete(dinfo);
643 644 645 646 647 648 649
	if (ret == 0) {
		pr_warning("Specified source line is not found.\n");
		return -ENOENT;
	} else if (ret < 0) {
		pr_warning("Debuginfo analysis failed. (%d)\n", ret);
		return ret;
	}
650

651 652
	/* Convert source file path */
	tmp = lr->path;
653
	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
654 655 656 657 658 659
	free(tmp);	/* Free old path */
	if (ret < 0) {
		pr_warning("Failed to find source file. (%d)\n", ret);
		return ret;
	}

660 661 662
	setup_pager();

	if (lr->function)
663
		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
664 665
			lr->start - lr->offset);
	else
666
		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
667 668

	fp = fopen(lr->path, "r");
669 670 671 672 673
	if (fp == NULL) {
		pr_warning("Failed to open %s: %s\n", lr->path,
			   strerror(errno));
		return -errno;
	}
674
	/* Skip to starting line number */
675
	while (l < lr->start) {
676
		ret = skip_one_line(fp, l++);
677 678 679
		if (ret < 0)
			goto end;
	}
680

681 682
	intlist__for_each(ln, lr->line_list) {
		for (; ln->i > l; l++) {
683
			ret = show_one_line(fp, l - lr->offset);
684 685 686
			if (ret < 0)
				goto end;
		}
687
		ret = show_one_line_with_num(fp, l++ - lr->offset);
688 689
		if (ret < 0)
			goto end;
690 691 692 693
	}

	if (lr->end == INT_MAX)
		lr->end = l + NR_ADDITIONAL_LINES;
694 695 696
	while (l <= lr->end) {
		ret = show_one_line_or_eof(fp, l++ - lr->offset);
		if (ret <= 0)
697 698
			break;
	}
699
end:
700
	fclose(fp);
701
	return ret;
702 703
}

704 705 706 707 708 709 710 711 712 713 714 715 716
int show_line_range(struct line_range *lr, const char *module)
{
	int ret;

	ret = init_symbol_maps(false);
	if (ret < 0)
		return ret;
	ret = __show_line_range(lr, module);
	exit_symbol_maps();

	return ret;
}

717 718
static int show_available_vars_at(struct debuginfo *dinfo,
				  struct perf_probe_event *pev,
719 720
				  int max_vls, struct strfilter *_filter,
				  bool externs)
721 722
{
	char *buf;
723
	int ret, i, nvars;
724 725
	struct str_node *node;
	struct variable_list *vls = NULL, *vl;
726
	const char *var;
727 728 729 730 731 732

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

733 734
	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
						max_vls, externs);
735 736 737 738 739 740 741 742 743 744 745 746 747 748
	if (ret <= 0) {
		pr_err("Failed to find variables at %s (%d)\n", buf, ret);
		goto end;
	}
	/* 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);
749
		zfree(&vl->point.symbol);
750 751 752 753 754
		nvars = 0;
		if (vl->vars) {
			strlist__for_each(node, vl->vars) {
				var = strchr(node->s, '\t') + 1;
				if (strfilter__compare(_filter, var)) {
755
					fprintf(stdout, "\t\t%s\n", node->s);
756 757 758 759
					nvars++;
				}
			}
			strlist__delete(vl->vars);
760
		}
761 762 763 764 765
		if (nvars == 0)
			fprintf(stdout, "\t\t(No matched variables)\n");
	}
	free(vls);
end:
766 767 768 769 770 771
	free(buf);
	return ret;
}

/* Show available variables on given probe point */
int show_available_vars(struct perf_probe_event *pevs, int npevs,
772 773
			int max_vls, const char *module,
			struct strfilter *_filter, bool externs)
774
{
775 776
	int i, ret = 0;
	struct debuginfo *dinfo;
777

778
	ret = init_symbol_maps(false);
779 780 781
	if (ret < 0)
		return ret;

782 783 784
	dinfo = open_debuginfo(module);
	if (!dinfo) {
		pr_warning("Failed to open debuginfo file.\n");
785 786
		ret = -ENOENT;
		goto out;
787 788
	}

789 790
	setup_pager();

791 792
	for (i = 0; i < npevs && ret >= 0; i++)
		ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
793
					     externs);
794 795

	debuginfo__delete(dinfo);
796 797
out:
	exit_symbol_maps();
798 799 800
	return ret;
}

801
#else	/* !HAVE_DWARF_SUPPORT */
802

803 804 805 806
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)
807
{
808
	return -ENOSYS;
809 810
}

811
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
812
				struct probe_trace_event **tevs __maybe_unused,
813 814
				int max_tevs __maybe_unused,
				const char *target __maybe_unused)
815
{
816 817 818 819
	if (perf_probe_event_need_dwarf(pev)) {
		pr_warning("Debuginfo-analysis is not supported.\n");
		return -ENOSYS;
	}
820

821 822 823
	return 0;
}

824 825
int show_line_range(struct line_range *lr __maybe_unused,
		    const char *module __maybe_unused)
826
{
827 828
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
829 830
}

831 832 833 834 835
int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
			int npevs __maybe_unused, int max_vls __maybe_unused,
			const char *module __maybe_unused,
			struct strfilter *filter __maybe_unused,
			bool externs __maybe_unused)
836 837 838 839
{
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
}
840 841
#endif

842 843 844 845 846 847
void line_range__clear(struct line_range *lr)
{
	free(lr->function);
	free(lr->file);
	free(lr->path);
	free(lr->comp_dir);
848
	intlist__delete(lr->line_list);
849 850 851
	memset(lr, 0, sizeof(*lr));
}

852
int line_range__init(struct line_range *lr)
853 854
{
	memset(lr, 0, sizeof(*lr));
855 856 857 858 859
	lr->line_list = intlist__new(NULL);
	if (!lr->line_list)
		return -ENOMEM;
	else
		return 0;
860 861
}

862 863 864 865 866 867 868 869 870 871 872 873 874
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;
}

875 876 877 878 879
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
880
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
881
 */
882
int parse_line_range_desc(const char *arg, struct line_range *lr)
883
{
884
	char *range, *file, *name = strdup(arg);
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
	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--;
			}
		}
919

920
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
921 922

		err = -EINVAL;
923
		if (lr->start > lr->end) {
924
			semantic_error("Start line must be smaller"
925
				       " than end line.\n");
926
			goto err;
927
		}
928 929 930
		if (*range != '\0') {
			semantic_error("Tailing with invalid str '%s'.\n", range);
			goto err;
931
		}
932
	}
933

934 935 936 937 938 939 940 941 942 943
	file = strchr(name, '@');
	if (file) {
		*file = '\0';
		lr->file = strdup(++file);
		if (lr->file == NULL) {
			err = -ENOMEM;
			goto err;
		}
		lr->function = name;
	} else if (strchr(name, '.'))
944
		lr->file = name;
945
	else
946
		lr->function = name;
947 948

	return 0;
949 950 951
err:
	free(name);
	return err;
952 953
}

954 955 956 957 958 959 960 961 962 963 964 965
/* Check the name is good for event/group */
static bool check_event_name(const char *name)
{
	if (!isalpha(*name) && *name != '_')
		return false;
	while (*++name != '\0') {
		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
			return false;
	}
	return true;
}

966
/* Parse probepoint definition. */
967
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
968
{
969
	struct perf_probe_point *pp = &pev->point;
970 971 972 973
	char *ptr, *tmp;
	char c, nc = 0;
	/*
	 * <Syntax>
974 975
	 * perf probe [EVENT=]SRC[:LN|;PTN]
	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
976 977
	 *
	 * TODO:Group name support
978 979
	 */

980 981
	ptr = strpbrk(arg, ";=@+%");
	if (ptr && *ptr == '=') {	/* Event name */
982 983
		*ptr = '\0';
		tmp = ptr + 1;
984 985 986 987 988
		if (strchr(arg, ':')) {
			semantic_error("Group name is not supported yet.\n");
			return -ENOTSUP;
		}
		if (!check_event_name(arg)) {
989
			semantic_error("%s is bad for event name -it must "
990 991 992
				       "follow C symbol-naming rule.\n", arg);
			return -EINVAL;
		}
993 994 995
		pev->event = strdup(arg);
		if (pev->event == NULL)
			return -ENOMEM;
996
		pev->group = NULL;
997 998 999
		arg = tmp;
	}

1000
	ptr = strpbrk(arg, ";:+@%");
1001 1002 1003 1004 1005
	if (ptr) {
		nc = *ptr;
		*ptr++ = '\0';
	}

1006 1007 1008 1009
	tmp = strdup(arg);
	if (tmp == NULL)
		return -ENOMEM;

1010
	/* Check arg is function or file and copy it */
1011 1012
	if (strchr(tmp, '.'))	/* File */
		pp->file = tmp;
1013
	else			/* Function */
1014
		pp->function = tmp;
1015 1016 1017 1018 1019

	/* Parse other options */
	while (ptr) {
		arg = ptr;
		c = nc;
1020
		if (c == ';') {	/* Lazy pattern must be the last part */
1021 1022 1023
			pp->lazy_line = strdup(arg);
			if (pp->lazy_line == NULL)
				return -ENOMEM;
1024 1025 1026
			break;
		}
		ptr = strpbrk(arg, ";:+@%");
1027 1028 1029 1030 1031 1032 1033
		if (ptr) {
			nc = *ptr;
			*ptr++ = '\0';
		}
		switch (c) {
		case ':':	/* Line number */
			pp->line = strtoul(arg, &tmp, 0);
1034
			if (*tmp != '\0') {
1035
				semantic_error("There is non-digit char"
1036 1037 1038
					       " in line number.\n");
				return -EINVAL;
			}
1039 1040 1041
			break;
		case '+':	/* Byte offset from a symbol */
			pp->offset = strtoul(arg, &tmp, 0);
1042
			if (*tmp != '\0') {
1043
				semantic_error("There is non-digit character"
1044 1045 1046
						" in offset.\n");
				return -EINVAL;
			}
1047 1048
			break;
		case '@':	/* File name */
1049 1050 1051 1052
			if (pp->file) {
				semantic_error("SRC@SRC is not allowed.\n");
				return -EINVAL;
			}
1053 1054 1055
			pp->file = strdup(arg);
			if (pp->file == NULL)
				return -ENOMEM;
1056 1057 1058 1059
			break;
		case '%':	/* Probe places */
			if (strcmp(arg, "return") == 0) {
				pp->retprobe = 1;
1060 1061 1062 1063
			} else {	/* Others not supported yet */
				semantic_error("%%%s is not supported.\n", arg);
				return -ENOTSUP;
			}
1064
			break;
1065 1066 1067 1068
		default:	/* Buggy case */
			pr_err("This program has a bug at %s:%d.\n",
				__FILE__, __LINE__);
			return -ENOTSUP;
1069 1070 1071 1072 1073
			break;
		}
	}

	/* Exclusion check */
1074
	if (pp->lazy_line && pp->line) {
M
Masami Hiramatsu 已提交
1075 1076
		semantic_error("Lazy pattern can't be used with"
			       " line number.\n");
1077 1078
		return -EINVAL;
	}
1079

1080
	if (pp->lazy_line && pp->offset) {
M
Masami Hiramatsu 已提交
1081
		semantic_error("Lazy pattern can't be used with offset.\n");
1082 1083
		return -EINVAL;
	}
1084

1085
	if (pp->line && pp->offset) {
M
Masami Hiramatsu 已提交
1086
		semantic_error("Offset can't be used with line number.\n");
1087 1088
		return -EINVAL;
	}
1089

1090
	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1091
		semantic_error("File always requires line number or "
M
Masami Hiramatsu 已提交
1092
			       "lazy pattern.\n");
1093 1094
		return -EINVAL;
	}
1095

1096
	if (pp->offset && !pp->function) {
M
Masami Hiramatsu 已提交
1097
		semantic_error("Offset requires an entry function.\n");
1098 1099
		return -EINVAL;
	}
1100

1101
	if (pp->retprobe && !pp->function) {
M
Masami Hiramatsu 已提交
1102
		semantic_error("Return probe requires an entry function.\n");
1103 1104
		return -EINVAL;
	}
1105

1106
	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1107
		semantic_error("Offset/Line/Lazy pattern can't be used with "
M
Masami Hiramatsu 已提交
1108
			       "return probe.\n");
1109 1110
		return -EINVAL;
	}
1111

1112
	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1113 1114
		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
		 pp->lazy_line);
1115
	return 0;
1116 1117
}

1118
/* Parse perf-probe event argument */
1119
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1120
{
1121
	char *tmp, *goodname;
1122 1123 1124 1125
	struct perf_probe_arg_field **fieldp;

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

1126 1127
	tmp = strchr(str, '=');
	if (tmp) {
1128 1129 1130
		arg->name = strndup(str, tmp - str);
		if (arg->name == NULL)
			return -ENOMEM;
1131
		pr_debug("name:%s ", arg->name);
1132 1133 1134
		str = tmp + 1;
	}

1135 1136 1137
	tmp = strchr(str, ':');
	if (tmp) {	/* Type setting */
		*tmp = '\0';
1138 1139 1140
		arg->type = strdup(tmp + 1);
		if (arg->type == NULL)
			return -ENOMEM;
1141 1142 1143
		pr_debug("type:%s ", arg->type);
	}

1144
	tmp = strpbrk(str, "-.[");
1145 1146
	if (!is_c_varname(str) || !tmp) {
		/* A variable, register, symbol or special value */
1147 1148 1149
		arg->var = strdup(str);
		if (arg->var == NULL)
			return -ENOMEM;
1150
		pr_debug("%s\n", arg->var);
1151
		return 0;
1152 1153
	}

1154
	/* Structure fields or array element */
1155 1156 1157
	arg->var = strndup(str, tmp - str);
	if (arg->var == NULL)
		return -ENOMEM;
1158
	goodname = arg->var;
1159
	pr_debug("%s, ", arg->var);
1160 1161 1162
	fieldp = &arg->field;

	do {
1163 1164 1165
		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
		if (*fieldp == NULL)
			return -ENOMEM;
1166 1167 1168
		if (*tmp == '[') {	/* Array */
			str = tmp;
			(*fieldp)->index = strtol(str + 1, &tmp, 0);
1169
			(*fieldp)->ref = true;
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
			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, "-.[");
1191
		}
1192
		if (tmp) {
1193 1194 1195
			(*fieldp)->name = strndup(str, tmp - str);
			if ((*fieldp)->name == NULL)
				return -ENOMEM;
1196 1197
			if (*str != '[')
				goodname = (*fieldp)->name;
1198 1199 1200 1201
			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
			fieldp = &(*fieldp)->next;
		}
	} while (tmp);
1202 1203 1204
	(*fieldp)->name = strdup(str);
	if ((*fieldp)->name == NULL)
		return -ENOMEM;
1205 1206
	if (*str != '[')
		goodname = (*fieldp)->name;
1207
	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1208

1209
	/* If no name is specified, set the last field name (not array index)*/
1210
	if (!arg->name) {
1211
		arg->name = strdup(goodname);
1212 1213 1214
		if (arg->name == NULL)
			return -ENOMEM;
	}
1215
	return 0;
1216 1217
}

1218
/* Parse perf-probe event command */
1219
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1220
{
1221
	char **argv;
1222
	int argc, i, ret = 0;
1223

1224
	argv = argv_split(cmd, &argc);
1225 1226 1227 1228 1229 1230 1231 1232 1233
	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;
	}
1234
	/* Parse probe point */
1235 1236 1237
	ret = parse_perf_probe_point(argv[0], pev);
	if (ret < 0)
		goto out;
1238

1239
	/* Copy arguments and ensure return probe has no C argument */
1240
	pev->nargs = argc - 1;
1241 1242 1243 1244 1245
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1246 1247 1248 1249
	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) {
1250
			semantic_error("You can't specify local variable for"
1251 1252 1253
				       " kretprobe.\n");
			ret = -EINVAL;
		}
1254
	}
1255
out:
1256
	argv_free(argv);
1257 1258

	return ret;
1259 1260
}

1261 1262 1263 1264 1265 1266 1267 1268 1269
/* 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++)
1270
		if (is_c_varname(pev->args[i].var))
1271 1272 1273 1274 1275
			return true;

	return false;
}

1276 1277
/* Parse probe_events event into struct probe_point */
static int parse_probe_trace_command(const char *cmd,
1278
				     struct probe_trace_event *tev)
1279
{
1280
	struct probe_trace_point *tp = &tev->point;
1281 1282
	char pr;
	char *p;
1283
	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1284 1285 1286
	int ret, i, argc;
	char **argv;

1287
	pr_debug("Parsing probe_events: %s\n", cmd);
1288
	argv = argv_split(cmd, &argc);
1289 1290 1291 1292 1293 1294 1295 1296 1297
	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;
	}
1298 1299

	/* Scan event and group name. */
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
	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) {
1310 1311 1312 1313
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1314 1315 1316 1317 1318 1319 1320
	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;
	}
1321
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1322

1323
	tp->retprobe = (pr == 'r');
1324

1325 1326 1327 1328 1329 1330 1331
	/* 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];
1332
	fmt1_str = strtok_r(p, "+", &fmt);
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
	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);
1347
	}
1348

1349
	tev->nargs = argc - 2;
1350
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1351 1352 1353 1354
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1355
	for (i = 0; i < tev->nargs; i++) {
1356 1357
		p = strchr(argv[i + 2], '=');
		if (p)	/* We don't need which register is assigned. */
1358 1359 1360
			*p++ = '\0';
		else
			p = argv[i + 2];
1361
		tev->args[i].name = strdup(argv[i + 2]);
1362
		/* TODO: parse regs and offset */
1363 1364 1365 1366 1367
		tev->args[i].value = strdup(p);
		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
			ret = -ENOMEM;
			goto out;
		}
1368
	}
1369 1370
	ret = 0;
out:
1371
	free(argv0_str);
1372
	argv_free(argv);
1373
	return ret;
1374 1375
}

1376 1377 1378 1379 1380 1381 1382
/* 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;

1383 1384 1385 1386
	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);
1387 1388 1389 1390 1391 1392
	if (ret <= 0)
		goto error;
	tmp += ret;
	len -= ret;

	while (field) {
1393 1394 1395 1396 1397
		if (field->name[0] == '[')
			ret = e_snprintf(tmp, len, "%s", field->name);
		else
			ret = e_snprintf(tmp, len, "%s%s",
					 field->ref ? "->" : ".", field->name);
1398 1399 1400 1401 1402 1403
		if (ret <= 0)
			goto error;
		tmp += ret;
		len -= ret;
		field = field->next;
	}
1404 1405 1406 1407 1408 1409 1410 1411 1412

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

1413 1414
	return tmp - buf;
error:
M
Masami Hiramatsu 已提交
1415
	pr_debug("Failed to synthesize perf probe argument: %s\n",
1416 1417
		 strerror(-ret));
	return ret;
1418 1419
}

1420 1421
/* Compose only probe point (not argument) */
static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1422
{
1423 1424 1425
	char *buf, *tmp;
	char offs[32] = "", line[32] = "", file[32] = "";
	int ret, len;
1426

1427 1428 1429 1430 1431
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL) {
		ret = -ENOMEM;
		goto error;
	}
1432
	if (pp->offset) {
1433
		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1434 1435 1436 1437
		if (ret <= 0)
			goto error;
	}
	if (pp->line) {
1438 1439 1440 1441 1442
		ret = e_snprintf(line, 32, ":%d", pp->line);
		if (ret <= 0)
			goto error;
	}
	if (pp->file) {
1443 1444 1445 1446 1447 1448 1449
		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);
1450 1451 1452 1453 1454
		if (ret <= 0)
			goto error;
	}

	if (pp->function)
1455 1456 1457
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
				 offs, pp->retprobe ? "%return" : "", line,
				 file);
1458
	else
1459
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1460 1461 1462 1463
	if (ret <= 0)
		goto error;

	return buf;
1464
error:
M
Masami Hiramatsu 已提交
1465
	pr_debug("Failed to synthesize perf probe point: %s\n",
1466
		 strerror(-ret));
1467
	free(buf);
1468
	return NULL;
1469 1470
}

1471 1472
#if 0
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1473 1474 1475 1476
{
	char *buf;
	int i, len, ret;

1477 1478 1479
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return NULL;
1480

1481 1482
	len = strlen(buf);
	for (i = 0; i < pev->nargs; i++) {
1483
		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1484 1485 1486 1487 1488
				 pev->args[i].name);
		if (ret <= 0) {
			free(buf);
			return NULL;
		}
1489 1490 1491
		len += ret;
	}

1492 1493 1494 1495
	return buf;
}
#endif

1496
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1497 1498 1499 1500 1501
					     char **buf, size_t *buflen,
					     int depth)
{
	int ret;
	if (ref->next) {
1502
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
							 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;
1517 1518 1519

}

1520
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1521
				       char *buf, size_t buflen)
1522
{
1523
	struct probe_trace_arg_ref *ref = arg->ref;
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
	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;

1537 1538 1539 1540
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1541
	/* Dereferencing arguments */
1542
	if (ref) {
1543
		depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1544 1545 1546 1547 1548 1549
							  &buflen, 1);
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1550 1551 1552 1553 1554
	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);
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
	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;
	}
1568 1569 1570 1571 1572 1573 1574
	/* Print argument type */
	if (arg->type) {
		ret = e_snprintf(buf, buflen, ":%s", arg->type);
		if (ret <= 0)
			return ret;
		buf += ret;
	}
1575 1576 1577 1578

	return buf - tmp;
}

1579
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1580
{
1581
	struct probe_trace_point *tp = &tev->point;
1582 1583 1584
	char *buf;
	int i, len, ret;

1585 1586 1587 1588
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL)
		return NULL;

1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
	if (tev->uprobes)
		len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s:%s",
				 tp->retprobe ? 'r' : 'p',
				 tev->group, tev->event,
				 tp->module, tp->symbol);
	else
		len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s%s%s+%lu",
				 tp->retprobe ? 'r' : 'p',
				 tev->group, tev->event,
				 tp->module ?: "", tp->module ? ":" : "",
				 tp->symbol, tp->offset);

1601
	if (len <= 0)
1602 1603
		goto error;

1604
	for (i = 0; i < tev->nargs; i++) {
1605
		ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1606
						  MAX_CMDLEN - len);
1607
		if (ret <= 0)
1608 1609 1610 1611
			goto error;
		len += ret;
	}

1612
	return buf;
1613
error:
1614 1615 1616
	free(buf);
	return NULL;
}
1617

1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
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;
}

1691
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1692
			       struct perf_probe_event *pev, bool is_kprobe)
1693
{
1694
	char buf[64] = "";
1695
	int i, ret;
1696

1697
	/* Convert event/group name */
1698 1699 1700 1701
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
1702

1703
	/* Convert trace_point to probe_point */
1704
	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1705 1706
	if (ret < 0)
		return ret;
1707

1708 1709
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
1710 1711 1712
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
1713
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
1714
		if (tev->args[i].name)
1715
			pev->args[i].name = strdup(tev->args[i].name);
1716
		else {
1717
			ret = synthesize_probe_trace_arg(&tev->args[i],
1718
							  buf, 64);
1719
			pev->args[i].name = strdup(buf);
1720
		}
1721 1722 1723
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
1724 1725 1726 1727 1728

	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
1729 1730 1731 1732 1733
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
	struct perf_probe_point *pp = &pev->point;
1734
	struct perf_probe_arg_field *field, *next;
1735 1736
	int i;

1737 1738 1739 1740 1741 1742
	free(pev->event);
	free(pev->group);
	free(pp->file);
	free(pp->function);
	free(pp->lazy_line);

1743
	for (i = 0; i < pev->nargs; i++) {
1744 1745 1746
		free(pev->args[i].name);
		free(pev->args[i].var);
		free(pev->args[i].type);
1747 1748 1749
		field = pev->args[i].field;
		while (field) {
			next = field->next;
1750
			zfree(&field->name);
1751 1752 1753 1754
			free(field);
			field = next;
		}
	}
1755
	free(pev->args);
1756 1757 1758
	memset(pev, 0, sizeof(*pev));
}

1759
static void clear_probe_trace_event(struct probe_trace_event *tev)
1760
{
1761
	struct probe_trace_arg_ref *ref, *next;
1762 1763
	int i;

1764 1765 1766 1767
	free(tev->event);
	free(tev->group);
	free(tev->point.symbol);
	free(tev->point.module);
1768
	for (i = 0; i < tev->nargs; i++) {
1769 1770 1771
		free(tev->args[i].name);
		free(tev->args[i].value);
		free(tev->args[i].type);
1772 1773 1774 1775 1776 1777 1778
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
1779
	free(tev->args);
1780
	memset(tev, 0, sizeof(*tev));
1781 1782
}

1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
static void print_warn_msg(const char *file, bool is_kprobe)
{

	if (errno == ENOENT) {
		const char *config;

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

		pr_warning("%s file does not exist - please rebuild kernel"
				" with %s.\n", file, config);
	} else
		pr_warning("Failed to open %s file: %s\n", file,
				strerror(errno));
}

static int open_probe_events(const char *trace_file, bool readwrite,
				bool is_kprobe)
1803 1804
{
	char buf[PATH_MAX];
1805
	const char *__debugfs;
1806 1807
	int ret;

1808 1809 1810 1811 1812 1813
	__debugfs = debugfs_find_mountpoint();
	if (__debugfs == NULL) {
		pr_warning("Debugfs is not mounted.\n");
		return -ENOENT;
	}

1814
	ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
1815
	if (ret >= 0) {
1816
		pr_debug("Opening %s write=%d\n", buf, readwrite);
1817 1818 1819 1820
		if (readwrite && !probe_event_dry_run)
			ret = open(buf, O_RDWR, O_APPEND);
		else
			ret = open(buf, O_RDONLY, 0);
1821

1822 1823
		if (ret < 0)
			print_warn_msg(buf, is_kprobe);
1824 1825 1826 1827
	}
	return ret;
}

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
static int open_kprobe_events(bool readwrite)
{
	return open_probe_events("tracing/kprobe_events", readwrite, true);
}

static int open_uprobe_events(bool readwrite)
{
	return open_probe_events("tracing/uprobe_events", readwrite, false);
}

/* Get raw string list of current kprobe_events  or uprobe_events */
1839
static struct strlist *get_probe_trace_command_rawlist(int fd)
1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
{
	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);
1859 1860 1861 1862 1863
		if (ret < 0) {
			pr_debug("strlist__add failed: %s\n", strerror(-ret));
			strlist__delete(sl);
			return NULL;
		}
1864 1865 1866 1867 1868 1869
	}
	fclose(fp);

	return sl;
}

1870
/* Show an event */
1871 1872
static int show_perf_probe_event(struct perf_probe_event *pev,
				 const char *module)
1873
{
1874
	int i, ret;
1875
	char buf[128];
1876
	char *place;
1877

1878 1879
	/* Synthesize only event probe point */
	place = synthesize_perf_probe_point(&pev->point);
1880 1881
	if (!place)
		return -EINVAL;
1882 1883

	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
1884
	if (ret < 0)
1885 1886
		return ret;

1887
	printf("  %-20s (on %s", buf, place);
1888 1889
	if (module)
		printf(" in %s", module);
1890

1891
	if (pev->nargs > 0) {
1892
		printf(" with");
1893
		for (i = 0; i < pev->nargs; i++) {
1894 1895 1896 1897
			ret = synthesize_perf_probe_arg(&pev->args[i],
							buf, 128);
			if (ret < 0)
				break;
1898 1899
			printf(" %s", buf);
		}
1900 1901
	}
	printf(")\n");
1902
	free(place);
1903
	return ret;
1904 1905
}

1906
static int __show_perf_probe_events(int fd, bool is_kprobe)
1907
{
1908
	int ret = 0;
1909
	struct probe_trace_event tev;
1910
	struct perf_probe_event pev;
1911 1912 1913
	struct strlist *rawlist;
	struct str_node *ent;

1914 1915
	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
1916

1917
	rawlist = get_probe_trace_command_rawlist(fd);
1918 1919
	if (!rawlist)
		return -ENOENT;
1920

1921
	strlist__for_each(ent, rawlist) {
1922
		ret = parse_probe_trace_command(ent->s, &tev);
1923
		if (ret >= 0) {
1924 1925
			ret = convert_to_perf_probe_event(&tev, &pev,
								is_kprobe);
1926
			if (ret >= 0)
1927 1928
				ret = show_perf_probe_event(&pev,
							    tev.point.module);
1929
		}
1930
		clear_perf_probe_event(&pev);
1931
		clear_probe_trace_event(&tev);
1932 1933
		if (ret < 0)
			break;
1934 1935
	}
	strlist__delete(rawlist);
1936 1937

	return ret;
1938 1939
}

1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
/* List up current perf-probe events */
int show_perf_probe_events(void)
{
	int fd, ret;

	setup_pager();
	fd = open_kprobe_events(false);

	if (fd < 0)
		return fd;

1951
	ret = init_symbol_maps(false);
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
	if (ret < 0)
		return ret;

	ret = __show_perf_probe_events(fd, true);
	close(fd);

	fd = open_uprobe_events(false);
	if (fd >= 0) {
		ret = __show_perf_probe_events(fd, false);
		close(fd);
	}

1964
	exit_symbol_maps();
1965 1966 1967
	return ret;
}

1968
/* Get current perf-probe event names */
1969
static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
1970
{
1971
	char buf[128];
1972 1973
	struct strlist *sl, *rawlist;
	struct str_node *ent;
1974
	struct probe_trace_event tev;
1975
	int ret = 0;
1976

1977
	memset(&tev, 0, sizeof(tev));
1978
	rawlist = get_probe_trace_command_rawlist(fd);
1979
	sl = strlist__new(true, NULL);
1980
	strlist__for_each(ent, rawlist) {
1981
		ret = parse_probe_trace_command(ent->s, &tev);
1982 1983
		if (ret < 0)
			break;
1984
		if (include_group) {
1985 1986 1987 1988
			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
					tev.event);
			if (ret >= 0)
				ret = strlist__add(sl, buf);
1989
		} else
1990
			ret = strlist__add(sl, tev.event);
1991
		clear_probe_trace_event(&tev);
1992 1993
		if (ret < 0)
			break;
1994 1995 1996
	}
	strlist__delete(rawlist);

1997 1998 1999 2000
	if (ret < 0) {
		strlist__delete(sl);
		return NULL;
	}
2001 2002 2003
	return sl;
}

2004
static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2005
{
2006
	int ret = 0;
2007
	char *buf = synthesize_probe_trace_command(tev);
2008

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

2014
	pr_debug("Writing event: %s\n", buf);
2015 2016 2017
	if (!probe_event_dry_run) {
		ret = write(fd, buf, strlen(buf));
		if (ret <= 0)
2018 2019
			pr_warning("Failed to write event: %s\n",
				   strerror(errno));
2020
	}
2021
	free(buf);
2022
	return ret;
2023 2024
}

2025 2026
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
2027 2028
{
	int i, ret;
2029 2030 2031

	/* Try no suffix */
	ret = e_snprintf(buf, len, "%s", base);
2032 2033 2034 2035
	if (ret < 0) {
		pr_debug("snprintf() failed: %s\n", strerror(-ret));
		return ret;
	}
2036
	if (!strlist__has_entry(namelist, buf))
2037
		return 0;
2038

2039 2040 2041
	if (!allow_suffix) {
		pr_warning("Error: event \"%s\" already exists. "
			   "(Use -f to force duplicates.)\n", base);
2042
		return -EEXIST;
2043 2044
	}

2045 2046
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2047
		ret = e_snprintf(buf, len, "%s_%d", base, i);
2048 2049 2050 2051
		if (ret < 0) {
			pr_debug("snprintf() failed: %s\n", strerror(-ret));
			return ret;
		}
2052 2053 2054
		if (!strlist__has_entry(namelist, buf))
			break;
	}
2055 2056 2057 2058 2059 2060
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

	return ret;
2061 2062
}

2063 2064
static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
2065
				     int ntevs, bool allow_suffix)
2066
{
2067
	int i, fd, ret;
2068
	struct probe_trace_event *tev = NULL;
2069 2070
	char buf[64];
	const char *event, *group;
2071
	struct strlist *namelist;
2072

2073 2074 2075 2076 2077
	if (pev->uprobes)
		fd = open_uprobe_events(true);
	else
		fd = open_kprobe_events(true);

2078 2079
	if (fd < 0)
		return fd;
2080
	/* Get current event names */
2081
	namelist = get_probe_trace_event_names(fd, false);
2082 2083 2084 2085
	if (!namelist) {
		pr_debug("Failed to get current event list.\n");
		return -EIO;
	}
2086

2087
	ret = 0;
S
Srikar Dronamraju 已提交
2088
	printf("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2089
	for (i = 0; i < ntevs; i++) {
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
		tev = &tevs[i];
		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 */
2104 2105 2106 2107
		ret = get_new_event_name(buf, 64, event,
					 namelist, allow_suffix);
		if (ret < 0)
			break;
2108 2109
		event = buf;

2110 2111 2112 2113 2114 2115
		tev->event = strdup(event);
		tev->group = strdup(group);
		if (tev->event == NULL || tev->group == NULL) {
			ret = -ENOMEM;
			break;
		}
2116
		ret = write_probe_trace_event(fd, tev);
2117 2118
		if (ret < 0)
			break;
2119 2120 2121 2122 2123 2124 2125 2126
		/* 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;
2127
		show_perf_probe_event(pev, tev->point.module);
2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138
		/* 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;
2139
	}
2140 2141 2142

	if (ret >= 0) {
		/* Show how to use the event. */
S
Srikar Dronamraju 已提交
2143
		printf("\nYou can now use it in all perf tools, such as:\n\n");
2144 2145 2146
		printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
			 tev->event);
	}
2147

2148
	strlist__delete(namelist);
2149
	close(fd);
2150
	return ret;
2151
}
2152

2153 2154
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
					  struct probe_trace_event **tevs,
2155
					  int max_tevs, const char *target)
2156 2157
{
	struct symbol *sym;
2158
	int ret, i;
2159
	struct probe_trace_event *tev;
2160

2161 2162 2163 2164 2165 2166 2167 2168 2169
	if (pev->uprobes && !pev->group) {
		/* Replace group name if not given */
		ret = convert_exec_to_group(target, &pev->group);
		if (ret != 0) {
			pr_warning("Failed to make a group name.\n");
			return ret;
		}
	}

2170
	/* Convert perf_probe_event with debuginfo */
2171
	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
2172
	if (ret != 0)
2173
		return ret;	/* Found in debuginfo or got an error */
2174

2175 2176 2177 2178 2179 2180
	if (pev->uprobes) {
		ret = convert_name_to_addr(pev, target);
		if (ret < 0)
			return ret;
	}

2181
	/* Allocate trace event buffer */
2182
	tev = *tevs = zalloc(sizeof(struct probe_trace_event));
2183 2184
	if (tev == NULL)
		return -ENOMEM;
2185 2186

	/* Copy parameters */
2187 2188 2189 2190 2191
	tev->point.symbol = strdup(pev->point.function);
	if (tev->point.symbol == NULL) {
		ret = -ENOMEM;
		goto error;
	}
2192

2193 2194
	if (target) {
		tev->point.module = strdup(target);
2195 2196 2197 2198
		if (tev->point.module == NULL) {
			ret = -ENOMEM;
			goto error;
		}
2199
	}
2200

2201
	tev->point.offset = pev->point.offset;
2202
	tev->point.retprobe = pev->point.retprobe;
2203
	tev->nargs = pev->nargs;
2204 2205
	tev->uprobes = pev->uprobes;

2206
	if (tev->nargs) {
2207
		tev->args = zalloc(sizeof(struct probe_trace_arg)
2208 2209
				   * tev->nargs);
		if (tev->args == NULL) {
2210 2211
			ret = -ENOMEM;
			goto error;
2212
		}
2213
		for (i = 0; i < tev->nargs; i++) {
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
			if (pev->args[i].name) {
				tev->args[i].name = strdup(pev->args[i].name);
				if (tev->args[i].name == NULL) {
					ret = -ENOMEM;
					goto error;
				}
			}
			tev->args[i].value = strdup(pev->args[i].var);
			if (tev->args[i].value == NULL) {
				ret = -ENOMEM;
				goto error;
			}
			if (pev->args[i].type) {
				tev->args[i].type = strdup(pev->args[i].type);
				if (tev->args[i].type == NULL) {
					ret = -ENOMEM;
					goto error;
				}
			}
2233
		}
2234 2235
	}

2236 2237 2238
	if (pev->uprobes)
		return 1;

2239
	/* Currently just checking function name from symbol map */
2240
	sym = __find_kernel_function_by_name(tev->point.symbol, NULL);
2241 2242 2243
	if (!sym) {
		pr_warning("Kernel symbol \'%s\' not found.\n",
			   tev->point.symbol);
2244 2245
		ret = -ENOENT;
		goto error;
2246 2247 2248 2249 2250 2251
	} else if (tev->point.offset > sym->end - sym->start) {
		pr_warning("Offset specified is greater than size of %s\n",
			   tev->point.symbol);
		ret = -ENOENT;
		goto error;

2252
	}
2253

2254 2255
	return 1;
error:
2256
	clear_probe_trace_event(tev);
2257 2258
	free(tev);
	*tevs = NULL;
2259
	return ret;
2260 2261 2262 2263
}

struct __event_package {
	struct perf_probe_event		*pev;
2264
	struct probe_trace_event	*tevs;
2265 2266 2267
	int				ntevs;
};

2268
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
2269
			  int max_tevs, const char *target, bool force_add)
2270
{
2271
	int i, j, ret;
2272 2273
	struct __event_package *pkgs;

2274
	ret = 0;
2275
	pkgs = zalloc(sizeof(struct __event_package) * npevs);
2276

2277 2278
	if (pkgs == NULL)
		return -ENOMEM;
2279

2280
	ret = init_symbol_maps(pevs->uprobes);
2281 2282
	if (ret < 0) {
		free(pkgs);
2283
		return ret;
2284
	}
2285 2286 2287 2288 2289

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
		pkgs[i].pev = &pevs[i];
		/* Convert with or without debuginfo */
2290
		ret  = convert_to_probe_trace_events(pkgs[i].pev,
2291 2292
						     &pkgs[i].tevs,
						     max_tevs,
2293
						     target);
2294 2295 2296
		if (ret < 0)
			goto end;
		pkgs[i].ntevs = ret;
2297 2298
	}

2299
	/* Loop 2: add all events */
2300
	for (i = 0; i < npevs; i++) {
2301
		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2302
						pkgs[i].ntevs, force_add);
2303 2304 2305
		if (ret < 0)
			break;
	}
2306
end:
2307 2308
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
2309
		for (j = 0; j < pkgs[i].ntevs; j++)
2310
			clear_probe_trace_event(&pkgs[i].tevs[j]);
2311
		zfree(&pkgs[i].tevs);
2312 2313
	}
	free(pkgs);
2314
	exit_symbol_maps();
2315 2316

	return ret;
2317 2318
}

2319
static int __del_trace_probe_event(int fd, struct str_node *ent)
2320 2321 2322
{
	char *p;
	char buf[128];
2323
	int ret;
2324

2325
	/* Convert from perf-probe event to trace-probe event */
2326 2327 2328 2329
	ret = e_snprintf(buf, 128, "-:%s", ent->s);
	if (ret < 0)
		goto error;

2330
	p = strchr(buf + 2, ':');
2331 2332 2333 2334 2335 2336
	if (!p) {
		pr_debug("Internal error: %s should have ':' but not.\n",
			 ent->s);
		ret = -ENOTSUP;
		goto error;
	}
2337 2338
	*p = '/';

2339 2340
	pr_debug("Writing event: %s\n", buf);
	ret = write(fd, buf, strlen(buf));
2341 2342
	if (ret < 0) {
		ret = -errno;
2343
		goto error;
2344
	}
2345

S
Srikar Dronamraju 已提交
2346
	printf("Removed event: %s\n", ent->s);
2347 2348 2349 2350
	return 0;
error:
	pr_warning("Failed to delete event: %s\n", strerror(-ret));
	return ret;
2351 2352
}

2353 2354
static int del_trace_probe_event(int fd, const char *buf,
						  struct strlist *namelist)
2355
{
2356
	struct str_node *ent, *n;
2357
	int ret = -1;
2358

2359 2360 2361
	if (strpbrk(buf, "*?")) { /* Glob-exp */
		strlist__for_each_safe(ent, n, namelist)
			if (strglobmatch(ent->s, buf)) {
2362
				ret = __del_trace_probe_event(fd, ent);
2363 2364
				if (ret < 0)
					break;
2365 2366 2367 2368 2369
				strlist__remove(namelist, ent);
			}
	} else {
		ent = strlist__find(namelist, buf);
		if (ent) {
2370
			ret = __del_trace_probe_event(fd, ent);
2371 2372
			if (ret >= 0)
				strlist__remove(namelist, ent);
2373 2374
		}
	}
2375 2376

	return ret;
2377 2378
}

2379
int del_perf_probe_events(struct strlist *dellist)
2380
{
2381 2382
	int ret = -1, ufd = -1, kfd = -1;
	char buf[128];
2383 2384 2385
	const char *group, *event;
	char *p, *str;
	struct str_node *ent;
2386
	struct strlist *namelist = NULL, *unamelist = NULL;
2387

2388
	/* Get current event names */
2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
	kfd = open_kprobe_events(true);
	if (kfd < 0)
		return kfd;

	namelist = get_probe_trace_event_names(kfd, true);
	ufd = open_uprobe_events(true);

	if (ufd >= 0)
		unamelist = get_probe_trace_event_names(ufd, true);

	if (namelist == NULL && unamelist == NULL)
		goto error;
2401

2402
	strlist__for_each(ent, dellist) {
2403 2404 2405
		str = strdup(ent->s);
		if (str == NULL) {
			ret = -ENOMEM;
2406
			goto error;
2407
		}
2408
		pr_debug("Parsing: %s\n", str);
2409 2410 2411 2412 2413 2414
		p = strchr(str, ':');
		if (p) {
			group = str;
			*p = '\0';
			event = p + 1;
		} else {
2415
			group = "*";
2416 2417
			event = str;
		}
2418 2419 2420 2421 2422 2423 2424 2425

		ret = e_snprintf(buf, 128, "%s:%s", group, event);
		if (ret < 0) {
			pr_err("Failed to copy event.");
			free(str);
			goto error;
		}

2426
		pr_debug("Group: %s, Event: %s\n", group, event);
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436

		if (namelist)
			ret = del_trace_probe_event(kfd, buf, namelist);

		if (unamelist && ret != 0)
			ret = del_trace_probe_event(ufd, buf, unamelist);

		if (ret != 0)
			pr_info("Info: Event \"%s\" does not exist.\n", buf);

2437 2438
		free(str);
	}
2439 2440 2441

error:
	if (kfd >= 0) {
2442
		strlist__delete(namelist);
2443 2444 2445 2446
		close(kfd);
	}

	if (ufd >= 0) {
2447
		strlist__delete(unamelist);
2448 2449
		close(ufd);
	}
2450 2451

	return ret;
2452
}
2453

2454 2455
/* TODO: don't use a global variable for filter ... */
static struct strfilter *available_func_filter;
2456

2457
/*
2458 2459
 * If a symbol corresponds to a function with global binding and
 * matches filter return 0. For all others return 1.
2460
 */
2461
static int filter_available_functions(struct map *map __maybe_unused,
2462
				      struct symbol *sym)
2463
{
2464 2465 2466 2467
	if (sym->binding == STB_GLOBAL &&
	    strfilter__compare(available_func_filter, sym->name))
		return 0;
	return 1;
2468 2469
}

2470 2471
int show_available_funcs(const char *target, struct strfilter *_filter,
					bool user)
2472 2473 2474 2475
{
	struct map *map;
	int ret;

2476
	ret = init_symbol_maps(user);
2477 2478 2479
	if (ret < 0)
		return ret;

2480 2481 2482 2483 2484
	/* Get a symbol map */
	if (user)
		map = dso__new_map(target);
	else
		map = kernel_get_module_map(target);
2485
	if (!map) {
2486
		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2487 2488
		return -EINVAL;
	}
2489

2490
	/* Load symbols with given filter */
2491
	available_func_filter = _filter;
2492 2493 2494 2495 2496 2497
	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);
2498

2499 2500 2501 2502 2503 2504 2505 2506 2507
	/* 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();
2508

2509
	return ret;
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
}

/*
 * uprobe_events only accepts address:
 * Convert function and any offset to address
 */
static int convert_name_to_addr(struct perf_probe_event *pev, const char *exec)
{
	struct perf_probe_point *pp = &pev->point;
	struct symbol *sym;
	struct map *map = NULL;
2521
	char *function = NULL;
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
	int ret = -EINVAL;
	unsigned long long vaddr = 0;

	if (!pp->function) {
		pr_warning("No function specified for uprobes");
		goto out;
	}

	function = strdup(pp->function);
	if (!function) {
		pr_warning("Failed to allocate memory by strdup.\n");
		ret = -ENOMEM;
		goto out;
	}

2537
	map = dso__new_map(exec);
2538 2539 2540 2541 2542
	if (!map) {
		pr_warning("Cannot find appropriate DSO for %s.\n", exec);
		goto out;
	}
	available_func_filter = strfilter__new(function, NULL);
2543
	if (map__load(map, filter_available_functions)) {
2544
		pr_err("Failed to load map.\n");
2545
		goto out;
2546 2547
	}

2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
	sym = map__find_symbol_by_name(map, function, NULL);
	if (!sym) {
		pr_warning("Cannot find %s in DSO %s\n", function, exec);
		goto out;
	}

	if (map->start > sym->start)
		vaddr = map->start;
	vaddr += sym->start + pp->offset + map->pgoff;
	pp->offset = 0;

	if (!pev->event) {
		pev->event = function;
		function = NULL;
	}
	if (!pev->group) {
2564
		char *ptr1, *ptr2, *exec_copy;
2565 2566

		pev->group = zalloc(sizeof(char *) * 64);
2567 2568 2569 2570 2571 2572 2573 2574
		exec_copy = strdup(exec);
		if (!exec_copy) {
			ret = -ENOMEM;
			pr_warning("Failed to copy exec string.\n");
			goto out;
		}

		ptr1 = strdup(basename(exec_copy));
2575 2576 2577 2578 2579 2580 2581 2582
		if (ptr1) {
			ptr2 = strpbrk(ptr1, "-._");
			if (ptr2)
				*ptr2 = '\0';
			e_snprintf(pev->group, 64, "%s_%s", PERFPROBE_GROUP,
					ptr1);
			free(ptr1);
		}
2583
		free(exec_copy);
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
	}
	free(pp->function);
	pp->function = zalloc(sizeof(char *) * MAX_PROBE_ARGS);
	if (!pp->function) {
		ret = -ENOMEM;
		pr_warning("Failed to allocate memory by zalloc.\n");
		goto out;
	}
	e_snprintf(pp->function, MAX_PROBE_ARGS, "0x%llx", vaddr);
	ret = 0;

out:
	if (map) {
		dso__delete(map->dso);
		map__delete(map);
	}
	if (function)
		free(function);
	return ret;
2603
}