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 */ 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 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. */ 70 static int parse_probe_event(const char *str) 71 { 72 struct perf_probe_event *pev = ¶ms.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 96 static 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 125 static 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 161 static 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 171 static 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 183 static 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 221 static 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, ¶ms.line_range); 237 238 return ret; 239 } 240 241 static 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 = ¶ms.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 261 static 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 282 static int init_params(void) 283 { 284 return line_range__init(¶ms.line_range); 285 } 286 287 static 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(¶ms.line_range); 296 free(params.target); 297 if (params.filter) 298 strfilter__delete(params.filter); 299 memset(¶ms, 0, sizeof(params)); 300 } 301 302 static 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 312 static 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", ¶ms.quiet, 330 "be quiet (do not show any mesages)"), 331 OPT_BOOLEAN('l', "list", ¶ms.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", ¶ms.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", ¶ms.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", ¶ms.max_probe_points, 380 "Set how many probe points can be found for a probe."), 381 OPT_BOOLEAN('F', "funcs", ¶ms.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(¶ms.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 515 int 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