Linux Perf
builtin-probe.c
Go to the documentation of this file.
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 */
53  bool uprobes;
54  bool quiet;
56  int nevents;
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 
380  /* We use tev's name for showing new events */
381  show_perf_probe_event(tev->group, tev->event, pev,
382  tev->point.module, false);
383 
384  /* Save the last valid name */
385  event = tev->event;
386  group = tev->group;
387  }
388  }
389 
390  /* Note that it is possible to skip all events because of blacklist */
391  if (event) {
392  /* Show how to use the event. */
393  pr_info("\nYou can now use it in all perf tools, such as:\n\n");
394  pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", group, event);
395  }
396 
397 out_cleanup:
398  cleanup_perf_probe_events(pevs, npevs);
400  return ret;
401 }
402 
404 {
405  struct probe_cache *cache;
406  struct strlist *bidlist;
407  struct str_node *nd;
408  int ret;
409 
410  bidlist = build_id_cache__list_all(false);
411  if (!bidlist) {
412  ret = -errno;
413  pr_debug("Failed to get buildids: %d\n", ret);
414  return ret ?: -ENOMEM;
415  }
416 
417  strlist__for_each_entry(nd, bidlist) {
418  cache = probe_cache__new(nd->s, NULL);
419  if (!cache)
420  continue;
421  if (probe_cache__filter_purge(cache, filter) < 0 ||
422  probe_cache__commit(cache) < 0)
423  pr_warning("Failed to remove entries for %s\n", nd->s);
424  probe_cache__delete(cache);
425  }
426  return 0;
427 }
428 
430 {
431  int ret, ret2, ufd = -1, kfd = -1;
432  char *str = strfilter__string(filter);
433  struct strlist *klist = NULL, *ulist = NULL;
434  struct str_node *ent;
435 
436  if (!str)
437  return -EINVAL;
438 
439  pr_debug("Delete filter: \'%s\'\n", str);
440 
441  if (probe_conf.cache)
442  return del_perf_probe_caches(filter);
443 
444  /* Get current event names */
445  ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
446  if (ret < 0)
447  goto out;
448 
449  klist = strlist__new(NULL, NULL);
450  ulist = strlist__new(NULL, NULL);
451  if (!klist || !ulist) {
452  ret = -ENOMEM;
453  goto out;
454  }
455 
456  ret = probe_file__get_events(kfd, filter, klist);
457  if (ret == 0) {
458  strlist__for_each_entry(ent, klist)
459  pr_info("Removed event: %s\n", ent->s);
460 
461  ret = probe_file__del_strlist(kfd, klist);
462  if (ret < 0)
463  goto error;
464  }
465 
466  ret2 = probe_file__get_events(ufd, filter, ulist);
467  if (ret2 == 0) {
468  strlist__for_each_entry(ent, ulist)
469  pr_info("Removed event: %s\n", ent->s);
470 
471  ret2 = probe_file__del_strlist(ufd, ulist);
472  if (ret2 < 0)
473  goto error;
474  }
475 
476  if (ret == -ENOENT && ret2 == -ENOENT)
477  pr_warning("\"%s\" does not hit any event.\n", str);
478  else
479  ret = 0;
480 
481 error:
482  if (kfd >= 0)
483  close(kfd);
484  if (ufd >= 0)
485  close(ufd);
486 out:
487  strlist__delete(klist);
488  strlist__delete(ulist);
489  free(str);
490 
491  return ret;
492 }
493 
494 #ifdef HAVE_DWARF_SUPPORT
495 #define PROBEDEF_STR \
496  "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT [[NAME=]ARG ...]"
497 #else
498 #define PROBEDEF_STR "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]"
499 #endif
500 
501 
502 static int
503 __cmd_probe(int argc, const char **argv)
504 {
505  const char * const probe_usage[] = {
506  "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
507  "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
508  "perf probe [<options>] --del '[GROUP:]EVENT' ...",
509  "perf probe --list [GROUP:]EVENT ...",
510 #ifdef HAVE_DWARF_SUPPORT
511  "perf probe [<options>] --line 'LINEDESC'",
512  "perf probe [<options>] --vars 'PROBEPOINT'",
513 #endif
514  "perf probe [<options>] --funcs",
515  NULL
516  };
517  struct option options[] = {
518  OPT_INCR('v', "verbose", &verbose,
519  "be more verbose (show parsed arguments, etc)"),
520  OPT_BOOLEAN('q', "quiet", &params.quiet,
521  "be quiet (do not show any messages)"),
522  OPT_CALLBACK_DEFAULT('l', "list", NULL, "[GROUP:]EVENT",
523  "list up probe events",
525  OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
527  OPT_CALLBACK('a', "add", NULL, PROBEDEF_STR,
528  "probe point definition, where\n"
529  "\t\tGROUP:\tGroup name (optional)\n"
530  "\t\tEVENT:\tEvent name\n"
531  "\t\tFUNC:\tFunction name\n"
532  "\t\tOFF:\tOffset from function entry (in byte)\n"
533  "\t\t%return:\tPut the probe at function return\n"
534 #ifdef HAVE_DWARF_SUPPORT
535  "\t\tSRC:\tSource code path\n"
536  "\t\tRL:\tRelative line number from function entry.\n"
537  "\t\tAL:\tAbsolute line number in file.\n"
538  "\t\tPT:\tLazy expression of line code.\n"
539  "\t\tARG:\tProbe argument (local variable name or\n"
540  "\t\t\tkprobe-tracer argument format.)\n",
541 #else
542  "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
543 #endif
545  OPT_CALLBACK('D', "definition", NULL, PROBEDEF_STR,
546  "Show trace event definition of given traceevent for k/uprobe_events.",
547  opt_add_probe_event),
548  OPT_BOOLEAN('f', "force", &probe_conf.force_add, "forcibly add events"
549  " with existing name"),
550  OPT_CALLBACK('L', "line", NULL,
551  "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
552  "Show source code lines.", opt_show_lines),
553  OPT_CALLBACK('V', "vars", NULL,
554  "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
555  "Show accessible variables on PROBEDEF", opt_show_vars),
556  OPT_BOOLEAN('\0', "externs", &probe_conf.show_ext_vars,
557  "Show external variables too (with --vars only)"),
558  OPT_BOOLEAN('\0', "range", &probe_conf.show_location_range,
559  "Show variables location range in scope (with --vars only)"),
560  OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
561  "file", "vmlinux pathname"),
562  OPT_STRING('s', "source", &symbol_conf.source_prefix,
563  "directory", "path to kernel source"),
564  OPT_BOOLEAN('\0', "no-inlines", &probe_conf.no_inlines,
565  "Don't search inlined functions"),
566  OPT__DRY_RUN(&probe_event_dry_run),
567  OPT_INTEGER('\0', "max-probes", &probe_conf.max_probes,
568  "Set how many probe points can be found for a probe."),
569  OPT_CALLBACK_DEFAULT('F', "funcs", NULL, "[FILTER]",
570  "Show potential probe-able functions.",
572  OPT_CALLBACK('\0', "filter", NULL,
573  "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
574  "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
575  "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
577  OPT_CALLBACK('x', "exec", NULL, "executable|path",
578  "target executable name or path", opt_set_target),
579  OPT_CALLBACK('m', "module", NULL, "modname|path",
580  "target module name (for online) or path (for offline)",
582  OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
583  "Enable symbol demangling"),
584  OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
585  "Enable kernel symbol demangling"),
586  OPT_BOOLEAN(0, "cache", &probe_conf.cache, "Manipulate probe cache"),
587  OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
588  "Look for files with symbols relative to this directory"),
589  OPT_CALLBACK(0, "target-ns", NULL, "pid",
590  "target pid for namespace contexts", opt_set_target_ns),
591  OPT_END()
592  };
593  int ret;
594 
595  set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE);
596  set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE);
597  set_option_flag(options, 'D', "definition", PARSE_OPT_EXCLUSIVE);
598  set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE);
599 #ifdef HAVE_DWARF_SUPPORT
600  set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE);
601  set_option_flag(options, 'V', "vars", PARSE_OPT_EXCLUSIVE);
602 #else
603 # define set_nobuild(s, l, c) set_option_nobuild(options, s, l, "NO_DWARF=1", c)
604  set_nobuild('L', "line", false);
605  set_nobuild('V', "vars", false);
606  set_nobuild('\0', "externs", false);
607  set_nobuild('\0', "range", false);
608  set_nobuild('k', "vmlinux", true);
609  set_nobuild('s', "source", true);
610  set_nobuild('\0', "no-inlines", true);
611 # undef set_nobuild
612 #endif
613  set_option_flag(options, 'F', "funcs", PARSE_OPT_EXCLUSIVE);
614 
615  argc = parse_options(argc, argv, options, probe_usage,
616  PARSE_OPT_STOP_AT_NON_OPTION);
617  if (argc > 0) {
618  if (strcmp(argv[0], "-") == 0) {
619  usage_with_options_msg(probe_usage, options,
620  "'-' is not supported.\n");
621  }
622  if (params.command && params.command != 'a') {
623  usage_with_options_msg(probe_usage, options,
624  "another command except --add is set.\n");
625  }
626  ret = parse_probe_event_argv(argc, argv);
627  if (ret < 0) {
628  pr_err_with_code(" Error: Command Parse Error.", ret);
629  return ret;
630  }
631  params.command = 'a';
632  }
633 
634  if (params.quiet) {
635  if (verbose != 0) {
636  pr_err(" Error: -v and -q are exclusive.\n");
637  return -EINVAL;
638  }
639  verbose = -1;
640  }
641 
642  if (probe_conf.max_probes == 0)
644 
645  /*
646  * Only consider the user's kernel image path if given.
647  */
649 
650  /*
651  * Except for --list, --del and --add, other command doesn't depend
652  * nor change running kernel. So if user gives offline vmlinux,
653  * ignore its buildid.
654  */
655  if (!strchr("lda", params.command) && symbol_conf.vmlinux_name)
657 
658  switch (params.command) {
659  case 'l':
660  if (params.uprobes) {
661  pr_err(" Error: Don't use --list with --exec.\n");
662  parse_options_usage(probe_usage, options, "l", true);
663  parse_options_usage(NULL, options, "x", true);
664  return -EINVAL;
665  }
666  ret = show_perf_probe_events(params.filter);
667  if (ret < 0)
668  pr_err_with_code(" Error: Failed to show event list.", ret);
669  return ret;
670  case 'F':
671  ret = show_available_funcs(params.target, params.nsi,
672  params.filter, params.uprobes);
673  if (ret < 0)
674  pr_err_with_code(" Error: Failed to show functions.", ret);
675  return ret;
676 #ifdef HAVE_DWARF_SUPPORT
677  case 'L':
678  ret = show_line_range(&params.line_range, params.target,
679  params.nsi, params.uprobes);
680  if (ret < 0)
681  pr_err_with_code(" Error: Failed to show lines.", ret);
682  return ret;
683  case 'V':
684  if (!params.filter)
686  NULL);
687 
688  ret = show_available_vars(params.events, params.nevents,
689  params.filter);
690  if (ret < 0)
691  pr_err_with_code(" Error: Failed to show vars.", ret);
692  return ret;
693 #endif
694  case 'd':
695  ret = perf_del_probe_events(params.filter);
696  if (ret < 0) {
697  pr_err_with_code(" Error: Failed to delete events.", ret);
698  return ret;
699  }
700  break;
701  case 'D':
702  case 'a':
703 
704  /* Ensure the last given target is used */
705  if (params.target && !params.target_used) {
706  pr_err(" Error: -x/-m must follow the probe definitions.\n");
707  parse_options_usage(probe_usage, options, "m", true);
708  parse_options_usage(NULL, options, "x", true);
709  return -EINVAL;
710  }
711 
712  ret = perf_add_probe_events(params.events, params.nevents);
713  if (ret < 0) {
714  pr_err_with_code(" Error: Failed to add events.", ret);
715  return ret;
716  }
717  break;
718  default:
719  usage_with_options(probe_usage, options);
720  }
721  return 0;
722 }
723 
724 int cmd_probe(int argc, const char **argv)
725 {
726  int ret;
727 
728  ret = init_params();
729  if (!ret) {
730  ret = __cmd_probe(argc, argv);
731  cleanup_params();
732  }
733 
734  return ret < 0 ? ret : 0;
735 }
#define DEFAULT_LIST_FILTER
Definition: builtin-probe.c:47
struct nsinfo * nsinfo__new(pid_t pid)
Definition: namespaces.c:112
int show_perf_probe_events(struct strfilter *filter)
Definition: probe-event.c:2536
#define DEFAULT_FUNC_FILTER
Definition: builtin-probe.c:46
#define opt_show_lines
struct perf_probe_event events[MAX_PROBES]
Definition: builtin-probe.c:57
const char * source_prefix
Definition: symbol.h:123
int show_perf_probe_event(const char *group, const char *event, struct perf_probe_event *pev, const char *module, bool use_stdout)
Definition: probe-event.c:2459
const char * vmlinux_name
Definition: symbol.h:123
struct strfilter * strfilter__new(const char *rules, const char **err)
Definition: strfilter.c:159
char * nsinfo__realpath(const char *path, struct nsinfo *nsi)
Definition: namespaces.c:239
static int opt_add_probe_event(const struct option *opt, const char *str, int unset __maybe_unused)
int probe_file__open_both(int *kfd, int *ufd, int flag)
Definition: probe-file.c:125
struct probe_trace_point point
Definition: probe-event.h:52
int init_probe_symbol_maps(bool user_only)
Definition: probe-event.c:77
def strerror(nr)
Definition: Util.py:86
#define DEFAULT_VAR_FILTER
Definition: builtin-probe.c:45
int int err
Definition: 5sec.c:44
bool try_vmlinux_path
Definition: symbol.h:93
void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
Definition: probe-event.c:3394
#define pr_debug2(fmt,...)
Definition: debug.h:33
bool uprobes
Definition: builtin-probe.c:53
int probe_file__del_strlist(int fd, struct strlist *namelist)
Definition: probe-file.c:321
bool force_add
Definition: probe-event.h:14
static int __cmd_probe(int argc, const char **argv)
struct nsinfo * nsi
Definition: builtin-probe.c:61
int strfilter__or(struct strfilter *filter, const char *rules, const char **err)
Definition: strfilter.c:206
bool show_location_range
Definition: probe-event.h:13
x86 movsq based memset() in arch/x86/lib/memset_64.S") MEMSET_FN(memset_erms
#define pr_err(fmt,...)
Definition: json.h:21
int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
Definition: probe-event.c:3379
void line_range__clear(struct line_range *lr)
Definition: probe-event.c:1182
int nevents
Definition: builtin-probe.c:56
struct probe_trace_event * tevs
Definition: probe-event.h:95
static int init_params(void)
int show_available_vars(struct perf_probe_event *pevs __maybe_unused, int npevs __maybe_unused, struct strfilter *filter __maybe_unused)
Definition: probe-event.c:1173
static int set_target(const char *ptr)
int show_available_funcs(const char *target, struct nsinfo *nsi, struct strfilter *_filter, bool user)
Definition: probe-event.c:3464
int parse_line_range_desc(const char *arg, struct line_range *lr)
Definition: probe-event.c:1234
#define PROBEDEF_STR
const char * symfs
Definition: symbol.h:148
void strfilter__delete(struct strfilter *filter)
Definition: strfilter.c:28
#define MAX_PROBES
Definition: probe-finder.h:11
bool no_inlines
Definition: probe-event.h:15
#define pr_debug(fmt,...)
Definition: json.h:27
int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
Definition: probe-event.c:3312
void clear_perf_probe_event(struct perf_probe_event *pev)
Definition: probe-event.c:2183
void exit_probe_symbol_maps(void)
Definition: probe-event.c:107
static int perf_del_probe_events(struct strfilter *filter)
bool list_events
Definition: builtin-probe.c:52
bool probe_event_dry_run
Definition: probe-event.c:57
static int str(yyscan_t scanner, int token)
static int parse_probe_event(const char *str)
Definition: builtin-probe.c:65
#define strlist__for_each_entry(pos, slist)
Definition: strlist.h:77
bool show_ext_vars
Definition: probe-event.h:12
struct probe_cache * probe_cache__new(const char *target, struct nsinfo *nsi)
Definition: probe-file.c:562
#define event
static int perf_add_probe_events(struct perf_probe_event *pevs, int npevs)
char * strfilter__string(struct strfilter *filter)
Definition: strfilter.c:297
static bool group
Definition: builtin-stat.c:160
bool ignore_vmlinux_buildid
Definition: symbol.h:93
bool cache
Definition: probe-event.h:16
void probe_cache__delete(struct probe_cache *pcache)
Definition: probe-file.c:551
int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
Definition: probe-event.c:3349
int command
Definition: builtin-probe.c:51
struct nsinfo * nsinfo__get(struct nsinfo *nsi)
Definition: namespaces.c:167
struct strfilter * filter
Definition: builtin-probe.c:60
#define opt_show_vars
static struct @7 params
int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
Definition: probe-event.c:1656
int probe_cache__commit(struct probe_cache *pcache)
Definition: probe-file.c:902
static int params_add_filter(const char *str)
Definition: builtin-probe.c:93
bool target_used
Definition: builtin-probe.c:55
bool demangle
Definition: symbol.h:93
int probe_cache__filter_purge(struct probe_cache *pcache, struct strfilter *filter)
Definition: probe-file.c:938
int show_line_range(struct line_range *lr __maybe_unused, const char *module __maybe_unused, struct nsinfo *nsi __maybe_unused, bool user __maybe_unused)
Definition: probe-event.c:1164
void strlist__delete(struct strlist *slist)
Definition: strlist.c:193
static int opt_set_target_ns(const struct option *opt __maybe_unused, const char *str, int unset __maybe_unused)
Definition: numa.c:71
static int parse_probe_event_argv(int argc, const char **argv)
static int opt_set_filter(const struct option *opt __maybe_unused, const char *str, int unset __maybe_unused)
struct strlist * build_id_cache__list_all(bool validonly)
Definition: build-id.c:431
#define pr_info(fmt,...)
Definition: json.h:24
#define STRERR_BUFSIZE
Definition: debug.h:43
void free(void *)
static void pr_err_with_code(const char *msg, int err)
int max_probes
Definition: probe-event.h:17
bool demangle_kernel
Definition: symbol.h:93
int verbose
Definition: jevents.c:53
int cmd_probe(int argc, const char **argv)
static int del_perf_probe_caches(struct strfilter *filter)
#define pr_warning(fmt,...)
Definition: debug.h:25
bool need_setns
Definition: namespaces.h:32
int line_range__init(struct line_range *lr)
Definition: probe-event.c:1192
void nsinfo__put(struct nsinfo *nsi)
Definition: namespaces.c:174
const char * s
Definition: strlist.h:12
static int opt_set_filter_with_command(const struct option *opt, const char *str, int unset)
static int opt_set_target(const struct option *opt, const char *str, int unset __maybe_unused)
int probe_file__get_events(int fd, struct strfilter *filter, struct strlist *plist)
Definition: probe-file.c:293
struct strlist * strlist__new(const char *list, const struct strlist_config *config)
Definition: strlist.c:160
#define PF_FL_RW
Definition: probe-file.h:34
char * target
Definition: builtin-probe.c:59
struct nsinfo * nsi
Definition: probe-event.h:97
static void cleanup_params(void)
bool quiet
Definition: builtin-probe.c:54
void static void * zalloc(size_t size)
Definition: util.h:20
#define set_nobuild(s, l, c)