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