1 /* 2 * Kprobes-based tracing events 3 * 4 * Created by Masami Hiramatsu <mhiramat@redhat.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20 #include <linux/module.h> 21 #include <linux/uaccess.h> 22 #include <linux/kprobes.h> 23 #include <linux/seq_file.h> 24 #include <linux/slab.h> 25 #include <linux/smp.h> 26 #include <linux/debugfs.h> 27 #include <linux/types.h> 28 #include <linux/string.h> 29 #include <linux/ctype.h> 30 #include <linux/ptrace.h> 31 #include <linux/perf_event.h> 32 33 #include "trace.h" 34 #include "trace_output.h" 35 36 #define MAX_TRACE_ARGS 128 37 #define MAX_ARGSTR_LEN 63 38 #define MAX_EVENT_NAME_LEN 64 39 #define KPROBE_EVENT_SYSTEM "kprobes" 40 41 /* Reserved field names */ 42 #define FIELD_STRING_IP "__probe_ip" 43 #define FIELD_STRING_NARGS "__probe_nargs" 44 #define FIELD_STRING_RETIP "__probe_ret_ip" 45 #define FIELD_STRING_FUNC "__probe_func" 46 47 const char *reserved_field_names[] = { 48 "common_type", 49 "common_flags", 50 "common_preempt_count", 51 "common_pid", 52 "common_tgid", 53 "common_lock_depth", 54 FIELD_STRING_IP, 55 FIELD_STRING_NARGS, 56 FIELD_STRING_RETIP, 57 FIELD_STRING_FUNC, 58 }; 59 60 struct fetch_func { 61 unsigned long (*func)(struct pt_regs *, void *); 62 void *data; 63 }; 64 65 static __kprobes unsigned long call_fetch(struct fetch_func *f, 66 struct pt_regs *regs) 67 { 68 return f->func(regs, f->data); 69 } 70 71 /* fetch handlers */ 72 static __kprobes unsigned long fetch_register(struct pt_regs *regs, 73 void *offset) 74 { 75 return regs_get_register(regs, (unsigned int)((unsigned long)offset)); 76 } 77 78 static __kprobes unsigned long fetch_stack(struct pt_regs *regs, 79 void *num) 80 { 81 return regs_get_kernel_stack_nth(regs, 82 (unsigned int)((unsigned long)num)); 83 } 84 85 static __kprobes unsigned long fetch_memory(struct pt_regs *regs, void *addr) 86 { 87 unsigned long retval; 88 89 if (probe_kernel_address(addr, retval)) 90 return 0; 91 return retval; 92 } 93 94 static __kprobes unsigned long fetch_retvalue(struct pt_regs *regs, 95 void *dummy) 96 { 97 return regs_return_value(regs); 98 } 99 100 static __kprobes unsigned long fetch_stack_address(struct pt_regs *regs, 101 void *dummy) 102 { 103 return kernel_stack_pointer(regs); 104 } 105 106 /* Memory fetching by symbol */ 107 struct symbol_cache { 108 char *symbol; 109 long offset; 110 unsigned long addr; 111 }; 112 113 static unsigned long update_symbol_cache(struct symbol_cache *sc) 114 { 115 sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol); 116 if (sc->addr) 117 sc->addr += sc->offset; 118 return sc->addr; 119 } 120 121 static void free_symbol_cache(struct symbol_cache *sc) 122 { 123 kfree(sc->symbol); 124 kfree(sc); 125 } 126 127 static struct symbol_cache *alloc_symbol_cache(const char *sym, long offset) 128 { 129 struct symbol_cache *sc; 130 131 if (!sym || strlen(sym) == 0) 132 return NULL; 133 sc = kzalloc(sizeof(struct symbol_cache), GFP_KERNEL); 134 if (!sc) 135 return NULL; 136 137 sc->symbol = kstrdup(sym, GFP_KERNEL); 138 if (!sc->symbol) { 139 kfree(sc); 140 return NULL; 141 } 142 sc->offset = offset; 143 144 update_symbol_cache(sc); 145 return sc; 146 } 147 148 static __kprobes unsigned long fetch_symbol(struct pt_regs *regs, void *data) 149 { 150 struct symbol_cache *sc = data; 151 152 if (sc->addr) 153 return fetch_memory(regs, (void *)sc->addr); 154 else 155 return 0; 156 } 157 158 /* Special indirect memory access interface */ 159 struct indirect_fetch_data { 160 struct fetch_func orig; 161 long offset; 162 }; 163 164 static __kprobes unsigned long fetch_indirect(struct pt_regs *regs, void *data) 165 { 166 struct indirect_fetch_data *ind = data; 167 unsigned long addr; 168 169 addr = call_fetch(&ind->orig, regs); 170 if (addr) { 171 addr += ind->offset; 172 return fetch_memory(regs, (void *)addr); 173 } else 174 return 0; 175 } 176 177 static __kprobes void free_indirect_fetch_data(struct indirect_fetch_data *data) 178 { 179 if (data->orig.func == fetch_indirect) 180 free_indirect_fetch_data(data->orig.data); 181 else if (data->orig.func == fetch_symbol) 182 free_symbol_cache(data->orig.data); 183 kfree(data); 184 } 185 186 /** 187 * Kprobe event core functions 188 */ 189 190 struct probe_arg { 191 struct fetch_func fetch; 192 const char *name; 193 }; 194 195 /* Flags for trace_probe */ 196 #define TP_FLAG_TRACE 1 197 #define TP_FLAG_PROFILE 2 198 199 struct trace_probe { 200 struct list_head list; 201 struct kretprobe rp; /* Use rp.kp for kprobe use */ 202 unsigned long nhit; 203 unsigned int flags; /* For TP_FLAG_* */ 204 const char *symbol; /* symbol name */ 205 struct ftrace_event_call call; 206 struct trace_event event; 207 unsigned int nr_args; 208 struct probe_arg args[]; 209 }; 210 211 #define SIZEOF_TRACE_PROBE(n) \ 212 (offsetof(struct trace_probe, args) + \ 213 (sizeof(struct probe_arg) * (n))) 214 215 static __kprobes int probe_is_return(struct trace_probe *tp) 216 { 217 return tp->rp.handler != NULL; 218 } 219 220 static __kprobes const char *probe_symbol(struct trace_probe *tp) 221 { 222 return tp->symbol ? tp->symbol : "unknown"; 223 } 224 225 static int probe_arg_string(char *buf, size_t n, struct fetch_func *ff) 226 { 227 int ret = -EINVAL; 228 229 if (ff->func == fetch_register) { 230 const char *name; 231 name = regs_query_register_name((unsigned int)((long)ff->data)); 232 ret = snprintf(buf, n, "%%%s", name); 233 } else if (ff->func == fetch_stack) 234 ret = snprintf(buf, n, "$stack%lu", (unsigned long)ff->data); 235 else if (ff->func == fetch_memory) 236 ret = snprintf(buf, n, "@0x%p", ff->data); 237 else if (ff->func == fetch_symbol) { 238 struct symbol_cache *sc = ff->data; 239 if (sc->offset) 240 ret = snprintf(buf, n, "@%s%+ld", sc->symbol, 241 sc->offset); 242 else 243 ret = snprintf(buf, n, "@%s", sc->symbol); 244 } else if (ff->func == fetch_retvalue) 245 ret = snprintf(buf, n, "$retval"); 246 else if (ff->func == fetch_stack_address) 247 ret = snprintf(buf, n, "$stack"); 248 else if (ff->func == fetch_indirect) { 249 struct indirect_fetch_data *id = ff->data; 250 size_t l = 0; 251 ret = snprintf(buf, n, "%+ld(", id->offset); 252 if (ret >= n) 253 goto end; 254 l += ret; 255 ret = probe_arg_string(buf + l, n - l, &id->orig); 256 if (ret < 0) 257 goto end; 258 l += ret; 259 ret = snprintf(buf + l, n - l, ")"); 260 ret += l; 261 } 262 end: 263 if (ret >= n) 264 return -ENOSPC; 265 return ret; 266 } 267 268 static int register_probe_event(struct trace_probe *tp); 269 static void unregister_probe_event(struct trace_probe *tp); 270 271 static DEFINE_MUTEX(probe_lock); 272 static LIST_HEAD(probe_list); 273 274 static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs); 275 static int kretprobe_dispatcher(struct kretprobe_instance *ri, 276 struct pt_regs *regs); 277 278 /* Check the name is good for event/group */ 279 static int check_event_name(const char *name) 280 { 281 if (!isalpha(*name) && *name != '_') 282 return 0; 283 while (*++name != '\0') { 284 if (!isalpha(*name) && !isdigit(*name) && *name != '_') 285 return 0; 286 } 287 return 1; 288 } 289 290 /* 291 * Allocate new trace_probe and initialize it (including kprobes). 292 */ 293 static struct trace_probe *alloc_trace_probe(const char *group, 294 const char *event, 295 void *addr, 296 const char *symbol, 297 unsigned long offs, 298 int nargs, int is_return) 299 { 300 struct trace_probe *tp; 301 int ret = -ENOMEM; 302 303 tp = kzalloc(SIZEOF_TRACE_PROBE(nargs), GFP_KERNEL); 304 if (!tp) 305 return ERR_PTR(ret); 306 307 if (symbol) { 308 tp->symbol = kstrdup(symbol, GFP_KERNEL); 309 if (!tp->symbol) 310 goto error; 311 tp->rp.kp.symbol_name = tp->symbol; 312 tp->rp.kp.offset = offs; 313 } else 314 tp->rp.kp.addr = addr; 315 316 if (is_return) 317 tp->rp.handler = kretprobe_dispatcher; 318 else 319 tp->rp.kp.pre_handler = kprobe_dispatcher; 320 321 if (!event || !check_event_name(event)) { 322 ret = -EINVAL; 323 goto error; 324 } 325 326 tp->call.name = kstrdup(event, GFP_KERNEL); 327 if (!tp->call.name) 328 goto error; 329 330 if (!group || !check_event_name(group)) { 331 ret = -EINVAL; 332 goto error; 333 } 334 335 tp->call.system = kstrdup(group, GFP_KERNEL); 336 if (!tp->call.system) 337 goto error; 338 339 INIT_LIST_HEAD(&tp->list); 340 return tp; 341 error: 342 kfree(tp->call.name); 343 kfree(tp->symbol); 344 kfree(tp); 345 return ERR_PTR(ret); 346 } 347 348 static void free_probe_arg(struct probe_arg *arg) 349 { 350 if (arg->fetch.func == fetch_symbol) 351 free_symbol_cache(arg->fetch.data); 352 else if (arg->fetch.func == fetch_indirect) 353 free_indirect_fetch_data(arg->fetch.data); 354 kfree(arg->name); 355 } 356 357 static void free_trace_probe(struct trace_probe *tp) 358 { 359 int i; 360 361 for (i = 0; i < tp->nr_args; i++) 362 free_probe_arg(&tp->args[i]); 363 364 kfree(tp->call.system); 365 kfree(tp->call.name); 366 kfree(tp->symbol); 367 kfree(tp); 368 } 369 370 static struct trace_probe *find_probe_event(const char *event, 371 const char *group) 372 { 373 struct trace_probe *tp; 374 375 list_for_each_entry(tp, &probe_list, list) 376 if (strcmp(tp->call.name, event) == 0 && 377 strcmp(tp->call.system, group) == 0) 378 return tp; 379 return NULL; 380 } 381 382 /* Unregister a trace_probe and probe_event: call with locking probe_lock */ 383 static void unregister_trace_probe(struct trace_probe *tp) 384 { 385 if (probe_is_return(tp)) 386 unregister_kretprobe(&tp->rp); 387 else 388 unregister_kprobe(&tp->rp.kp); 389 list_del(&tp->list); 390 unregister_probe_event(tp); 391 } 392 393 /* Register a trace_probe and probe_event */ 394 static int register_trace_probe(struct trace_probe *tp) 395 { 396 struct trace_probe *old_tp; 397 int ret; 398 399 mutex_lock(&probe_lock); 400 401 /* register as an event */ 402 old_tp = find_probe_event(tp->call.name, tp->call.system); 403 if (old_tp) { 404 /* delete old event */ 405 unregister_trace_probe(old_tp); 406 free_trace_probe(old_tp); 407 } 408 ret = register_probe_event(tp); 409 if (ret) { 410 pr_warning("Faild to register probe event(%d)\n", ret); 411 goto end; 412 } 413 414 tp->rp.kp.flags |= KPROBE_FLAG_DISABLED; 415 if (probe_is_return(tp)) 416 ret = register_kretprobe(&tp->rp); 417 else 418 ret = register_kprobe(&tp->rp.kp); 419 420 if (ret) { 421 pr_warning("Could not insert probe(%d)\n", ret); 422 if (ret == -EILSEQ) { 423 pr_warning("Probing address(0x%p) is not an " 424 "instruction boundary.\n", 425 tp->rp.kp.addr); 426 ret = -EINVAL; 427 } 428 unregister_probe_event(tp); 429 } else 430 list_add_tail(&tp->list, &probe_list); 431 end: 432 mutex_unlock(&probe_lock); 433 return ret; 434 } 435 436 /* Split symbol and offset. */ 437 static int split_symbol_offset(char *symbol, unsigned long *offset) 438 { 439 char *tmp; 440 int ret; 441 442 if (!offset) 443 return -EINVAL; 444 445 tmp = strchr(symbol, '+'); 446 if (tmp) { 447 /* skip sign because strict_strtol doesn't accept '+' */ 448 ret = strict_strtoul(tmp + 1, 0, offset); 449 if (ret) 450 return ret; 451 *tmp = '\0'; 452 } else 453 *offset = 0; 454 return 0; 455 } 456 457 #define PARAM_MAX_ARGS 16 458 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long)) 459 460 static int parse_probe_vars(char *arg, struct fetch_func *ff, int is_return) 461 { 462 int ret = 0; 463 unsigned long param; 464 465 if (strcmp(arg, "retval") == 0) { 466 if (is_return) { 467 ff->func = fetch_retvalue; 468 ff->data = NULL; 469 } else 470 ret = -EINVAL; 471 } else if (strncmp(arg, "stack", 5) == 0) { 472 if (arg[5] == '\0') { 473 ff->func = fetch_stack_address; 474 ff->data = NULL; 475 } else if (isdigit(arg[5])) { 476 ret = strict_strtoul(arg + 5, 10, ¶m); 477 if (ret || param > PARAM_MAX_STACK) 478 ret = -EINVAL; 479 else { 480 ff->func = fetch_stack; 481 ff->data = (void *)param; 482 } 483 } else 484 ret = -EINVAL; 485 } else 486 ret = -EINVAL; 487 return ret; 488 } 489 490 /* Recursive argument parser */ 491 static int __parse_probe_arg(char *arg, struct fetch_func *ff, int is_return) 492 { 493 int ret = 0; 494 unsigned long param; 495 long offset; 496 char *tmp; 497 498 switch (arg[0]) { 499 case '$': 500 ret = parse_probe_vars(arg + 1, ff, is_return); 501 break; 502 case '%': /* named register */ 503 ret = regs_query_register_offset(arg + 1); 504 if (ret >= 0) { 505 ff->func = fetch_register; 506 ff->data = (void *)(unsigned long)ret; 507 ret = 0; 508 } 509 break; 510 case '@': /* memory or symbol */ 511 if (isdigit(arg[1])) { 512 ret = strict_strtoul(arg + 1, 0, ¶m); 513 if (ret) 514 break; 515 ff->func = fetch_memory; 516 ff->data = (void *)param; 517 } else { 518 ret = split_symbol_offset(arg + 1, &offset); 519 if (ret) 520 break; 521 ff->data = alloc_symbol_cache(arg + 1, offset); 522 if (ff->data) 523 ff->func = fetch_symbol; 524 else 525 ret = -EINVAL; 526 } 527 break; 528 case '+': /* indirect memory */ 529 case '-': 530 tmp = strchr(arg, '('); 531 if (!tmp) { 532 ret = -EINVAL; 533 break; 534 } 535 *tmp = '\0'; 536 ret = strict_strtol(arg + 1, 0, &offset); 537 if (ret) 538 break; 539 if (arg[0] == '-') 540 offset = -offset; 541 arg = tmp + 1; 542 tmp = strrchr(arg, ')'); 543 if (tmp) { 544 struct indirect_fetch_data *id; 545 *tmp = '\0'; 546 id = kzalloc(sizeof(struct indirect_fetch_data), 547 GFP_KERNEL); 548 if (!id) 549 return -ENOMEM; 550 id->offset = offset; 551 ret = __parse_probe_arg(arg, &id->orig, is_return); 552 if (ret) 553 kfree(id); 554 else { 555 ff->func = fetch_indirect; 556 ff->data = (void *)id; 557 } 558 } else 559 ret = -EINVAL; 560 break; 561 default: 562 /* TODO: support custom handler */ 563 ret = -EINVAL; 564 } 565 return ret; 566 } 567 568 /* String length checking wrapper */ 569 static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return) 570 { 571 if (strlen(arg) > MAX_ARGSTR_LEN) { 572 pr_info("Argument is too long.: %s\n", arg); 573 return -ENOSPC; 574 } 575 return __parse_probe_arg(arg, ff, is_return); 576 } 577 578 /* Return 1 if name is reserved or already used by another argument */ 579 static int conflict_field_name(const char *name, 580 struct probe_arg *args, int narg) 581 { 582 int i; 583 for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++) 584 if (strcmp(reserved_field_names[i], name) == 0) 585 return 1; 586 for (i = 0; i < narg; i++) 587 if (strcmp(args[i].name, name) == 0) 588 return 1; 589 return 0; 590 } 591 592 static int create_trace_probe(int argc, char **argv) 593 { 594 /* 595 * Argument syntax: 596 * - Add kprobe: p[:[GRP/]EVENT] KSYM[+OFFS]|KADDR [FETCHARGS] 597 * - Add kretprobe: r[:[GRP/]EVENT] KSYM[+0] [FETCHARGS] 598 * Fetch args: 599 * $retval : fetch return value 600 * $stack : fetch stack address 601 * $stackN : fetch Nth of stack (N:0-) 602 * @ADDR : fetch memory at ADDR (ADDR should be in kernel) 603 * @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol) 604 * %REG : fetch register REG 605 * Indirect memory fetch: 606 * +|-offs(ARG) : fetch memory at ARG +|- offs address. 607 * Alias name of args: 608 * NAME=FETCHARG : set NAME as alias of FETCHARG. 609 */ 610 struct trace_probe *tp; 611 int i, ret = 0; 612 int is_return = 0, is_delete = 0; 613 char *symbol = NULL, *event = NULL, *arg = NULL, *group = NULL; 614 unsigned long offset = 0; 615 void *addr = NULL; 616 char buf[MAX_EVENT_NAME_LEN]; 617 618 /* argc must be >= 1 */ 619 if (argv[0][0] == 'p') 620 is_return = 0; 621 else if (argv[0][0] == 'r') 622 is_return = 1; 623 else if (argv[0][0] == '-') 624 is_delete = 1; 625 else { 626 pr_info("Probe definition must be started with 'p', 'r' or" 627 " '-'.\n"); 628 return -EINVAL; 629 } 630 631 if (argv[0][1] == ':') { 632 event = &argv[0][2]; 633 if (strchr(event, '/')) { 634 group = event; 635 event = strchr(group, '/') + 1; 636 event[-1] = '\0'; 637 if (strlen(group) == 0) { 638 pr_info("Group name is not specified\n"); 639 return -EINVAL; 640 } 641 } 642 if (strlen(event) == 0) { 643 pr_info("Event name is not specified\n"); 644 return -EINVAL; 645 } 646 } 647 if (!group) 648 group = KPROBE_EVENT_SYSTEM; 649 650 if (is_delete) { 651 if (!event) { 652 pr_info("Delete command needs an event name.\n"); 653 return -EINVAL; 654 } 655 tp = find_probe_event(event, group); 656 if (!tp) { 657 pr_info("Event %s/%s doesn't exist.\n", group, event); 658 return -ENOENT; 659 } 660 /* delete an event */ 661 unregister_trace_probe(tp); 662 free_trace_probe(tp); 663 return 0; 664 } 665 666 if (argc < 2) { 667 pr_info("Probe point is not specified.\n"); 668 return -EINVAL; 669 } 670 if (isdigit(argv[1][0])) { 671 if (is_return) { 672 pr_info("Return probe point must be a symbol.\n"); 673 return -EINVAL; 674 } 675 /* an address specified */ 676 ret = strict_strtoul(&argv[1][0], 0, (unsigned long *)&addr); 677 if (ret) { 678 pr_info("Failed to parse address.\n"); 679 return ret; 680 } 681 } else { 682 /* a symbol specified */ 683 symbol = argv[1]; 684 /* TODO: support .init module functions */ 685 ret = split_symbol_offset(symbol, &offset); 686 if (ret) { 687 pr_info("Failed to parse symbol.\n"); 688 return ret; 689 } 690 if (offset && is_return) { 691 pr_info("Return probe must be used without offset.\n"); 692 return -EINVAL; 693 } 694 } 695 argc -= 2; argv += 2; 696 697 /* setup a probe */ 698 if (!event) { 699 /* Make a new event name */ 700 if (symbol) 701 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld", 702 is_return ? 'r' : 'p', symbol, offset); 703 else 704 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p", 705 is_return ? 'r' : 'p', addr); 706 event = buf; 707 } 708 tp = alloc_trace_probe(group, event, addr, symbol, offset, argc, 709 is_return); 710 if (IS_ERR(tp)) { 711 pr_info("Failed to allocate trace_probe.(%d)\n", 712 (int)PTR_ERR(tp)); 713 return PTR_ERR(tp); 714 } 715 716 /* parse arguments */ 717 ret = 0; 718 for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { 719 /* Parse argument name */ 720 arg = strchr(argv[i], '='); 721 if (arg) 722 *arg++ = '\0'; 723 else 724 arg = argv[i]; 725 726 if (conflict_field_name(argv[i], tp->args, i)) { 727 pr_info("Argument%d name '%s' conflicts with " 728 "another field.\n", i, argv[i]); 729 ret = -EINVAL; 730 goto error; 731 } 732 733 tp->args[i].name = kstrdup(argv[i], GFP_KERNEL); 734 if (!tp->args[i].name) { 735 pr_info("Failed to allocate argument%d name '%s'.\n", 736 i, argv[i]); 737 ret = -ENOMEM; 738 goto error; 739 } 740 741 /* Parse fetch argument */ 742 ret = parse_probe_arg(arg, &tp->args[i].fetch, is_return); 743 if (ret) { 744 pr_info("Parse error at argument%d. (%d)\n", i, ret); 745 kfree(tp->args[i].name); 746 goto error; 747 } 748 749 tp->nr_args++; 750 } 751 752 ret = register_trace_probe(tp); 753 if (ret) 754 goto error; 755 return 0; 756 757 error: 758 free_trace_probe(tp); 759 return ret; 760 } 761 762 static void cleanup_all_probes(void) 763 { 764 struct trace_probe *tp; 765 766 mutex_lock(&probe_lock); 767 /* TODO: Use batch unregistration */ 768 while (!list_empty(&probe_list)) { 769 tp = list_entry(probe_list.next, struct trace_probe, list); 770 unregister_trace_probe(tp); 771 free_trace_probe(tp); 772 } 773 mutex_unlock(&probe_lock); 774 } 775 776 777 /* Probes listing interfaces */ 778 static void *probes_seq_start(struct seq_file *m, loff_t *pos) 779 { 780 mutex_lock(&probe_lock); 781 return seq_list_start(&probe_list, *pos); 782 } 783 784 static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos) 785 { 786 return seq_list_next(v, &probe_list, pos); 787 } 788 789 static void probes_seq_stop(struct seq_file *m, void *v) 790 { 791 mutex_unlock(&probe_lock); 792 } 793 794 static int probes_seq_show(struct seq_file *m, void *v) 795 { 796 struct trace_probe *tp = v; 797 int i, ret; 798 char buf[MAX_ARGSTR_LEN + 1]; 799 800 seq_printf(m, "%c", probe_is_return(tp) ? 'r' : 'p'); 801 seq_printf(m, ":%s/%s", tp->call.system, tp->call.name); 802 803 if (!tp->symbol) 804 seq_printf(m, " 0x%p", tp->rp.kp.addr); 805 else if (tp->rp.kp.offset) 806 seq_printf(m, " %s+%u", probe_symbol(tp), tp->rp.kp.offset); 807 else 808 seq_printf(m, " %s", probe_symbol(tp)); 809 810 for (i = 0; i < tp->nr_args; i++) { 811 ret = probe_arg_string(buf, MAX_ARGSTR_LEN, &tp->args[i].fetch); 812 if (ret < 0) { 813 pr_warning("Argument%d decoding error(%d).\n", i, ret); 814 return ret; 815 } 816 seq_printf(m, " %s=%s", tp->args[i].name, buf); 817 } 818 seq_printf(m, "\n"); 819 return 0; 820 } 821 822 static const struct seq_operations probes_seq_op = { 823 .start = probes_seq_start, 824 .next = probes_seq_next, 825 .stop = probes_seq_stop, 826 .show = probes_seq_show 827 }; 828 829 static int probes_open(struct inode *inode, struct file *file) 830 { 831 if ((file->f_mode & FMODE_WRITE) && 832 (file->f_flags & O_TRUNC)) 833 cleanup_all_probes(); 834 835 return seq_open(file, &probes_seq_op); 836 } 837 838 static int command_trace_probe(const char *buf) 839 { 840 char **argv; 841 int argc = 0, ret = 0; 842 843 argv = argv_split(GFP_KERNEL, buf, &argc); 844 if (!argv) 845 return -ENOMEM; 846 847 if (argc) 848 ret = create_trace_probe(argc, argv); 849 850 argv_free(argv); 851 return ret; 852 } 853 854 #define WRITE_BUFSIZE 128 855 856 static ssize_t probes_write(struct file *file, const char __user *buffer, 857 size_t count, loff_t *ppos) 858 { 859 char *kbuf, *tmp; 860 int ret; 861 size_t done; 862 size_t size; 863 864 kbuf = kmalloc(WRITE_BUFSIZE, GFP_KERNEL); 865 if (!kbuf) 866 return -ENOMEM; 867 868 ret = done = 0; 869 while (done < count) { 870 size = count - done; 871 if (size >= WRITE_BUFSIZE) 872 size = WRITE_BUFSIZE - 1; 873 if (copy_from_user(kbuf, buffer + done, size)) { 874 ret = -EFAULT; 875 goto out; 876 } 877 kbuf[size] = '\0'; 878 tmp = strchr(kbuf, '\n'); 879 if (tmp) { 880 *tmp = '\0'; 881 size = tmp - kbuf + 1; 882 } else if (done + size < count) { 883 pr_warning("Line length is too long: " 884 "Should be less than %d.", WRITE_BUFSIZE); 885 ret = -EINVAL; 886 goto out; 887 } 888 done += size; 889 /* Remove comments */ 890 tmp = strchr(kbuf, '#'); 891 if (tmp) 892 *tmp = '\0'; 893 894 ret = command_trace_probe(kbuf); 895 if (ret) 896 goto out; 897 } 898 ret = done; 899 out: 900 kfree(kbuf); 901 return ret; 902 } 903 904 static const struct file_operations kprobe_events_ops = { 905 .owner = THIS_MODULE, 906 .open = probes_open, 907 .read = seq_read, 908 .llseek = seq_lseek, 909 .release = seq_release, 910 .write = probes_write, 911 }; 912 913 /* Probes profiling interfaces */ 914 static int probes_profile_seq_show(struct seq_file *m, void *v) 915 { 916 struct trace_probe *tp = v; 917 918 seq_printf(m, " %-44s %15lu %15lu\n", tp->call.name, tp->nhit, 919 tp->rp.kp.nmissed); 920 921 return 0; 922 } 923 924 static const struct seq_operations profile_seq_op = { 925 .start = probes_seq_start, 926 .next = probes_seq_next, 927 .stop = probes_seq_stop, 928 .show = probes_profile_seq_show 929 }; 930 931 static int profile_open(struct inode *inode, struct file *file) 932 { 933 return seq_open(file, &profile_seq_op); 934 } 935 936 static const struct file_operations kprobe_profile_ops = { 937 .owner = THIS_MODULE, 938 .open = profile_open, 939 .read = seq_read, 940 .llseek = seq_lseek, 941 .release = seq_release, 942 }; 943 944 /* Kprobe handler */ 945 static __kprobes void kprobe_trace_func(struct kprobe *kp, struct pt_regs *regs) 946 { 947 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp); 948 struct kprobe_trace_entry *entry; 949 struct ring_buffer_event *event; 950 struct ring_buffer *buffer; 951 int size, i, pc; 952 unsigned long irq_flags; 953 struct ftrace_event_call *call = &tp->call; 954 955 tp->nhit++; 956 957 local_save_flags(irq_flags); 958 pc = preempt_count(); 959 960 size = SIZEOF_KPROBE_TRACE_ENTRY(tp->nr_args); 961 962 event = trace_current_buffer_lock_reserve(&buffer, call->id, size, 963 irq_flags, pc); 964 if (!event) 965 return; 966 967 entry = ring_buffer_event_data(event); 968 entry->nargs = tp->nr_args; 969 entry->ip = (unsigned long)kp->addr; 970 for (i = 0; i < tp->nr_args; i++) 971 entry->args[i] = call_fetch(&tp->args[i].fetch, regs); 972 973 if (!filter_current_check_discard(buffer, call, entry, event)) 974 trace_nowake_buffer_unlock_commit(buffer, event, irq_flags, pc); 975 } 976 977 /* Kretprobe handler */ 978 static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri, 979 struct pt_regs *regs) 980 { 981 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp); 982 struct kretprobe_trace_entry *entry; 983 struct ring_buffer_event *event; 984 struct ring_buffer *buffer; 985 int size, i, pc; 986 unsigned long irq_flags; 987 struct ftrace_event_call *call = &tp->call; 988 989 local_save_flags(irq_flags); 990 pc = preempt_count(); 991 992 size = SIZEOF_KRETPROBE_TRACE_ENTRY(tp->nr_args); 993 994 event = trace_current_buffer_lock_reserve(&buffer, call->id, size, 995 irq_flags, pc); 996 if (!event) 997 return; 998 999 entry = ring_buffer_event_data(event); 1000 entry->nargs = tp->nr_args; 1001 entry->func = (unsigned long)tp->rp.kp.addr; 1002 entry->ret_ip = (unsigned long)ri->ret_addr; 1003 for (i = 0; i < tp->nr_args; i++) 1004 entry->args[i] = call_fetch(&tp->args[i].fetch, regs); 1005 1006 if (!filter_current_check_discard(buffer, call, entry, event)) 1007 trace_nowake_buffer_unlock_commit(buffer, event, irq_flags, pc); 1008 } 1009 1010 /* Event entry printers */ 1011 enum print_line_t 1012 print_kprobe_event(struct trace_iterator *iter, int flags) 1013 { 1014 struct kprobe_trace_entry *field; 1015 struct trace_seq *s = &iter->seq; 1016 struct trace_event *event; 1017 struct trace_probe *tp; 1018 int i; 1019 1020 field = (struct kprobe_trace_entry *)iter->ent; 1021 event = ftrace_find_event(field->ent.type); 1022 tp = container_of(event, struct trace_probe, event); 1023 1024 if (!trace_seq_printf(s, "%s: (", tp->call.name)) 1025 goto partial; 1026 1027 if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET)) 1028 goto partial; 1029 1030 if (!trace_seq_puts(s, ")")) 1031 goto partial; 1032 1033 for (i = 0; i < field->nargs; i++) 1034 if (!trace_seq_printf(s, " %s=%lx", 1035 tp->args[i].name, field->args[i])) 1036 goto partial; 1037 1038 if (!trace_seq_puts(s, "\n")) 1039 goto partial; 1040 1041 return TRACE_TYPE_HANDLED; 1042 partial: 1043 return TRACE_TYPE_PARTIAL_LINE; 1044 } 1045 1046 enum print_line_t 1047 print_kretprobe_event(struct trace_iterator *iter, int flags) 1048 { 1049 struct kretprobe_trace_entry *field; 1050 struct trace_seq *s = &iter->seq; 1051 struct trace_event *event; 1052 struct trace_probe *tp; 1053 int i; 1054 1055 field = (struct kretprobe_trace_entry *)iter->ent; 1056 event = ftrace_find_event(field->ent.type); 1057 tp = container_of(event, struct trace_probe, event); 1058 1059 if (!trace_seq_printf(s, "%s: (", tp->call.name)) 1060 goto partial; 1061 1062 if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET)) 1063 goto partial; 1064 1065 if (!trace_seq_puts(s, " <- ")) 1066 goto partial; 1067 1068 if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET)) 1069 goto partial; 1070 1071 if (!trace_seq_puts(s, ")")) 1072 goto partial; 1073 1074 for (i = 0; i < field->nargs; i++) 1075 if (!trace_seq_printf(s, " %s=%lx", 1076 tp->args[i].name, field->args[i])) 1077 goto partial; 1078 1079 if (!trace_seq_puts(s, "\n")) 1080 goto partial; 1081 1082 return TRACE_TYPE_HANDLED; 1083 partial: 1084 return TRACE_TYPE_PARTIAL_LINE; 1085 } 1086 1087 static int probe_event_enable(struct ftrace_event_call *call) 1088 { 1089 struct trace_probe *tp = (struct trace_probe *)call->data; 1090 1091 tp->flags |= TP_FLAG_TRACE; 1092 if (probe_is_return(tp)) 1093 return enable_kretprobe(&tp->rp); 1094 else 1095 return enable_kprobe(&tp->rp.kp); 1096 } 1097 1098 static void probe_event_disable(struct ftrace_event_call *call) 1099 { 1100 struct trace_probe *tp = (struct trace_probe *)call->data; 1101 1102 tp->flags &= ~TP_FLAG_TRACE; 1103 if (!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE))) { 1104 if (probe_is_return(tp)) 1105 disable_kretprobe(&tp->rp); 1106 else 1107 disable_kprobe(&tp->rp.kp); 1108 } 1109 } 1110 1111 static int probe_event_raw_init(struct ftrace_event_call *event_call) 1112 { 1113 INIT_LIST_HEAD(&event_call->fields); 1114 1115 return 0; 1116 } 1117 1118 #undef DEFINE_FIELD 1119 #define DEFINE_FIELD(type, item, name, is_signed) \ 1120 do { \ 1121 ret = trace_define_field(event_call, #type, name, \ 1122 offsetof(typeof(field), item), \ 1123 sizeof(field.item), is_signed, \ 1124 FILTER_OTHER); \ 1125 if (ret) \ 1126 return ret; \ 1127 } while (0) 1128 1129 static int kprobe_event_define_fields(struct ftrace_event_call *event_call) 1130 { 1131 int ret, i; 1132 struct kprobe_trace_entry field; 1133 struct trace_probe *tp = (struct trace_probe *)event_call->data; 1134 1135 DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0); 1136 DEFINE_FIELD(int, nargs, FIELD_STRING_NARGS, 1); 1137 /* Set argument names as fields */ 1138 for (i = 0; i < tp->nr_args; i++) 1139 DEFINE_FIELD(unsigned long, args[i], tp->args[i].name, 0); 1140 return 0; 1141 } 1142 1143 static int kretprobe_event_define_fields(struct ftrace_event_call *event_call) 1144 { 1145 int ret, i; 1146 struct kretprobe_trace_entry field; 1147 struct trace_probe *tp = (struct trace_probe *)event_call->data; 1148 1149 DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0); 1150 DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0); 1151 DEFINE_FIELD(int, nargs, FIELD_STRING_NARGS, 1); 1152 /* Set argument names as fields */ 1153 for (i = 0; i < tp->nr_args; i++) 1154 DEFINE_FIELD(unsigned long, args[i], tp->args[i].name, 0); 1155 return 0; 1156 } 1157 1158 static int __set_print_fmt(struct trace_probe *tp, char *buf, int len) 1159 { 1160 int i; 1161 int pos = 0; 1162 1163 const char *fmt, *arg; 1164 1165 if (!probe_is_return(tp)) { 1166 fmt = "(%lx)"; 1167 arg = "REC->" FIELD_STRING_IP; 1168 } else { 1169 fmt = "(%lx <- %lx)"; 1170 arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP; 1171 } 1172 1173 /* When len=0, we just calculate the needed length */ 1174 #define LEN_OR_ZERO (len ? len - pos : 0) 1175 1176 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt); 1177 1178 for (i = 0; i < tp->nr_args; i++) { 1179 pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%%lx", 1180 tp->args[i].name); 1181 } 1182 1183 pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg); 1184 1185 for (i = 0; i < tp->nr_args; i++) { 1186 pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s", 1187 tp->args[i].name); 1188 } 1189 1190 #undef LEN_OR_ZERO 1191 1192 /* return the length of print_fmt */ 1193 return pos; 1194 } 1195 1196 static int set_print_fmt(struct trace_probe *tp) 1197 { 1198 int len; 1199 char *print_fmt; 1200 1201 /* First: called with 0 length to calculate the needed length */ 1202 len = __set_print_fmt(tp, NULL, 0); 1203 print_fmt = kmalloc(len + 1, GFP_KERNEL); 1204 if (!print_fmt) 1205 return -ENOMEM; 1206 1207 /* Second: actually write the @print_fmt */ 1208 __set_print_fmt(tp, print_fmt, len + 1); 1209 tp->call.print_fmt = print_fmt; 1210 1211 return 0; 1212 } 1213 1214 #ifdef CONFIG_PERF_EVENTS 1215 1216 /* Kprobe profile handler */ 1217 static __kprobes void kprobe_perf_func(struct kprobe *kp, 1218 struct pt_regs *regs) 1219 { 1220 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp); 1221 struct ftrace_event_call *call = &tp->call; 1222 struct kprobe_trace_entry *entry; 1223 int size, __size, i; 1224 unsigned long irq_flags; 1225 int rctx; 1226 1227 __size = SIZEOF_KPROBE_TRACE_ENTRY(tp->nr_args); 1228 size = ALIGN(__size + sizeof(u32), sizeof(u64)); 1229 size -= sizeof(u32); 1230 if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, 1231 "profile buffer not large enough")) 1232 return; 1233 1234 entry = perf_trace_buf_prepare(size, call->id, &rctx, &irq_flags); 1235 if (!entry) 1236 return; 1237 1238 entry->nargs = tp->nr_args; 1239 entry->ip = (unsigned long)kp->addr; 1240 for (i = 0; i < tp->nr_args; i++) 1241 entry->args[i] = call_fetch(&tp->args[i].fetch, regs); 1242 1243 perf_trace_buf_submit(entry, size, rctx, entry->ip, 1, irq_flags, regs); 1244 } 1245 1246 /* Kretprobe profile handler */ 1247 static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri, 1248 struct pt_regs *regs) 1249 { 1250 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp); 1251 struct ftrace_event_call *call = &tp->call; 1252 struct kretprobe_trace_entry *entry; 1253 int size, __size, i; 1254 unsigned long irq_flags; 1255 int rctx; 1256 1257 __size = SIZEOF_KRETPROBE_TRACE_ENTRY(tp->nr_args); 1258 size = ALIGN(__size + sizeof(u32), sizeof(u64)); 1259 size -= sizeof(u32); 1260 if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, 1261 "profile buffer not large enough")) 1262 return; 1263 1264 entry = perf_trace_buf_prepare(size, call->id, &rctx, &irq_flags); 1265 if (!entry) 1266 return; 1267 1268 entry->nargs = tp->nr_args; 1269 entry->func = (unsigned long)tp->rp.kp.addr; 1270 entry->ret_ip = (unsigned long)ri->ret_addr; 1271 for (i = 0; i < tp->nr_args; i++) 1272 entry->args[i] = call_fetch(&tp->args[i].fetch, regs); 1273 1274 perf_trace_buf_submit(entry, size, rctx, entry->ret_ip, 1, 1275 irq_flags, regs); 1276 } 1277 1278 static int probe_perf_enable(struct ftrace_event_call *call) 1279 { 1280 struct trace_probe *tp = (struct trace_probe *)call->data; 1281 1282 tp->flags |= TP_FLAG_PROFILE; 1283 1284 if (probe_is_return(tp)) 1285 return enable_kretprobe(&tp->rp); 1286 else 1287 return enable_kprobe(&tp->rp.kp); 1288 } 1289 1290 static void probe_perf_disable(struct ftrace_event_call *call) 1291 { 1292 struct trace_probe *tp = (struct trace_probe *)call->data; 1293 1294 tp->flags &= ~TP_FLAG_PROFILE; 1295 1296 if (!(tp->flags & TP_FLAG_TRACE)) { 1297 if (probe_is_return(tp)) 1298 disable_kretprobe(&tp->rp); 1299 else 1300 disable_kprobe(&tp->rp.kp); 1301 } 1302 } 1303 #endif /* CONFIG_PERF_EVENTS */ 1304 1305 1306 static __kprobes 1307 int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs) 1308 { 1309 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp); 1310 1311 if (tp->flags & TP_FLAG_TRACE) 1312 kprobe_trace_func(kp, regs); 1313 #ifdef CONFIG_PERF_EVENTS 1314 if (tp->flags & TP_FLAG_PROFILE) 1315 kprobe_perf_func(kp, regs); 1316 #endif 1317 return 0; /* We don't tweek kernel, so just return 0 */ 1318 } 1319 1320 static __kprobes 1321 int kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs) 1322 { 1323 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp); 1324 1325 if (tp->flags & TP_FLAG_TRACE) 1326 kretprobe_trace_func(ri, regs); 1327 #ifdef CONFIG_PERF_EVENTS 1328 if (tp->flags & TP_FLAG_PROFILE) 1329 kretprobe_perf_func(ri, regs); 1330 #endif 1331 return 0; /* We don't tweek kernel, so just return 0 */ 1332 } 1333 1334 static int register_probe_event(struct trace_probe *tp) 1335 { 1336 struct ftrace_event_call *call = &tp->call; 1337 int ret; 1338 1339 /* Initialize ftrace_event_call */ 1340 if (probe_is_return(tp)) { 1341 tp->event.trace = print_kretprobe_event; 1342 call->raw_init = probe_event_raw_init; 1343 call->define_fields = kretprobe_event_define_fields; 1344 } else { 1345 tp->event.trace = print_kprobe_event; 1346 call->raw_init = probe_event_raw_init; 1347 call->define_fields = kprobe_event_define_fields; 1348 } 1349 if (set_print_fmt(tp) < 0) 1350 return -ENOMEM; 1351 call->event = &tp->event; 1352 call->id = register_ftrace_event(&tp->event); 1353 if (!call->id) { 1354 kfree(call->print_fmt); 1355 return -ENODEV; 1356 } 1357 call->enabled = 0; 1358 call->regfunc = probe_event_enable; 1359 call->unregfunc = probe_event_disable; 1360 1361 #ifdef CONFIG_PERF_EVENTS 1362 call->perf_event_enable = probe_perf_enable; 1363 call->perf_event_disable = probe_perf_disable; 1364 #endif 1365 call->data = tp; 1366 ret = trace_add_event_call(call); 1367 if (ret) { 1368 pr_info("Failed to register kprobe event: %s\n", call->name); 1369 kfree(call->print_fmt); 1370 unregister_ftrace_event(&tp->event); 1371 } 1372 return ret; 1373 } 1374 1375 static void unregister_probe_event(struct trace_probe *tp) 1376 { 1377 /* tp->event is unregistered in trace_remove_event_call() */ 1378 trace_remove_event_call(&tp->call); 1379 kfree(tp->call.print_fmt); 1380 } 1381 1382 /* Make a debugfs interface for controling probe points */ 1383 static __init int init_kprobe_trace(void) 1384 { 1385 struct dentry *d_tracer; 1386 struct dentry *entry; 1387 1388 d_tracer = tracing_init_dentry(); 1389 if (!d_tracer) 1390 return 0; 1391 1392 entry = debugfs_create_file("kprobe_events", 0644, d_tracer, 1393 NULL, &kprobe_events_ops); 1394 1395 /* Event list interface */ 1396 if (!entry) 1397 pr_warning("Could not create debugfs " 1398 "'kprobe_events' entry\n"); 1399 1400 /* Profile interface */ 1401 entry = debugfs_create_file("kprobe_profile", 0444, d_tracer, 1402 NULL, &kprobe_profile_ops); 1403 1404 if (!entry) 1405 pr_warning("Could not create debugfs " 1406 "'kprobe_profile' entry\n"); 1407 return 0; 1408 } 1409 fs_initcall(init_kprobe_trace); 1410 1411 1412 #ifdef CONFIG_FTRACE_STARTUP_TEST 1413 1414 static int kprobe_trace_selftest_target(int a1, int a2, int a3, 1415 int a4, int a5, int a6) 1416 { 1417 return a1 + a2 + a3 + a4 + a5 + a6; 1418 } 1419 1420 static __init int kprobe_trace_self_tests_init(void) 1421 { 1422 int ret, warn = 0; 1423 int (*target)(int, int, int, int, int, int); 1424 struct trace_probe *tp; 1425 1426 target = kprobe_trace_selftest_target; 1427 1428 pr_info("Testing kprobe tracing: "); 1429 1430 ret = command_trace_probe("p:testprobe kprobe_trace_selftest_target " 1431 "$stack $stack0 +0($stack)"); 1432 if (WARN_ON_ONCE(ret)) { 1433 pr_warning("error on probing function entry.\n"); 1434 warn++; 1435 } else { 1436 /* Enable trace point */ 1437 tp = find_probe_event("testprobe", KPROBE_EVENT_SYSTEM); 1438 if (WARN_ON_ONCE(tp == NULL)) { 1439 pr_warning("error on getting new probe.\n"); 1440 warn++; 1441 } else 1442 probe_event_enable(&tp->call); 1443 } 1444 1445 ret = command_trace_probe("r:testprobe2 kprobe_trace_selftest_target " 1446 "$retval"); 1447 if (WARN_ON_ONCE(ret)) { 1448 pr_warning("error on probing function return.\n"); 1449 warn++; 1450 } else { 1451 /* Enable trace point */ 1452 tp = find_probe_event("testprobe2", KPROBE_EVENT_SYSTEM); 1453 if (WARN_ON_ONCE(tp == NULL)) { 1454 pr_warning("error on getting new probe.\n"); 1455 warn++; 1456 } else 1457 probe_event_enable(&tp->call); 1458 } 1459 1460 if (warn) 1461 goto end; 1462 1463 ret = target(1, 2, 3, 4, 5, 6); 1464 1465 ret = command_trace_probe("-:testprobe"); 1466 if (WARN_ON_ONCE(ret)) { 1467 pr_warning("error on deleting a probe.\n"); 1468 warn++; 1469 } 1470 1471 ret = command_trace_probe("-:testprobe2"); 1472 if (WARN_ON_ONCE(ret)) { 1473 pr_warning("error on deleting a probe.\n"); 1474 warn++; 1475 } 1476 1477 end: 1478 cleanup_all_probes(); 1479 if (warn) 1480 pr_cont("NG: Some tests are failed. Please check them.\n"); 1481 else 1482 pr_cont("OK\n"); 1483 return 0; 1484 } 1485 1486 late_initcall(kprobe_trace_self_tests_init); 1487 1488 #endif 1489