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 #define DEFAULT_LIST_FILTER "*:*" 48 49 /* Session management structure */ 50 static struct { 51 int command; /* Command short_name */ 52 bool list_events; 53 bool force_add; 54 bool show_ext_vars; 55 bool uprobes; 56 bool quiet; 57 bool target_used; 58 int nevents; 59 struct perf_probe_event events[MAX_PROBES]; 60 struct line_range line_range; 61 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 = ¶ms.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 pev->uprobes = params.uprobes; 79 if (params.target) { 80 pev->target = strdup(params.target); 81 if (!pev->target) 82 return -ENOMEM; 83 params.target_used = true; 84 } 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 #ifdef HAVE_DWARF_SUPPORT 189 else if (!strcmp(opt->long_name, "module")) 190 params.uprobes = false; 191 #endif 192 else 193 return ret; 194 195 /* Expand given path to absolute path, except for modulename */ 196 if (params.uprobes || strchr(str, '/')) { 197 tmp = realpath(str, NULL); 198 if (!tmp) { 199 pr_warning("Failed to get the absolute path of %s: %m\n", str); 200 return ret; 201 } 202 } else { 203 tmp = strdup(str); 204 if (!tmp) 205 return -ENOMEM; 206 } 207 free(params.target); 208 params.target = tmp; 209 params.target_used = false; 210 ret = 0; 211 } 212 213 return ret; 214 } 215 216 /* Command option callbacks */ 217 218 #ifdef HAVE_DWARF_SUPPORT 219 static int opt_show_lines(const struct option *opt, 220 const char *str, int unset __maybe_unused) 221 { 222 int ret = 0; 223 224 if (!str) 225 return 0; 226 227 if (params.command == 'L') { 228 pr_warning("Warning: more than one --line options are" 229 " detected. Only the first one is valid.\n"); 230 return 0; 231 } 232 233 params.command = opt->short_name; 234 ret = parse_line_range_desc(str, ¶ms.line_range); 235 236 return ret; 237 } 238 239 static int opt_show_vars(const struct option *opt, 240 const char *str, int unset __maybe_unused) 241 { 242 struct perf_probe_event *pev = ¶ms.events[params.nevents]; 243 int ret; 244 245 if (!str) 246 return 0; 247 248 ret = parse_probe_event(str); 249 if (!ret && pev->nargs != 0) { 250 pr_err(" Error: '--vars' doesn't accept arguments.\n"); 251 return -EINVAL; 252 } 253 params.command = opt->short_name; 254 255 return ret; 256 } 257 #endif 258 static int opt_add_probe_event(const struct option *opt, 259 const char *str, int unset __maybe_unused) 260 { 261 if (str) { 262 params.command = opt->short_name; 263 return parse_probe_event(str); 264 } 265 266 return 0; 267 } 268 269 static int opt_set_filter_with_command(const struct option *opt, 270 const char *str, int unset) 271 { 272 if (!unset) 273 params.command = opt->short_name; 274 275 if (str) 276 return params_add_filter(str); 277 278 return 0; 279 } 280 281 static int opt_set_filter(const struct option *opt __maybe_unused, 282 const char *str, int unset __maybe_unused) 283 { 284 if (str) 285 return params_add_filter(str); 286 287 return 0; 288 } 289 290 static int init_params(void) 291 { 292 return line_range__init(¶ms.line_range); 293 } 294 295 static void cleanup_params(void) 296 { 297 int i; 298 299 for (i = 0; i < params.nevents; i++) 300 clear_perf_probe_event(params.events + i); 301 line_range__clear(¶ms.line_range); 302 free(params.target); 303 if (params.filter) 304 strfilter__delete(params.filter); 305 memset(¶ms, 0, sizeof(params)); 306 } 307 308 static void pr_err_with_code(const char *msg, int err) 309 { 310 char sbuf[STRERR_BUFSIZE]; 311 312 pr_err("%s", msg); 313 pr_debug(" Reason: %s (Code: %d)", 314 strerror_r(-err, sbuf, sizeof(sbuf)), err); 315 pr_err("\n"); 316 } 317 318 static int 319 __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused) 320 { 321 const char * const probe_usage[] = { 322 "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]", 323 "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]", 324 "perf probe [<options>] --del '[GROUP:]EVENT' ...", 325 "perf probe --list [GROUP:]EVENT ...", 326 #ifdef HAVE_DWARF_SUPPORT 327 "perf probe [<options>] --line 'LINEDESC'", 328 "perf probe [<options>] --vars 'PROBEPOINT'", 329 #endif 330 "perf probe [<options>] --funcs", 331 NULL 332 }; 333 struct option options[] = { 334 OPT_INCR('v', "verbose", &verbose, 335 "be more verbose (show parsed arguments, etc)"), 336 OPT_BOOLEAN('q', "quiet", ¶ms.quiet, 337 "be quiet (do not show any mesages)"), 338 OPT_CALLBACK_DEFAULT('l', "list", NULL, "[GROUP:]EVENT", 339 "list up probe events", 340 opt_set_filter_with_command, DEFAULT_LIST_FILTER), 341 OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.", 342 opt_set_filter_with_command), 343 OPT_CALLBACK('a', "add", NULL, 344 #ifdef HAVE_DWARF_SUPPORT 345 "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT" 346 " [[NAME=]ARG ...]", 347 #else 348 "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]", 349 #endif 350 "probe point definition, where\n" 351 "\t\tGROUP:\tGroup name (optional)\n" 352 "\t\tEVENT:\tEvent name\n" 353 "\t\tFUNC:\tFunction name\n" 354 "\t\tOFF:\tOffset from function entry (in byte)\n" 355 "\t\t%return:\tPut the probe at function return\n" 356 #ifdef HAVE_DWARF_SUPPORT 357 "\t\tSRC:\tSource code path\n" 358 "\t\tRL:\tRelative line number from function entry.\n" 359 "\t\tAL:\tAbsolute line number in file.\n" 360 "\t\tPT:\tLazy expression of line code.\n" 361 "\t\tARG:\tProbe argument (local variable name or\n" 362 "\t\t\tkprobe-tracer argument format.)\n", 363 #else 364 "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n", 365 #endif 366 opt_add_probe_event), 367 OPT_BOOLEAN('f', "force", ¶ms.force_add, "forcibly add events" 368 " with existing name"), 369 #ifdef HAVE_DWARF_SUPPORT 370 OPT_CALLBACK('L', "line", NULL, 371 "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]", 372 "Show source code lines.", opt_show_lines), 373 OPT_CALLBACK('V', "vars", NULL, 374 "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT", 375 "Show accessible variables on PROBEDEF", opt_show_vars), 376 OPT_BOOLEAN('\0', "externs", ¶ms.show_ext_vars, 377 "Show external variables too (with --vars only)"), 378 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 379 "file", "vmlinux pathname"), 380 OPT_STRING('s', "source", &symbol_conf.source_prefix, 381 "directory", "path to kernel source"), 382 OPT_CALLBACK('m', "module", NULL, "modname|path", 383 "target module name (for online) or path (for offline)", 384 opt_set_target), 385 #endif 386 OPT__DRY_RUN(&probe_event_dry_run), 387 OPT_INTEGER('\0', "max-probes", ¶ms.max_probe_points, 388 "Set how many probe points can be found for a probe."), 389 OPT_CALLBACK_DEFAULT('F', "funcs", NULL, "[FILTER]", 390 "Show potential probe-able functions.", 391 opt_set_filter_with_command, DEFAULT_FUNC_FILTER), 392 OPT_CALLBACK('\0', "filter", NULL, 393 "[!]FILTER", "Set a filter (with --vars/funcs only)\n" 394 "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n" 395 "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)", 396 opt_set_filter), 397 OPT_CALLBACK('x', "exec", NULL, "executable|path", 398 "target executable name or path", opt_set_target), 399 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle, 400 "Enable symbol demangling"), 401 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel, 402 "Enable kernel symbol demangling"), 403 OPT_END() 404 }; 405 int ret; 406 407 set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE); 408 set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE); 409 set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE); 410 #ifdef HAVE_DWARF_SUPPORT 411 set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE); 412 set_option_flag(options, 'V', "vars", PARSE_OPT_EXCLUSIVE); 413 #endif 414 set_option_flag(options, 'F', "funcs", PARSE_OPT_EXCLUSIVE); 415 416 argc = parse_options(argc, argv, options, probe_usage, 417 PARSE_OPT_STOP_AT_NON_OPTION); 418 if (argc > 0) { 419 if (strcmp(argv[0], "-") == 0) { 420 pr_warning(" Error: '-' is not supported.\n"); 421 usage_with_options(probe_usage, options); 422 } 423 if (params.command && params.command != 'a') { 424 pr_warning(" Error: another command except --add is set.\n"); 425 usage_with_options(probe_usage, options); 426 } 427 ret = parse_probe_event_argv(argc, argv); 428 if (ret < 0) { 429 pr_err_with_code(" Error: Command Parse Error.", ret); 430 return ret; 431 } 432 params.command = 'a'; 433 } 434 435 if (params.quiet) { 436 if (verbose != 0) { 437 pr_err(" Error: -v and -q are exclusive.\n"); 438 return -EINVAL; 439 } 440 verbose = -1; 441 } 442 443 if (params.max_probe_points == 0) 444 params.max_probe_points = MAX_PROBES; 445 446 /* 447 * Only consider the user's kernel image path if given. 448 */ 449 symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL); 450 451 switch (params.command) { 452 case 'l': 453 if (params.uprobes) { 454 pr_warning(" Error: Don't use --list with --exec.\n"); 455 usage_with_options(probe_usage, options); 456 } 457 ret = show_perf_probe_events(params.filter); 458 if (ret < 0) 459 pr_err_with_code(" Error: Failed to show event list.", ret); 460 return ret; 461 case 'F': 462 ret = show_available_funcs(params.target, params.filter, 463 params.uprobes); 464 if (ret < 0) 465 pr_err_with_code(" Error: Failed to show functions.", ret); 466 return ret; 467 #ifdef HAVE_DWARF_SUPPORT 468 case 'L': 469 ret = show_line_range(¶ms.line_range, params.target, 470 params.uprobes); 471 if (ret < 0) 472 pr_err_with_code(" Error: Failed to show lines.", ret); 473 return ret; 474 case 'V': 475 if (!params.filter) 476 params.filter = strfilter__new(DEFAULT_VAR_FILTER, 477 NULL); 478 479 ret = show_available_vars(params.events, params.nevents, 480 params.max_probe_points, 481 params.target, 482 params.filter, 483 params.show_ext_vars); 484 if (ret < 0) 485 pr_err_with_code(" Error: Failed to show vars.", ret); 486 return ret; 487 #endif 488 case 'd': 489 ret = del_perf_probe_events(params.filter); 490 if (ret < 0) { 491 pr_err_with_code(" Error: Failed to delete events.", ret); 492 return ret; 493 } 494 break; 495 case 'a': 496 /* Ensure the last given target is used */ 497 if (params.target && !params.target_used) { 498 pr_warning(" Error: -x/-m must follow the probe definitions.\n"); 499 usage_with_options(probe_usage, options); 500 } 501 502 ret = add_perf_probe_events(params.events, params.nevents, 503 params.max_probe_points, 504 params.force_add); 505 if (ret < 0) { 506 pr_err_with_code(" Error: Failed to add events.", ret); 507 return ret; 508 } 509 break; 510 default: 511 usage_with_options(probe_usage, options); 512 } 513 return 0; 514 } 515 516 int cmd_probe(int argc, const char **argv, const char *prefix) 517 { 518 int ret; 519 520 ret = init_params(); 521 if (!ret) { 522 ret = __cmd_probe(argc, argv, prefix); 523 cleanup_params(); 524 } 525 526 return ret < 0 ? ret : 0; 527 } 528