[deliverable/linux.git] / tools / perf / builtin-probe.c

/*
 * builtin-probe.c
 *
 * Builtin probe command: Set up probe events by C expression
 *
 * 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>

#include "perf.h"
#include "builtin.h"
#include "util/util.h"
#include "util/strlist.h"
#include "util/strfilter.h"
#include "util/symbol.h"
#include "util/debug.h"
#include <lk/debugfs.h>
#include "util/parse-options.h"
#include "util/probe-finder.h"
#include "util/probe-event.h"

#define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
#define DEFAULT_FUNC_FILTER "!_*"

/* Session management structure */
static struct {
	bool list_events;
	bool force_add;
	bool show_lines;
	bool show_vars;
	bool show_ext_vars;
	bool show_funcs;
	bool mod_events;
	bool uprobes;
	int nevents;
	struct perf_probe_event events[MAX_PROBES];
	struct strlist *dellist;
	struct line_range line_range;
	const char *target;
	int max_probe_points;
	struct strfilter *filter;
} params;

/* Parse an event definition. Note that any error must die. */
static int parse_probe_event(const char *str)
{
	struct perf_probe_event *pev = &params.events[params.nevents];
	int ret;

	pr_debug("probe-definition(%d): %s\n", params.nevents, str);
	if (++params.nevents == MAX_PROBES) {
		pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
		return -1;
	}

	pev->uprobes = params.uprobes;

	/* Parse a perf-probe command into event */
	ret = parse_perf_probe_command(str, pev);
	pr_debug("%d arguments\n", pev->nargs);

	return ret;
}

static int set_target(const char *ptr)
{
	int found = 0;
	const char *buf;

	/*
	 * The first argument after options can be an absolute path
	 * to an executable / library or kernel module.
	 *
	 * TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
	 * short module name.
	 */
	if (!params.target && ptr && *ptr == '/') {
		params.target = ptr;
		found = 1;
		buf = ptr + (strlen(ptr) - 3);

		if (strcmp(buf, ".ko"))
			params.uprobes = true;

	}

	return found;
}

static int parse_probe_event_argv(int argc, const char **argv)
{
	int i, len, ret, found_target;
	char *buf;

	found_target = set_target(argv[0]);
	if (found_target && argc == 1)
		return 0;

	/* Bind up rest arguments */
	len = 0;
	for (i = 0; i < argc; i++) {
		if (i == 0 && found_target)
			continue;

		len += strlen(argv[i]) + 1;
	}
	buf = zalloc(len + 1);
	if (buf == NULL)
		return -ENOMEM;
	len = 0;
	for (i = 0; i < argc; i++) {
		if (i == 0 && found_target)
			continue;

		len += sprintf(&buf[len], "%s ", argv[i]);
	}
	params.mod_events = true;
	ret = parse_probe_event(buf);
	free(buf);
	return ret;
}

static int opt_add_probe_event(const struct option *opt __maybe_unused,
			      const char *str, int unset __maybe_unused)
{
	if (str) {
		params.mod_events = true;
		return parse_probe_event(str);
	} else
		return 0;
}

static int opt_del_probe_event(const struct option *opt __maybe_unused,
			       const char *str, int unset __maybe_unused)
{
	if (str) {
		params.mod_events = true;
		if (!params.dellist)
			params.dellist = strlist__new(true, NULL);
		strlist__add(params.dellist, str);
	}
	return 0;
}

static int opt_set_target(const struct option *opt, const char *str,
			int unset __maybe_unused)
{
	int ret = -ENOENT;

	if  (str && !params.target) {
		if (!strcmp(opt->long_name, "exec"))
			params.uprobes = true;
#ifdef HAVE_DWARF_SUPPORT
		else if (!strcmp(opt->long_name, "module"))
			params.uprobes = false;
#endif
		else
			return ret;

		params.target = str;
		ret = 0;
	}

	return ret;
}

#ifdef HAVE_DWARF_SUPPORT
static int opt_show_lines(const struct option *opt __maybe_unused,
			  const char *str, int unset __maybe_unused)
{
	int ret = 0;

	if (!str)
		return 0;

	if (params.show_lines) {
		pr_warning("Warning: more than one --line options are"
			   " detected. Only the first one is valid.\n");
		return 0;
	}

	params.show_lines = true;
	ret = parse_line_range_desc(str, &params.line_range);
	INIT_LIST_HEAD(&params.line_range.line_list);

	return ret;
}

static int opt_show_vars(const struct option *opt __maybe_unused,
			 const char *str, int unset __maybe_unused)
{
	struct perf_probe_event *pev = &params.events[params.nevents];
	int ret;

	if (!str)
		return 0;

	ret = parse_probe_event(str);
	if (!ret && pev->nargs != 0) {
		pr_err("  Error: '--vars' doesn't accept arguments.\n");
		return -EINVAL;
	}
	params.show_vars = true;

	return ret;
}
#endif

static int opt_set_filter(const struct option *opt __maybe_unused,
			  const char *str, int unset __maybe_unused)
{
	const char *err;

	if (str) {
		pr_debug2("Set filter: %s\n", str);
		if (params.filter)
			strfilter__delete(params.filter);
		params.filter = strfilter__new(str, &err);
		if (!params.filter) {
			pr_err("Filter parse error at %td.\n", err - str + 1);
			pr_err("Source: \"%s\"\n", str);
			pr_err("         %*c\n", (int)(err - str + 1), '^');
			return -EINVAL;
		}
	}

	return 0;
}

int cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
{
	const char * const probe_usage[] = {
		"perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
		"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
		"perf probe [<options>] --del '[GROUP:]EVENT' ...",
		"perf probe --list",
#ifdef HAVE_DWARF_SUPPORT
		"perf probe [<options>] --line 'LINEDESC'",
		"perf probe [<options>] --vars 'PROBEPOINT'",
#endif
		NULL
};
	const struct option options[] = {
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show parsed arguments, etc)"),
	OPT_BOOLEAN('l', "list", &params.list_events,
		    "list up current probe events"),
	OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
		opt_del_probe_event),
	OPT_CALLBACK('a', "add", NULL,
#ifdef HAVE_DWARF_SUPPORT
		"[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
		" [[NAME=]ARG ...]",
#else
		"[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
#endif
		"probe point definition, where\n"
		"\t\tGROUP:\tGroup name (optional)\n"
		"\t\tEVENT:\tEvent name\n"
		"\t\tFUNC:\tFunction name\n"
		"\t\tOFF:\tOffset from function entry (in byte)\n"
		"\t\t%return:\tPut the probe at function return\n"
#ifdef HAVE_DWARF_SUPPORT
		"\t\tSRC:\tSource code path\n"
		"\t\tRL:\tRelative line number from function entry.\n"
		"\t\tAL:\tAbsolute line number in file.\n"
		"\t\tPT:\tLazy expression of line code.\n"
		"\t\tARG:\tProbe argument (local variable name or\n"
		"\t\t\tkprobe-tracer argument format.)\n",
#else
		"\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
#endif
		opt_add_probe_event),
	OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
		    " with existing name"),
#ifdef HAVE_DWARF_SUPPORT
	OPT_CALLBACK('L', "line", NULL,
		     "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
		     "Show source code lines.", opt_show_lines),
	OPT_CALLBACK('V', "vars", NULL,
		     "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
		     "Show accessible variables on PROBEDEF", opt_show_vars),
	OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
		    "Show external variables too (with --vars only)"),
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
	OPT_STRING('s', "source", &symbol_conf.source_prefix,
		   "directory", "path to kernel source"),
	OPT_CALLBACK('m', "module", NULL, "modname|path",
		"target module name (for online) or path (for offline)",
		opt_set_target),
#endif
	OPT__DRY_RUN(&probe_event_dry_run),
	OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
		 "Set how many probe points can be found for a probe."),
	OPT_BOOLEAN('F', "funcs", &params.show_funcs,
		    "Show potential probe-able functions."),
	OPT_CALLBACK('\0', "filter", NULL,
		     "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
		     "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
		     "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
		     opt_set_filter),
	OPT_CALLBACK('x', "exec", NULL, "executable|path",
			"target executable name or path", opt_set_target),
	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
		    "Disable symbol demangling"),
	OPT_END()
	};
	int ret;

	argc = parse_options(argc, argv, options, probe_usage,
			     PARSE_OPT_STOP_AT_NON_OPTION);
	if (argc > 0) {
		if (strcmp(argv[0], "-") == 0) {
			pr_warning("  Error: '-' is not supported.\n");
			usage_with_options(probe_usage, options);
		}
		ret = parse_probe_event_argv(argc, argv);
		if (ret < 0) {
			pr_err("  Error: Parse Error.  (%d)\n", ret);
			return ret;
		}
	}

	if (params.max_probe_points == 0)
		params.max_probe_points = MAX_PROBES;

	if ((!params.nevents && !params.dellist && !params.list_events &&
	     !params.show_lines && !params.show_funcs))
		usage_with_options(probe_usage, options);

	/*
	 * Only consider the user's kernel image path if given.
	 */
	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);

	if (params.list_events) {
		if (params.mod_events) {
			pr_err("  Error: Don't use --list with --add/--del.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_lines) {
			pr_err("  Error: Don't use --list with --line.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_vars) {
			pr_err(" Error: Don't use --list with --vars.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_funcs) {
			pr_err("  Error: Don't use --list with --funcs.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.uprobes) {
			pr_warning("  Error: Don't use --list with --exec.\n");
			usage_with_options(probe_usage, options);
		}
		ret = show_perf_probe_events();
		if (ret < 0)
			pr_err("  Error: Failed to show event list. (%d)\n",
			       ret);
		return ret;
	}
	if (params.show_funcs) {
		if (params.nevents != 0 || params.dellist) {
			pr_err("  Error: Don't use --funcs with"
			       " --add/--del.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_lines) {
			pr_err("  Error: Don't use --funcs with --line.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_vars) {
			pr_err("  Error: Don't use --funcs with --vars.\n");
			usage_with_options(probe_usage, options);
		}
		if (!params.filter)
			params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
						       NULL);
		ret = show_available_funcs(params.target, params.filter,
					params.uprobes);
		strfilter__delete(params.filter);
		if (ret < 0)
			pr_err("  Error: Failed to show functions."
			       " (%d)\n", ret);
		return ret;
	}

#ifdef HAVE_DWARF_SUPPORT
	if (params.show_lines && !params.uprobes) {
		if (params.mod_events) {
			pr_err("  Error: Don't use --line with"
			       " --add/--del.\n");
			usage_with_options(probe_usage, options);
		}
		if (params.show_vars) {
			pr_err(" Error: Don't use --line with --vars.\n");
			usage_with_options(probe_usage, options);
		}

		ret = show_line_range(&params.line_range, params.target);
		if (ret < 0)
			pr_err("  Error: Failed to show lines. (%d)\n", ret);
		return ret;
	}
	if (params.show_vars) {
		if (params.mod_events) {
			pr_err("  Error: Don't use --vars with"
			       " --add/--del.\n");
			usage_with_options(probe_usage, options);
		}
		if (!params.filter)
			params.filter = strfilter__new(DEFAULT_VAR_FILTER,
						       NULL);

		ret = show_available_vars(params.events, params.nevents,
					  params.max_probe_points,
					  params.target,
					  params.filter,
					  params.show_ext_vars);
		strfilter__delete(params.filter);
		if (ret < 0)
			pr_err("  Error: Failed to show vars. (%d)\n", ret);
		return ret;
	}
#endif

	if (params.dellist) {
		ret = del_perf_probe_events(params.dellist);
		strlist__delete(params.dellist);
		if (ret < 0) {
			pr_err("  Error: Failed to delete events. (%d)\n", ret);
			return ret;
		}
	}

	if (params.nevents) {
		ret = add_perf_probe_events(params.events, params.nevents,
					    params.max_probe_points,
					    params.target,
					    params.force_add);
		if (ret < 0) {
			pr_err("  Error: Failed to add events. (%d)\n", ret);
			return ret;
		}
	}
	return 0;
}
Commit	Line	Data
4ea42b18 MH	1	/*
	2	* builtin-probe.c
	3	*
	4	* Builtin probe command: Set up probe events by C expression
	5	*
	6	* Written by Masami Hiramatsu <mhiramat@redhat.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	21	*
	22	*/
4ea42b18 MH	23	#include <sys/utsname.h>
	24	#include <sys/types.h>
	25	#include <sys/stat.h>
	26	#include <fcntl.h>
	27	#include <errno.h>
	28	#include <stdio.h>
	29	#include <unistd.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32
4ea42b18 MH	33	#include "perf.h"
	34	#include "builtin.h"
	35	#include "util/util.h"
fa28244d	36	#include "util/strlist.h"
bd09d7b5	37	#include "util/strfilter.h"
e0faa8d3	38	#include "util/symbol.h"
89c69c0e	39	#include "util/debug.h"
85c66be1	40	#include <lk/debugfs.h>
4ea42b18	41	#include "util/parse-options.h"
4ea42b18	42	#include "util/probe-finder.h"
50656eec	43	#include "util/probe-event.h"
4ea42b18	44
bd09d7b5	45	#define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
3c42258c	46	#define DEFAULT_FUNC_FILTER "!_*"
4ea42b18 MH	47
	48	/* Session management structure */
	49	static struct {
fac13fd5	50	bool list_events;
d761b08b	51	bool force_add;
631c9def	52	bool show_lines;
cf6eb489	53	bool show_vars;
fb8c5a56	54	bool show_ext_vars;
e80711ca	55	bool show_funcs;
cf6eb489	56	bool mod_events;
225466f1	57	bool uprobes;
4235b045 MH	58	int nevents;
4235b045 MH	59	struct perf_probe_event events[MAX_PROBES];
fa28244d	60	struct strlist *dellist;
631c9def	61	struct line_range line_range;
4eced234	62	const char *target;
ef4a3565	63	int max_probe_points;
bd09d7b5	64	struct strfilter *filter;
12a1fadb	65	} params;
4ea42b18	66
253977b0	67	/* Parse an event definition. Note that any error must die. */
146a1439	68	static int parse_probe_event(const char *str)
4ea42b18	69	{
4235b045	70	struct perf_probe_event *pev = &params.events[params.nevents];
146a1439	71	int ret;
4ea42b18	72
4235b045	73	pr_debug("probe-definition(%d): %s\n", params.nevents, str);
8a7ddad8 ACM	74	if (++params.nevents == MAX_PROBES) {
	75	pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
	76	return -1;
	77	}
4ea42b18	78
225466f1 SD	79	pev->uprobes = params.uprobes;
225466f1 SD	80
4235b045	81	/* Parse a perf-probe command into event */
146a1439	82	ret = parse_perf_probe_command(str, pev);
4235b045	83	pr_debug("%d arguments\n", pev->nargs);
146a1439 MH	84
146a1439 MH	85	return ret;
46ab4926 MH	86	}
46ab4926 MH	87
73eff9f5 SD	88	static int set_target(const char *ptr)
	89	{
	90	int found = 0;
	91	const char *buf;
	92
	93	/*
	94	* The first argument after options can be an absolute path
	95	* to an executable / library or kernel module.
	96	*
	97	* TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
	98	* short module name.
	99	*/
	100	if (!params.target && ptr && *ptr == '/') {
	101	params.target = ptr;
	102	found = 1;
	103	buf = ptr + (strlen(ptr) - 3);
	104
	105	if (strcmp(buf, ".ko"))
	106	params.uprobes = true;
	107
	108	}
	109
	110	return found;
	111	}
	112
146a1439	113	static int parse_probe_event_argv(int argc, const char **argv)
d1bde3f7	114	{
73eff9f5	115	int i, len, ret, found_target;
d1bde3f7 MH	116	char *buf;
d1bde3f7 MH	117
73eff9f5 SD	118	found_target = set_target(argv[0]);
	119	if (found_target && argc == 1)
	120	return 0;
	121
d1bde3f7 MH	122	/* Bind up rest arguments */
d1bde3f7 MH	123	len = 0;
73eff9f5 SD	124	for (i = 0; i < argc; i++) {
	125	if (i == 0 && found_target)
	126	continue;
	127
d1bde3f7	128	len += strlen(argv[i]) + 1;
73eff9f5	129	}
8a7ddad8 ACM	130	buf = zalloc(len + 1);
	131	if (buf == NULL)
	132	return -ENOMEM;
d1bde3f7	133	len = 0;
73eff9f5 SD	134	for (i = 0; i < argc; i++) {
	135	if (i == 0 && found_target)
	136	continue;
	137
d1bde3f7	138	len += sprintf(&buf[len], "%s ", argv[i]);
73eff9f5	139	}
cf6eb489	140	params.mod_events = true;
146a1439	141	ret = parse_probe_event(buf);
d1bde3f7	142	free(buf);
146a1439	143	return ret;
d1bde3f7 MH	144	}
d1bde3f7 MH	145
1d037ca1 IT	146	static int opt_add_probe_event(const struct option *opt __maybe_unused,
1d037ca1 IT	147	const char *str, int unset __maybe_unused)
46ab4926	148	{
cf6eb489 MH	149	if (str) {
cf6eb489 MH	150	params.mod_events = true;
146a1439	151	return parse_probe_event(str);
cf6eb489	152	} else
146a1439	153	return 0;
4ea42b18 MH	154	}
4ea42b18 MH	155
1d037ca1 IT	156	static int opt_del_probe_event(const struct option *opt __maybe_unused,
1d037ca1 IT	157	const char *str, int unset __maybe_unused)
fa28244d MH	158	{
fa28244d MH	159	if (str) {
cf6eb489	160	params.mod_events = true;
12a1fadb MH	161	if (!params.dellist)
	162	params.dellist = strlist__new(true, NULL);
	163	strlist__add(params.dellist, str);
fa28244d MH	164	}
	165	return 0;
	166	}
	167
225466f1	168	static int opt_set_target(const struct option opt, const char str,
1d037ca1	169	int unset __maybe_unused)
225466f1 SD	170	{
	171	int ret = -ENOENT;
	172
	173	if (str && !params.target) {
	174	if (!strcmp(opt->long_name, "exec"))
	175	params.uprobes = true;
89fe808a	176	#ifdef HAVE_DWARF_SUPPORT
225466f1 SD	177	else if (!strcmp(opt->long_name, "module"))
	178	params.uprobes = false;
	179	#endif
	180	else
	181	return ret;
	182
	183	params.target = str;
	184	ret = 0;
	185	}
	186
	187	return ret;
	188	}
	189
89fe808a	190	#ifdef HAVE_DWARF_SUPPORT
1d037ca1 IT	191	static int opt_show_lines(const struct option *opt __maybe_unused,
1d037ca1 IT	192	const char *str, int unset __maybe_unused)
0eda7385	193	{
146a1439 MH	194	int ret = 0;
146a1439 MH	195
13e27d76 MH	196	if (!str)
	197	return 0;
	198
	199	if (params.show_lines) {
	200	pr_warning("Warning: more than one --line options are"
	201	" detected. Only the first one is valid.\n");
	202	return 0;
	203	}
	204
12a1fadb	205	params.show_lines = true;
13e27d76 MH	206	ret = parse_line_range_desc(str, &params.line_range);
13e27d76 MH	207	INIT_LIST_HEAD(&params.line_range.line_list);
146a1439 MH	208
146a1439 MH	209	return ret;
0eda7385	210	}
cf6eb489	211
1d037ca1 IT	212	static int opt_show_vars(const struct option *opt __maybe_unused,
1d037ca1 IT	213	const char *str, int unset __maybe_unused)
cf6eb489 MH	214	{
	215	struct perf_probe_event *pev = &params.events[params.nevents];
	216	int ret;
	217
	218	if (!str)
	219	return 0;
	220
	221	ret = parse_probe_event(str);
	222	if (!ret && pev->nargs != 0) {
	223	pr_err(" Error: '--vars' doesn't accept arguments.\n");
	224	return -EINVAL;
	225	}
	226	params.show_vars = true;
	227
	228	return ret;
	229	}
3c42258c	230	#endif
bd09d7b5	231
1d037ca1 IT	232	static int opt_set_filter(const struct option *opt __maybe_unused,
1d037ca1 IT	233	const char *str, int unset __maybe_unused)
bd09d7b5 MH	234	{
	235	const char *err;
	236
	237	if (str) {
	238	pr_debug2("Set filter: %s\n", str);
	239	if (params.filter)
	240	strfilter__delete(params.filter);
	241	params.filter = strfilter__new(str, &err);
	242	if (!params.filter) {
823c7164	243	pr_err("Filter parse error at %td.\n", err - str + 1);
bd09d7b5 MH	244	pr_err("Source: \"%s\"\n", str);
	245	pr_err(" %*c\n", (int)(err - str + 1), '^');
	246	return -EINVAL;
	247	}
	248	}
	249
	250	return 0;
	251	}
4ea42b18	252
11c4e4a3 ACM	253	int cmd_probe(int argc, const char *argv, const char prefix __maybe_unused)
	254	{
	255	const char * const probe_usage[] = {
	256	"perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
	257	"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
	258	"perf probe [<options>] --del '[GROUP:]EVENT' ...",
	259	"perf probe --list",
89fe808a	260	#ifdef HAVE_DWARF_SUPPORT
11c4e4a3 ACM	261	"perf probe [<options>] --line 'LINEDESC'",
11c4e4a3 ACM	262	"perf probe [<options>] --vars 'PROBEPOINT'",
f3ab481c	263	#endif
11c4e4a3	264	NULL
4ea42b18	265	};
11c4e4a3	266	const struct option options[] = {
c0555642	267	OPT_INCR('v', "verbose", &verbose,
89c69c0e	268	"be more verbose (show parsed arguments, etc)"),
12a1fadb	269	OPT_BOOLEAN('l', "list", &params.list_events,
fac13fd5	270	"list up current probe events"),
fa28244d MH	271	OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
fa28244d MH	272	opt_del_probe_event),
46ab4926	273	OPT_CALLBACK('a', "add", NULL,
89fe808a	274	#ifdef HAVE_DWARF_SUPPORT
32cb0dd5	275	"[EVENT=]FUNC[@SRC][+OFF\|%return\|:RL\|;PT]\|SRC:AL\|SRC;PT"
48481938	276	" [[NAME=]ARG ...]",
4b4da7f7	277	#else
48481938	278	"[EVENT=]FUNC[+OFF\|%return] [[NAME=]ARG ...]",
23e8ec0d	279	#endif
4ea42b18	280	"probe point definition, where\n"
af663d75 MH	281	"\t\tGROUP:\tGroup name (optional)\n"
af663d75 MH	282	"\t\tEVENT:\tEvent name\n"
4ea42b18	283	"\t\tFUNC:\tFunction name\n"
2a9c8c36	284	"\t\tOFF:\tOffset from function entry (in byte)\n"
253977b0	285	"\t\t%return:\tPut the probe at function return\n"
89fe808a	286	#ifdef HAVE_DWARF_SUPPORT
4ea42b18	287	"\t\tSRC:\tSource code path\n"
2a9c8c36 MH	288	"\t\tRL:\tRelative line number from function entry.\n"
	289	"\t\tAL:\tAbsolute line number in file.\n"
	290	"\t\tPT:\tLazy expression of line code.\n"
4ea42b18	291	"\t\tARG:\tProbe argument (local variable name or\n"
50656eec	292	"\t\t\tkprobe-tracer argument format.)\n",
4b4da7f7 MH	293	#else
	294	"\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
	295	#endif
253977b0	296	opt_add_probe_event),
12a1fadb	297	OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
d761b08b	298	" with existing name"),
89fe808a	299	#ifdef HAVE_DWARF_SUPPORT
631c9def	300	OPT_CALLBACK('L', "line", NULL,
085ea739	301	"FUNC[:RLN[+NUM\|-RLN2]]\|SRC:ALN[+NUM\|-ALN2]",
631c9def	302	"Show source code lines.", opt_show_lines),
cf6eb489 MH	303	OPT_CALLBACK('V', "vars", NULL,
	304	"FUNC[@SRC][+OFF\|%return\|:RL\|;PT]\|SRC:AL\|SRC;PT",
	305	"Show accessible variables on PROBEDEF", opt_show_vars),
fb8c5a56 MH	306	OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
fb8c5a56 MH	307	"Show external variables too (with --vars only)"),
4b4da7f7 MH	308	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
4b4da7f7 MH	309	"file", "vmlinux pathname"),
9ed7e1b8 CD	310	OPT_STRING('s', "source", &symbol_conf.source_prefix,
9ed7e1b8 CD	311	"directory", "path to kernel source"),
225466f1 SD	312	OPT_CALLBACK('m', "module", NULL, "modname\|path",
	313	"target module name (for online) or path (for offline)",
	314	opt_set_target),
631c9def	315	#endif
f4d7da49	316	OPT__DRY_RUN(&probe_event_dry_run),
ef4a3565 MH	317	OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
ef4a3565 MH	318	"Set how many probe points can be found for a probe."),
e80711ca MH	319	OPT_BOOLEAN('F', "funcs", &params.show_funcs,
e80711ca MH	320	"Show potential probe-able functions."),
3c42258c MH	321	OPT_CALLBACK('\0', "filter", NULL,
	322	"[!]FILTER", "Set a filter (with --vars/funcs only)\n"
	323	"\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
	324	"\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
	325	opt_set_filter),
225466f1 SD	326	OPT_CALLBACK('x', "exec", NULL, "executable\|path",
225466f1 SD	327	"target executable name or path", opt_set_target),
35e17b24 AK	328	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
35e17b24 AK	329	"Disable symbol demangling"),
4ea42b18	330	OPT_END()
11c4e4a3	331	};
146a1439 MH	332	int ret;
146a1439 MH	333
4ea42b18	334	argc = parse_options(argc, argv, options, probe_usage,
46ab4926	335	PARSE_OPT_STOP_AT_NON_OPTION);
ce11a603 MH	336	if (argc > 0) {
	337	if (strcmp(argv[0], "-") == 0) {
	338	pr_warning(" Error: '-' is not supported.\n");
	339	usage_with_options(probe_usage, options);
	340	}
146a1439 MH	341	ret = parse_probe_event_argv(argc, argv);
	342	if (ret < 0) {
	343	pr_err(" Error: Parse Error. (%d)\n", ret);
	344	return ret;
	345	}
ce11a603	346	}
46ab4926	347
ef4a3565 MH	348	if (params.max_probe_points == 0)
	349	params.max_probe_points = MAX_PROBES;
	350
4235b045	351	if ((!params.nevents && !params.dellist && !params.list_events &&
e80711ca	352	!params.show_lines && !params.show_funcs))
4ea42b18 MH	353	usage_with_options(probe_usage, options);
4ea42b18 MH	354
fd930ff9 FBH	355	/*
	356	* Only consider the user's kernel image path if given.
	357	*/
	358	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
	359
12a1fadb	360	if (params.list_events) {
cf6eb489	361	if (params.mod_events) {
146a1439	362	pr_err(" Error: Don't use --list with --add/--del.\n");
fa28244d MH	363	usage_with_options(probe_usage, options);
fa28244d MH	364	}
12a1fadb	365	if (params.show_lines) {
146a1439	366	pr_err(" Error: Don't use --list with --line.\n");
631c9def MH	367	usage_with_options(probe_usage, options);
631c9def MH	368	}
cf6eb489 MH	369	if (params.show_vars) {
	370	pr_err(" Error: Don't use --list with --vars.\n");
	371	usage_with_options(probe_usage, options);
	372	}
e80711ca MH	373	if (params.show_funcs) {
	374	pr_err(" Error: Don't use --list with --funcs.\n");
	375	usage_with_options(probe_usage, options);
	376	}
225466f1 SD	377	if (params.uprobes) {
	378	pr_warning(" Error: Don't use --list with --exec.\n");
	379	usage_with_options(probe_usage, options);
	380	}
146a1439 MH	381	ret = show_perf_probe_events();
	382	if (ret < 0)
	383	pr_err(" Error: Failed to show event list. (%d)\n",
	384	ret);
	385	return ret;
4de189fe	386	}
e80711ca MH	387	if (params.show_funcs) {
	388	if (params.nevents != 0 \|\| params.dellist) {
	389	pr_err(" Error: Don't use --funcs with"
	390	" --add/--del.\n");
	391	usage_with_options(probe_usage, options);
	392	}
	393	if (params.show_lines) {
	394	pr_err(" Error: Don't use --funcs with --line.\n");
	395	usage_with_options(probe_usage, options);
	396	}
	397	if (params.show_vars) {
	398	pr_err(" Error: Don't use --funcs with --vars.\n");
	399	usage_with_options(probe_usage, options);
	400	}
3c42258c MH	401	if (!params.filter)
	402	params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
	403	NULL);
225466f1 SD	404	ret = show_available_funcs(params.target, params.filter,
225466f1 SD	405	params.uprobes);
3c42258c	406	strfilter__delete(params.filter);
e80711ca MH	407	if (ret < 0)
	408	pr_err(" Error: Failed to show functions."
	409	" (%d)\n", ret);
	410	return ret;
	411	}
4de189fe	412
89fe808a	413	#ifdef HAVE_DWARF_SUPPORT
225466f1	414	if (params.show_lines && !params.uprobes) {
cf6eb489 MH	415	if (params.mod_events) {
	416	pr_err(" Error: Don't use --line with"
	417	" --add/--del.\n");
	418	usage_with_options(probe_usage, options);
	419	}
	420	if (params.show_vars) {
	421	pr_err(" Error: Don't use --line with --vars.\n");
631c9def MH	422	usage_with_options(probe_usage, options);
631c9def MH	423	}
e0faa8d3	424
4eced234	425	ret = show_line_range(&params.line_range, params.target);
146a1439 MH	426	if (ret < 0)
	427	pr_err(" Error: Failed to show lines. (%d)\n", ret);
	428	return ret;
631c9def	429	}
cf6eb489 MH	430	if (params.show_vars) {
	431	if (params.mod_events) {
	432	pr_err(" Error: Don't use --vars with"
	433	" --add/--del.\n");
	434	usage_with_options(probe_usage, options);
	435	}
bd09d7b5 MH	436	if (!params.filter)
	437	params.filter = strfilter__new(DEFAULT_VAR_FILTER,
	438	NULL);
	439
cf6eb489	440	ret = show_available_vars(params.events, params.nevents,
fb8c5a56	441	params.max_probe_points,
4eced234	442	params.target,
bd09d7b5	443	params.filter,
fb8c5a56	444	params.show_ext_vars);
bd09d7b5	445	strfilter__delete(params.filter);
cf6eb489 MH	446	if (ret < 0)
	447	pr_err(" Error: Failed to show vars. (%d)\n", ret);
	448	return ret;
	449	}
631c9def MH	450	#endif
631c9def MH	451
12a1fadb	452	if (params.dellist) {
146a1439	453	ret = del_perf_probe_events(params.dellist);
12a1fadb	454	strlist__delete(params.dellist);
146a1439 MH	455	if (ret < 0) {
	456	pr_err(" Error: Failed to delete events. (%d)\n", ret);
	457	return ret;
	458	}
fa28244d MH	459	}
fa28244d MH	460
146a1439 MH	461	if (params.nevents) {
146a1439 MH	462	ret = add_perf_probe_events(params.events, params.nevents,
c82ec0a2	463	params.max_probe_points,
4eced234	464	params.target,
c82ec0a2	465	params.force_add);
146a1439 MH	466	if (ret < 0) {
	467	pr_err(" Error: Failed to add events. (%d)\n", ret);
	468	return ret;
	469	}
	470	}
4ea42b18 MH	471	return 0;
4ea42b18 MH	472	}