GNU Linux-libre 4.19.211-gnu1
[releases.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 <subcmd/parse-options.h>
41 #include "util/probe-finder.h"
42 #include "util/probe-event.h"
43 #include "util/probe-file.h"
44
45 #define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
46 #define DEFAULT_FUNC_FILTER "!_*"
47 #define DEFAULT_LIST_FILTER "*"
48
49 /* Session management structure */
50 static struct {
51         int command;    /* Command short_name */
52         bool list_events;
53         bool uprobes;
54         bool quiet;
55         bool target_used;
56         int nevents;
57         struct perf_probe_event events[MAX_PROBES];
58         struct line_range line_range;
59         char *target;
60         struct strfilter *filter;
61         struct nsinfo *nsi;
62 } params;
63
64 /* Parse an event definition. Note that any error must die. */
65 static int parse_probe_event(const char *str)
66 {
67         struct perf_probe_event *pev = &params.events[params.nevents];
68         int ret;
69
70         pr_debug("probe-definition(%d): %s\n", params.nevents, str);
71         if (++params.nevents == MAX_PROBES) {
72                 pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
73                 return -1;
74         }
75
76         pev->uprobes = params.uprobes;
77         if (params.target) {
78                 pev->target = strdup(params.target);
79                 if (!pev->target)
80                         return -ENOMEM;
81                 params.target_used = true;
82         }
83
84         pev->nsi = nsinfo__get(params.nsi);
85
86         /* Parse a perf-probe command into event */
87         ret = parse_perf_probe_command(str, pev);
88         pr_debug("%d arguments\n", pev->nargs);
89
90         return ret;
91 }
92
93 static int params_add_filter(const char *str)
94 {
95         const char *err = NULL;
96         int ret = 0;
97
98         pr_debug2("Add filter: %s\n", str);
99         if (!params.filter) {
100                 params.filter = strfilter__new(str, &err);
101                 if (!params.filter)
102                         ret = err ? -EINVAL : -ENOMEM;
103         } else
104                 ret = strfilter__or(params.filter, str, &err);
105
106         if (ret == -EINVAL) {
107                 pr_err("Filter parse error at %td.\n", err - str + 1);
108                 pr_err("Source: \"%s\"\n", str);
109                 pr_err("         %*c\n", (int)(err - str + 1), '^');
110         }
111
112         return ret;
113 }
114
115 static int set_target(const char *ptr)
116 {
117         int found = 0;
118         const char *buf;
119
120         /*
121          * The first argument after options can be an absolute path
122          * to an executable / library or kernel module.
123          *
124          * TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
125          * short module name.
126          */
127         if (!params.target && ptr && *ptr == '/') {
128                 params.target = strdup(ptr);
129                 if (!params.target)
130                         return -ENOMEM;
131                 params.target_used = false;
132
133                 found = 1;
134                 buf = ptr + (strlen(ptr) - 3);
135
136                 if (strcmp(buf, ".ko"))
137                         params.uprobes = true;
138
139         }
140
141         return found;
142 }
143
144 static int parse_probe_event_argv(int argc, const char **argv)
145 {
146         int i, len, ret, found_target;
147         char *buf;
148
149         found_target = set_target(argv[0]);
150         if (found_target < 0)
151                 return found_target;
152
153         if (found_target && argc == 1)
154                 return 0;
155
156         /* Bind up rest arguments */
157         len = 0;
158         for (i = 0; i < argc; i++) {
159                 if (i == 0 && found_target)
160                         continue;
161
162                 len += strlen(argv[i]) + 1;
163         }
164         buf = zalloc(len + 1);
165         if (buf == NULL)
166                 return -ENOMEM;
167         len = 0;
168         for (i = 0; i < argc; i++) {
169                 if (i == 0 && found_target)
170                         continue;
171
172                 len += sprintf(&buf[len], "%s ", argv[i]);
173         }
174         ret = parse_probe_event(buf);
175         free(buf);
176         return ret;
177 }
178
179 static int opt_set_target(const struct option *opt, const char *str,
180                         int unset __maybe_unused)
181 {
182         int ret = -ENOENT;
183         char *tmp;
184
185         if  (str) {
186                 if (!strcmp(opt->long_name, "exec"))
187                         params.uprobes = true;
188                 else if (!strcmp(opt->long_name, "module"))
189                         params.uprobes = false;
190                 else
191                         return ret;
192
193                 /* Expand given path to absolute path, except for modulename */
194                 if (params.uprobes || strchr(str, '/')) {
195                         tmp = nsinfo__realpath(str, params.nsi);
196                         if (!tmp) {
197                                 pr_warning("Failed to get the absolute path of %s: %m\n", str);
198                                 return ret;
199                         }
200                 } else {
201                         tmp = strdup(str);
202                         if (!tmp)
203                                 return -ENOMEM;
204                 }
205                 free(params.target);
206                 params.target = tmp;
207                 params.target_used = false;
208                 ret = 0;
209         }
210
211         return ret;
212 }
213
214 static int opt_set_target_ns(const struct option *opt __maybe_unused,
215                              const char *str, int unset __maybe_unused)
216 {
217         int ret = -ENOENT;
218         pid_t ns_pid;
219         struct nsinfo *nsip;
220
221         if (str) {
222                 errno = 0;
223                 ns_pid = (pid_t)strtol(str, NULL, 10);
224                 if (errno != 0) {
225                         ret = -errno;
226                         pr_warning("Failed to parse %s as a pid: %s\n", str,
227                                    strerror(errno));
228                         return ret;
229                 }
230                 nsip = nsinfo__new(ns_pid);
231                 if (nsip && nsip->need_setns)
232                         params.nsi = nsinfo__get(nsip);
233                 nsinfo__put(nsip);
234
235                 ret = 0;
236         }
237
238         return ret;
239 }
240
241
242 /* Command option callbacks */
243
244 #ifdef HAVE_DWARF_SUPPORT
245 static int opt_show_lines(const struct option *opt,
246                           const char *str, int unset __maybe_unused)
247 {
248         int ret = 0;
249
250         if (!str)
251                 return 0;
252
253         if (params.command == 'L') {
254                 pr_warning("Warning: more than one --line options are"
255                            " detected. Only the first one is valid.\n");
256                 return 0;
257         }
258
259         params.command = opt->short_name;
260         ret = parse_line_range_desc(str, &params.line_range);
261
262         return ret;
263 }
264
265 static int opt_show_vars(const struct option *opt,
266                          const char *str, int unset __maybe_unused)
267 {
268         struct perf_probe_event *pev = &params.events[params.nevents];
269         int ret;
270
271         if (!str)
272                 return 0;
273
274         ret = parse_probe_event(str);
275         if (!ret && pev->nargs != 0) {
276                 pr_err("  Error: '--vars' doesn't accept arguments.\n");
277                 return -EINVAL;
278         }
279         params.command = opt->short_name;
280
281         return ret;
282 }
283 #else
284 # define opt_show_lines NULL
285 # define opt_show_vars NULL
286 #endif
287 static int opt_add_probe_event(const struct option *opt,
288                               const char *str, int unset __maybe_unused)
289 {
290         if (str) {
291                 params.command = opt->short_name;
292                 return parse_probe_event(str);
293         }
294
295         return 0;
296 }
297
298 static int opt_set_filter_with_command(const struct option *opt,
299                                        const char *str, int unset)
300 {
301         if (!unset)
302                 params.command = opt->short_name;
303
304         if (str)
305                 return params_add_filter(str);
306
307         return 0;
308 }
309
310 static int opt_set_filter(const struct option *opt __maybe_unused,
311                           const char *str, int unset __maybe_unused)
312 {
313         if (str)
314                 return params_add_filter(str);
315
316         return 0;
317 }
318
319 static int init_params(void)
320 {
321         return line_range__init(&params.line_range);
322 }
323
324 static void cleanup_params(void)
325 {
326         int i;
327
328         for (i = 0; i < params.nevents; i++)
329                 clear_perf_probe_event(params.events + i);
330         line_range__clear(&params.line_range);
331         free(params.target);
332         strfilter__delete(params.filter);
333         nsinfo__put(params.nsi);
334         memset(&params, 0, sizeof(params));
335 }
336
337 static void pr_err_with_code(const char *msg, int err)
338 {
339         char sbuf[STRERR_BUFSIZE];
340
341         pr_err("%s", msg);
342         pr_debug(" Reason: %s (Code: %d)",
343                  str_error_r(-err, sbuf, sizeof(sbuf)), err);
344         pr_err("\n");
345 }
346
347 static int perf_add_probe_events(struct perf_probe_event *pevs, int npevs)
348 {
349         int ret;
350         int i, k;
351         const char *event = NULL, *group = NULL;
352
353         ret = init_probe_symbol_maps(pevs->uprobes);
354         if (ret < 0)
355                 return ret;
356
357         ret = convert_perf_probe_events(pevs, npevs);
358         if (ret < 0)
359                 goto out_cleanup;
360
361         if (params.command == 'D') {    /* it shows definition */
362                 ret = show_probe_trace_events(pevs, npevs);
363                 goto out_cleanup;
364         }
365
366         ret = apply_perf_probe_events(pevs, npevs);
367         if (ret < 0)
368                 goto out_cleanup;
369
370         for (i = k = 0; i < npevs; i++)
371                 k += pevs[i].ntevs;
372
373         pr_info("Added new event%s\n", (k > 1) ? "s:" : ":");
374         for (i = 0; i < npevs; i++) {
375                 struct perf_probe_event *pev = &pevs[i];
376
377                 for (k = 0; k < pev->ntevs; k++) {
378                         struct probe_trace_event *tev = &pev->tevs[k];
379                         /* Skipped events have no event name */
380                         if (!tev->event)
381                                 continue;
382
383                         /* We use tev's name for showing new events */
384                         show_perf_probe_event(tev->group, tev->event, pev,
385                                               tev->point.module, false);
386
387                         /* Save the last valid name */
388                         event = tev->event;
389                         group = tev->group;
390                 }
391         }
392
393         /* Note that it is possible to skip all events because of blacklist */
394         if (event) {
395                 /* Show how to use the event. */
396                 pr_info("\nYou can now use it in all perf tools, such as:\n\n");
397                 pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", group, event);
398         }
399
400 out_cleanup:
401         cleanup_perf_probe_events(pevs, npevs);
402         exit_probe_symbol_maps();
403         return ret;
404 }
405
406 static int del_perf_probe_caches(struct strfilter *filter)
407 {
408         struct probe_cache *cache;
409         struct strlist *bidlist;
410         struct str_node *nd;
411         int ret;
412
413         bidlist = build_id_cache__list_all(false);
414         if (!bidlist) {
415                 ret = -errno;
416                 pr_debug("Failed to get buildids: %d\n", ret);
417                 return ret ?: -ENOMEM;
418         }
419
420         strlist__for_each_entry(nd, bidlist) {
421                 cache = probe_cache__new(nd->s, NULL);
422                 if (!cache)
423                         continue;
424                 if (probe_cache__filter_purge(cache, filter) < 0 ||
425                     probe_cache__commit(cache) < 0)
426                         pr_warning("Failed to remove entries for %s\n", nd->s);
427                 probe_cache__delete(cache);
428         }
429         return 0;
430 }
431
432 static int perf_del_probe_events(struct strfilter *filter)
433 {
434         int ret, ret2, ufd = -1, kfd = -1;
435         char *str = strfilter__string(filter);
436         struct strlist *klist = NULL, *ulist = NULL;
437         struct str_node *ent;
438
439         if (!str)
440                 return -EINVAL;
441
442         pr_debug("Delete filter: \'%s\'\n", str);
443
444         if (probe_conf.cache)
445                 return del_perf_probe_caches(filter);
446
447         /* Get current event names */
448         ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
449         if (ret < 0)
450                 goto out;
451
452         klist = strlist__new(NULL, NULL);
453         ulist = strlist__new(NULL, NULL);
454         if (!klist || !ulist) {
455                 ret = -ENOMEM;
456                 goto out;
457         }
458
459         ret = probe_file__get_events(kfd, filter, klist);
460         if (ret == 0) {
461                 strlist__for_each_entry(ent, klist)
462                         pr_info("Removed event: %s\n", ent->s);
463
464                 ret = probe_file__del_strlist(kfd, klist);
465                 if (ret < 0)
466                         goto error;
467         }
468
469         ret2 = probe_file__get_events(ufd, filter, ulist);
470         if (ret2 == 0) {
471                 strlist__for_each_entry(ent, ulist)
472                         pr_info("Removed event: %s\n", ent->s);
473
474                 ret2 = probe_file__del_strlist(ufd, ulist);
475                 if (ret2 < 0)
476                         goto error;
477         }
478
479         if (ret == -ENOENT && ret2 == -ENOENT)
480                 pr_warning("\"%s\" does not hit any event.\n", str);
481         else
482                 ret = 0;
483
484 error:
485         if (kfd >= 0)
486                 close(kfd);
487         if (ufd >= 0)
488                 close(ufd);
489 out:
490         strlist__delete(klist);
491         strlist__delete(ulist);
492         free(str);
493
494         return ret;
495 }
496
497 #ifdef HAVE_DWARF_SUPPORT
498 #define PROBEDEF_STR    \
499         "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT [[NAME=]ARG ...]"
500 #else
501 #define PROBEDEF_STR    "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]"
502 #endif
503
504
505 static int
506 __cmd_probe(int argc, const char **argv)
507 {
508         const char * const probe_usage[] = {
509                 "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
510                 "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
511                 "perf probe [<options>] --del '[GROUP:]EVENT' ...",
512                 "perf probe --list [GROUP:]EVENT ...",
513 #ifdef HAVE_DWARF_SUPPORT
514                 "perf probe [<options>] --line 'LINEDESC'",
515                 "perf probe [<options>] --vars 'PROBEPOINT'",
516 #endif
517                 "perf probe [<options>] --funcs",
518                 NULL
519         };
520         struct option options[] = {
521         OPT_INCR('v', "verbose", &verbose,
522                     "be more verbose (show parsed arguments, etc)"),
523         OPT_BOOLEAN('q', "quiet", &params.quiet,
524                     "be quiet (do not show any messages)"),
525         OPT_CALLBACK_DEFAULT('l', "list", NULL, "[GROUP:]EVENT",
526                              "list up probe events",
527                              opt_set_filter_with_command, DEFAULT_LIST_FILTER),
528         OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
529                      opt_set_filter_with_command),
530         OPT_CALLBACK('a', "add", NULL, PROBEDEF_STR,
531                 "probe point definition, where\n"
532                 "\t\tGROUP:\tGroup name (optional)\n"
533                 "\t\tEVENT:\tEvent name\n"
534                 "\t\tFUNC:\tFunction name\n"
535                 "\t\tOFF:\tOffset from function entry (in byte)\n"
536                 "\t\t%return:\tPut the probe at function return\n"
537 #ifdef HAVE_DWARF_SUPPORT
538                 "\t\tSRC:\tSource code path\n"
539                 "\t\tRL:\tRelative line number from function entry.\n"
540                 "\t\tAL:\tAbsolute line number in file.\n"
541                 "\t\tPT:\tLazy expression of line code.\n"
542                 "\t\tARG:\tProbe argument (local variable name or\n"
543                 "\t\t\tkprobe-tracer argument format.)\n",
544 #else
545                 "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
546 #endif
547                 opt_add_probe_event),
548         OPT_CALLBACK('D', "definition", NULL, PROBEDEF_STR,
549                 "Show trace event definition of given traceevent for k/uprobe_events.",
550                 opt_add_probe_event),
551         OPT_BOOLEAN('f', "force", &probe_conf.force_add, "forcibly add events"
552                     " with existing name"),
553         OPT_CALLBACK('L', "line", NULL,
554                      "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
555                      "Show source code lines.", opt_show_lines),
556         OPT_CALLBACK('V', "vars", NULL,
557                      "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
558                      "Show accessible variables on PROBEDEF", opt_show_vars),
559         OPT_BOOLEAN('\0', "externs", &probe_conf.show_ext_vars,
560                     "Show external variables too (with --vars only)"),
561         OPT_BOOLEAN('\0', "range", &probe_conf.show_location_range,
562                 "Show variables location range in scope (with --vars only)"),
563         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
564                    "file", "vmlinux pathname"),
565         OPT_STRING('s', "source", &symbol_conf.source_prefix,
566                    "directory", "path to kernel source"),
567         OPT_BOOLEAN('\0', "no-inlines", &probe_conf.no_inlines,
568                 "Don't search inlined functions"),
569         OPT__DRY_RUN(&probe_event_dry_run),
570         OPT_INTEGER('\0', "max-probes", &probe_conf.max_probes,
571                  "Set how many probe points can be found for a probe."),
572         OPT_CALLBACK_DEFAULT('F', "funcs", NULL, "[FILTER]",
573                              "Show potential probe-able functions.",
574                              opt_set_filter_with_command, DEFAULT_FUNC_FILTER),
575         OPT_CALLBACK('\0', "filter", NULL,
576                      "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
577                      "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
578                      "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
579                      opt_set_filter),
580         OPT_CALLBACK('x', "exec", NULL, "executable|path",
581                         "target executable name or path", opt_set_target),
582         OPT_CALLBACK('m', "module", NULL, "modname|path",
583                 "target module name (for online) or path (for offline)",
584                 opt_set_target),
585         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
586                     "Enable symbol demangling"),
587         OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
588                     "Enable kernel symbol demangling"),
589         OPT_BOOLEAN(0, "cache", &probe_conf.cache, "Manipulate probe cache"),
590         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
591                    "Look for files with symbols relative to this directory"),
592         OPT_CALLBACK(0, "target-ns", NULL, "pid",
593                      "target pid for namespace contexts", opt_set_target_ns),
594         OPT_END()
595         };
596         int ret;
597
598         set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE);
599         set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE);
600         set_option_flag(options, 'D', "definition", PARSE_OPT_EXCLUSIVE);
601         set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE);
602 #ifdef HAVE_DWARF_SUPPORT
603         set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE);
604         set_option_flag(options, 'V', "vars", PARSE_OPT_EXCLUSIVE);
605 #else
606 # define set_nobuild(s, l, c) set_option_nobuild(options, s, l, "NO_DWARF=1", c)
607         set_nobuild('L', "line", false);
608         set_nobuild('V', "vars", false);
609         set_nobuild('\0', "externs", false);
610         set_nobuild('\0', "range", false);
611         set_nobuild('k', "vmlinux", true);
612         set_nobuild('s', "source", true);
613         set_nobuild('\0', "no-inlines", true);
614 # undef set_nobuild
615 #endif
616         set_option_flag(options, 'F', "funcs", PARSE_OPT_EXCLUSIVE);
617
618         argc = parse_options(argc, argv, options, probe_usage,
619                              PARSE_OPT_STOP_AT_NON_OPTION);
620         if (argc > 0) {
621                 if (strcmp(argv[0], "-") == 0) {
622                         usage_with_options_msg(probe_usage, options,
623                                 "'-' is not supported.\n");
624                 }
625                 if (params.command && params.command != 'a') {
626                         usage_with_options_msg(probe_usage, options,
627                                 "another command except --add is set.\n");
628                 }
629                 ret = parse_probe_event_argv(argc, argv);
630                 if (ret < 0) {
631                         pr_err_with_code("  Error: Command Parse Error.", ret);
632                         return ret;
633                 }
634                 params.command = 'a';
635         }
636
637         if (params.quiet) {
638                 if (verbose != 0) {
639                         pr_err("  Error: -v and -q are exclusive.\n");
640                         return -EINVAL;
641                 }
642                 verbose = -1;
643         }
644
645         if (probe_conf.max_probes == 0)
646                 probe_conf.max_probes = MAX_PROBES;
647
648         /*
649          * Only consider the user's kernel image path if given.
650          */
651         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
652
653         /*
654          * Except for --list, --del and --add, other command doesn't depend
655          * nor change running kernel. So if user gives offline vmlinux,
656          * ignore its buildid.
657          */
658         if (!strchr("lda", params.command) && symbol_conf.vmlinux_name)
659                 symbol_conf.ignore_vmlinux_buildid = true;
660
661         switch (params.command) {
662         case 'l':
663                 if (params.uprobes) {
664                         pr_err("  Error: Don't use --list with --exec.\n");
665                         parse_options_usage(probe_usage, options, "l", true);
666                         parse_options_usage(NULL, options, "x", true);
667                         return -EINVAL;
668                 }
669                 ret = show_perf_probe_events(params.filter);
670                 if (ret < 0)
671                         pr_err_with_code("  Error: Failed to show event list.", ret);
672                 return ret;
673         case 'F':
674                 ret = show_available_funcs(params.target, params.nsi,
675                                            params.filter, params.uprobes);
676                 if (ret < 0)
677                         pr_err_with_code("  Error: Failed to show functions.", ret);
678                 return ret;
679 #ifdef HAVE_DWARF_SUPPORT
680         case 'L':
681                 ret = show_line_range(&params.line_range, params.target,
682                                       params.nsi, params.uprobes);
683                 if (ret < 0)
684                         pr_err_with_code("  Error: Failed to show lines.", ret);
685                 return ret;
686         case 'V':
687                 if (!params.filter)
688                         params.filter = strfilter__new(DEFAULT_VAR_FILTER,
689                                                        NULL);
690
691                 ret = show_available_vars(params.events, params.nevents,
692                                           params.filter);
693                 if (ret < 0)
694                         pr_err_with_code("  Error: Failed to show vars.", ret);
695                 return ret;
696 #endif
697         case 'd':
698                 ret = perf_del_probe_events(params.filter);
699                 if (ret < 0) {
700                         pr_err_with_code("  Error: Failed to delete events.", ret);
701                         return ret;
702                 }
703                 break;
704         case 'D':
705         case 'a':
706
707                 /* Ensure the last given target is used */
708                 if (params.target && !params.target_used) {
709                         pr_err("  Error: -x/-m must follow the probe definitions.\n");
710                         parse_options_usage(probe_usage, options, "m", true);
711                         parse_options_usage(NULL, options, "x", true);
712                         return -EINVAL;
713                 }
714
715                 ret = perf_add_probe_events(params.events, params.nevents);
716                 if (ret < 0) {
717
718                         /*
719                          * When perf_add_probe_events() fails it calls
720                          * cleanup_perf_probe_events(pevs, npevs), i.e.
721                          * cleanup_perf_probe_events(params.events, params.nevents), which
722                          * will call clear_perf_probe_event(), so set nevents to zero
723                          * to avoid cleanup_params() to call clear_perf_probe_event() again
724                          * on the same pevs.
725                          */
726                         params.nevents = 0;
727                         pr_err_with_code("  Error: Failed to add events.", ret);
728                         return ret;
729                 }
730                 break;
731         default:
732                 usage_with_options(probe_usage, options);
733         }
734         return 0;
735 }
736
737 int cmd_probe(int argc, const char **argv)
738 {
739         int ret;
740
741         ret = init_params();
742         if (!ret) {
743                 ret = __cmd_probe(argc, argv);
744                 cleanup_params();
745         }
746
747         return ret < 0 ? ret : 0;
748 }