pktgen: correctly handle failures when adding a device
[linux-2.6.git] / tools / perf / builtin-probe.c
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 "util/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 */
49 static 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         int nevents;
58         struct perf_probe_event events[MAX_PROBES];
59         struct strlist *dellist;
60         struct line_range line_range;
61         const char *target;
62         int max_probe_points;
63         struct strfilter *filter;
64 } params;
65
66 /* Parse an event definition. Note that any error must die. */
67 static int parse_probe_event(const char *str)
68 {
69         struct perf_probe_event *pev = &params.events[params.nevents];
70         int ret;
71
72         pr_debug("probe-definition(%d): %s\n", params.nevents, str);
73         if (++params.nevents == MAX_PROBES) {
74                 pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
75                 return -1;
76         }
77
78         /* Parse a perf-probe command into event */
79         ret = parse_perf_probe_command(str, pev);
80         pr_debug("%d arguments\n", pev->nargs);
81
82         return ret;
83 }
84
85 static int parse_probe_event_argv(int argc, const char **argv)
86 {
87         int i, len, ret;
88         char *buf;
89
90         /* Bind up rest arguments */
91         len = 0;
92         for (i = 0; i < argc; i++)
93                 len += strlen(argv[i]) + 1;
94         buf = zalloc(len + 1);
95         if (buf == NULL)
96                 return -ENOMEM;
97         len = 0;
98         for (i = 0; i < argc; i++)
99                 len += sprintf(&buf[len], "%s ", argv[i]);
100         params.mod_events = true;
101         ret = parse_probe_event(buf);
102         free(buf);
103         return ret;
104 }
105
106 static int opt_add_probe_event(const struct option *opt __used,
107                               const char *str, int unset __used)
108 {
109         if (str) {
110                 params.mod_events = true;
111                 return parse_probe_event(str);
112         } else
113                 return 0;
114 }
115
116 static int opt_del_probe_event(const struct option *opt __used,
117                                const char *str, int unset __used)
118 {
119         if (str) {
120                 params.mod_events = true;
121                 if (!params.dellist)
122                         params.dellist = strlist__new(true, NULL);
123                 strlist__add(params.dellist, str);
124         }
125         return 0;
126 }
127
128 #ifdef DWARF_SUPPORT
129 static int opt_show_lines(const struct option *opt __used,
130                           const char *str, int unset __used)
131 {
132         int ret = 0;
133
134         if (!str)
135                 return 0;
136
137         if (params.show_lines) {
138                 pr_warning("Warning: more than one --line options are"
139                            " detected. Only the first one is valid.\n");
140                 return 0;
141         }
142
143         params.show_lines = true;
144         ret = parse_line_range_desc(str, &params.line_range);
145         INIT_LIST_HEAD(&params.line_range.line_list);
146
147         return ret;
148 }
149
150 static int opt_show_vars(const struct option *opt __used,
151                          const char *str, int unset __used)
152 {
153         struct perf_probe_event *pev = &params.events[params.nevents];
154         int ret;
155
156         if (!str)
157                 return 0;
158
159         ret = parse_probe_event(str);
160         if (!ret && pev->nargs != 0) {
161                 pr_err("  Error: '--vars' doesn't accept arguments.\n");
162                 return -EINVAL;
163         }
164         params.show_vars = true;
165
166         return ret;
167 }
168 #endif
169
170 static int opt_set_filter(const struct option *opt __used,
171                           const char *str, int unset __used)
172 {
173         const char *err;
174
175         if (str) {
176                 pr_debug2("Set filter: %s\n", str);
177                 if (params.filter)
178                         strfilter__delete(params.filter);
179                 params.filter = strfilter__new(str, &err);
180                 if (!params.filter) {
181                         pr_err("Filter parse error at %td.\n", err - str + 1);
182                         pr_err("Source: \"%s\"\n", str);
183                         pr_err("         %*c\n", (int)(err - str + 1), '^');
184                         return -EINVAL;
185                 }
186         }
187
188         return 0;
189 }
190
191 static const char * const probe_usage[] = {
192         "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
193         "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
194         "perf probe [<options>] --del '[GROUP:]EVENT' ...",
195         "perf probe --list",
196 #ifdef DWARF_SUPPORT
197         "perf probe [<options>] --line 'LINEDESC'",
198         "perf probe [<options>] --vars 'PROBEPOINT'",
199 #endif
200         NULL
201 };
202
203 static const struct option options[] = {
204         OPT_INCR('v', "verbose", &verbose,
205                     "be more verbose (show parsed arguments, etc)"),
206         OPT_BOOLEAN('l', "list", &params.list_events,
207                     "list up current probe events"),
208         OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
209                 opt_del_probe_event),
210         OPT_CALLBACK('a', "add", NULL,
211 #ifdef DWARF_SUPPORT
212                 "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
213                 " [[NAME=]ARG ...]",
214 #else
215                 "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
216 #endif
217                 "probe point definition, where\n"
218                 "\t\tGROUP:\tGroup name (optional)\n"
219                 "\t\tEVENT:\tEvent name\n"
220                 "\t\tFUNC:\tFunction name\n"
221                 "\t\tOFF:\tOffset from function entry (in byte)\n"
222                 "\t\t%return:\tPut the probe at function return\n"
223 #ifdef DWARF_SUPPORT
224                 "\t\tSRC:\tSource code path\n"
225                 "\t\tRL:\tRelative line number from function entry.\n"
226                 "\t\tAL:\tAbsolute line number in file.\n"
227                 "\t\tPT:\tLazy expression of line code.\n"
228                 "\t\tARG:\tProbe argument (local variable name or\n"
229                 "\t\t\tkprobe-tracer argument format.)\n",
230 #else
231                 "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
232 #endif
233                 opt_add_probe_event),
234         OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
235                     " with existing name"),
236 #ifdef DWARF_SUPPORT
237         OPT_CALLBACK('L', "line", NULL,
238                      "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
239                      "Show source code lines.", opt_show_lines),
240         OPT_CALLBACK('V', "vars", NULL,
241                      "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
242                      "Show accessible variables on PROBEDEF", opt_show_vars),
243         OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
244                     "Show external variables too (with --vars only)"),
245         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
246                    "file", "vmlinux pathname"),
247         OPT_STRING('s', "source", &symbol_conf.source_prefix,
248                    "directory", "path to kernel source"),
249         OPT_STRING('m', "module", &params.target,
250                    "modname|path",
251                    "target module name (for online) or path (for offline)"),
252 #endif
253         OPT__DRY_RUN(&probe_event_dry_run),
254         OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
255                  "Set how many probe points can be found for a probe."),
256         OPT_BOOLEAN('F', "funcs", &params.show_funcs,
257                     "Show potential probe-able functions."),
258         OPT_CALLBACK('\0', "filter", NULL,
259                      "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
260                      "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
261                      "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
262                      opt_set_filter),
263         OPT_END()
264 };
265
266 int cmd_probe(int argc, const char **argv, const char *prefix __used)
267 {
268         int ret;
269
270         argc = parse_options(argc, argv, options, probe_usage,
271                              PARSE_OPT_STOP_AT_NON_OPTION);
272         if (argc > 0) {
273                 if (strcmp(argv[0], "-") == 0) {
274                         pr_warning("  Error: '-' is not supported.\n");
275                         usage_with_options(probe_usage, options);
276                 }
277                 ret = parse_probe_event_argv(argc, argv);
278                 if (ret < 0) {
279                         pr_err("  Error: Parse Error.  (%d)\n", ret);
280                         return ret;
281                 }
282         }
283
284         if (params.max_probe_points == 0)
285                 params.max_probe_points = MAX_PROBES;
286
287         if ((!params.nevents && !params.dellist && !params.list_events &&
288              !params.show_lines && !params.show_funcs))
289                 usage_with_options(probe_usage, options);
290
291         /*
292          * Only consider the user's kernel image path if given.
293          */
294         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
295
296         if (params.list_events) {
297                 if (params.mod_events) {
298                         pr_err("  Error: Don't use --list with --add/--del.\n");
299                         usage_with_options(probe_usage, options);
300                 }
301                 if (params.show_lines) {
302                         pr_err("  Error: Don't use --list with --line.\n");
303                         usage_with_options(probe_usage, options);
304                 }
305                 if (params.show_vars) {
306                         pr_err(" Error: Don't use --list with --vars.\n");
307                         usage_with_options(probe_usage, options);
308                 }
309                 if (params.show_funcs) {
310                         pr_err("  Error: Don't use --list with --funcs.\n");
311                         usage_with_options(probe_usage, options);
312                 }
313                 ret = show_perf_probe_events();
314                 if (ret < 0)
315                         pr_err("  Error: Failed to show event list. (%d)\n",
316                                ret);
317                 return ret;
318         }
319         if (params.show_funcs) {
320                 if (params.nevents != 0 || params.dellist) {
321                         pr_err("  Error: Don't use --funcs with"
322                                " --add/--del.\n");
323                         usage_with_options(probe_usage, options);
324                 }
325                 if (params.show_lines) {
326                         pr_err("  Error: Don't use --funcs with --line.\n");
327                         usage_with_options(probe_usage, options);
328                 }
329                 if (params.show_vars) {
330                         pr_err("  Error: Don't use --funcs with --vars.\n");
331                         usage_with_options(probe_usage, options);
332                 }
333                 if (!params.filter)
334                         params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
335                                                        NULL);
336                 ret = show_available_funcs(params.target,
337                                            params.filter);
338                 strfilter__delete(params.filter);
339                 if (ret < 0)
340                         pr_err("  Error: Failed to show functions."
341                                " (%d)\n", ret);
342                 return ret;
343         }
344
345 #ifdef DWARF_SUPPORT
346         if (params.show_lines) {
347                 if (params.mod_events) {
348                         pr_err("  Error: Don't use --line with"
349                                " --add/--del.\n");
350                         usage_with_options(probe_usage, options);
351                 }
352                 if (params.show_vars) {
353                         pr_err(" Error: Don't use --line with --vars.\n");
354                         usage_with_options(probe_usage, options);
355                 }
356
357                 ret = show_line_range(&params.line_range, params.target);
358                 if (ret < 0)
359                         pr_err("  Error: Failed to show lines. (%d)\n", ret);
360                 return ret;
361         }
362         if (params.show_vars) {
363                 if (params.mod_events) {
364                         pr_err("  Error: Don't use --vars with"
365                                " --add/--del.\n");
366                         usage_with_options(probe_usage, options);
367                 }
368                 if (!params.filter)
369                         params.filter = strfilter__new(DEFAULT_VAR_FILTER,
370                                                        NULL);
371
372                 ret = show_available_vars(params.events, params.nevents,
373                                           params.max_probe_points,
374                                           params.target,
375                                           params.filter,
376                                           params.show_ext_vars);
377                 strfilter__delete(params.filter);
378                 if (ret < 0)
379                         pr_err("  Error: Failed to show vars. (%d)\n", ret);
380                 return ret;
381         }
382 #endif
383
384         if (params.dellist) {
385                 ret = del_perf_probe_events(params.dellist);
386                 strlist__delete(params.dellist);
387                 if (ret < 0) {
388                         pr_err("  Error: Failed to delete events. (%d)\n", ret);
389                         return ret;
390                 }
391         }
392
393         if (params.nevents) {
394                 ret = add_perf_probe_events(params.events, params.nevents,
395                                             params.max_probe_points,
396                                             params.target,
397                                             params.force_add);
398                 if (ret < 0) {
399                         pr_err("  Error: Failed to add events. (%d)\n", ret);
400                         return ret;
401                 }
402         }
403         return 0;
404 }