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 23#include "trace_probe.h" 24 25#define KPROBE_EVENT_SYSTEM "kprobes" 26 27/** 28 * Kprobe event core functions 29 */ 30struct trace_kprobe { 31 struct list_head list; 32 struct kretprobe rp; /* Use rp.kp for kprobe use */ 33 unsigned long nhit; 34 const char *symbol; /* symbol name */ 35 struct trace_probe tp; 36}; 37 38#define SIZEOF_TRACE_KPROBE(n) \ 39 (offsetof(struct trace_kprobe, tp.args) + \ 40 (sizeof(struct probe_arg) * (n))) 41 42 43static nokprobe_inline bool trace_kprobe_is_return(struct trace_kprobe *tk) 44{ 45 return tk->rp.handler != NULL; 46} 47 48static nokprobe_inline const char *trace_kprobe_symbol(struct trace_kprobe *tk) 49{ 50 return tk->symbol ? tk->symbol : "unknown"; 51} 52 53static nokprobe_inline unsigned long trace_kprobe_offset(struct trace_kprobe *tk) 54{ 55 return tk->rp.kp.offset; 56} 57 58static nokprobe_inline bool trace_kprobe_has_gone(struct trace_kprobe *tk) 59{ 60 return !!(kprobe_gone(&tk->rp.kp)); 61} 62 63static nokprobe_inline bool trace_kprobe_within_module(struct trace_kprobe *tk, 64 struct module *mod) 65{ 66 int len = strlen(mod->name); 67 const char *name = trace_kprobe_symbol(tk); 68 return strncmp(mod->name, name, len) == 0 && name[len] == ':'; 69} 70 71static nokprobe_inline bool trace_kprobe_is_on_module(struct trace_kprobe *tk) 72{ 73 return !!strchr(trace_kprobe_symbol(tk), ':'); 74} 75 76static int register_kprobe_event(struct trace_kprobe *tk); 77static int unregister_kprobe_event(struct trace_kprobe *tk); 78 79static DEFINE_MUTEX(probe_lock); 80static LIST_HEAD(probe_list); 81 82static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs); 83static int kretprobe_dispatcher(struct kretprobe_instance *ri, 84 struct pt_regs *regs); 85 86/* Memory fetching by symbol */ 87struct symbol_cache { 88 char *symbol; 89 long offset; 90 unsigned long addr; 91}; 92 93unsigned long update_symbol_cache(struct symbol_cache *sc) 94{ 95 sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol); 96 97 if (sc->addr) 98 sc->addr += sc->offset; 99 100 return sc->addr; 101} 102 103void free_symbol_cache(struct symbol_cache *sc) 104{ 105 kfree(sc->symbol); 106 kfree(sc); 107} 108 109struct symbol_cache *alloc_symbol_cache(const char *sym, long offset) 110{ 111 struct symbol_cache *sc; 112 113 if (!sym || strlen(sym) == 0) 114 return NULL; 115 116 sc = kzalloc(sizeof(struct symbol_cache), GFP_KERNEL); 117 if (!sc) 118 return NULL; 119 120 sc->symbol = kstrdup(sym, GFP_KERNEL); 121 if (!sc->symbol) { 122 kfree(sc); 123 return NULL; 124 } 125 sc->offset = offset; 126 update_symbol_cache(sc); 127 128 return sc; 129} 130 131/* 132 * Kprobes-specific fetch functions 133 */ 134#define DEFINE_FETCH_stack(type) \ 135static void FETCH_FUNC_NAME(stack, type)(struct pt_regs *regs, \ 136 void *offset, void *dest) \ 137{ \ 138 *(type *)dest = (type)regs_get_kernel_stack_nth(regs, \ 139 (unsigned int)((unsigned long)offset)); \ 140} \ 141NOKPROBE_SYMBOL(FETCH_FUNC_NAME(stack, type)); 142 143DEFINE_BASIC_FETCH_FUNCS(stack) 144/* No string on the stack entry */ 145#define fetch_stack_string NULL 146#define fetch_stack_string_size NULL 147 148#define DEFINE_FETCH_memory(type) \ 149static void FETCH_FUNC_NAME(memory, type)(struct pt_regs *regs, \ 150 void *addr, void *dest) \ 151{ \ 152 type retval; \ 153 if (probe_kernel_address(addr, retval)) \ 154 *(type *)dest = 0; \ 155 else \ 156 *(type *)dest = retval; \ 157} \ 158NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, type)); 159 160DEFINE_BASIC_FETCH_FUNCS(memory) 161/* 162 * Fetch a null-terminated string. Caller MUST set *(u32 *)dest with max 163 * length and relative data location. 164 */ 165static void FETCH_FUNC_NAME(memory, string)(struct pt_regs *regs, 166 void *addr, void *dest) 167{ 168 long ret; 169 int maxlen = get_rloc_len(*(u32 *)dest); 170 u8 *dst = get_rloc_data(dest); 171 u8 *src = addr; 172 mm_segment_t old_fs = get_fs(); 173 174 if (!maxlen) 175 return; 176 177 /* 178 * Try to get string again, since the string can be changed while 179 * probing. 180 */ 181 set_fs(KERNEL_DS); 182 pagefault_disable(); 183 184 do 185 ret = __copy_from_user_inatomic(dst++, src++, 1); 186 while (dst[-1] && ret == 0 && src - (u8 *)addr < maxlen); 187 188 dst[-1] = '\0'; 189 pagefault_enable(); 190 set_fs(old_fs); 191 192 if (ret < 0) { /* Failed to fetch string */ 193 ((u8 *)get_rloc_data(dest))[0] = '\0'; 194 *(u32 *)dest = make_data_rloc(0, get_rloc_offs(*(u32 *)dest)); 195 } else { 196 *(u32 *)dest = make_data_rloc(src - (u8 *)addr, 197 get_rloc_offs(*(u32 *)dest)); 198 } 199} 200NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, string)); 201 202/* Return the length of string -- including null terminal byte */ 203static void FETCH_FUNC_NAME(memory, string_size)(struct pt_regs *regs, 204 void *addr, void *dest) 205{ 206 mm_segment_t old_fs; 207 int ret, len = 0; 208 u8 c; 209 210 old_fs = get_fs(); 211 set_fs(KERNEL_DS); 212 pagefault_disable(); 213 214 do { 215 ret = __copy_from_user_inatomic(&c, (u8 *)addr + len, 1); 216 len++; 217 } while (c && ret == 0 && len < MAX_STRING_SIZE); 218 219 pagefault_enable(); 220 set_fs(old_fs); 221 222 if (ret < 0) /* Failed to check the length */ 223 *(u32 *)dest = 0; 224 else 225 *(u32 *)dest = len; 226} 227NOKPROBE_SYMBOL(FETCH_FUNC_NAME(memory, string_size)); 228 229#define DEFINE_FETCH_symbol(type) \ 230void FETCH_FUNC_NAME(symbol, type)(struct pt_regs *regs, void *data, void *dest)\ 231{ \ 232 struct symbol_cache *sc = data; \ 233 if (sc->addr) \ 234 fetch_memory_##type(regs, (void *)sc->addr, dest); \ 235 else \ 236 *(type *)dest = 0; \ 237} \ 238NOKPROBE_SYMBOL(FETCH_FUNC_NAME(symbol, type)); 239 240DEFINE_BASIC_FETCH_FUNCS(symbol) 241DEFINE_FETCH_symbol(string) 242DEFINE_FETCH_symbol(string_size) 243 244/* kprobes don't support file_offset fetch methods */ 245#define fetch_file_offset_u8 NULL 246#define fetch_file_offset_u16 NULL 247#define fetch_file_offset_u32 NULL 248#define fetch_file_offset_u64 NULL 249#define fetch_file_offset_string NULL 250#define fetch_file_offset_string_size NULL 251 252/* Fetch type information table */ 253static const struct fetch_type kprobes_fetch_type_table[] = { 254 /* Special types */ 255 [FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string, 256 sizeof(u32), 1, "__data_loc char[]"), 257 [FETCH_TYPE_STRSIZE] = __ASSIGN_FETCH_TYPE("string_size", u32, 258 string_size, sizeof(u32), 0, "u32"), 259 /* Basic types */ 260 ASSIGN_FETCH_TYPE(u8, u8, 0), 261 ASSIGN_FETCH_TYPE(u16, u16, 0), 262 ASSIGN_FETCH_TYPE(u32, u32, 0), 263 ASSIGN_FETCH_TYPE(u64, u64, 0), 264 ASSIGN_FETCH_TYPE(s8, u8, 1), 265 ASSIGN_FETCH_TYPE(s16, u16, 1), 266 ASSIGN_FETCH_TYPE(s32, u32, 1), 267 ASSIGN_FETCH_TYPE(s64, u64, 1), 268 269 ASSIGN_FETCH_TYPE_END 270}; 271 272/* 273 * Allocate new trace_probe and initialize it (including kprobes). 274 */ 275static struct trace_kprobe *alloc_trace_kprobe(const char *group, 276 const char *event, 277 void *addr, 278 const char *symbol, 279 unsigned long offs, 280 int nargs, bool is_return) 281{ 282 struct trace_kprobe *tk; 283 int ret = -ENOMEM; 284 285 tk = kzalloc(SIZEOF_TRACE_KPROBE(nargs), GFP_KERNEL); 286 if (!tk) 287 return ERR_PTR(ret); 288 289 if (symbol) { 290 tk->symbol = kstrdup(symbol, GFP_KERNEL); 291 if (!tk->symbol) 292 goto error; 293 tk->rp.kp.symbol_name = tk->symbol; 294 tk->rp.kp.offset = offs; 295 } else 296 tk->rp.kp.addr = addr; 297 298 if (is_return) 299 tk->rp.handler = kretprobe_dispatcher; 300 else 301 tk->rp.kp.pre_handler = kprobe_dispatcher; 302 303 if (!event || !is_good_name(event)) { 304 ret = -EINVAL; 305 goto error; 306 } 307 308 tk->tp.call.class = &tk->tp.class; 309 tk->tp.call.name = kstrdup(event, GFP_KERNEL); 310 if (!tk->tp.call.name) 311 goto error; 312 313 if (!group || !is_good_name(group)) { 314 ret = -EINVAL; 315 goto error; 316 } 317 318 tk->tp.class.system = kstrdup(group, GFP_KERNEL); 319 if (!tk->tp.class.system) 320 goto error; 321 322 INIT_LIST_HEAD(&tk->list); 323 INIT_LIST_HEAD(&tk->tp.files); 324 return tk; 325error: 326 kfree(tk->tp.call.name); 327 kfree(tk->symbol); 328 kfree(tk); 329 return ERR_PTR(ret); 330} 331 332static void free_trace_kprobe(struct trace_kprobe *tk) 333{ 334 int i; 335 336 for (i = 0; i < tk->tp.nr_args; i++) 337 traceprobe_free_probe_arg(&tk->tp.args[i]); 338 339 kfree(tk->tp.call.class->system); 340 kfree(tk->tp.call.name); 341 kfree(tk->symbol); 342 kfree(tk); 343} 344 345static struct trace_kprobe *find_trace_kprobe(const char *event, 346 const char *group) 347{ 348 struct trace_kprobe *tk; 349 350 list_for_each_entry(tk, &probe_list, list) 351 if (strcmp(ftrace_event_name(&tk->tp.call), event) == 0 && 352 strcmp(tk->tp.call.class->system, group) == 0) 353 return tk; 354 return NULL; 355} 356 357/* 358 * Enable trace_probe 359 * if the file is NULL, enable "perf" handler, or enable "trace" handler. 360 */ 361static int 362enable_trace_kprobe(struct trace_kprobe *tk, struct ftrace_event_file *file) 363{ 364 int ret = 0; 365 366 if (file) { 367 struct event_file_link *link; 368 369 link = kmalloc(sizeof(*link), GFP_KERNEL); 370 if (!link) { 371 ret = -ENOMEM; 372 goto out; 373 } 374 375 link->file = file; 376 list_add_tail_rcu(&link->list, &tk->tp.files); 377 378 tk->tp.flags |= TP_FLAG_TRACE; 379 } else 380 tk->tp.flags |= TP_FLAG_PROFILE; 381 382 if (trace_probe_is_registered(&tk->tp) && !trace_kprobe_has_gone(tk)) { 383 if (trace_kprobe_is_return(tk)) 384 ret = enable_kretprobe(&tk->rp); 385 else 386 ret = enable_kprobe(&tk->rp.kp); 387 } 388 out: 389 return ret; 390} 391 392/* 393 * Disable trace_probe 394 * if the file is NULL, disable "perf" handler, or disable "trace" handler. 395 */ 396static int 397disable_trace_kprobe(struct trace_kprobe *tk, struct ftrace_event_file *file) 398{ 399 struct event_file_link *link = NULL; 400 int wait = 0; 401 int ret = 0; 402 403 if (file) { 404 link = find_event_file_link(&tk->tp, file); 405 if (!link) { 406 ret = -EINVAL; 407 goto out; 408 } 409 410 list_del_rcu(&link->list); 411 wait = 1; 412 if (!list_empty(&tk->tp.files)) 413 goto out; 414 415 tk->tp.flags &= ~TP_FLAG_TRACE; 416 } else 417 tk->tp.flags &= ~TP_FLAG_PROFILE; 418 419 if (!trace_probe_is_enabled(&tk->tp) && trace_probe_is_registered(&tk->tp)) { 420 if (trace_kprobe_is_return(tk)) 421 disable_kretprobe(&tk->rp); 422 else 423 disable_kprobe(&tk->rp.kp); 424 wait = 1; 425 } 426 out: 427 if (wait) { 428 /* 429 * Synchronize with kprobe_trace_func/kretprobe_trace_func 430 * to ensure disabled (all running handlers are finished). 431 * This is not only for kfree(), but also the caller, 432 * trace_remove_event_call() supposes it for releasing 433 * event_call related objects, which will be accessed in 434 * the kprobe_trace_func/kretprobe_trace_func. 435 */ 436 synchronize_sched(); 437 kfree(link); /* Ignored if link == NULL */ 438 } 439 440 return ret; 441} 442 443/* Internal register function - just handle k*probes and flags */ 444static int __register_trace_kprobe(struct trace_kprobe *tk) 445{ 446 int i, ret; 447 448 if (trace_probe_is_registered(&tk->tp)) 449 return -EINVAL; 450 451 for (i = 0; i < tk->tp.nr_args; i++) 452 traceprobe_update_arg(&tk->tp.args[i]); 453 454 /* Set/clear disabled flag according to tp->flag */ 455 if (trace_probe_is_enabled(&tk->tp)) 456 tk->rp.kp.flags &= ~KPROBE_FLAG_DISABLED; 457 else 458 tk->rp.kp.flags |= KPROBE_FLAG_DISABLED; 459 460 if (trace_kprobe_is_return(tk)) 461 ret = register_kretprobe(&tk->rp); 462 else 463 ret = register_kprobe(&tk->rp.kp); 464 465 if (ret == 0) 466 tk->tp.flags |= TP_FLAG_REGISTERED; 467 else { 468 pr_warning("Could not insert probe at %s+%lu: %d\n", 469 trace_kprobe_symbol(tk), trace_kprobe_offset(tk), ret); 470 if (ret == -ENOENT && trace_kprobe_is_on_module(tk)) { 471 pr_warning("This probe might be able to register after" 472 "target module is loaded. Continue.\n"); 473 ret = 0; 474 } else if (ret == -EILSEQ) { 475 pr_warning("Probing address(0x%p) is not an " 476 "instruction boundary.\n", 477 tk->rp.kp.addr); 478 ret = -EINVAL; 479 } 480 } 481 482 return ret; 483} 484 485/* Internal unregister function - just handle k*probes and flags */ 486static void __unregister_trace_kprobe(struct trace_kprobe *tk) 487{ 488 if (trace_probe_is_registered(&tk->tp)) { 489 if (trace_kprobe_is_return(tk)) 490 unregister_kretprobe(&tk->rp); 491 else 492 unregister_kprobe(&tk->rp.kp); 493 tk->tp.flags &= ~TP_FLAG_REGISTERED; 494 /* Cleanup kprobe for reuse */ 495 if (tk->rp.kp.symbol_name) 496 tk->rp.kp.addr = NULL; 497 } 498} 499 500/* Unregister a trace_probe and probe_event: call with locking probe_lock */ 501static int unregister_trace_kprobe(struct trace_kprobe *tk) 502{ 503 /* Enabled event can not be unregistered */ 504 if (trace_probe_is_enabled(&tk->tp)) 505 return -EBUSY; 506 507 /* Will fail if probe is being used by ftrace or perf */ 508 if (unregister_kprobe_event(tk)) 509 return -EBUSY; 510 511 __unregister_trace_kprobe(tk); 512 list_del(&tk->list); 513 514 return 0; 515} 516 517/* Register a trace_probe and probe_event */ 518static int register_trace_kprobe(struct trace_kprobe *tk) 519{ 520 struct trace_kprobe *old_tk; 521 int ret; 522 523 mutex_lock(&probe_lock); 524 525 /* Delete old (same name) event if exist */ 526 old_tk = find_trace_kprobe(ftrace_event_name(&tk->tp.call), 527 tk->tp.call.class->system); 528 if (old_tk) { 529 ret = unregister_trace_kprobe(old_tk); 530 if (ret < 0) 531 goto end; 532 free_trace_kprobe(old_tk); 533 } 534 535 /* Register new event */ 536 ret = register_kprobe_event(tk); 537 if (ret) { 538 pr_warning("Failed to register probe event(%d)\n", ret); 539 goto end; 540 } 541 542 /* Register k*probe */ 543 ret = __register_trace_kprobe(tk); 544 if (ret < 0) 545 unregister_kprobe_event(tk); 546 else 547 list_add_tail(&tk->list, &probe_list); 548 549end: 550 mutex_unlock(&probe_lock); 551 return ret; 552} 553 554/* Module notifier call back, checking event on the module */ 555static int trace_kprobe_module_callback(struct notifier_block *nb, 556 unsigned long val, void *data) 557{ 558 struct module *mod = data; 559 struct trace_kprobe *tk; 560 int ret; 561 562 if (val != MODULE_STATE_COMING) 563 return NOTIFY_DONE; 564 565 /* Update probes on coming module */ 566 mutex_lock(&probe_lock); 567 list_for_each_entry(tk, &probe_list, list) { 568 if (trace_kprobe_within_module(tk, mod)) { 569 /* Don't need to check busy - this should have gone. */ 570 __unregister_trace_kprobe(tk); 571 ret = __register_trace_kprobe(tk); 572 if (ret) 573 pr_warning("Failed to re-register probe %s on" 574 "%s: %d\n", 575 ftrace_event_name(&tk->tp.call), 576 mod->name, ret); 577 } 578 } 579 mutex_unlock(&probe_lock); 580 581 return NOTIFY_DONE; 582} 583 584static struct notifier_block trace_kprobe_module_nb = { 585 .notifier_call = trace_kprobe_module_callback, 586 .priority = 1 /* Invoked after kprobe module callback */ 587}; 588 589static int create_trace_kprobe(int argc, char **argv) 590{ 591 /* 592 * Argument syntax: 593 * - Add kprobe: p[:[GRP/]EVENT] [MOD:]KSYM[+OFFS]|KADDR [FETCHARGS] 594 * - Add kretprobe: r[:[GRP/]EVENT] [MOD:]KSYM[+0] [FETCHARGS] 595 * Fetch args: 596 * $retval : fetch return value 597 * $stack : fetch stack address 598 * $stackN : fetch Nth of stack (N:0-) 599 * @ADDR : fetch memory at ADDR (ADDR should be in kernel) 600 * @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol) 601 * %REG : fetch register REG 602 * Dereferencing memory fetch: 603 * +|-offs(ARG) : fetch memory at ARG +|- offs address. 604 * Alias name of args: 605 * NAME=FETCHARG : set NAME as alias of FETCHARG. 606 * Type of args: 607 * FETCHARG:TYPE : use TYPE instead of unsigned long. 608 */ 609 struct trace_kprobe *tk; 610 int i, ret = 0; 611 bool is_return = false, is_delete = false; 612 char *symbol = NULL, *event = NULL, *group = NULL; 613 char *arg; 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 = false; 621 else if (argv[0][0] == 'r') 622 is_return = true; 623 else if (argv[0][0] == '-') 624 is_delete = true; 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 mutex_lock(&probe_lock); 656 tk = find_trace_kprobe(event, group); 657 if (!tk) { 658 mutex_unlock(&probe_lock); 659 pr_info("Event %s/%s doesn't exist.\n", group, event); 660 return -ENOENT; 661 } 662 /* delete an event */ 663 ret = unregister_trace_kprobe(tk); 664 if (ret == 0) 665 free_trace_kprobe(tk); 666 mutex_unlock(&probe_lock); 667 return ret; 668 } 669 670 if (argc < 2) { 671 pr_info("Probe point is not specified.\n"); 672 return -EINVAL; 673 } 674 if (isdigit(argv[1][0])) { 675 if (is_return) { 676 pr_info("Return probe point must be a symbol.\n"); 677 return -EINVAL; 678 } 679 /* an address specified */ 680 ret = kstrtoul(&argv[1][0], 0, (unsigned long *)&addr); 681 if (ret) { 682 pr_info("Failed to parse address.\n"); 683 return ret; 684 } 685 } else { 686 /* a symbol specified */ 687 symbol = argv[1]; 688 /* TODO: support .init module functions */ 689 ret = traceprobe_split_symbol_offset(symbol, &offset); 690 if (ret) { 691 pr_info("Failed to parse symbol.\n"); 692 return ret; 693 } 694 if (offset && is_return) { 695 pr_info("Return probe must be used without offset.\n"); 696 return -EINVAL; 697 } 698 } 699 argc -= 2; argv += 2; 700 701 /* setup a probe */ 702 if (!event) { 703 /* Make a new event name */ 704 if (symbol) 705 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld", 706 is_return ? 'r' : 'p', symbol, offset); 707 else 708 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p", 709 is_return ? 'r' : 'p', addr); 710 event = buf; 711 } 712 tk = alloc_trace_kprobe(group, event, addr, symbol, offset, argc, 713 is_return); 714 if (IS_ERR(tk)) { 715 pr_info("Failed to allocate trace_probe.(%d)\n", 716 (int)PTR_ERR(tk)); 717 return PTR_ERR(tk); 718 } 719 720 /* parse arguments */ 721 ret = 0; 722 for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { 723 struct probe_arg *parg = &tk->tp.args[i]; 724 725 /* Increment count for freeing args in error case */ 726 tk->tp.nr_args++; 727 728 /* Parse argument name */ 729 arg = strchr(argv[i], '='); 730 if (arg) { 731 *arg++ = '\0'; 732 parg->name = kstrdup(argv[i], GFP_KERNEL); 733 } else { 734 arg = argv[i]; 735 /* If argument name is omitted, set "argN" */ 736 snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1); 737 parg->name = kstrdup(buf, GFP_KERNEL); 738 } 739 740 if (!parg->name) { 741 pr_info("Failed to allocate argument[%d] name.\n", i); 742 ret = -ENOMEM; 743 goto error; 744 } 745 746 if (!is_good_name(parg->name)) { 747 pr_info("Invalid argument[%d] name: %s\n", 748 i, parg->name); 749 ret = -EINVAL; 750 goto error; 751 } 752 753 if (traceprobe_conflict_field_name(parg->name, 754 tk->tp.args, i)) { 755 pr_info("Argument[%d] name '%s' conflicts with " 756 "another field.\n", i, argv[i]); 757 ret = -EINVAL; 758 goto error; 759 } 760 761 /* Parse fetch argument */ 762 ret = traceprobe_parse_probe_arg(arg, &tk->tp.size, parg, 763 is_return, true, 764 kprobes_fetch_type_table); 765 if (ret) { 766 pr_info("Parse error at argument[%d]. (%d)\n", i, ret); 767 goto error; 768 } 769 } 770 771 ret = register_trace_kprobe(tk); 772 if (ret) 773 goto error; 774 return 0; 775 776error: 777 free_trace_kprobe(tk); 778 return ret; 779} 780 781static int release_all_trace_kprobes(void) 782{ 783 struct trace_kprobe *tk; 784 int ret = 0; 785 786 mutex_lock(&probe_lock); 787 /* Ensure no probe is in use. */ 788 list_for_each_entry(tk, &probe_list, list) 789 if (trace_probe_is_enabled(&tk->tp)) { 790 ret = -EBUSY; 791 goto end; 792 } 793 /* TODO: Use batch unregistration */ 794 while (!list_empty(&probe_list)) { 795 tk = list_entry(probe_list.next, struct trace_kprobe, list); 796 ret = unregister_trace_kprobe(tk); 797 if (ret) 798 goto end; 799 free_trace_kprobe(tk); 800 } 801 802end: 803 mutex_unlock(&probe_lock); 804 805 return ret; 806} 807 808/* Probes listing interfaces */ 809static void *probes_seq_start(struct seq_file *m, loff_t *pos) 810{ 811 mutex_lock(&probe_lock); 812 return seq_list_start(&probe_list, *pos); 813} 814 815static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos) 816{ 817 return seq_list_next(v, &probe_list, pos); 818} 819 820static void probes_seq_stop(struct seq_file *m, void *v) 821{ 822 mutex_unlock(&probe_lock); 823} 824 825static int probes_seq_show(struct seq_file *m, void *v) 826{ 827 struct trace_kprobe *tk = v; 828 int i; 829 830 seq_putc(m, trace_kprobe_is_return(tk) ? 'r' : 'p'); 831 seq_printf(m, ":%s/%s", tk->tp.call.class->system, 832 ftrace_event_name(&tk->tp.call)); 833 834 if (!tk->symbol) 835 seq_printf(m, " 0x%p", tk->rp.kp.addr); 836 else if (tk->rp.kp.offset) 837 seq_printf(m, " %s+%u", trace_kprobe_symbol(tk), 838 tk->rp.kp.offset); 839 else 840 seq_printf(m, " %s", trace_kprobe_symbol(tk)); 841 842 for (i = 0; i < tk->tp.nr_args; i++) 843 seq_printf(m, " %s=%s", tk->tp.args[i].name, tk->tp.args[i].comm); 844 seq_putc(m, '\n'); 845 846 return 0; 847} 848 849static const struct seq_operations probes_seq_op = { 850 .start = probes_seq_start, 851 .next = probes_seq_next, 852 .stop = probes_seq_stop, 853 .show = probes_seq_show 854}; 855 856static int probes_open(struct inode *inode, struct file *file) 857{ 858 int ret; 859 860 if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) { 861 ret = release_all_trace_kprobes(); 862 if (ret < 0) 863 return ret; 864 } 865 866 return seq_open(file, &probes_seq_op); 867} 868 869static ssize_t probes_write(struct file *file, const char __user *buffer, 870 size_t count, loff_t *ppos) 871{ 872 return traceprobe_probes_write(file, buffer, count, ppos, 873 create_trace_kprobe); 874} 875 876static const struct file_operations kprobe_events_ops = { 877 .owner = THIS_MODULE, 878 .open = probes_open, 879 .read = seq_read, 880 .llseek = seq_lseek, 881 .release = seq_release, 882 .write = probes_write, 883}; 884 885/* Probes profiling interfaces */ 886static int probes_profile_seq_show(struct seq_file *m, void *v) 887{ 888 struct trace_kprobe *tk = v; 889 890 seq_printf(m, " %-44s %15lu %15lu\n", 891 ftrace_event_name(&tk->tp.call), tk->nhit, 892 tk->rp.kp.nmissed); 893 894 return 0; 895} 896 897static const struct seq_operations profile_seq_op = { 898 .start = probes_seq_start, 899 .next = probes_seq_next, 900 .stop = probes_seq_stop, 901 .show = probes_profile_seq_show 902}; 903 904static int profile_open(struct inode *inode, struct file *file) 905{ 906 return seq_open(file, &profile_seq_op); 907} 908 909static const struct file_operations kprobe_profile_ops = { 910 .owner = THIS_MODULE, 911 .open = profile_open, 912 .read = seq_read, 913 .llseek = seq_lseek, 914 .release = seq_release, 915}; 916 917/* Kprobe handler */ 918static nokprobe_inline void 919__kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs, 920 struct ftrace_event_file *ftrace_file) 921{ 922 struct kprobe_trace_entry_head *entry; 923 struct ring_buffer_event *event; 924 struct ring_buffer *buffer; 925 int size, dsize, pc; 926 unsigned long irq_flags; 927 struct ftrace_event_call *call = &tk->tp.call; 928 929 WARN_ON(call != ftrace_file->event_call); 930 931 if (ftrace_trigger_soft_disabled(ftrace_file)) 932 return; 933 934 local_save_flags(irq_flags); 935 pc = preempt_count(); 936 937 dsize = __get_data_size(&tk->tp, regs); 938 size = sizeof(*entry) + tk->tp.size + dsize; 939 940 event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, 941 call->event.type, 942 size, irq_flags, pc); 943 if (!event) 944 return; 945 946 entry = ring_buffer_event_data(event); 947 entry->ip = (unsigned long)tk->rp.kp.addr; 948 store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize); 949 950 event_trigger_unlock_commit_regs(ftrace_file, buffer, event, 951 entry, irq_flags, pc, regs); 952} 953 954static void 955kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs) 956{ 957 struct event_file_link *link; 958 959 list_for_each_entry_rcu(link, &tk->tp.files, list) 960 __kprobe_trace_func(tk, regs, link->file); 961} 962NOKPROBE_SYMBOL(kprobe_trace_func); 963 964/* Kretprobe handler */ 965static nokprobe_inline void 966__kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri, 967 struct pt_regs *regs, 968 struct ftrace_event_file *ftrace_file) 969{ 970 struct kretprobe_trace_entry_head *entry; 971 struct ring_buffer_event *event; 972 struct ring_buffer *buffer; 973 int size, pc, dsize; 974 unsigned long irq_flags; 975 struct ftrace_event_call *call = &tk->tp.call; 976 977 WARN_ON(call != ftrace_file->event_call); 978 979 if (ftrace_trigger_soft_disabled(ftrace_file)) 980 return; 981 982 local_save_flags(irq_flags); 983 pc = preempt_count(); 984 985 dsize = __get_data_size(&tk->tp, regs); 986 size = sizeof(*entry) + tk->tp.size + dsize; 987 988 event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, 989 call->event.type, 990 size, irq_flags, pc); 991 if (!event) 992 return; 993 994 entry = ring_buffer_event_data(event); 995 entry->func = (unsigned long)tk->rp.kp.addr; 996 entry->ret_ip = (unsigned long)ri->ret_addr; 997 store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize); 998 999 event_trigger_unlock_commit_regs(ftrace_file, buffer, event, 1000 entry, irq_flags, pc, regs); 1001} 1002 1003static void 1004kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri, 1005 struct pt_regs *regs) 1006{ 1007 struct event_file_link *link; 1008 1009 list_for_each_entry_rcu(link, &tk->tp.files, list) 1010 __kretprobe_trace_func(tk, ri, regs, link->file); 1011} 1012NOKPROBE_SYMBOL(kretprobe_trace_func); 1013 1014/* Event entry printers */ 1015static enum print_line_t 1016print_kprobe_event(struct trace_iterator *iter, int flags, 1017 struct trace_event *event) 1018{ 1019 struct kprobe_trace_entry_head *field; 1020 struct trace_seq *s = &iter->seq; 1021 struct trace_probe *tp; 1022 u8 *data; 1023 int i; 1024 1025 field = (struct kprobe_trace_entry_head *)iter->ent; 1026 tp = container_of(event, struct trace_probe, call.event); 1027 1028 trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call)); 1029 1030 if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET)) 1031 goto out; 1032 1033 trace_seq_putc(s, ')'); 1034 1035 data = (u8 *)&field[1]; 1036 for (i = 0; i < tp->nr_args; i++) 1037 if (!tp->args[i].type->print(s, tp->args[i].name, 1038 data + tp->args[i].offset, field)) 1039 goto out; 1040 1041 trace_seq_putc(s, '\n'); 1042 out: 1043 return trace_handle_return(s); 1044} 1045 1046static enum print_line_t 1047print_kretprobe_event(struct trace_iterator *iter, int flags, 1048 struct trace_event *event) 1049{ 1050 struct kretprobe_trace_entry_head *field; 1051 struct trace_seq *s = &iter->seq; 1052 struct trace_probe *tp; 1053 u8 *data; 1054 int i; 1055 1056 field = (struct kretprobe_trace_entry_head *)iter->ent; 1057 tp = container_of(event, struct trace_probe, call.event); 1058 1059 trace_seq_printf(s, "%s: (", ftrace_event_name(&tp->call)); 1060 1061 if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET)) 1062 goto out; 1063 1064 trace_seq_puts(s, " <- "); 1065 1066 if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET)) 1067 goto out; 1068 1069 trace_seq_putc(s, ')'); 1070 1071 data = (u8 *)&field[1]; 1072 for (i = 0; i < tp->nr_args; i++) 1073 if (!tp->args[i].type->print(s, tp->args[i].name, 1074 data + tp->args[i].offset, field)) 1075 goto out; 1076 1077 trace_seq_putc(s, '\n'); 1078 1079 out: 1080 return trace_handle_return(s); 1081} 1082 1083 1084static int kprobe_event_define_fields(struct ftrace_event_call *event_call) 1085{ 1086 int ret, i; 1087 struct kprobe_trace_entry_head field; 1088 struct trace_kprobe *tk = (struct trace_kprobe *)event_call->data; 1089 1090 DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0); 1091 /* Set argument names as fields */ 1092 for (i = 0; i < tk->tp.nr_args; i++) { 1093 struct probe_arg *parg = &tk->tp.args[i]; 1094 1095 ret = trace_define_field(event_call, parg->type->fmttype, 1096 parg->name, 1097 sizeof(field) + parg->offset, 1098 parg->type->size, 1099 parg->type->is_signed, 1100 FILTER_OTHER); 1101 if (ret) 1102 return ret; 1103 } 1104 return 0; 1105} 1106 1107static int kretprobe_event_define_fields(struct ftrace_event_call *event_call) 1108{ 1109 int ret, i; 1110 struct kretprobe_trace_entry_head field; 1111 struct trace_kprobe *tk = (struct trace_kprobe *)event_call->data; 1112 1113 DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0); 1114 DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0); 1115 /* Set argument names as fields */ 1116 for (i = 0; i < tk->tp.nr_args; i++) { 1117 struct probe_arg *parg = &tk->tp.args[i]; 1118 1119 ret = trace_define_field(event_call, parg->type->fmttype, 1120 parg->name, 1121 sizeof(field) + parg->offset, 1122 parg->type->size, 1123 parg->type->is_signed, 1124 FILTER_OTHER); 1125 if (ret) 1126 return ret; 1127 } 1128 return 0; 1129} 1130 1131#ifdef CONFIG_PERF_EVENTS 1132 1133/* Kprobe profile handler */ 1134static void 1135kprobe_perf_func(struct trace_kprobe *tk, struct pt_regs *regs) 1136{ 1137 struct ftrace_event_call *call = &tk->tp.call; 1138 struct bpf_prog *prog = call->prog; 1139 struct kprobe_trace_entry_head *entry; 1140 struct hlist_head *head; 1141 int size, __size, dsize; 1142 int rctx; 1143 1144 if (prog && !trace_call_bpf(prog, regs)) 1145 return; 1146 1147 head = this_cpu_ptr(call->perf_events); 1148 if (hlist_empty(head)) 1149 return; 1150 1151 dsize = __get_data_size(&tk->tp, regs); 1152 __size = sizeof(*entry) + tk->tp.size + dsize; 1153 size = ALIGN(__size + sizeof(u32), sizeof(u64)); 1154 size -= sizeof(u32); 1155 1156 entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx); 1157 if (!entry) 1158 return; 1159 1160 entry->ip = (unsigned long)tk->rp.kp.addr; 1161 memset(&entry[1], 0, dsize); 1162 store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize); 1163 perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL); 1164} 1165NOKPROBE_SYMBOL(kprobe_perf_func); 1166 1167/* Kretprobe profile handler */ 1168static void 1169kretprobe_perf_func(struct trace_kprobe *tk, struct kretprobe_instance *ri, 1170 struct pt_regs *regs) 1171{ 1172 struct ftrace_event_call *call = &tk->tp.call; 1173 struct bpf_prog *prog = call->prog; 1174 struct kretprobe_trace_entry_head *entry; 1175 struct hlist_head *head; 1176 int size, __size, dsize; 1177 int rctx; 1178 1179 if (prog && !trace_call_bpf(prog, regs)) 1180 return; 1181 1182 head = this_cpu_ptr(call->perf_events); 1183 if (hlist_empty(head)) 1184 return; 1185 1186 dsize = __get_data_size(&tk->tp, regs); 1187 __size = sizeof(*entry) + tk->tp.size + dsize; 1188 size = ALIGN(__size + sizeof(u32), sizeof(u64)); 1189 size -= sizeof(u32); 1190 1191 entry = perf_trace_buf_prepare(size, call->event.type, NULL, &rctx); 1192 if (!entry) 1193 return; 1194 1195 entry->func = (unsigned long)tk->rp.kp.addr; 1196 entry->ret_ip = (unsigned long)ri->ret_addr; 1197 store_trace_args(sizeof(*entry), &tk->tp, regs, (u8 *)&entry[1], dsize); 1198 perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL); 1199} 1200NOKPROBE_SYMBOL(kretprobe_perf_func); 1201#endif /* CONFIG_PERF_EVENTS */ 1202 1203/* 1204 * called by perf_trace_init() or __ftrace_set_clr_event() under event_mutex. 1205 * 1206 * kprobe_trace_self_tests_init() does enable_trace_probe/disable_trace_probe 1207 * lockless, but we can't race with this __init function. 1208 */ 1209static int kprobe_register(struct ftrace_event_call *event, 1210 enum trace_reg type, void *data) 1211{ 1212 struct trace_kprobe *tk = (struct trace_kprobe *)event->data; 1213 struct ftrace_event_file *file = data; 1214 1215 switch (type) { 1216 case TRACE_REG_REGISTER: 1217 return enable_trace_kprobe(tk, file); 1218 case TRACE_REG_UNREGISTER: 1219 return disable_trace_kprobe(tk, file); 1220 1221#ifdef CONFIG_PERF_EVENTS 1222 case TRACE_REG_PERF_REGISTER: 1223 return enable_trace_kprobe(tk, NULL); 1224 case TRACE_REG_PERF_UNREGISTER: 1225 return disable_trace_kprobe(tk, NULL); 1226 case TRACE_REG_PERF_OPEN: 1227 case TRACE_REG_PERF_CLOSE: 1228 case TRACE_REG_PERF_ADD: 1229 case TRACE_REG_PERF_DEL: 1230 return 0; 1231#endif 1232 } 1233 return 0; 1234} 1235 1236static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs) 1237{ 1238 struct trace_kprobe *tk = container_of(kp, struct trace_kprobe, rp.kp); 1239 1240 tk->nhit++; 1241 1242 if (tk->tp.flags & TP_FLAG_TRACE) 1243 kprobe_trace_func(tk, regs); 1244#ifdef CONFIG_PERF_EVENTS 1245 if (tk->tp.flags & TP_FLAG_PROFILE) 1246 kprobe_perf_func(tk, regs); 1247#endif 1248 return 0; /* We don't tweek kernel, so just return 0 */ 1249} 1250NOKPROBE_SYMBOL(kprobe_dispatcher); 1251 1252static int 1253kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs) 1254{ 1255 struct trace_kprobe *tk = container_of(ri->rp, struct trace_kprobe, rp); 1256 1257 tk->nhit++; 1258 1259 if (tk->tp.flags & TP_FLAG_TRACE) 1260 kretprobe_trace_func(tk, ri, regs); 1261#ifdef CONFIG_PERF_EVENTS 1262 if (tk->tp.flags & TP_FLAG_PROFILE) 1263 kretprobe_perf_func(tk, ri, regs); 1264#endif 1265 return 0; /* We don't tweek kernel, so just return 0 */ 1266} 1267NOKPROBE_SYMBOL(kretprobe_dispatcher); 1268 1269static struct trace_event_functions kretprobe_funcs = { 1270 .trace = print_kretprobe_event 1271}; 1272 1273static struct trace_event_functions kprobe_funcs = { 1274 .trace = print_kprobe_event 1275}; 1276 1277static int register_kprobe_event(struct trace_kprobe *tk) 1278{ 1279 struct ftrace_event_call *call = &tk->tp.call; 1280 int ret; 1281 1282 /* Initialize ftrace_event_call */ 1283 INIT_LIST_HEAD(&call->class->fields); 1284 if (trace_kprobe_is_return(tk)) { 1285 call->event.funcs = &kretprobe_funcs; 1286 call->class->define_fields = kretprobe_event_define_fields; 1287 } else { 1288 call->event.funcs = &kprobe_funcs; 1289 call->class->define_fields = kprobe_event_define_fields; 1290 } 1291 if (set_print_fmt(&tk->tp, trace_kprobe_is_return(tk)) < 0) 1292 return -ENOMEM; 1293 ret = register_ftrace_event(&call->event); 1294 if (!ret) { 1295 kfree(call->print_fmt); 1296 return -ENODEV; 1297 } 1298 call->flags = TRACE_EVENT_FL_KPROBE; 1299 call->class->reg = kprobe_register; 1300 call->data = tk; 1301 ret = trace_add_event_call(call); 1302 if (ret) { 1303 pr_info("Failed to register kprobe event: %s\n", 1304 ftrace_event_name(call)); 1305 kfree(call->print_fmt); 1306 unregister_ftrace_event(&call->event); 1307 } 1308 return ret; 1309} 1310 1311static int unregister_kprobe_event(struct trace_kprobe *tk) 1312{ 1313 int ret; 1314 1315 /* tp->event is unregistered in trace_remove_event_call() */ 1316 ret = trace_remove_event_call(&tk->tp.call); 1317 if (!ret) 1318 kfree(tk->tp.call.print_fmt); 1319 return ret; 1320} 1321 1322/* Make a tracefs interface for controlling probe points */ 1323static __init int init_kprobe_trace(void) 1324{ 1325 struct dentry *d_tracer; 1326 struct dentry *entry; 1327 1328 if (register_module_notifier(&trace_kprobe_module_nb)) 1329 return -EINVAL; 1330 1331 d_tracer = tracing_init_dentry(); 1332 if (IS_ERR(d_tracer)) 1333 return 0; 1334 1335 entry = tracefs_create_file("kprobe_events", 0644, d_tracer, 1336 NULL, &kprobe_events_ops); 1337 1338 /* Event list interface */ 1339 if (!entry) 1340 pr_warning("Could not create tracefs " 1341 "'kprobe_events' entry\n"); 1342 1343 /* Profile interface */ 1344 entry = tracefs_create_file("kprobe_profile", 0444, d_tracer, 1345 NULL, &kprobe_profile_ops); 1346 1347 if (!entry) 1348 pr_warning("Could not create tracefs " 1349 "'kprobe_profile' entry\n"); 1350 return 0; 1351} 1352fs_initcall(init_kprobe_trace); 1353 1354 1355#ifdef CONFIG_FTRACE_STARTUP_TEST 1356 1357/* 1358 * The "__used" keeps gcc from removing the function symbol 1359 * from the kallsyms table. 1360 */ 1361static __used int kprobe_trace_selftest_target(int a1, int a2, int a3, 1362 int a4, int a5, int a6) 1363{ 1364 return a1 + a2 + a3 + a4 + a5 + a6; 1365} 1366 1367static struct ftrace_event_file * 1368find_trace_probe_file(struct trace_kprobe *tk, struct trace_array *tr) 1369{ 1370 struct ftrace_event_file *file; 1371 1372 list_for_each_entry(file, &tr->events, list) 1373 if (file->event_call == &tk->tp.call) 1374 return file; 1375 1376 return NULL; 1377} 1378 1379/* 1380 * Nobody but us can call enable_trace_kprobe/disable_trace_kprobe at this 1381 * stage, we can do this lockless. 1382 */ 1383static __init int kprobe_trace_self_tests_init(void) 1384{ 1385 int ret, warn = 0; 1386 int (*target)(int, int, int, int, int, int); 1387 struct trace_kprobe *tk; 1388 struct ftrace_event_file *file; 1389 1390 if (tracing_is_disabled()) 1391 return -ENODEV; 1392 1393 target = kprobe_trace_selftest_target; 1394 1395 pr_info("Testing kprobe tracing: "); 1396 1397 ret = traceprobe_command("p:testprobe kprobe_trace_selftest_target " 1398 "$stack $stack0 +0($stack)", 1399 create_trace_kprobe); 1400 if (WARN_ON_ONCE(ret)) { 1401 pr_warn("error on probing function entry.\n"); 1402 warn++; 1403 } else { 1404 /* Enable trace point */ 1405 tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM); 1406 if (WARN_ON_ONCE(tk == NULL)) { 1407 pr_warn("error on getting new probe.\n"); 1408 warn++; 1409 } else { 1410 file = find_trace_probe_file(tk, top_trace_array()); 1411 if (WARN_ON_ONCE(file == NULL)) { 1412 pr_warn("error on getting probe file.\n"); 1413 warn++; 1414 } else 1415 enable_trace_kprobe(tk, file); 1416 } 1417 } 1418 1419 ret = traceprobe_command("r:testprobe2 kprobe_trace_selftest_target " 1420 "$retval", create_trace_kprobe); 1421 if (WARN_ON_ONCE(ret)) { 1422 pr_warn("error on probing function return.\n"); 1423 warn++; 1424 } else { 1425 /* Enable trace point */ 1426 tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM); 1427 if (WARN_ON_ONCE(tk == NULL)) { 1428 pr_warn("error on getting 2nd new probe.\n"); 1429 warn++; 1430 } else { 1431 file = find_trace_probe_file(tk, top_trace_array()); 1432 if (WARN_ON_ONCE(file == NULL)) { 1433 pr_warn("error on getting probe file.\n"); 1434 warn++; 1435 } else 1436 enable_trace_kprobe(tk, file); 1437 } 1438 } 1439 1440 if (warn) 1441 goto end; 1442 1443 ret = target(1, 2, 3, 4, 5, 6); 1444 1445 /* Disable trace points before removing it */ 1446 tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM); 1447 if (WARN_ON_ONCE(tk == NULL)) { 1448 pr_warn("error on getting test probe.\n"); 1449 warn++; 1450 } else { 1451 file = find_trace_probe_file(tk, top_trace_array()); 1452 if (WARN_ON_ONCE(file == NULL)) { 1453 pr_warn("error on getting probe file.\n"); 1454 warn++; 1455 } else 1456 disable_trace_kprobe(tk, file); 1457 } 1458 1459 tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM); 1460 if (WARN_ON_ONCE(tk == NULL)) { 1461 pr_warn("error on getting 2nd test probe.\n"); 1462 warn++; 1463 } else { 1464 file = find_trace_probe_file(tk, top_trace_array()); 1465 if (WARN_ON_ONCE(file == NULL)) { 1466 pr_warn("error on getting probe file.\n"); 1467 warn++; 1468 } else 1469 disable_trace_kprobe(tk, file); 1470 } 1471 1472 ret = traceprobe_command("-:testprobe", create_trace_kprobe); 1473 if (WARN_ON_ONCE(ret)) { 1474 pr_warn("error on deleting a probe.\n"); 1475 warn++; 1476 } 1477 1478 ret = traceprobe_command("-:testprobe2", create_trace_kprobe); 1479 if (WARN_ON_ONCE(ret)) { 1480 pr_warn("error on deleting a probe.\n"); 1481 warn++; 1482 } 1483 1484end: 1485 release_all_trace_kprobes(); 1486 if (warn) 1487 pr_cont("NG: Some tests are failed. Please check them.\n"); 1488 else 1489 pr_cont("OK\n"); 1490 return 0; 1491} 1492 1493late_initcall(kprobe_trace_self_tests_init); 1494 1495#endif 1496