probe-event.c 44.0 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 31
 *
 * 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.
 *
 */

#define _GNU_SOURCE
#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>
32 33
#include <stdarg.h>
#include <limits.h>
34
#include <elf.h>
35 36

#undef _GNU_SOURCE
37
#include "util.h"
38
#include "event.h"
39
#include "string.h"
40
#include "strlist.h"
41
#include "debug.h"
42
#include "cache.h"
43
#include "color.h"
44 45
#include "symbol.h"
#include "thread.h"
46
#include "debugfs.h"
47
#include "trace-event.h"	/* For __unused */
48
#include "probe-event.h"
49
#include "probe-finder.h"
50 51 52 53 54

#define MAX_CMDLEN 256
#define MAX_PROBE_ARGS 128
#define PERFPROBE_GROUP "probe"

55 56
bool probe_event_dry_run;	/* Dry run flag */

57
#define semantic_error(msg ...) pr_err("Semantic error :" msg)
58

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

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

75
static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
76
static struct machine machine;
77

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

83 84 85 86 87
	symbol_conf.sort_by_name = true;
	if (symbol_conf.vmlinux_name == NULL)
		symbol_conf.try_vmlinux_path = true;
	else
		pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
88 89 90 91 92
	ret = symbol__init();
	if (ret < 0) {
		pr_debug("Failed to init symbol map.\n");
		goto out;
	}
93

94
	ret = machine__init(&machine, "", HOST_KERNEL_ID);
95 96 97
	if (ret < 0)
		goto out;

98
	if (machine__create_kernel_maps(&machine) < 0) {
M
Masami Hiramatsu 已提交
99
		pr_debug("machine__create_kernel_maps() failed.\n");
100 101
		goto out;
	}
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
static struct symbol *__find_kernel_function_by_name(const char *name,
						     struct map **mapp)
{
	return machine__find_kernel_function_by_name(&machine, name, mapp,
						     NULL);
}

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
static struct map *kernel_get_module_map(const char *module)
{
	struct rb_node *nd;
	struct map_groups *grp = &machine.kmaps;

	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)
134 135
{
	struct dso *dso;
136 137
	struct map *map;
	const char *vmlinux_name;
138 139 140 141 142 143 144 145 146

	if (module) {
		list_for_each_entry(dso, &machine.kernel_dsos, node) {
			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;
147 148 149 150 151 152 153 154 155
	}

	map = machine.vmlinux_maps[MAP__FUNCTION];
	dso = map->dso;

	vmlinux_name = symbol_conf.vmlinux_name;
	if (vmlinux_name) {
		if (dso__load_vmlinux(dso, map, vmlinux_name, NULL) <= 0)
			return NULL;
156
	} else {
157
		if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
158 159 160 161 162
			pr_debug("Failed to load kernel map.\n");
			return NULL;
		}
	}
found:
163 164 165 166 167 168 169
	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;
170 171
}

172
#ifdef DWARF_SUPPORT
173
static int open_vmlinux(const char *module)
174
{
175 176
	const char *path = kernel_get_module_path(module);
	if (!path) {
M
Masami Hiramatsu 已提交
177 178
		pr_err("Failed to find path of %s module.\n",
		       module ?: "kernel");
179
		return -ENOENT;
180
	}
181 182
	pr_debug("Try to open %s\n", path);
	return open(path, O_RDONLY);
183
}
184

185 186 187 188 189
/*
 * Convert trace point to probe point with debuginfo
 * Currently only handles kprobes.
 */
static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
190
					struct perf_probe_point *pp)
191 192
{
	struct symbol *sym;
193 194 195
	struct map *map;
	u64 addr;
	int ret = -ENOENT;
196

197
	sym = __find_kernel_function_by_name(tp->symbol, &map);
198
	if (sym) {
199
		addr = map->unmap_ip(map, sym->start + tp->offset);
200
		pr_debug("try to find %s+%ld@%" PRIx64 "\n", tp->symbol,
201 202
			 tp->offset, addr);
		ret = find_perf_probe_point((unsigned long)addr, pp);
203 204
	}
	if (ret <= 0) {
205 206
		pr_debug("Failed to find corresponding probes from "
			 "debuginfo. Use kprobe event information.\n");
207 208 209
		pp->function = strdup(tp->symbol);
		if (pp->function == NULL)
			return -ENOMEM;
210 211 212
		pp->offset = tp->offset;
	}
	pp->retprobe = tp->retprobe;
213 214

	return 0;
215 216 217
}

/* Try to find perf_probe_event with debuginfo */
218 219
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
					   struct probe_trace_event **tevs,
220
					   int max_tevs, const char *module)
221 222 223 224
{
	bool need_dwarf = perf_probe_event_need_dwarf(pev);
	int fd, ntevs;

225
	fd = open_vmlinux(module);
226
	if (fd < 0) {
227 228 229 230
		if (need_dwarf) {
			pr_warning("Failed to open debuginfo file.\n");
			return fd;
		}
231 232 233 234 235
		pr_debug("Could not open vmlinux. Try to use symbols.\n");
		return 0;
	}

	/* Searching trace events corresponding to probe event */
236
	ntevs = find_probe_trace_events(fd, pev, tevs, max_tevs);
237 238
	close(fd);

239
	if (ntevs > 0) {	/* Succeeded to find trace events */
240
		pr_debug("find %d probe_trace_events.\n", ntevs);
241
		return ntevs;
242
	}
243

244 245 246 247 248 249
	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 */
250 251 252 253 254
	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 已提交
255
			pr_debug("Trying to use symbols.\n");
256 257
			return 0;
		}
258
	}
259
	return ntevs;
260 261
}

262 263 264 265 266 267
/*
 * 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.
 */
268 269
static int get_real_path(const char *raw_path, const char *comp_dir,
			 char **new_path)
270
{
271 272 273 274 275 276 277 278 279 280 281 282 283
	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;
		}
284 285
	}

286
	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
287 288 289 290
	if (!*new_path)
		return -ENOMEM;

	for (;;) {
291
		sprintf(*new_path, "%s/%s", prefix, raw_path);
292 293 294 295

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

296 297 298 299
		if (!symbol_conf.source_prefix)
			/* In case of searching comp_dir, don't retry */
			return -errno;

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
		switch (errno) {
		case ENAMETOOLONG:
		case ENOENT:
		case EROFS:
		case EFAULT:
			raw_path = strchr(++raw_path, '/');
			if (!raw_path) {
				free(*new_path);
				*new_path = NULL;
				return -ENOENT;
			}
			continue;

		default:
			free(*new_path);
			*new_path = NULL;
			return -errno;
		}
	}
}

321 322 323
#define LINEBUF_SIZE 256
#define NR_ADDITIONAL_LINES 2

324
static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
325 326
{
	char buf[LINEBUF_SIZE];
327 328
	const char *color = show_num ? "" : PERF_COLOR_BLUE;
	const char *prefix = NULL;
329

330
	do {
331 332
		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
			goto error;
333 334 335 336 337
		if (skip)
			continue;
		if (!prefix) {
			prefix = show_num ? "%7d  " : "         ";
			color_fprintf(stdout, color, prefix, l);
338
		}
339 340 341
		color_fprintf(stdout, color, "%s", buf);

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

343
	return 1;
344
error:
345
	if (ferror(fp)) {
346
		pr_warning("File read error: %s\n", strerror(errno));
347 348 349 350
		return -1;
	}
	return 0;
}
351

352 353 354 355 356 357 358 359
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;
360 361
}

362 363 364 365 366
#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)

367 368 369 370
/*
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
371
int show_line_range(struct line_range *lr, const char *module)
372
{
373
	int l = 1;
374 375 376
	struct line_node *ln;
	FILE *fp;
	int fd, ret;
377
	char *tmp;
378 379

	/* Search a line range */
380 381 382 383
	ret = init_vmlinux();
	if (ret < 0)
		return ret;

384
	fd = open_vmlinux(module);
385 386 387 388 389
	if (fd < 0) {
		pr_warning("Failed to open debuginfo file.\n");
		return fd;
	}

390 391
	ret = find_line_range(fd, lr);
	close(fd);
392 393 394 395 396 397 398
	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;
	}
399

400 401
	/* Convert source file path */
	tmp = lr->path;
402
	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
403 404 405 406 407 408
	free(tmp);	/* Free old path */
	if (ret < 0) {
		pr_warning("Failed to find source file. (%d)\n", ret);
		return ret;
	}

409 410 411
	setup_pager();

	if (lr->function)
412
		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
413 414
			lr->start - lr->offset);
	else
415
		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
416 417

	fp = fopen(lr->path, "r");
418 419 420 421 422
	if (fp == NULL) {
		pr_warning("Failed to open %s: %s\n", lr->path,
			   strerror(errno));
		return -errno;
	}
423
	/* Skip to starting line number */
424
	while (l < lr->start) {
425
		ret = skip_one_line(fp, l++);
426 427 428
		if (ret < 0)
			goto end;
	}
429 430

	list_for_each_entry(ln, &lr->line_list, list) {
431
		for (; ln->line > l; l++) {
432
			ret = show_one_line(fp, l - lr->offset);
433 434 435
			if (ret < 0)
				goto end;
		}
436
		ret = show_one_line_with_num(fp, l++ - lr->offset);
437 438
		if (ret < 0)
			goto end;
439 440 441 442
	}

	if (lr->end == INT_MAX)
		lr->end = l + NR_ADDITIONAL_LINES;
443 444 445
	while (l <= lr->end) {
		ret = show_one_line_or_eof(fp, l++ - lr->offset);
		if (ret <= 0)
446 447
			break;
	}
448
end:
449
	fclose(fp);
450
	return ret;
451 452
}

453
static int show_available_vars_at(int fd, struct perf_probe_event *pev,
454 455
				  int max_vls, struct strfilter *_filter,
				  bool externs)
456 457
{
	char *buf;
458
	int ret, i, nvars;
459 460
	struct str_node *node;
	struct variable_list *vls = NULL, *vl;
461
	const char *var;
462 463 464 465 466 467

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

468
	ret = find_available_vars_at(fd, pev, &vls, max_vls, externs);
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
	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);
		free(vl->point.symbol);
		nvars = 0;
		if (vl->vars) {
			strlist__for_each(node, vl->vars) {
				var = strchr(node->s, '\t') + 1;
				if (strfilter__compare(_filter, var)) {
489
					fprintf(stdout, "\t\t%s\n", node->s);
490 491 492 493
					nvars++;
				}
			}
			strlist__delete(vl->vars);
494
		}
495 496 497 498 499
		if (nvars == 0)
			fprintf(stdout, "\t\t(No matched variables)\n");
	}
	free(vls);
end:
500 501 502 503 504 505
	free(buf);
	return ret;
}

/* Show available variables on given probe point */
int show_available_vars(struct perf_probe_event *pevs, int npevs,
506 507
			int max_vls, const char *module,
			struct strfilter *_filter, bool externs)
508 509 510 511 512 513 514
{
	int i, fd, ret = 0;

	ret = init_vmlinux();
	if (ret < 0)
		return ret;

515
	fd = open_vmlinux(module);
516
	if (fd < 0) {
M
Masami Hiramatsu 已提交
517
		pr_warning("Failed to open debug information file.\n");
518 519 520 521 522 523
		return fd;
	}

	setup_pager();

	for (i = 0; i < npevs && ret >= 0; i++)
524 525
		ret = show_available_vars_at(fd, &pevs[i], max_vls, _filter,
					     externs);
526 527 528 529 530

	close(fd);
	return ret;
}

531 532
#else	/* !DWARF_SUPPORT */

533
static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
534
					struct perf_probe_point *pp)
535
{
536 537 538 539 540 541 542
	struct symbol *sym;

	sym = __find_kernel_function_by_name(tp->symbol, NULL);
	if (!sym) {
		pr_err("Failed to find symbol %s in kernel.\n", tp->symbol);
		return -ENOENT;
	}
543 544 545
	pp->function = strdup(tp->symbol);
	if (pp->function == NULL)
		return -ENOMEM;
546 547
	pp->offset = tp->offset;
	pp->retprobe = tp->retprobe;
548 549

	return 0;
550 551
}

552 553
static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
				struct probe_trace_event **tevs __unused,
554
				int max_tevs __unused, const char *mod __unused)
555
{
556 557 558 559
	if (perf_probe_event_need_dwarf(pev)) {
		pr_warning("Debuginfo-analysis is not supported.\n");
		return -ENOSYS;
	}
560 561 562
	return 0;
}

563
int show_line_range(struct line_range *lr __unused, const char *module __unused)
564
{
565 566
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
567 568
}

569
int show_available_vars(struct perf_probe_event *pevs __unused,
570
			int npevs __unused, int max_vls __unused,
571 572 573
			const char *module __unused,
			struct strfilter *filter __unused,
			bool externs __unused)
574 575 576 577
{
	pr_warning("Debuginfo-analysis is not supported.\n");
	return -ENOSYS;
}
578 579
#endif

580 581 582 583 584 585 586 587 588 589 590 591 592
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;
}

593 594 595 596 597
/*
 * Stuff 'lr' according to the line range described by 'arg'.
 * The line range syntax is described by:
 *
 *         SRC[:SLN[+NUM|-ELN]]
598
 *         FNC[@SRC][:SLN[+NUM|-ELN]]
599
 */
600
int parse_line_range_desc(const char *arg, struct line_range *lr)
601
{
602
	char *range, *file, *name = strdup(arg);
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
	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--;
			}
		}
637

638
		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
639 640

		err = -EINVAL;
641
		if (lr->start > lr->end) {
642
			semantic_error("Start line must be smaller"
643
				       " than end line.\n");
644
			goto err;
645
		}
646 647 648
		if (*range != '\0') {
			semantic_error("Tailing with invalid str '%s'.\n", range);
			goto err;
649
		}
650
	}
651

652 653 654 655 656 657 658 659 660 661
	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, '.'))
662
		lr->file = name;
663
	else
664
		lr->function = name;
665 666

	return 0;
667 668 669
err:
	free(name);
	return err;
670 671
}

672 673 674 675 676 677 678 679 680 681 682 683
/* 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;
}

684
/* Parse probepoint definition. */
685
static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
686
{
687
	struct perf_probe_point *pp = &pev->point;
688 689 690 691
	char *ptr, *tmp;
	char c, nc = 0;
	/*
	 * <Syntax>
692 693
	 * perf probe [EVENT=]SRC[:LN|;PTN]
	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
694 695
	 *
	 * TODO:Group name support
696 697
	 */

698 699
	ptr = strpbrk(arg, ";=@+%");
	if (ptr && *ptr == '=') {	/* Event name */
700 701
		*ptr = '\0';
		tmp = ptr + 1;
702 703 704 705 706
		if (strchr(arg, ':')) {
			semantic_error("Group name is not supported yet.\n");
			return -ENOTSUP;
		}
		if (!check_event_name(arg)) {
707
			semantic_error("%s is bad for event name -it must "
708 709 710
				       "follow C symbol-naming rule.\n", arg);
			return -EINVAL;
		}
711 712 713
		pev->event = strdup(arg);
		if (pev->event == NULL)
			return -ENOMEM;
714
		pev->group = NULL;
715 716 717
		arg = tmp;
	}

718
	ptr = strpbrk(arg, ";:+@%");
719 720 721 722 723
	if (ptr) {
		nc = *ptr;
		*ptr++ = '\0';
	}

724 725 726 727
	tmp = strdup(arg);
	if (tmp == NULL)
		return -ENOMEM;

728
	/* Check arg is function or file and copy it */
729 730
	if (strchr(tmp, '.'))	/* File */
		pp->file = tmp;
731
	else			/* Function */
732
		pp->function = tmp;
733 734 735 736 737

	/* Parse other options */
	while (ptr) {
		arg = ptr;
		c = nc;
738
		if (c == ';') {	/* Lazy pattern must be the last part */
739 740 741
			pp->lazy_line = strdup(arg);
			if (pp->lazy_line == NULL)
				return -ENOMEM;
742 743 744
			break;
		}
		ptr = strpbrk(arg, ";:+@%");
745 746 747 748 749 750 751
		if (ptr) {
			nc = *ptr;
			*ptr++ = '\0';
		}
		switch (c) {
		case ':':	/* Line number */
			pp->line = strtoul(arg, &tmp, 0);
752
			if (*tmp != '\0') {
753
				semantic_error("There is non-digit char"
754 755 756
					       " in line number.\n");
				return -EINVAL;
			}
757 758 759
			break;
		case '+':	/* Byte offset from a symbol */
			pp->offset = strtoul(arg, &tmp, 0);
760
			if (*tmp != '\0') {
761
				semantic_error("There is non-digit character"
762 763 764
						" in offset.\n");
				return -EINVAL;
			}
765 766
			break;
		case '@':	/* File name */
767 768 769 770
			if (pp->file) {
				semantic_error("SRC@SRC is not allowed.\n");
				return -EINVAL;
			}
771 772 773
			pp->file = strdup(arg);
			if (pp->file == NULL)
				return -ENOMEM;
774 775 776 777
			break;
		case '%':	/* Probe places */
			if (strcmp(arg, "return") == 0) {
				pp->retprobe = 1;
778 779 780 781
			} else {	/* Others not supported yet */
				semantic_error("%%%s is not supported.\n", arg);
				return -ENOTSUP;
			}
782
			break;
783 784 785 786
		default:	/* Buggy case */
			pr_err("This program has a bug at %s:%d.\n",
				__FILE__, __LINE__);
			return -ENOTSUP;
787 788 789 790 791
			break;
		}
	}

	/* Exclusion check */
792
	if (pp->lazy_line && pp->line) {
M
Masami Hiramatsu 已提交
793 794
		semantic_error("Lazy pattern can't be used with"
			       " line number.\n");
795 796
		return -EINVAL;
	}
797

798
	if (pp->lazy_line && pp->offset) {
M
Masami Hiramatsu 已提交
799
		semantic_error("Lazy pattern can't be used with offset.\n");
800 801
		return -EINVAL;
	}
802

803
	if (pp->line && pp->offset) {
M
Masami Hiramatsu 已提交
804
		semantic_error("Offset can't be used with line number.\n");
805 806
		return -EINVAL;
	}
807

808
	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
809
		semantic_error("File always requires line number or "
M
Masami Hiramatsu 已提交
810
			       "lazy pattern.\n");
811 812
		return -EINVAL;
	}
813

814
	if (pp->offset && !pp->function) {
M
Masami Hiramatsu 已提交
815
		semantic_error("Offset requires an entry function.\n");
816 817
		return -EINVAL;
	}
818

819
	if (pp->retprobe && !pp->function) {
M
Masami Hiramatsu 已提交
820
		semantic_error("Return probe requires an entry function.\n");
821 822
		return -EINVAL;
	}
823

824
	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
825
		semantic_error("Offset/Line/Lazy pattern can't be used with "
M
Masami Hiramatsu 已提交
826
			       "return probe.\n");
827 828
		return -EINVAL;
	}
829

830
	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
831 832
		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
		 pp->lazy_line);
833
	return 0;
834 835
}

836
/* Parse perf-probe event argument */
837
static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
838
{
839
	char *tmp, *goodname;
840 841 842 843
	struct perf_probe_arg_field **fieldp;

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

844 845
	tmp = strchr(str, '=');
	if (tmp) {
846 847 848
		arg->name = strndup(str, tmp - str);
		if (arg->name == NULL)
			return -ENOMEM;
849
		pr_debug("name:%s ", arg->name);
850 851 852
		str = tmp + 1;
	}

853 854 855
	tmp = strchr(str, ':');
	if (tmp) {	/* Type setting */
		*tmp = '\0';
856 857 858
		arg->type = strdup(tmp + 1);
		if (arg->type == NULL)
			return -ENOMEM;
859 860 861
		pr_debug("type:%s ", arg->type);
	}

862
	tmp = strpbrk(str, "-.[");
863 864
	if (!is_c_varname(str) || !tmp) {
		/* A variable, register, symbol or special value */
865 866 867
		arg->var = strdup(str);
		if (arg->var == NULL)
			return -ENOMEM;
868
		pr_debug("%s\n", arg->var);
869
		return 0;
870 871
	}

872
	/* Structure fields or array element */
873 874 875
	arg->var = strndup(str, tmp - str);
	if (arg->var == NULL)
		return -ENOMEM;
876
	goodname = arg->var;
877
	pr_debug("%s, ", arg->var);
878 879 880
	fieldp = &arg->field;

	do {
881 882 883
		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
		if (*fieldp == NULL)
			return -ENOMEM;
884 885 886
		if (*tmp == '[') {	/* Array */
			str = tmp;
			(*fieldp)->index = strtol(str + 1, &tmp, 0);
887
			(*fieldp)->ref = true;
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
			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, "-.[");
909
		}
910
		if (tmp) {
911 912 913
			(*fieldp)->name = strndup(str, tmp - str);
			if ((*fieldp)->name == NULL)
				return -ENOMEM;
914 915
			if (*str != '[')
				goodname = (*fieldp)->name;
916 917 918 919
			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
			fieldp = &(*fieldp)->next;
		}
	} while (tmp);
920 921 922
	(*fieldp)->name = strdup(str);
	if ((*fieldp)->name == NULL)
		return -ENOMEM;
923 924
	if (*str != '[')
		goodname = (*fieldp)->name;
925
	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
926

927
	/* If no name is specified, set the last field name (not array index)*/
928
	if (!arg->name) {
929
		arg->name = strdup(goodname);
930 931 932
		if (arg->name == NULL)
			return -ENOMEM;
	}
933
	return 0;
934 935
}

936
/* Parse perf-probe event command */
937
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
938
{
939
	char **argv;
940
	int argc, i, ret = 0;
941

942
	argv = argv_split(cmd, &argc);
943 944 945 946 947 948 949 950 951
	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;
	}
952
	/* Parse probe point */
953 954 955
	ret = parse_perf_probe_point(argv[0], pev);
	if (ret < 0)
		goto out;
956

957
	/* Copy arguments and ensure return probe has no C argument */
958
	pev->nargs = argc - 1;
959 960 961 962 963
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
964 965 966 967
	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) {
968
			semantic_error("You can't specify local variable for"
969 970 971
				       " kretprobe.\n");
			ret = -EINVAL;
		}
972
	}
973
out:
974
	argv_free(argv);
975 976

	return ret;
977 978
}

979 980 981 982 983 984 985 986 987
/* 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++)
988
		if (is_c_varname(pev->args[i].var))
989 990 991 992 993
			return true;

	return false;
}

994 995 996
/* Parse probe_events event into struct probe_point */
static int parse_probe_trace_command(const char *cmd,
					struct probe_trace_event *tev)
997
{
998
	struct probe_trace_point *tp = &tev->point;
999 1000 1001 1002 1003
	char pr;
	char *p;
	int ret, i, argc;
	char **argv;

1004
	pr_debug("Parsing probe_events: %s\n", cmd);
1005
	argv = argv_split(cmd, &argc);
1006 1007 1008 1009 1010 1011 1012 1013 1014
	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;
	}
1015 1016

	/* Scan event and group name. */
1017
	ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
1018 1019
		     &pr, (float *)(void *)&tev->group,
		     (float *)(void *)&tev->event);
1020 1021 1022 1023 1024
	if (ret != 3) {
		semantic_error("Failed to parse event name: %s\n", argv[0]);
		ret = -EINVAL;
		goto out;
	}
1025
	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1026

1027
	tp->retprobe = (pr == 'r');
1028 1029

	/* Scan function name and offset */
1030 1031
	ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol,
		     &tp->offset);
1032
	if (ret == 1)
1033
		tp->offset = 0;
1034

1035
	tev->nargs = argc - 2;
1036
	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1037 1038 1039 1040
	if (tev->args == NULL) {
		ret = -ENOMEM;
		goto out;
	}
1041
	for (i = 0; i < tev->nargs; i++) {
1042 1043
		p = strchr(argv[i + 2], '=');
		if (p)	/* We don't need which register is assigned. */
1044 1045 1046
			*p++ = '\0';
		else
			p = argv[i + 2];
1047
		tev->args[i].name = strdup(argv[i + 2]);
1048
		/* TODO: parse regs and offset */
1049 1050 1051 1052 1053
		tev->args[i].value = strdup(p);
		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
			ret = -ENOMEM;
			goto out;
		}
1054
	}
1055 1056
	ret = 0;
out:
1057
	argv_free(argv);
1058
	return ret;
1059 1060
}

1061 1062 1063 1064 1065 1066 1067
/* 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;

1068 1069 1070 1071
	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);
1072 1073 1074 1075 1076 1077
	if (ret <= 0)
		goto error;
	tmp += ret;
	len -= ret;

	while (field) {
1078 1079 1080 1081 1082
		if (field->name[0] == '[')
			ret = e_snprintf(tmp, len, "%s", field->name);
		else
			ret = e_snprintf(tmp, len, "%s%s",
					 field->ref ? "->" : ".", field->name);
1083 1084 1085 1086 1087 1088
		if (ret <= 0)
			goto error;
		tmp += ret;
		len -= ret;
		field = field->next;
	}
1089 1090 1091 1092 1093 1094 1095 1096 1097

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

1098 1099
	return tmp - buf;
error:
M
Masami Hiramatsu 已提交
1100
	pr_debug("Failed to synthesize perf probe argument: %s\n",
1101 1102
		 strerror(-ret));
	return ret;
1103 1104
}

1105 1106
/* Compose only probe point (not argument) */
static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1107
{
1108 1109 1110
	char *buf, *tmp;
	char offs[32] = "", line[32] = "", file[32] = "";
	int ret, len;
1111

1112 1113 1114 1115 1116
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL) {
		ret = -ENOMEM;
		goto error;
	}
1117
	if (pp->offset) {
1118
		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1119 1120 1121 1122
		if (ret <= 0)
			goto error;
	}
	if (pp->line) {
1123 1124 1125 1126 1127
		ret = e_snprintf(line, 32, ":%d", pp->line);
		if (ret <= 0)
			goto error;
	}
	if (pp->file) {
1128 1129 1130 1131 1132 1133 1134
		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);
1135 1136 1137 1138 1139
		if (ret <= 0)
			goto error;
	}

	if (pp->function)
1140 1141 1142
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
				 offs, pp->retprobe ? "%return" : "", line,
				 file);
1143
	else
1144
		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1145 1146 1147 1148
	if (ret <= 0)
		goto error;

	return buf;
1149
error:
M
Masami Hiramatsu 已提交
1150
	pr_debug("Failed to synthesize perf probe point: %s\n",
1151
		 strerror(-ret));
1152 1153
	if (buf)
		free(buf);
1154
	return NULL;
1155 1156
}

1157 1158
#if 0
char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1159 1160 1161 1162
{
	char *buf;
	int i, len, ret;

1163 1164 1165
	buf = synthesize_perf_probe_point(&pev->point);
	if (!buf)
		return NULL;
1166

1167 1168
	len = strlen(buf);
	for (i = 0; i < pev->nargs; i++) {
1169
		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1170 1171 1172 1173 1174
				 pev->args[i].name);
		if (ret <= 0) {
			free(buf);
			return NULL;
		}
1175 1176 1177
		len += ret;
	}

1178 1179 1180 1181
	return buf;
}
#endif

1182
static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1183 1184 1185 1186 1187
					     char **buf, size_t *buflen,
					     int depth)
{
	int ret;
	if (ref->next) {
1188
		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
							 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;
1203 1204 1205

}

1206
static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1207
				       char *buf, size_t buflen)
1208
{
1209
	struct probe_trace_arg_ref *ref = arg->ref;
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
	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;

1223 1224 1225 1226
	/* Special case: @XXX */
	if (arg->value[0] == '@' && arg->ref)
			ref = ref->next;

1227
	/* Dereferencing arguments */
1228
	if (ref) {
1229
		depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1230 1231 1232 1233 1234 1235
							  &buflen, 1);
		if (depth < 0)
			return depth;
	}

	/* Print argument value */
1236 1237 1238 1239 1240
	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);
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
	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;
	}
1254 1255 1256 1257 1258 1259 1260
	/* Print argument type */
	if (arg->type) {
		ret = e_snprintf(buf, buflen, ":%s", arg->type);
		if (ret <= 0)
			return ret;
		buf += ret;
	}
1261 1262 1263 1264

	return buf - tmp;
}

1265
char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1266
{
1267
	struct probe_trace_point *tp = &tev->point;
1268 1269 1270
	char *buf;
	int i, len, ret;

1271 1272 1273 1274
	buf = zalloc(MAX_CMDLEN);
	if (buf == NULL)
		return NULL;

1275 1276 1277 1278 1279
	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu",
			 tp->retprobe ? 'r' : 'p',
			 tev->group, tev->event,
			 tp->symbol, tp->offset);
	if (len <= 0)
1280 1281
		goto error;

1282
	for (i = 0; i < tev->nargs; i++) {
1283
		ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1284
						  MAX_CMDLEN - len);
1285
		if (ret <= 0)
1286 1287 1288 1289
			goto error;
		len += ret;
	}

1290
	return buf;
1291
error:
1292 1293 1294
	free(buf);
	return NULL;
}
1295

1296
static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1297
				       struct perf_probe_event *pev)
1298
{
1299
	char buf[64] = "";
1300
	int i, ret;
1301

1302
	/* Convert event/group name */
1303 1304 1305 1306
	pev->event = strdup(tev->event);
	pev->group = strdup(tev->group);
	if (pev->event == NULL || pev->group == NULL)
		return -ENOMEM;
1307

1308
	/* Convert trace_point to probe_point */
1309
	ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
1310 1311
	if (ret < 0)
		return ret;
1312

1313 1314
	/* Convert trace_arg to probe_arg */
	pev->nargs = tev->nargs;
1315 1316 1317
	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
	if (pev->args == NULL)
		return -ENOMEM;
1318
	for (i = 0; i < tev->nargs && ret >= 0; i++) {
1319
		if (tev->args[i].name)
1320
			pev->args[i].name = strdup(tev->args[i].name);
1321
		else {
1322
			ret = synthesize_probe_trace_arg(&tev->args[i],
1323
							  buf, 64);
1324
			pev->args[i].name = strdup(buf);
1325
		}
1326 1327 1328
		if (pev->args[i].name == NULL && ret >= 0)
			ret = -ENOMEM;
	}
1329 1330 1331 1332 1333

	if (ret < 0)
		clear_perf_probe_event(pev);

	return ret;
1334 1335 1336 1337 1338
}

void clear_perf_probe_event(struct perf_probe_event *pev)
{
	struct perf_probe_point *pp = &pev->point;
1339
	struct perf_probe_arg_field *field, *next;
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	int i;

	if (pev->event)
		free(pev->event);
	if (pev->group)
		free(pev->group);
	if (pp->file)
		free(pp->file);
	if (pp->function)
		free(pp->function);
	if (pp->lazy_line)
		free(pp->lazy_line);
1352
	for (i = 0; i < pev->nargs; i++) {
1353 1354
		if (pev->args[i].name)
			free(pev->args[i].name);
1355 1356
		if (pev->args[i].var)
			free(pev->args[i].var);
1357 1358
		if (pev->args[i].type)
			free(pev->args[i].type);
1359 1360 1361 1362 1363 1364 1365 1366 1367
		field = pev->args[i].field;
		while (field) {
			next = field->next;
			if (field->name)
				free(field->name);
			free(field);
			field = next;
		}
	}
1368 1369 1370 1371 1372
	if (pev->args)
		free(pev->args);
	memset(pev, 0, sizeof(*pev));
}

1373
static void clear_probe_trace_event(struct probe_trace_event *tev)
1374
{
1375
	struct probe_trace_arg_ref *ref, *next;
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
	int i;

	if (tev->event)
		free(tev->event);
	if (tev->group)
		free(tev->group);
	if (tev->point.symbol)
		free(tev->point.symbol);
	for (i = 0; i < tev->nargs; i++) {
		if (tev->args[i].name)
			free(tev->args[i].name);
		if (tev->args[i].value)
			free(tev->args[i].value);
1389 1390
		if (tev->args[i].type)
			free(tev->args[i].type);
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
		ref = tev->args[i].ref;
		while (ref) {
			next = ref->next;
			free(ref);
			ref = next;
		}
	}
	if (tev->args)
		free(tev->args);
	memset(tev, 0, sizeof(*tev));
1401 1402
}

1403
static int open_kprobe_events(bool readwrite)
1404 1405
{
	char buf[PATH_MAX];
1406
	const char *__debugfs;
1407 1408
	int ret;

1409 1410 1411 1412 1413 1414 1415
	__debugfs = debugfs_find_mountpoint();
	if (__debugfs == NULL) {
		pr_warning("Debugfs is not mounted.\n");
		return -ENOENT;
	}

	ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
1416
	if (ret >= 0) {
1417
		pr_debug("Opening %s write=%d\n", buf, readwrite);
1418 1419 1420 1421 1422
		if (readwrite && !probe_event_dry_run)
			ret = open(buf, O_RDWR, O_APPEND);
		else
			ret = open(buf, O_RDONLY, 0);
	}
1423

1424 1425
	if (ret < 0) {
		if (errno == ENOENT)
1426 1427
			pr_warning("kprobe_events file does not exist - please"
				 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
1428
		else
1429 1430
			pr_warning("Failed to open kprobe_events file: %s\n",
				   strerror(errno));
1431 1432 1433 1434 1435
	}
	return ret;
}

/* Get raw string list of current kprobe_events */
1436
static struct strlist *get_probe_trace_command_rawlist(int fd)
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
{
	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);
1456 1457 1458 1459 1460
		if (ret < 0) {
			pr_debug("strlist__add failed: %s\n", strerror(-ret));
			strlist__delete(sl);
			return NULL;
		}
1461 1462 1463 1464 1465 1466
	}
	fclose(fp);

	return sl;
}

1467
/* Show an event */
1468
static int show_perf_probe_event(struct perf_probe_event *pev)
1469
{
1470
	int i, ret;
1471
	char buf[128];
1472
	char *place;
1473

1474 1475
	/* Synthesize only event probe point */
	place = synthesize_perf_probe_point(&pev->point);
1476 1477
	if (!place)
		return -EINVAL;
1478 1479

	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
1480
	if (ret < 0)
1481 1482
		return ret;

1483
	printf("  %-20s (on %s", buf, place);
1484

1485
	if (pev->nargs > 0) {
1486
		printf(" with");
1487
		for (i = 0; i < pev->nargs; i++) {
1488 1489 1490 1491
			ret = synthesize_perf_probe_arg(&pev->args[i],
							buf, 128);
			if (ret < 0)
				break;
1492 1493
			printf(" %s", buf);
		}
1494 1495
	}
	printf(")\n");
1496
	free(place);
1497
	return ret;
1498 1499
}

1500
/* List up current perf-probe events */
1501
int show_perf_probe_events(void)
1502
{
1503
	int fd, ret;
1504
	struct probe_trace_event tev;
1505
	struct perf_probe_event pev;
1506 1507 1508
	struct strlist *rawlist;
	struct str_node *ent;

1509
	setup_pager();
1510 1511 1512
	ret = init_vmlinux();
	if (ret < 0)
		return ret;
1513 1514 1515

	memset(&tev, 0, sizeof(tev));
	memset(&pev, 0, sizeof(pev));
1516

1517
	fd = open_kprobe_events(false);
1518 1519 1520
	if (fd < 0)
		return fd;

1521
	rawlist = get_probe_trace_command_rawlist(fd);
1522
	close(fd);
1523 1524
	if (!rawlist)
		return -ENOENT;
1525

1526
	strlist__for_each(ent, rawlist) {
1527
		ret = parse_probe_trace_command(ent->s, &tev);
1528 1529 1530 1531 1532
		if (ret >= 0) {
			ret = convert_to_perf_probe_event(&tev, &pev);
			if (ret >= 0)
				ret = show_perf_probe_event(&pev);
		}
1533
		clear_perf_probe_event(&pev);
1534
		clear_probe_trace_event(&tev);
1535 1536
		if (ret < 0)
			break;
1537 1538
	}
	strlist__delete(rawlist);
1539 1540

	return ret;
1541 1542
}

1543
/* Get current perf-probe event names */
1544
static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
1545
{
1546
	char buf[128];
1547 1548
	struct strlist *sl, *rawlist;
	struct str_node *ent;
1549
	struct probe_trace_event tev;
1550
	int ret = 0;
1551

1552
	memset(&tev, 0, sizeof(tev));
1553
	rawlist = get_probe_trace_command_rawlist(fd);
1554
	sl = strlist__new(true, NULL);
1555
	strlist__for_each(ent, rawlist) {
1556
		ret = parse_probe_trace_command(ent->s, &tev);
1557 1558
		if (ret < 0)
			break;
1559
		if (include_group) {
1560 1561 1562 1563
			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
					tev.event);
			if (ret >= 0)
				ret = strlist__add(sl, buf);
1564
		} else
1565
			ret = strlist__add(sl, tev.event);
1566
		clear_probe_trace_event(&tev);
1567 1568
		if (ret < 0)
			break;
1569 1570 1571
	}
	strlist__delete(rawlist);

1572 1573 1574 1575
	if (ret < 0) {
		strlist__delete(sl);
		return NULL;
	}
1576 1577 1578
	return sl;
}

1579
static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
1580
{
1581
	int ret = 0;
1582
	char *buf = synthesize_probe_trace_command(tev);
1583

1584
	if (!buf) {
1585
		pr_debug("Failed to synthesize probe trace event.\n");
1586 1587 1588
		return -EINVAL;
	}

1589
	pr_debug("Writing event: %s\n", buf);
1590 1591 1592
	if (!probe_event_dry_run) {
		ret = write(fd, buf, strlen(buf));
		if (ret <= 0)
1593 1594
			pr_warning("Failed to write event: %s\n",
				   strerror(errno));
1595
	}
1596
	free(buf);
1597
	return ret;
1598 1599
}

1600 1601
static int get_new_event_name(char *buf, size_t len, const char *base,
			      struct strlist *namelist, bool allow_suffix)
1602 1603
{
	int i, ret;
1604 1605 1606

	/* Try no suffix */
	ret = e_snprintf(buf, len, "%s", base);
1607 1608 1609 1610
	if (ret < 0) {
		pr_debug("snprintf() failed: %s\n", strerror(-ret));
		return ret;
	}
1611
	if (!strlist__has_entry(namelist, buf))
1612
		return 0;
1613

1614 1615 1616
	if (!allow_suffix) {
		pr_warning("Error: event \"%s\" already exists. "
			   "(Use -f to force duplicates.)\n", base);
1617
		return -EEXIST;
1618 1619
	}

1620 1621
	/* Try to add suffix */
	for (i = 1; i < MAX_EVENT_INDEX; i++) {
1622
		ret = e_snprintf(buf, len, "%s_%d", base, i);
1623 1624 1625 1626
		if (ret < 0) {
			pr_debug("snprintf() failed: %s\n", strerror(-ret));
			return ret;
		}
1627 1628 1629
		if (!strlist__has_entry(namelist, buf))
			break;
	}
1630 1631 1632 1633 1634 1635
	if (i == MAX_EVENT_INDEX) {
		pr_warning("Too many events are on the same function.\n");
		ret = -ERANGE;
	}

	return ret;
1636 1637
}

1638 1639
static int __add_probe_trace_events(struct perf_probe_event *pev,
				     struct probe_trace_event *tevs,
1640
				     int ntevs, bool allow_suffix)
1641
{
1642
	int i, fd, ret;
1643
	struct probe_trace_event *tev = NULL;
1644 1645
	char buf[64];
	const char *event, *group;
1646
	struct strlist *namelist;
1647

1648
	fd = open_kprobe_events(true);
1649 1650
	if (fd < 0)
		return fd;
1651
	/* Get current event names */
1652
	namelist = get_probe_trace_event_names(fd, false);
1653 1654 1655 1656
	if (!namelist) {
		pr_debug("Failed to get current event list.\n");
		return -EIO;
	}
1657

1658
	ret = 0;
1659
	printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
1660
	for (i = 0; i < ntevs; i++) {
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
		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 */
1675 1676 1677 1678
		ret = get_new_event_name(buf, 64, event,
					 namelist, allow_suffix);
		if (ret < 0)
			break;
1679 1680
		event = buf;

1681 1682 1683 1684 1685 1686
		tev->event = strdup(event);
		tev->group = strdup(group);
		if (tev->event == NULL || tev->group == NULL) {
			ret = -ENOMEM;
			break;
		}
1687
		ret = write_probe_trace_event(fd, tev);
1688 1689
		if (ret < 0)
			break;
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
		/* 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;
		show_perf_probe_event(pev);
		/* 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;
1710
	}
1711 1712 1713 1714 1715 1716 1717

	if (ret >= 0) {
		/* Show how to use the event. */
		printf("\nYou can now use it on all perf tools, such as:\n\n");
		printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
			 tev->event);
	}
1718

1719
	strlist__delete(namelist);
1720
	close(fd);
1721
	return ret;
1722
}
1723

1724 1725
static int convert_to_probe_trace_events(struct perf_probe_event *pev,
					  struct probe_trace_event **tevs,
1726
					  int max_tevs, const char *module)
1727 1728
{
	struct symbol *sym;
1729
	int ret = 0, i;
1730
	struct probe_trace_event *tev;
1731

1732
	/* Convert perf_probe_event with debuginfo */
1733
	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, module);
1734 1735
	if (ret != 0)
		return ret;
1736

1737
	/* Allocate trace event buffer */
1738
	tev = *tevs = zalloc(sizeof(struct probe_trace_event));
1739 1740
	if (tev == NULL)
		return -ENOMEM;
1741 1742

	/* Copy parameters */
1743 1744 1745 1746 1747
	tev->point.symbol = strdup(pev->point.function);
	if (tev->point.symbol == NULL) {
		ret = -ENOMEM;
		goto error;
	}
1748
	tev->point.offset = pev->point.offset;
1749
	tev->point.retprobe = pev->point.retprobe;
1750 1751
	tev->nargs = pev->nargs;
	if (tev->nargs) {
1752
		tev->args = zalloc(sizeof(struct probe_trace_arg)
1753 1754
				   * tev->nargs);
		if (tev->args == NULL) {
1755 1756
			ret = -ENOMEM;
			goto error;
1757
		}
1758
		for (i = 0; i < tev->nargs; i++) {
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
			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;
				}
			}
1778
		}
1779 1780 1781
	}

	/* Currently just checking function name from symbol map */
1782
	sym = __find_kernel_function_by_name(tev->point.symbol, NULL);
1783 1784 1785
	if (!sym) {
		pr_warning("Kernel symbol \'%s\' not found.\n",
			   tev->point.symbol);
1786 1787 1788
		ret = -ENOENT;
		goto error;
	}
1789

1790 1791
	return 1;
error:
1792
	clear_probe_trace_event(tev);
1793 1794
	free(tev);
	*tevs = NULL;
1795
	return ret;
1796 1797 1798 1799
}

struct __event_package {
	struct perf_probe_event		*pev;
1800
	struct probe_trace_event	*tevs;
1801 1802 1803
	int				ntevs;
};

1804
int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
1805
			  int max_tevs, const char *module, bool force_add)
1806
{
1807
	int i, j, ret;
1808 1809
	struct __event_package *pkgs;

1810 1811 1812
	pkgs = zalloc(sizeof(struct __event_package) * npevs);
	if (pkgs == NULL)
		return -ENOMEM;
1813 1814

	/* Init vmlinux path */
1815
	ret = init_vmlinux();
1816 1817
	if (ret < 0) {
		free(pkgs);
1818
		return ret;
1819
	}
1820 1821 1822 1823 1824

	/* Loop 1: convert all events */
	for (i = 0; i < npevs; i++) {
		pkgs[i].pev = &pevs[i];
		/* Convert with or without debuginfo */
1825
		ret  = convert_to_probe_trace_events(pkgs[i].pev,
1826 1827 1828
						     &pkgs[i].tevs,
						     max_tevs,
						     module);
1829 1830 1831
		if (ret < 0)
			goto end;
		pkgs[i].ntevs = ret;
1832 1833
	}

1834
	/* Loop 2: add all events */
1835
	for (i = 0; i < npevs && ret >= 0; i++) {
1836
		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
1837
						pkgs[i].ntevs, force_add);
1838 1839 1840
		if (ret < 0)
			break;
	}
1841
end:
1842 1843
	/* Loop 3: cleanup and free trace events  */
	for (i = 0; i < npevs; i++) {
1844
		for (j = 0; j < pkgs[i].ntevs; j++)
1845
			clear_probe_trace_event(&pkgs[i].tevs[j]);
1846 1847 1848
		free(pkgs[i].tevs);
	}
	free(pkgs);
1849 1850

	return ret;
1851 1852
}

1853
static int __del_trace_probe_event(int fd, struct str_node *ent)
1854 1855 1856
{
	char *p;
	char buf[128];
1857
	int ret;
1858

1859
	/* Convert from perf-probe event to trace-probe event */
1860 1861 1862 1863
	ret = e_snprintf(buf, 128, "-:%s", ent->s);
	if (ret < 0)
		goto error;

1864
	p = strchr(buf + 2, ':');
1865 1866 1867 1868 1869 1870
	if (!p) {
		pr_debug("Internal error: %s should have ':' but not.\n",
			 ent->s);
		ret = -ENOTSUP;
		goto error;
	}
1871 1872
	*p = '/';

1873 1874
	pr_debug("Writing event: %s\n", buf);
	ret = write(fd, buf, strlen(buf));
1875 1876 1877
	if (ret < 0)
		goto error;

1878
	printf("Remove event: %s\n", ent->s);
1879 1880 1881 1882
	return 0;
error:
	pr_warning("Failed to delete event: %s\n", strerror(-ret));
	return ret;
1883 1884
}

1885
static int del_trace_probe_event(int fd, const char *group,
1886
				  const char *event, struct strlist *namelist)
1887 1888
{
	char buf[128];
1889
	struct str_node *ent, *n;
1890
	int found = 0, ret = 0;
1891

1892 1893
	ret = e_snprintf(buf, 128, "%s:%s", group, event);
	if (ret < 0) {
M
Masami Hiramatsu 已提交
1894
		pr_err("Failed to copy event.\n");
1895 1896
		return ret;
	}
1897

1898 1899 1900 1901
	if (strpbrk(buf, "*?")) { /* Glob-exp */
		strlist__for_each_safe(ent, n, namelist)
			if (strglobmatch(ent->s, buf)) {
				found++;
1902
				ret = __del_trace_probe_event(fd, ent);
1903 1904
				if (ret < 0)
					break;
1905 1906 1907 1908 1909 1910
				strlist__remove(namelist, ent);
			}
	} else {
		ent = strlist__find(namelist, buf);
		if (ent) {
			found++;
1911
			ret = __del_trace_probe_event(fd, ent);
1912 1913
			if (ret >= 0)
				strlist__remove(namelist, ent);
1914 1915
		}
	}
1916 1917 1918 1919
	if (found == 0 && ret >= 0)
		pr_info("Info: Event \"%s\" does not exist.\n", buf);

	return ret;
1920 1921
}

1922
int del_perf_probe_events(struct strlist *dellist)
1923
{
1924
	int fd, ret = 0;
1925 1926 1927 1928 1929
	const char *group, *event;
	char *p, *str;
	struct str_node *ent;
	struct strlist *namelist;

1930
	fd = open_kprobe_events(true);
1931 1932 1933
	if (fd < 0)
		return fd;

1934
	/* Get current event names */
1935
	namelist = get_probe_trace_event_names(fd, true);
1936 1937
	if (namelist == NULL)
		return -EINVAL;
1938

1939
	strlist__for_each(ent, dellist) {
1940 1941 1942 1943 1944
		str = strdup(ent->s);
		if (str == NULL) {
			ret = -ENOMEM;
			break;
		}
1945
		pr_debug("Parsing: %s\n", str);
1946 1947 1948 1949 1950 1951
		p = strchr(str, ':');
		if (p) {
			group = str;
			*p = '\0';
			event = p + 1;
		} else {
1952
			group = "*";
1953 1954
			event = str;
		}
1955
		pr_debug("Group: %s, Event: %s\n", group, event);
1956
		ret = del_trace_probe_event(fd, group, event, namelist);
1957
		free(str);
1958 1959
		if (ret < 0)
			break;
1960 1961 1962
	}
	strlist__delete(namelist);
	close(fd);
1963 1964

	return ret;
1965
}
1966 1967
/* TODO: don't use a global variable for filter ... */
static struct strfilter *available_func_filter;
1968

1969
/*
1970 1971
 * If a symbol corresponds to a function with global binding and
 * matches filter return 0. For all others return 1.
1972
 */
1973 1974
static int filter_available_functions(struct map *map __unused,
				      struct symbol *sym)
1975
{
1976 1977 1978 1979
	if (sym->binding == STB_GLOBAL &&
	    strfilter__compare(available_func_filter, sym->name))
		return 0;
	return 1;
1980 1981
}

1982
int show_available_funcs(const char *module, struct strfilter *_filter)
1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
{
	struct map *map;
	int ret;

	setup_pager();

	ret = init_vmlinux();
	if (ret < 0)
		return ret;

	map = kernel_get_module_map(module);
	if (!map) {
		pr_err("Failed to find %s map.\n", (module) ? : "kernel");
		return -EINVAL;
	}
1998 1999
	available_func_filter = _filter;
	if (map__load(map, filter_available_functions)) {
2000 2001 2002 2003 2004 2005 2006 2007 2008
		pr_err("Failed to load map.\n");
		return -EINVAL;
	}
	if (!dso__sorted_by_name(map->dso, map->type))
		dso__sort_by_name(map->dso, map->type);

	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
	return 0;
}