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 */
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
33#include "perf.h"
34#include "builtin.h"
35#include "util/util.h"
36#include "util/strlist.h"
37#include "util/strfilter.h"
38#include "util/symbol.h"
39#include "util/debug.h"
40#include <api/fs/debugfs.h>
41#include "util/parse-options.h"
42#include "util/probe-finder.h"
43#include "util/probe-event.h"
44
45#define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
46#define DEFAULT_FUNC_FILTER "!_*"
47
48/* Session management structure */
49static struct {
50	bool list_events;
51	bool force_add;
52	bool show_lines;
53	bool show_vars;
54	bool show_ext_vars;
55	bool show_funcs;
56	bool mod_events;
57	bool uprobes;
58	bool quiet;
59	bool target_used;
60	int nevents;
61	struct perf_probe_event events[MAX_PROBES];
62	struct strlist *dellist;
63	struct line_range line_range;
64	char *target;
65	int max_probe_points;
66	struct strfilter *filter;
67} params;
68
69/* Parse an event definition. Note that any error must die. */
70static int parse_probe_event(const char *str)
71{
72	struct perf_probe_event *pev = &params.events[params.nevents];
73	int ret;
74
75	pr_debug("probe-definition(%d): %s\n", params.nevents, str);
76	if (++params.nevents == MAX_PROBES) {
77		pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
78		return -1;
79	}
80
81	pev->uprobes = params.uprobes;
82	if (params.target) {
83		pev->target = strdup(params.target);
84		if (!pev->target)
85			return -ENOMEM;
86		params.target_used = true;
87	}
88
89	/* Parse a perf-probe command into event */
90	ret = parse_perf_probe_command(str, pev);
91	pr_debug("%d arguments\n", pev->nargs);
92
93	return ret;
94}
95
96static int set_target(const char *ptr)
97{
98	int found = 0;
99	const char *buf;
100
101	/*
102	 * The first argument after options can be an absolute path
103	 * to an executable / library or kernel module.
104	 *
105	 * TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
106	 * short module name.
107	 */
108	if (!params.target && ptr && *ptr == '/') {
109		params.target = strdup(ptr);
110		if (!params.target)
111			return -ENOMEM;
112		params.target_used = false;
113
114		found = 1;
115		buf = ptr + (strlen(ptr) - 3);
116
117		if (strcmp(buf, ".ko"))
118			params.uprobes = true;
119
120	}
121
122	return found;
123}
124
125static int parse_probe_event_argv(int argc, const char **argv)
126{
127	int i, len, ret, found_target;
128	char *buf;
129
130	found_target = set_target(argv[0]);
131	if (found_target < 0)
132		return found_target;
133
134	if (found_target && argc == 1)
135		return 0;
136
137	/* Bind up rest arguments */
138	len = 0;
139	for (i = 0; i < argc; i++) {
140		if (i == 0 && found_target)
141			continue;
142
143		len += strlen(argv[i]) + 1;
144	}
145	buf = zalloc(len + 1);
146	if (buf == NULL)
147		return -ENOMEM;
148	len = 0;
149	for (i = 0; i < argc; i++) {
150		if (i == 0 && found_target)
151			continue;
152
153		len += sprintf(&buf[len], "%s ", argv[i]);
154	}
155	params.mod_events = true;
156	ret = parse_probe_event(buf);
157	free(buf);
158	return ret;
159}
160
161static int opt_add_probe_event(const struct option *opt __maybe_unused,
162			      const char *str, int unset __maybe_unused)
163{
164	if (str) {
165		params.mod_events = true;
166		return parse_probe_event(str);
167	} else
168		return 0;
169}
170
171static int opt_del_probe_event(const struct option *opt __maybe_unused,
172			       const char *str, int unset __maybe_unused)
173{
174	if (str) {
175		params.mod_events = true;
176		if (!params.dellist)
177			params.dellist = strlist__new(true, NULL);
178		strlist__add(params.dellist, str);
179	}
180	return 0;
181}
182
183static int opt_set_target(const struct option *opt, const char *str,
184			int unset __maybe_unused)
185{
186	int ret = -ENOENT;
187	char *tmp;
188
189	if  (str) {
190		if (!strcmp(opt->long_name, "exec"))
191			params.uprobes = true;
192#ifdef HAVE_DWARF_SUPPORT
193		else if (!strcmp(opt->long_name, "module"))
194			params.uprobes = false;
195#endif
196		else
197			return ret;
198
199		/* Expand given path to absolute path, except for modulename */
200		if (params.uprobes || strchr(str, '/')) {
201			tmp = realpath(str, NULL);
202			if (!tmp) {
203				pr_warning("Failed to get the absolute path of %s: %m\n", str);
204				return ret;
205			}
206		} else {
207			tmp = strdup(str);
208			if (!tmp)
209				return -ENOMEM;
210		}
211		free(params.target);
212		params.target = tmp;
213		params.target_used = false;
214		ret = 0;
215	}
216
217	return ret;
218}
219
220#ifdef HAVE_DWARF_SUPPORT
221static int opt_show_lines(const struct option *opt __maybe_unused,
222			  const char *str, int unset __maybe_unused)
223{
224	int ret = 0;
225
226	if (!str)
227		return 0;
228
229	if (params.show_lines) {
230		pr_warning("Warning: more than one --line options are"
231			   " detected. Only the first one is valid.\n");
232		return 0;
233	}
234
235	params.show_lines = true;
236	ret = parse_line_range_desc(str, &params.line_range);
237
238	return ret;
239}
240
241static int opt_show_vars(const struct option *opt __maybe_unused,
242			 const char *str, int unset __maybe_unused)
243{
244	struct perf_probe_event *pev = &params.events[params.nevents];
245	int ret;
246
247	if (!str)
248		return 0;
249
250	ret = parse_probe_event(str);
251	if (!ret && pev->nargs != 0) {
252		pr_err("  Error: '--vars' doesn't accept arguments.\n");
253		return -EINVAL;
254	}
255	params.show_vars = true;
256
257	return ret;
258}
259#endif
260
261static int opt_set_filter(const struct option *opt __maybe_unused,
262			  const char *str, int unset __maybe_unused)
263{
264	const char *err;
265
266	if (str) {
267		pr_debug2("Set filter: %s\n", str);
268		if (params.filter)
269			strfilter__delete(params.filter);
270		params.filter = strfilter__new(str, &err);
271		if (!params.filter) {
272			pr_err("Filter parse error at %td.\n", err - str + 1);
273			pr_err("Source: \"%s\"\n", str);
274			pr_err("         %*c\n", (int)(err - str + 1), '^');
275			return -EINVAL;
276		}
277	}
278
279	return 0;
280}
281
282static int init_params(void)
283{
284	return line_range__init(&params.line_range);
285}
286
287static void cleanup_params(void)
288{
289	int i;
290
291	for (i = 0; i < params.nevents; i++)
292		clear_perf_probe_event(params.events + i);
293	if (params.dellist)
294		strlist__delete(params.dellist);
295	line_range__clear(&params.line_range);
296	free(params.target);
297	if (params.filter)
298		strfilter__delete(params.filter);
299	memset(&params, 0, sizeof(params));
300}
301
302static void pr_err_with_code(const char *msg, int err)
303{
304	char sbuf[STRERR_BUFSIZE];
305
306	pr_err("%s", msg);
307	pr_debug(" Reason: %s (Code: %d)",
308		 strerror_r(-err, sbuf, sizeof(sbuf)), err);
309	pr_err("\n");
310}
311
312static int
313__cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
314{
315	const char * const probe_usage[] = {
316		"perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
317		"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
318		"perf probe [<options>] --del '[GROUP:]EVENT' ...",
319		"perf probe --list",
320#ifdef HAVE_DWARF_SUPPORT
321		"perf probe [<options>] --line 'LINEDESC'",
322		"perf probe [<options>] --vars 'PROBEPOINT'",
323#endif
324		NULL
325};
326	struct option options[] = {
327	OPT_INCR('v', "verbose", &verbose,
328		    "be more verbose (show parsed arguments, etc)"),
329	OPT_BOOLEAN('q', "quiet", &params.quiet,
330		    "be quiet (do not show any mesages)"),
331	OPT_BOOLEAN('l', "list", &params.list_events,
332		    "list up current probe events"),
333	OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
334		opt_del_probe_event),
335	OPT_CALLBACK('a', "add", NULL,
336#ifdef HAVE_DWARF_SUPPORT
337		"[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
338		" [[NAME=]ARG ...]",
339#else
340		"[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
341#endif
342		"probe point definition, where\n"
343		"\t\tGROUP:\tGroup name (optional)\n"
344		"\t\tEVENT:\tEvent name\n"
345		"\t\tFUNC:\tFunction name\n"
346		"\t\tOFF:\tOffset from function entry (in byte)\n"
347		"\t\t%return:\tPut the probe at function return\n"
348#ifdef HAVE_DWARF_SUPPORT
349		"\t\tSRC:\tSource code path\n"
350		"\t\tRL:\tRelative line number from function entry.\n"
351		"\t\tAL:\tAbsolute line number in file.\n"
352		"\t\tPT:\tLazy expression of line code.\n"
353		"\t\tARG:\tProbe argument (local variable name or\n"
354		"\t\t\tkprobe-tracer argument format.)\n",
355#else
356		"\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
357#endif
358		opt_add_probe_event),
359	OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
360		    " with existing name"),
361#ifdef HAVE_DWARF_SUPPORT
362	OPT_CALLBACK('L', "line", NULL,
363		     "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
364		     "Show source code lines.", opt_show_lines),
365	OPT_CALLBACK('V', "vars", NULL,
366		     "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
367		     "Show accessible variables on PROBEDEF", opt_show_vars),
368	OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
369		    "Show external variables too (with --vars only)"),
370	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
371		   "file", "vmlinux pathname"),
372	OPT_STRING('s', "source", &symbol_conf.source_prefix,
373		   "directory", "path to kernel source"),
374	OPT_CALLBACK('m', "module", NULL, "modname|path",
375		"target module name (for online) or path (for offline)",
376		opt_set_target),
377#endif
378	OPT__DRY_RUN(&probe_event_dry_run),
379	OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
380		 "Set how many probe points can be found for a probe."),
381	OPT_BOOLEAN('F', "funcs", &params.show_funcs,
382		    "Show potential probe-able functions."),
383	OPT_CALLBACK('\0', "filter", NULL,
384		     "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
385		     "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
386		     "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
387		     opt_set_filter),
388	OPT_CALLBACK('x', "exec", NULL, "executable|path",
389			"target executable name or path", opt_set_target),
390	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
391		    "Enable symbol demangling"),
392	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
393		    "Enable kernel symbol demangling"),
394	OPT_END()
395	};
396	int ret;
397
398	set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE);
399	set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE);
400	set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE);
401#ifdef HAVE_DWARF_SUPPORT
402	set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE);
403	set_option_flag(options, 'V', "vars", PARSE_OPT_EXCLUSIVE);
404#endif
405
406	argc = parse_options(argc, argv, options, probe_usage,
407			     PARSE_OPT_STOP_AT_NON_OPTION);
408	if (argc > 0) {
409		if (strcmp(argv[0], "-") == 0) {
410			pr_warning("  Error: '-' is not supported.\n");
411			usage_with_options(probe_usage, options);
412		}
413		ret = parse_probe_event_argv(argc, argv);
414		if (ret < 0) {
415			pr_err_with_code("  Error: Command Parse Error.", ret);
416			return ret;
417		}
418	}
419
420	if (params.quiet) {
421		if (verbose != 0) {
422			pr_err("  Error: -v and -q are exclusive.\n");
423			return -EINVAL;
424		}
425		verbose = -1;
426	}
427
428	if (params.max_probe_points == 0)
429		params.max_probe_points = MAX_PROBES;
430
431	if ((!params.nevents && !params.dellist && !params.list_events &&
432	     !params.show_lines && !params.show_funcs))
433		usage_with_options(probe_usage, options);
434
435	/*
436	 * Only consider the user's kernel image path if given.
437	 */
438	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
439
440	if (params.list_events) {
441		if (params.uprobes) {
442			pr_warning("  Error: Don't use --list with --exec.\n");
443			usage_with_options(probe_usage, options);
444		}
445		ret = show_perf_probe_events();
446		if (ret < 0)
447			pr_err_with_code("  Error: Failed to show event list.", ret);
448		return ret;
449	}
450	if (params.show_funcs) {
451		if (!params.filter)
452			params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
453						       NULL);
454		ret = show_available_funcs(params.target, params.filter,
455					params.uprobes);
456		strfilter__delete(params.filter);
457		params.filter = NULL;
458		if (ret < 0)
459			pr_err_with_code("  Error: Failed to show functions.", ret);
460		return ret;
461	}
462
463#ifdef HAVE_DWARF_SUPPORT
464	if (params.show_lines) {
465		ret = show_line_range(&params.line_range, params.target,
466				      params.uprobes);
467		if (ret < 0)
468			pr_err_with_code("  Error: Failed to show lines.", ret);
469		return ret;
470	}
471	if (params.show_vars) {
472		if (!params.filter)
473			params.filter = strfilter__new(DEFAULT_VAR_FILTER,
474						       NULL);
475
476		ret = show_available_vars(params.events, params.nevents,
477					  params.max_probe_points,
478					  params.target,
479					  params.filter,
480					  params.show_ext_vars);
481		strfilter__delete(params.filter);
482		params.filter = NULL;
483		if (ret < 0)
484			pr_err_with_code("  Error: Failed to show vars.", ret);
485		return ret;
486	}
487#endif
488
489	if (params.dellist) {
490		ret = del_perf_probe_events(params.dellist);
491		if (ret < 0) {
492			pr_err_with_code("  Error: Failed to delete events.", ret);
493			return ret;
494		}
495	}
496
497	if (params.nevents) {
498		/* Ensure the last given target is used */
499		if (params.target && !params.target_used) {
500			pr_warning("  Error: -x/-m must follow the probe definitions.\n");
501			usage_with_options(probe_usage, options);
502		}
503
504		ret = add_perf_probe_events(params.events, params.nevents,
505					    params.max_probe_points,
506					    params.force_add);
507		if (ret < 0) {
508			pr_err_with_code("  Error: Failed to add events.", ret);
509			return ret;
510		}
511	}
512	return 0;
513}
514
515int cmd_probe(int argc, const char **argv, const char *prefix)
516{
517	int ret;
518
519	ret = init_params();
520	if (!ret) {
521		ret = __cmd_probe(argc, argv, prefix);
522		cleanup_params();
523	}
524
525	return ret;
526}
527