1 /* 2 * event tracer 3 * 4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> 5 * 6 * - Added format output of fields of the trace point. 7 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>. 8 * 9 */ 10 11 #include <linux/workqueue.h> 12 #include <linux/spinlock.h> 13 #include <linux/kthread.h> 14 #include <linux/debugfs.h> 15 #include <linux/uaccess.h> 16 #include <linux/module.h> 17 #include <linux/ctype.h> 18 #include <linux/slab.h> 19 #include <linux/delay.h> 20 21 #include <asm/setup.h> 22 23 #include "trace_output.h" 24 25 #undef TRACE_SYSTEM 26 #define TRACE_SYSTEM "TRACE_SYSTEM" 27 28 DEFINE_MUTEX(event_mutex); 29 30 LIST_HEAD(ftrace_events); 31 static LIST_HEAD(ftrace_common_fields); 32 33 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO) 34 35 static struct kmem_cache *field_cachep; 36 static struct kmem_cache *file_cachep; 37 38 #define SYSTEM_FL_FREE_NAME (1 << 31) 39 40 static inline int system_refcount(struct event_subsystem *system) 41 { 42 return system->ref_count & ~SYSTEM_FL_FREE_NAME; 43 } 44 45 static int system_refcount_inc(struct event_subsystem *system) 46 { 47 return (system->ref_count++) & ~SYSTEM_FL_FREE_NAME; 48 } 49 50 static int system_refcount_dec(struct event_subsystem *system) 51 { 52 return (--system->ref_count) & ~SYSTEM_FL_FREE_NAME; 53 } 54 55 /* Double loops, do not use break, only goto's work */ 56 #define do_for_each_event_file(tr, file) \ 57 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 58 list_for_each_entry(file, &tr->events, list) 59 60 #define do_for_each_event_file_safe(tr, file) \ 61 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 62 struct ftrace_event_file *___n; \ 63 list_for_each_entry_safe(file, ___n, &tr->events, list) 64 65 #define while_for_each_event_file() \ 66 } 67 68 static struct list_head * 69 trace_get_fields(struct ftrace_event_call *event_call) 70 { 71 if (!event_call->class->get_fields) 72 return &event_call->class->fields; 73 return event_call->class->get_fields(event_call); 74 } 75 76 static struct ftrace_event_field * 77 __find_event_field(struct list_head *head, char *name) 78 { 79 struct ftrace_event_field *field; 80 81 list_for_each_entry(field, head, link) { 82 if (!strcmp(field->name, name)) 83 return field; 84 } 85 86 return NULL; 87 } 88 89 struct ftrace_event_field * 90 trace_find_event_field(struct ftrace_event_call *call, char *name) 91 { 92 struct ftrace_event_field *field; 93 struct list_head *head; 94 95 field = __find_event_field(&ftrace_common_fields, name); 96 if (field) 97 return field; 98 99 head = trace_get_fields(call); 100 return __find_event_field(head, name); 101 } 102 103 static int __trace_define_field(struct list_head *head, const char *type, 104 const char *name, int offset, int size, 105 int is_signed, int filter_type) 106 { 107 struct ftrace_event_field *field; 108 109 field = kmem_cache_alloc(field_cachep, GFP_TRACE); 110 if (!field) 111 return -ENOMEM; 112 113 field->name = name; 114 field->type = type; 115 116 if (filter_type == FILTER_OTHER) 117 field->filter_type = filter_assign_type(type); 118 else 119 field->filter_type = filter_type; 120 121 field->offset = offset; 122 field->size = size; 123 field->is_signed = is_signed; 124 125 list_add(&field->link, head); 126 127 return 0; 128 } 129 130 int trace_define_field(struct ftrace_event_call *call, const char *type, 131 const char *name, int offset, int size, int is_signed, 132 int filter_type) 133 { 134 struct list_head *head; 135 136 if (WARN_ON(!call->class)) 137 return 0; 138 139 head = trace_get_fields(call); 140 return __trace_define_field(head, type, name, offset, size, 141 is_signed, filter_type); 142 } 143 EXPORT_SYMBOL_GPL(trace_define_field); 144 145 #define __common_field(type, item) \ 146 ret = __trace_define_field(&ftrace_common_fields, #type, \ 147 "common_" #item, \ 148 offsetof(typeof(ent), item), \ 149 sizeof(ent.item), \ 150 is_signed_type(type), FILTER_OTHER); \ 151 if (ret) \ 152 return ret; 153 154 static int trace_define_common_fields(void) 155 { 156 int ret; 157 struct trace_entry ent; 158 159 __common_field(unsigned short, type); 160 __common_field(unsigned char, flags); 161 __common_field(unsigned char, preempt_count); 162 __common_field(int, pid); 163 164 return ret; 165 } 166 167 static void trace_destroy_fields(struct ftrace_event_call *call) 168 { 169 struct ftrace_event_field *field, *next; 170 struct list_head *head; 171 172 head = trace_get_fields(call); 173 list_for_each_entry_safe(field, next, head, link) { 174 list_del(&field->link); 175 kmem_cache_free(field_cachep, field); 176 } 177 } 178 179 int trace_event_raw_init(struct ftrace_event_call *call) 180 { 181 int id; 182 183 id = register_ftrace_event(&call->event); 184 if (!id) 185 return -ENODEV; 186 187 return 0; 188 } 189 EXPORT_SYMBOL_GPL(trace_event_raw_init); 190 191 void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer, 192 struct ftrace_event_file *ftrace_file, 193 unsigned long len) 194 { 195 struct ftrace_event_call *event_call = ftrace_file->event_call; 196 197 local_save_flags(fbuffer->flags); 198 fbuffer->pc = preempt_count(); 199 fbuffer->ftrace_file = ftrace_file; 200 201 fbuffer->event = 202 trace_event_buffer_lock_reserve(&fbuffer->buffer, ftrace_file, 203 event_call->event.type, len, 204 fbuffer->flags, fbuffer->pc); 205 if (!fbuffer->event) 206 return NULL; 207 208 fbuffer->entry = ring_buffer_event_data(fbuffer->event); 209 return fbuffer->entry; 210 } 211 EXPORT_SYMBOL_GPL(ftrace_event_buffer_reserve); 212 213 void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer) 214 { 215 event_trigger_unlock_commit(fbuffer->ftrace_file, fbuffer->buffer, 216 fbuffer->event, fbuffer->entry, 217 fbuffer->flags, fbuffer->pc); 218 } 219 EXPORT_SYMBOL_GPL(ftrace_event_buffer_commit); 220 221 int ftrace_event_reg(struct ftrace_event_call *call, 222 enum trace_reg type, void *data) 223 { 224 struct ftrace_event_file *file = data; 225 226 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT)); 227 switch (type) { 228 case TRACE_REG_REGISTER: 229 return tracepoint_probe_register(call->tp, 230 call->class->probe, 231 file); 232 case TRACE_REG_UNREGISTER: 233 tracepoint_probe_unregister(call->tp, 234 call->class->probe, 235 file); 236 return 0; 237 238 #ifdef CONFIG_PERF_EVENTS 239 case TRACE_REG_PERF_REGISTER: 240 return tracepoint_probe_register(call->tp, 241 call->class->perf_probe, 242 call); 243 case TRACE_REG_PERF_UNREGISTER: 244 tracepoint_probe_unregister(call->tp, 245 call->class->perf_probe, 246 call); 247 return 0; 248 case TRACE_REG_PERF_OPEN: 249 case TRACE_REG_PERF_CLOSE: 250 case TRACE_REG_PERF_ADD: 251 case TRACE_REG_PERF_DEL: 252 return 0; 253 #endif 254 } 255 return 0; 256 } 257 EXPORT_SYMBOL_GPL(ftrace_event_reg); 258 259 void trace_event_enable_cmd_record(bool enable) 260 { 261 struct ftrace_event_file *file; 262 struct trace_array *tr; 263 264 mutex_lock(&event_mutex); 265 do_for_each_event_file(tr, file) { 266 267 if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) 268 continue; 269 270 if (enable) { 271 tracing_start_cmdline_record(); 272 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 273 } else { 274 tracing_stop_cmdline_record(); 275 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 276 } 277 } while_for_each_event_file(); 278 mutex_unlock(&event_mutex); 279 } 280 281 static int __ftrace_event_enable_disable(struct ftrace_event_file *file, 282 int enable, int soft_disable) 283 { 284 struct ftrace_event_call *call = file->event_call; 285 int ret = 0; 286 int disable; 287 288 switch (enable) { 289 case 0: 290 /* 291 * When soft_disable is set and enable is cleared, the sm_ref 292 * reference counter is decremented. If it reaches 0, we want 293 * to clear the SOFT_DISABLED flag but leave the event in the 294 * state that it was. That is, if the event was enabled and 295 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED 296 * is set we do not want the event to be enabled before we 297 * clear the bit. 298 * 299 * When soft_disable is not set but the SOFT_MODE flag is, 300 * we do nothing. Do not disable the tracepoint, otherwise 301 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work. 302 */ 303 if (soft_disable) { 304 if (atomic_dec_return(&file->sm_ref) > 0) 305 break; 306 disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED; 307 clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags); 308 } else 309 disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE); 310 311 if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) { 312 clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags); 313 if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) { 314 tracing_stop_cmdline_record(); 315 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 316 } 317 call->class->reg(call, TRACE_REG_UNREGISTER, file); 318 } 319 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */ 320 if (file->flags & FTRACE_EVENT_FL_SOFT_MODE) 321 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 322 else 323 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 324 break; 325 case 1: 326 /* 327 * When soft_disable is set and enable is set, we want to 328 * register the tracepoint for the event, but leave the event 329 * as is. That means, if the event was already enabled, we do 330 * nothing (but set SOFT_MODE). If the event is disabled, we 331 * set SOFT_DISABLED before enabling the event tracepoint, so 332 * it still seems to be disabled. 333 */ 334 if (!soft_disable) 335 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 336 else { 337 if (atomic_inc_return(&file->sm_ref) > 1) 338 break; 339 set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags); 340 } 341 342 if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) { 343 344 /* Keep the event disabled, when going to SOFT_MODE. */ 345 if (soft_disable) 346 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 347 348 if (trace_flags & TRACE_ITER_RECORD_CMD) { 349 tracing_start_cmdline_record(); 350 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 351 } 352 ret = call->class->reg(call, TRACE_REG_REGISTER, file); 353 if (ret) { 354 tracing_stop_cmdline_record(); 355 pr_info("event trace: Could not enable event " 356 "%s\n", ftrace_event_name(call)); 357 break; 358 } 359 set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags); 360 361 /* WAS_ENABLED gets set but never cleared. */ 362 call->flags |= TRACE_EVENT_FL_WAS_ENABLED; 363 } 364 break; 365 } 366 367 return ret; 368 } 369 370 int trace_event_enable_disable(struct ftrace_event_file *file, 371 int enable, int soft_disable) 372 { 373 return __ftrace_event_enable_disable(file, enable, soft_disable); 374 } 375 376 static int ftrace_event_enable_disable(struct ftrace_event_file *file, 377 int enable) 378 { 379 return __ftrace_event_enable_disable(file, enable, 0); 380 } 381 382 static void ftrace_clear_events(struct trace_array *tr) 383 { 384 struct ftrace_event_file *file; 385 386 mutex_lock(&event_mutex); 387 list_for_each_entry(file, &tr->events, list) { 388 ftrace_event_enable_disable(file, 0); 389 } 390 mutex_unlock(&event_mutex); 391 } 392 393 static void __put_system(struct event_subsystem *system) 394 { 395 struct event_filter *filter = system->filter; 396 397 WARN_ON_ONCE(system_refcount(system) == 0); 398 if (system_refcount_dec(system)) 399 return; 400 401 list_del(&system->list); 402 403 if (filter) { 404 kfree(filter->filter_string); 405 kfree(filter); 406 } 407 if (system->ref_count & SYSTEM_FL_FREE_NAME) 408 kfree(system->name); 409 kfree(system); 410 } 411 412 static void __get_system(struct event_subsystem *system) 413 { 414 WARN_ON_ONCE(system_refcount(system) == 0); 415 system_refcount_inc(system); 416 } 417 418 static void __get_system_dir(struct ftrace_subsystem_dir *dir) 419 { 420 WARN_ON_ONCE(dir->ref_count == 0); 421 dir->ref_count++; 422 __get_system(dir->subsystem); 423 } 424 425 static void __put_system_dir(struct ftrace_subsystem_dir *dir) 426 { 427 WARN_ON_ONCE(dir->ref_count == 0); 428 /* If the subsystem is about to be freed, the dir must be too */ 429 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1); 430 431 __put_system(dir->subsystem); 432 if (!--dir->ref_count) 433 kfree(dir); 434 } 435 436 static void put_system(struct ftrace_subsystem_dir *dir) 437 { 438 mutex_lock(&event_mutex); 439 __put_system_dir(dir); 440 mutex_unlock(&event_mutex); 441 } 442 443 static void remove_subsystem(struct ftrace_subsystem_dir *dir) 444 { 445 if (!dir) 446 return; 447 448 if (!--dir->nr_events) { 449 debugfs_remove_recursive(dir->entry); 450 list_del(&dir->list); 451 __put_system_dir(dir); 452 } 453 } 454 455 static void remove_event_file_dir(struct ftrace_event_file *file) 456 { 457 struct dentry *dir = file->dir; 458 struct dentry *child; 459 460 if (dir) { 461 spin_lock(&dir->d_lock); /* probably unneeded */ 462 list_for_each_entry(child, &dir->d_subdirs, d_u.d_child) { 463 if (child->d_inode) /* probably unneeded */ 464 child->d_inode->i_private = NULL; 465 } 466 spin_unlock(&dir->d_lock); 467 468 debugfs_remove_recursive(dir); 469 } 470 471 list_del(&file->list); 472 remove_subsystem(file->system); 473 kmem_cache_free(file_cachep, file); 474 } 475 476 /* 477 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events. 478 */ 479 static int 480 __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match, 481 const char *sub, const char *event, int set) 482 { 483 struct ftrace_event_file *file; 484 struct ftrace_event_call *call; 485 const char *name; 486 int ret = -EINVAL; 487 488 list_for_each_entry(file, &tr->events, list) { 489 490 call = file->event_call; 491 name = ftrace_event_name(call); 492 493 if (!name || !call->class || !call->class->reg) 494 continue; 495 496 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) 497 continue; 498 499 if (match && 500 strcmp(match, name) != 0 && 501 strcmp(match, call->class->system) != 0) 502 continue; 503 504 if (sub && strcmp(sub, call->class->system) != 0) 505 continue; 506 507 if (event && strcmp(event, name) != 0) 508 continue; 509 510 ftrace_event_enable_disable(file, set); 511 512 ret = 0; 513 } 514 515 return ret; 516 } 517 518 static int __ftrace_set_clr_event(struct trace_array *tr, const char *match, 519 const char *sub, const char *event, int set) 520 { 521 int ret; 522 523 mutex_lock(&event_mutex); 524 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set); 525 mutex_unlock(&event_mutex); 526 527 return ret; 528 } 529 530 static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set) 531 { 532 char *event = NULL, *sub = NULL, *match; 533 534 /* 535 * The buf format can be <subsystem>:<event-name> 536 * *:<event-name> means any event by that name. 537 * :<event-name> is the same. 538 * 539 * <subsystem>:* means all events in that subsystem 540 * <subsystem>: means the same. 541 * 542 * <name> (no ':') means all events in a subsystem with 543 * the name <name> or any event that matches <name> 544 */ 545 546 match = strsep(&buf, ":"); 547 if (buf) { 548 sub = match; 549 event = buf; 550 match = NULL; 551 552 if (!strlen(sub) || strcmp(sub, "*") == 0) 553 sub = NULL; 554 if (!strlen(event) || strcmp(event, "*") == 0) 555 event = NULL; 556 } 557 558 return __ftrace_set_clr_event(tr, match, sub, event, set); 559 } 560 561 /** 562 * trace_set_clr_event - enable or disable an event 563 * @system: system name to match (NULL for any system) 564 * @event: event name to match (NULL for all events, within system) 565 * @set: 1 to enable, 0 to disable 566 * 567 * This is a way for other parts of the kernel to enable or disable 568 * event recording. 569 * 570 * Returns 0 on success, -EINVAL if the parameters do not match any 571 * registered events. 572 */ 573 int trace_set_clr_event(const char *system, const char *event, int set) 574 { 575 struct trace_array *tr = top_trace_array(); 576 577 if (!tr) 578 return -ENODEV; 579 580 return __ftrace_set_clr_event(tr, NULL, system, event, set); 581 } 582 EXPORT_SYMBOL_GPL(trace_set_clr_event); 583 584 /* 128 should be much more than enough */ 585 #define EVENT_BUF_SIZE 127 586 587 static ssize_t 588 ftrace_event_write(struct file *file, const char __user *ubuf, 589 size_t cnt, loff_t *ppos) 590 { 591 struct trace_parser parser; 592 struct seq_file *m = file->private_data; 593 struct trace_array *tr = m->private; 594 ssize_t read, ret; 595 596 if (!cnt) 597 return 0; 598 599 ret = tracing_update_buffers(); 600 if (ret < 0) 601 return ret; 602 603 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1)) 604 return -ENOMEM; 605 606 read = trace_get_user(&parser, ubuf, cnt, ppos); 607 608 if (read >= 0 && trace_parser_loaded((&parser))) { 609 int set = 1; 610 611 if (*parser.buffer == '!') 612 set = 0; 613 614 parser.buffer[parser.idx] = 0; 615 616 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set); 617 if (ret) 618 goto out_put; 619 } 620 621 ret = read; 622 623 out_put: 624 trace_parser_put(&parser); 625 626 return ret; 627 } 628 629 static void * 630 t_next(struct seq_file *m, void *v, loff_t *pos) 631 { 632 struct ftrace_event_file *file = v; 633 struct ftrace_event_call *call; 634 struct trace_array *tr = m->private; 635 636 (*pos)++; 637 638 list_for_each_entry_continue(file, &tr->events, list) { 639 call = file->event_call; 640 /* 641 * The ftrace subsystem is for showing formats only. 642 * They can not be enabled or disabled via the event files. 643 */ 644 if (call->class && call->class->reg) 645 return file; 646 } 647 648 return NULL; 649 } 650 651 static void *t_start(struct seq_file *m, loff_t *pos) 652 { 653 struct ftrace_event_file *file; 654 struct trace_array *tr = m->private; 655 loff_t l; 656 657 mutex_lock(&event_mutex); 658 659 file = list_entry(&tr->events, struct ftrace_event_file, list); 660 for (l = 0; l <= *pos; ) { 661 file = t_next(m, file, &l); 662 if (!file) 663 break; 664 } 665 return file; 666 } 667 668 static void * 669 s_next(struct seq_file *m, void *v, loff_t *pos) 670 { 671 struct ftrace_event_file *file = v; 672 struct trace_array *tr = m->private; 673 674 (*pos)++; 675 676 list_for_each_entry_continue(file, &tr->events, list) { 677 if (file->flags & FTRACE_EVENT_FL_ENABLED) 678 return file; 679 } 680 681 return NULL; 682 } 683 684 static void *s_start(struct seq_file *m, loff_t *pos) 685 { 686 struct ftrace_event_file *file; 687 struct trace_array *tr = m->private; 688 loff_t l; 689 690 mutex_lock(&event_mutex); 691 692 file = list_entry(&tr->events, struct ftrace_event_file, list); 693 for (l = 0; l <= *pos; ) { 694 file = s_next(m, file, &l); 695 if (!file) 696 break; 697 } 698 return file; 699 } 700 701 static int t_show(struct seq_file *m, void *v) 702 { 703 struct ftrace_event_file *file = v; 704 struct ftrace_event_call *call = file->event_call; 705 706 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) 707 seq_printf(m, "%s:", call->class->system); 708 seq_printf(m, "%s\n", ftrace_event_name(call)); 709 710 return 0; 711 } 712 713 static void t_stop(struct seq_file *m, void *p) 714 { 715 mutex_unlock(&event_mutex); 716 } 717 718 static ssize_t 719 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 720 loff_t *ppos) 721 { 722 struct ftrace_event_file *file; 723 unsigned long flags; 724 char buf[4] = "0"; 725 726 mutex_lock(&event_mutex); 727 file = event_file_data(filp); 728 if (likely(file)) 729 flags = file->flags; 730 mutex_unlock(&event_mutex); 731 732 if (!file) 733 return -ENODEV; 734 735 if (flags & FTRACE_EVENT_FL_ENABLED && 736 !(flags & FTRACE_EVENT_FL_SOFT_DISABLED)) 737 strcpy(buf, "1"); 738 739 if (flags & FTRACE_EVENT_FL_SOFT_DISABLED || 740 flags & FTRACE_EVENT_FL_SOFT_MODE) 741 strcat(buf, "*"); 742 743 strcat(buf, "\n"); 744 745 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf)); 746 } 747 748 static ssize_t 749 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 750 loff_t *ppos) 751 { 752 struct ftrace_event_file *file; 753 unsigned long val; 754 int ret; 755 756 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 757 if (ret) 758 return ret; 759 760 ret = tracing_update_buffers(); 761 if (ret < 0) 762 return ret; 763 764 switch (val) { 765 case 0: 766 case 1: 767 ret = -ENODEV; 768 mutex_lock(&event_mutex); 769 file = event_file_data(filp); 770 if (likely(file)) 771 ret = ftrace_event_enable_disable(file, val); 772 mutex_unlock(&event_mutex); 773 break; 774 775 default: 776 return -EINVAL; 777 } 778 779 *ppos += cnt; 780 781 return ret ? ret : cnt; 782 } 783 784 static ssize_t 785 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 786 loff_t *ppos) 787 { 788 const char set_to_char[4] = { '?', '0', '1', 'X' }; 789 struct ftrace_subsystem_dir *dir = filp->private_data; 790 struct event_subsystem *system = dir->subsystem; 791 struct ftrace_event_call *call; 792 struct ftrace_event_file *file; 793 struct trace_array *tr = dir->tr; 794 char buf[2]; 795 int set = 0; 796 int ret; 797 798 mutex_lock(&event_mutex); 799 list_for_each_entry(file, &tr->events, list) { 800 call = file->event_call; 801 if (!ftrace_event_name(call) || !call->class || !call->class->reg) 802 continue; 803 804 if (system && strcmp(call->class->system, system->name) != 0) 805 continue; 806 807 /* 808 * We need to find out if all the events are set 809 * or if all events or cleared, or if we have 810 * a mixture. 811 */ 812 set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED)); 813 814 /* 815 * If we have a mixture, no need to look further. 816 */ 817 if (set == 3) 818 break; 819 } 820 mutex_unlock(&event_mutex); 821 822 buf[0] = set_to_char[set]; 823 buf[1] = '\n'; 824 825 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2); 826 827 return ret; 828 } 829 830 static ssize_t 831 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 832 loff_t *ppos) 833 { 834 struct ftrace_subsystem_dir *dir = filp->private_data; 835 struct event_subsystem *system = dir->subsystem; 836 const char *name = NULL; 837 unsigned long val; 838 ssize_t ret; 839 840 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 841 if (ret) 842 return ret; 843 844 ret = tracing_update_buffers(); 845 if (ret < 0) 846 return ret; 847 848 if (val != 0 && val != 1) 849 return -EINVAL; 850 851 /* 852 * Opening of "enable" adds a ref count to system, 853 * so the name is safe to use. 854 */ 855 if (system) 856 name = system->name; 857 858 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val); 859 if (ret) 860 goto out; 861 862 ret = cnt; 863 864 out: 865 *ppos += cnt; 866 867 return ret; 868 } 869 870 enum { 871 FORMAT_HEADER = 1, 872 FORMAT_FIELD_SEPERATOR = 2, 873 FORMAT_PRINTFMT = 3, 874 }; 875 876 static void *f_next(struct seq_file *m, void *v, loff_t *pos) 877 { 878 struct ftrace_event_call *call = event_file_data(m->private); 879 struct list_head *common_head = &ftrace_common_fields; 880 struct list_head *head = trace_get_fields(call); 881 struct list_head *node = v; 882 883 (*pos)++; 884 885 switch ((unsigned long)v) { 886 case FORMAT_HEADER: 887 node = common_head; 888 break; 889 890 case FORMAT_FIELD_SEPERATOR: 891 node = head; 892 break; 893 894 case FORMAT_PRINTFMT: 895 /* all done */ 896 return NULL; 897 } 898 899 node = node->prev; 900 if (node == common_head) 901 return (void *)FORMAT_FIELD_SEPERATOR; 902 else if (node == head) 903 return (void *)FORMAT_PRINTFMT; 904 else 905 return node; 906 } 907 908 static int f_show(struct seq_file *m, void *v) 909 { 910 struct ftrace_event_call *call = event_file_data(m->private); 911 struct ftrace_event_field *field; 912 const char *array_descriptor; 913 914 switch ((unsigned long)v) { 915 case FORMAT_HEADER: 916 seq_printf(m, "name: %s\n", ftrace_event_name(call)); 917 seq_printf(m, "ID: %d\n", call->event.type); 918 seq_printf(m, "format:\n"); 919 return 0; 920 921 case FORMAT_FIELD_SEPERATOR: 922 seq_putc(m, '\n'); 923 return 0; 924 925 case FORMAT_PRINTFMT: 926 seq_printf(m, "\nprint fmt: %s\n", 927 call->print_fmt); 928 return 0; 929 } 930 931 field = list_entry(v, struct ftrace_event_field, link); 932 /* 933 * Smartly shows the array type(except dynamic array). 934 * Normal: 935 * field:TYPE VAR 936 * If TYPE := TYPE[LEN], it is shown: 937 * field:TYPE VAR[LEN] 938 */ 939 array_descriptor = strchr(field->type, '['); 940 941 if (!strncmp(field->type, "__data_loc", 10)) 942 array_descriptor = NULL; 943 944 if (!array_descriptor) 945 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 946 field->type, field->name, field->offset, 947 field->size, !!field->is_signed); 948 else 949 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 950 (int)(array_descriptor - field->type), 951 field->type, field->name, 952 array_descriptor, field->offset, 953 field->size, !!field->is_signed); 954 955 return 0; 956 } 957 958 static void *f_start(struct seq_file *m, loff_t *pos) 959 { 960 void *p = (void *)FORMAT_HEADER; 961 loff_t l = 0; 962 963 /* ->stop() is called even if ->start() fails */ 964 mutex_lock(&event_mutex); 965 if (!event_file_data(m->private)) 966 return ERR_PTR(-ENODEV); 967 968 while (l < *pos && p) 969 p = f_next(m, p, &l); 970 971 return p; 972 } 973 974 static void f_stop(struct seq_file *m, void *p) 975 { 976 mutex_unlock(&event_mutex); 977 } 978 979 static const struct seq_operations trace_format_seq_ops = { 980 .start = f_start, 981 .next = f_next, 982 .stop = f_stop, 983 .show = f_show, 984 }; 985 986 static int trace_format_open(struct inode *inode, struct file *file) 987 { 988 struct seq_file *m; 989 int ret; 990 991 ret = seq_open(file, &trace_format_seq_ops); 992 if (ret < 0) 993 return ret; 994 995 m = file->private_data; 996 m->private = file; 997 998 return 0; 999 } 1000 1001 static ssize_t 1002 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1003 { 1004 int id = (long)event_file_data(filp); 1005 char buf[32]; 1006 int len; 1007 1008 if (*ppos) 1009 return 0; 1010 1011 if (unlikely(!id)) 1012 return -ENODEV; 1013 1014 len = sprintf(buf, "%d\n", id); 1015 1016 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len); 1017 } 1018 1019 static ssize_t 1020 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1021 loff_t *ppos) 1022 { 1023 struct ftrace_event_file *file; 1024 struct trace_seq *s; 1025 int r = -ENODEV; 1026 1027 if (*ppos) 1028 return 0; 1029 1030 s = kmalloc(sizeof(*s), GFP_KERNEL); 1031 1032 if (!s) 1033 return -ENOMEM; 1034 1035 trace_seq_init(s); 1036 1037 mutex_lock(&event_mutex); 1038 file = event_file_data(filp); 1039 if (file) 1040 print_event_filter(file, s); 1041 mutex_unlock(&event_mutex); 1042 1043 if (file) 1044 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1045 1046 kfree(s); 1047 1048 return r; 1049 } 1050 1051 static ssize_t 1052 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1053 loff_t *ppos) 1054 { 1055 struct ftrace_event_file *file; 1056 char *buf; 1057 int err = -ENODEV; 1058 1059 if (cnt >= PAGE_SIZE) 1060 return -EINVAL; 1061 1062 buf = (char *)__get_free_page(GFP_TEMPORARY); 1063 if (!buf) 1064 return -ENOMEM; 1065 1066 if (copy_from_user(buf, ubuf, cnt)) { 1067 free_page((unsigned long) buf); 1068 return -EFAULT; 1069 } 1070 buf[cnt] = '\0'; 1071 1072 mutex_lock(&event_mutex); 1073 file = event_file_data(filp); 1074 if (file) 1075 err = apply_event_filter(file, buf); 1076 mutex_unlock(&event_mutex); 1077 1078 free_page((unsigned long) buf); 1079 if (err < 0) 1080 return err; 1081 1082 *ppos += cnt; 1083 1084 return cnt; 1085 } 1086 1087 static LIST_HEAD(event_subsystems); 1088 1089 static int subsystem_open(struct inode *inode, struct file *filp) 1090 { 1091 struct event_subsystem *system = NULL; 1092 struct ftrace_subsystem_dir *dir = NULL; /* Initialize for gcc */ 1093 struct trace_array *tr; 1094 int ret; 1095 1096 if (tracing_is_disabled()) 1097 return -ENODEV; 1098 1099 /* Make sure the system still exists */ 1100 mutex_lock(&trace_types_lock); 1101 mutex_lock(&event_mutex); 1102 list_for_each_entry(tr, &ftrace_trace_arrays, list) { 1103 list_for_each_entry(dir, &tr->systems, list) { 1104 if (dir == inode->i_private) { 1105 /* Don't open systems with no events */ 1106 if (dir->nr_events) { 1107 __get_system_dir(dir); 1108 system = dir->subsystem; 1109 } 1110 goto exit_loop; 1111 } 1112 } 1113 } 1114 exit_loop: 1115 mutex_unlock(&event_mutex); 1116 mutex_unlock(&trace_types_lock); 1117 1118 if (!system) 1119 return -ENODEV; 1120 1121 /* Some versions of gcc think dir can be uninitialized here */ 1122 WARN_ON(!dir); 1123 1124 /* Still need to increment the ref count of the system */ 1125 if (trace_array_get(tr) < 0) { 1126 put_system(dir); 1127 return -ENODEV; 1128 } 1129 1130 ret = tracing_open_generic(inode, filp); 1131 if (ret < 0) { 1132 trace_array_put(tr); 1133 put_system(dir); 1134 } 1135 1136 return ret; 1137 } 1138 1139 static int system_tr_open(struct inode *inode, struct file *filp) 1140 { 1141 struct ftrace_subsystem_dir *dir; 1142 struct trace_array *tr = inode->i_private; 1143 int ret; 1144 1145 if (tracing_is_disabled()) 1146 return -ENODEV; 1147 1148 if (trace_array_get(tr) < 0) 1149 return -ENODEV; 1150 1151 /* Make a temporary dir that has no system but points to tr */ 1152 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1153 if (!dir) { 1154 trace_array_put(tr); 1155 return -ENOMEM; 1156 } 1157 1158 dir->tr = tr; 1159 1160 ret = tracing_open_generic(inode, filp); 1161 if (ret < 0) { 1162 trace_array_put(tr); 1163 kfree(dir); 1164 return ret; 1165 } 1166 1167 filp->private_data = dir; 1168 1169 return 0; 1170 } 1171 1172 static int subsystem_release(struct inode *inode, struct file *file) 1173 { 1174 struct ftrace_subsystem_dir *dir = file->private_data; 1175 1176 trace_array_put(dir->tr); 1177 1178 /* 1179 * If dir->subsystem is NULL, then this is a temporary 1180 * descriptor that was made for a trace_array to enable 1181 * all subsystems. 1182 */ 1183 if (dir->subsystem) 1184 put_system(dir); 1185 else 1186 kfree(dir); 1187 1188 return 0; 1189 } 1190 1191 static ssize_t 1192 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1193 loff_t *ppos) 1194 { 1195 struct ftrace_subsystem_dir *dir = filp->private_data; 1196 struct event_subsystem *system = dir->subsystem; 1197 struct trace_seq *s; 1198 int r; 1199 1200 if (*ppos) 1201 return 0; 1202 1203 s = kmalloc(sizeof(*s), GFP_KERNEL); 1204 if (!s) 1205 return -ENOMEM; 1206 1207 trace_seq_init(s); 1208 1209 print_subsystem_event_filter(system, s); 1210 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1211 1212 kfree(s); 1213 1214 return r; 1215 } 1216 1217 static ssize_t 1218 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1219 loff_t *ppos) 1220 { 1221 struct ftrace_subsystem_dir *dir = filp->private_data; 1222 char *buf; 1223 int err; 1224 1225 if (cnt >= PAGE_SIZE) 1226 return -EINVAL; 1227 1228 buf = (char *)__get_free_page(GFP_TEMPORARY); 1229 if (!buf) 1230 return -ENOMEM; 1231 1232 if (copy_from_user(buf, ubuf, cnt)) { 1233 free_page((unsigned long) buf); 1234 return -EFAULT; 1235 } 1236 buf[cnt] = '\0'; 1237 1238 err = apply_subsystem_event_filter(dir, buf); 1239 free_page((unsigned long) buf); 1240 if (err < 0) 1241 return err; 1242 1243 *ppos += cnt; 1244 1245 return cnt; 1246 } 1247 1248 static ssize_t 1249 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1250 { 1251 int (*func)(struct trace_seq *s) = filp->private_data; 1252 struct trace_seq *s; 1253 int r; 1254 1255 if (*ppos) 1256 return 0; 1257 1258 s = kmalloc(sizeof(*s), GFP_KERNEL); 1259 if (!s) 1260 return -ENOMEM; 1261 1262 trace_seq_init(s); 1263 1264 func(s); 1265 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1266 1267 kfree(s); 1268 1269 return r; 1270 } 1271 1272 static int ftrace_event_avail_open(struct inode *inode, struct file *file); 1273 static int ftrace_event_set_open(struct inode *inode, struct file *file); 1274 static int ftrace_event_release(struct inode *inode, struct file *file); 1275 1276 static const struct seq_operations show_event_seq_ops = { 1277 .start = t_start, 1278 .next = t_next, 1279 .show = t_show, 1280 .stop = t_stop, 1281 }; 1282 1283 static const struct seq_operations show_set_event_seq_ops = { 1284 .start = s_start, 1285 .next = s_next, 1286 .show = t_show, 1287 .stop = t_stop, 1288 }; 1289 1290 static const struct file_operations ftrace_avail_fops = { 1291 .open = ftrace_event_avail_open, 1292 .read = seq_read, 1293 .llseek = seq_lseek, 1294 .release = seq_release, 1295 }; 1296 1297 static const struct file_operations ftrace_set_event_fops = { 1298 .open = ftrace_event_set_open, 1299 .read = seq_read, 1300 .write = ftrace_event_write, 1301 .llseek = seq_lseek, 1302 .release = ftrace_event_release, 1303 }; 1304 1305 static const struct file_operations ftrace_enable_fops = { 1306 .open = tracing_open_generic, 1307 .read = event_enable_read, 1308 .write = event_enable_write, 1309 .llseek = default_llseek, 1310 }; 1311 1312 static const struct file_operations ftrace_event_format_fops = { 1313 .open = trace_format_open, 1314 .read = seq_read, 1315 .llseek = seq_lseek, 1316 .release = seq_release, 1317 }; 1318 1319 static const struct file_operations ftrace_event_id_fops = { 1320 .read = event_id_read, 1321 .llseek = default_llseek, 1322 }; 1323 1324 static const struct file_operations ftrace_event_filter_fops = { 1325 .open = tracing_open_generic, 1326 .read = event_filter_read, 1327 .write = event_filter_write, 1328 .llseek = default_llseek, 1329 }; 1330 1331 static const struct file_operations ftrace_subsystem_filter_fops = { 1332 .open = subsystem_open, 1333 .read = subsystem_filter_read, 1334 .write = subsystem_filter_write, 1335 .llseek = default_llseek, 1336 .release = subsystem_release, 1337 }; 1338 1339 static const struct file_operations ftrace_system_enable_fops = { 1340 .open = subsystem_open, 1341 .read = system_enable_read, 1342 .write = system_enable_write, 1343 .llseek = default_llseek, 1344 .release = subsystem_release, 1345 }; 1346 1347 static const struct file_operations ftrace_tr_enable_fops = { 1348 .open = system_tr_open, 1349 .read = system_enable_read, 1350 .write = system_enable_write, 1351 .llseek = default_llseek, 1352 .release = subsystem_release, 1353 }; 1354 1355 static const struct file_operations ftrace_show_header_fops = { 1356 .open = tracing_open_generic, 1357 .read = show_header, 1358 .llseek = default_llseek, 1359 }; 1360 1361 static int 1362 ftrace_event_open(struct inode *inode, struct file *file, 1363 const struct seq_operations *seq_ops) 1364 { 1365 struct seq_file *m; 1366 int ret; 1367 1368 ret = seq_open(file, seq_ops); 1369 if (ret < 0) 1370 return ret; 1371 m = file->private_data; 1372 /* copy tr over to seq ops */ 1373 m->private = inode->i_private; 1374 1375 return ret; 1376 } 1377 1378 static int ftrace_event_release(struct inode *inode, struct file *file) 1379 { 1380 struct trace_array *tr = inode->i_private; 1381 1382 trace_array_put(tr); 1383 1384 return seq_release(inode, file); 1385 } 1386 1387 static int 1388 ftrace_event_avail_open(struct inode *inode, struct file *file) 1389 { 1390 const struct seq_operations *seq_ops = &show_event_seq_ops; 1391 1392 return ftrace_event_open(inode, file, seq_ops); 1393 } 1394 1395 static int 1396 ftrace_event_set_open(struct inode *inode, struct file *file) 1397 { 1398 const struct seq_operations *seq_ops = &show_set_event_seq_ops; 1399 struct trace_array *tr = inode->i_private; 1400 int ret; 1401 1402 if (trace_array_get(tr) < 0) 1403 return -ENODEV; 1404 1405 if ((file->f_mode & FMODE_WRITE) && 1406 (file->f_flags & O_TRUNC)) 1407 ftrace_clear_events(tr); 1408 1409 ret = ftrace_event_open(inode, file, seq_ops); 1410 if (ret < 0) 1411 trace_array_put(tr); 1412 return ret; 1413 } 1414 1415 static struct event_subsystem * 1416 create_new_subsystem(const char *name) 1417 { 1418 struct event_subsystem *system; 1419 1420 /* need to create new entry */ 1421 system = kmalloc(sizeof(*system), GFP_KERNEL); 1422 if (!system) 1423 return NULL; 1424 1425 system->ref_count = 1; 1426 1427 /* Only allocate if dynamic (kprobes and modules) */ 1428 if (!core_kernel_data((unsigned long)name)) { 1429 system->ref_count |= SYSTEM_FL_FREE_NAME; 1430 system->name = kstrdup(name, GFP_KERNEL); 1431 if (!system->name) 1432 goto out_free; 1433 } else 1434 system->name = name; 1435 1436 system->filter = NULL; 1437 1438 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL); 1439 if (!system->filter) 1440 goto out_free; 1441 1442 list_add(&system->list, &event_subsystems); 1443 1444 return system; 1445 1446 out_free: 1447 if (system->ref_count & SYSTEM_FL_FREE_NAME) 1448 kfree(system->name); 1449 kfree(system); 1450 return NULL; 1451 } 1452 1453 static struct dentry * 1454 event_subsystem_dir(struct trace_array *tr, const char *name, 1455 struct ftrace_event_file *file, struct dentry *parent) 1456 { 1457 struct ftrace_subsystem_dir *dir; 1458 struct event_subsystem *system; 1459 struct dentry *entry; 1460 1461 /* First see if we did not already create this dir */ 1462 list_for_each_entry(dir, &tr->systems, list) { 1463 system = dir->subsystem; 1464 if (strcmp(system->name, name) == 0) { 1465 dir->nr_events++; 1466 file->system = dir; 1467 return dir->entry; 1468 } 1469 } 1470 1471 /* Now see if the system itself exists. */ 1472 list_for_each_entry(system, &event_subsystems, list) { 1473 if (strcmp(system->name, name) == 0) 1474 break; 1475 } 1476 /* Reset system variable when not found */ 1477 if (&system->list == &event_subsystems) 1478 system = NULL; 1479 1480 dir = kmalloc(sizeof(*dir), GFP_KERNEL); 1481 if (!dir) 1482 goto out_fail; 1483 1484 if (!system) { 1485 system = create_new_subsystem(name); 1486 if (!system) 1487 goto out_free; 1488 } else 1489 __get_system(system); 1490 1491 dir->entry = debugfs_create_dir(name, parent); 1492 if (!dir->entry) { 1493 pr_warning("Failed to create system directory %s\n", name); 1494 __put_system(system); 1495 goto out_free; 1496 } 1497 1498 dir->tr = tr; 1499 dir->ref_count = 1; 1500 dir->nr_events = 1; 1501 dir->subsystem = system; 1502 file->system = dir; 1503 1504 entry = debugfs_create_file("filter", 0644, dir->entry, dir, 1505 &ftrace_subsystem_filter_fops); 1506 if (!entry) { 1507 kfree(system->filter); 1508 system->filter = NULL; 1509 pr_warning("Could not create debugfs '%s/filter' entry\n", name); 1510 } 1511 1512 trace_create_file("enable", 0644, dir->entry, dir, 1513 &ftrace_system_enable_fops); 1514 1515 list_add(&dir->list, &tr->systems); 1516 1517 return dir->entry; 1518 1519 out_free: 1520 kfree(dir); 1521 out_fail: 1522 /* Only print this message if failed on memory allocation */ 1523 if (!dir || !system) 1524 pr_warning("No memory to create event subsystem %s\n", 1525 name); 1526 return NULL; 1527 } 1528 1529 static int 1530 event_create_dir(struct dentry *parent, struct ftrace_event_file *file) 1531 { 1532 struct ftrace_event_call *call = file->event_call; 1533 struct trace_array *tr = file->tr; 1534 struct list_head *head; 1535 struct dentry *d_events; 1536 const char *name; 1537 int ret; 1538 1539 /* 1540 * If the trace point header did not define TRACE_SYSTEM 1541 * then the system would be called "TRACE_SYSTEM". 1542 */ 1543 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) { 1544 d_events = event_subsystem_dir(tr, call->class->system, file, parent); 1545 if (!d_events) 1546 return -ENOMEM; 1547 } else 1548 d_events = parent; 1549 1550 name = ftrace_event_name(call); 1551 file->dir = debugfs_create_dir(name, d_events); 1552 if (!file->dir) { 1553 pr_warning("Could not create debugfs '%s' directory\n", 1554 name); 1555 return -1; 1556 } 1557 1558 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) 1559 trace_create_file("enable", 0644, file->dir, file, 1560 &ftrace_enable_fops); 1561 1562 #ifdef CONFIG_PERF_EVENTS 1563 if (call->event.type && call->class->reg) 1564 trace_create_file("id", 0444, file->dir, 1565 (void *)(long)call->event.type, 1566 &ftrace_event_id_fops); 1567 #endif 1568 1569 /* 1570 * Other events may have the same class. Only update 1571 * the fields if they are not already defined. 1572 */ 1573 head = trace_get_fields(call); 1574 if (list_empty(head)) { 1575 ret = call->class->define_fields(call); 1576 if (ret < 0) { 1577 pr_warning("Could not initialize trace point" 1578 " events/%s\n", name); 1579 return -1; 1580 } 1581 } 1582 trace_create_file("filter", 0644, file->dir, file, 1583 &ftrace_event_filter_fops); 1584 1585 trace_create_file("trigger", 0644, file->dir, file, 1586 &event_trigger_fops); 1587 1588 trace_create_file("format", 0444, file->dir, call, 1589 &ftrace_event_format_fops); 1590 1591 return 0; 1592 } 1593 1594 static void remove_event_from_tracers(struct ftrace_event_call *call) 1595 { 1596 struct ftrace_event_file *file; 1597 struct trace_array *tr; 1598 1599 do_for_each_event_file_safe(tr, file) { 1600 if (file->event_call != call) 1601 continue; 1602 1603 remove_event_file_dir(file); 1604 /* 1605 * The do_for_each_event_file_safe() is 1606 * a double loop. After finding the call for this 1607 * trace_array, we use break to jump to the next 1608 * trace_array. 1609 */ 1610 break; 1611 } while_for_each_event_file(); 1612 } 1613 1614 static void event_remove(struct ftrace_event_call *call) 1615 { 1616 struct trace_array *tr; 1617 struct ftrace_event_file *file; 1618 1619 do_for_each_event_file(tr, file) { 1620 if (file->event_call != call) 1621 continue; 1622 ftrace_event_enable_disable(file, 0); 1623 destroy_preds(file); 1624 /* 1625 * The do_for_each_event_file() is 1626 * a double loop. After finding the call for this 1627 * trace_array, we use break to jump to the next 1628 * trace_array. 1629 */ 1630 break; 1631 } while_for_each_event_file(); 1632 1633 if (call->event.funcs) 1634 __unregister_ftrace_event(&call->event); 1635 remove_event_from_tracers(call); 1636 list_del(&call->list); 1637 } 1638 1639 static int event_init(struct ftrace_event_call *call) 1640 { 1641 int ret = 0; 1642 const char *name; 1643 1644 name = ftrace_event_name(call); 1645 if (WARN_ON(!name)) 1646 return -EINVAL; 1647 1648 if (call->class->raw_init) { 1649 ret = call->class->raw_init(call); 1650 if (ret < 0 && ret != -ENOSYS) 1651 pr_warn("Could not initialize trace events/%s\n", 1652 name); 1653 } 1654 1655 return ret; 1656 } 1657 1658 static int 1659 __register_event(struct ftrace_event_call *call, struct module *mod) 1660 { 1661 int ret; 1662 1663 ret = event_init(call); 1664 if (ret < 0) 1665 return ret; 1666 1667 list_add(&call->list, &ftrace_events); 1668 call->mod = mod; 1669 1670 return 0; 1671 } 1672 1673 static struct ftrace_event_file * 1674 trace_create_new_event(struct ftrace_event_call *call, 1675 struct trace_array *tr) 1676 { 1677 struct ftrace_event_file *file; 1678 1679 file = kmem_cache_alloc(file_cachep, GFP_TRACE); 1680 if (!file) 1681 return NULL; 1682 1683 file->event_call = call; 1684 file->tr = tr; 1685 atomic_set(&file->sm_ref, 0); 1686 atomic_set(&file->tm_ref, 0); 1687 INIT_LIST_HEAD(&file->triggers); 1688 list_add(&file->list, &tr->events); 1689 1690 return file; 1691 } 1692 1693 /* Add an event to a trace directory */ 1694 static int 1695 __trace_add_new_event(struct ftrace_event_call *call, struct trace_array *tr) 1696 { 1697 struct ftrace_event_file *file; 1698 1699 file = trace_create_new_event(call, tr); 1700 if (!file) 1701 return -ENOMEM; 1702 1703 return event_create_dir(tr->event_dir, file); 1704 } 1705 1706 /* 1707 * Just create a decriptor for early init. A descriptor is required 1708 * for enabling events at boot. We want to enable events before 1709 * the filesystem is initialized. 1710 */ 1711 static __init int 1712 __trace_early_add_new_event(struct ftrace_event_call *call, 1713 struct trace_array *tr) 1714 { 1715 struct ftrace_event_file *file; 1716 1717 file = trace_create_new_event(call, tr); 1718 if (!file) 1719 return -ENOMEM; 1720 1721 return 0; 1722 } 1723 1724 struct ftrace_module_file_ops; 1725 static void __add_event_to_tracers(struct ftrace_event_call *call); 1726 1727 /* Add an additional event_call dynamically */ 1728 int trace_add_event_call(struct ftrace_event_call *call) 1729 { 1730 int ret; 1731 mutex_lock(&trace_types_lock); 1732 mutex_lock(&event_mutex); 1733 1734 ret = __register_event(call, NULL); 1735 if (ret >= 0) 1736 __add_event_to_tracers(call); 1737 1738 mutex_unlock(&event_mutex); 1739 mutex_unlock(&trace_types_lock); 1740 return ret; 1741 } 1742 1743 /* 1744 * Must be called under locking of trace_types_lock, event_mutex and 1745 * trace_event_sem. 1746 */ 1747 static void __trace_remove_event_call(struct ftrace_event_call *call) 1748 { 1749 event_remove(call); 1750 trace_destroy_fields(call); 1751 destroy_call_preds(call); 1752 } 1753 1754 static int probe_remove_event_call(struct ftrace_event_call *call) 1755 { 1756 struct trace_array *tr; 1757 struct ftrace_event_file *file; 1758 1759 #ifdef CONFIG_PERF_EVENTS 1760 if (call->perf_refcount) 1761 return -EBUSY; 1762 #endif 1763 do_for_each_event_file(tr, file) { 1764 if (file->event_call != call) 1765 continue; 1766 /* 1767 * We can't rely on ftrace_event_enable_disable(enable => 0) 1768 * we are going to do, FTRACE_EVENT_FL_SOFT_MODE can suppress 1769 * TRACE_REG_UNREGISTER. 1770 */ 1771 if (file->flags & FTRACE_EVENT_FL_ENABLED) 1772 return -EBUSY; 1773 /* 1774 * The do_for_each_event_file_safe() is 1775 * a double loop. After finding the call for this 1776 * trace_array, we use break to jump to the next 1777 * trace_array. 1778 */ 1779 break; 1780 } while_for_each_event_file(); 1781 1782 __trace_remove_event_call(call); 1783 1784 return 0; 1785 } 1786 1787 /* Remove an event_call */ 1788 int trace_remove_event_call(struct ftrace_event_call *call) 1789 { 1790 int ret; 1791 1792 mutex_lock(&trace_types_lock); 1793 mutex_lock(&event_mutex); 1794 down_write(&trace_event_sem); 1795 ret = probe_remove_event_call(call); 1796 up_write(&trace_event_sem); 1797 mutex_unlock(&event_mutex); 1798 mutex_unlock(&trace_types_lock); 1799 1800 return ret; 1801 } 1802 1803 #define for_each_event(event, start, end) \ 1804 for (event = start; \ 1805 (unsigned long)event < (unsigned long)end; \ 1806 event++) 1807 1808 #ifdef CONFIG_MODULES 1809 1810 static void trace_module_add_events(struct module *mod) 1811 { 1812 struct ftrace_event_call **call, **start, **end; 1813 1814 if (!mod->num_trace_events) 1815 return; 1816 1817 /* Don't add infrastructure for mods without tracepoints */ 1818 if (trace_module_has_bad_taint(mod)) { 1819 pr_err("%s: module has bad taint, not creating trace events\n", 1820 mod->name); 1821 return; 1822 } 1823 1824 start = mod->trace_events; 1825 end = mod->trace_events + mod->num_trace_events; 1826 1827 for_each_event(call, start, end) { 1828 __register_event(*call, mod); 1829 __add_event_to_tracers(*call); 1830 } 1831 } 1832 1833 static void trace_module_remove_events(struct module *mod) 1834 { 1835 struct ftrace_event_call *call, *p; 1836 bool clear_trace = false; 1837 1838 down_write(&trace_event_sem); 1839 list_for_each_entry_safe(call, p, &ftrace_events, list) { 1840 if (call->mod == mod) { 1841 if (call->flags & TRACE_EVENT_FL_WAS_ENABLED) 1842 clear_trace = true; 1843 __trace_remove_event_call(call); 1844 } 1845 } 1846 up_write(&trace_event_sem); 1847 1848 /* 1849 * It is safest to reset the ring buffer if the module being unloaded 1850 * registered any events that were used. The only worry is if 1851 * a new module gets loaded, and takes on the same id as the events 1852 * of this module. When printing out the buffer, traced events left 1853 * over from this module may be passed to the new module events and 1854 * unexpected results may occur. 1855 */ 1856 if (clear_trace) 1857 tracing_reset_all_online_cpus(); 1858 } 1859 1860 static int trace_module_notify(struct notifier_block *self, 1861 unsigned long val, void *data) 1862 { 1863 struct module *mod = data; 1864 1865 mutex_lock(&trace_types_lock); 1866 mutex_lock(&event_mutex); 1867 switch (val) { 1868 case MODULE_STATE_COMING: 1869 trace_module_add_events(mod); 1870 break; 1871 case MODULE_STATE_GOING: 1872 trace_module_remove_events(mod); 1873 break; 1874 } 1875 mutex_unlock(&event_mutex); 1876 mutex_unlock(&trace_types_lock); 1877 1878 return 0; 1879 } 1880 1881 static struct notifier_block trace_module_nb = { 1882 .notifier_call = trace_module_notify, 1883 .priority = 0, 1884 }; 1885 #endif /* CONFIG_MODULES */ 1886 1887 /* Create a new event directory structure for a trace directory. */ 1888 static void 1889 __trace_add_event_dirs(struct trace_array *tr) 1890 { 1891 struct ftrace_event_call *call; 1892 int ret; 1893 1894 list_for_each_entry(call, &ftrace_events, list) { 1895 ret = __trace_add_new_event(call, tr); 1896 if (ret < 0) 1897 pr_warning("Could not create directory for event %s\n", 1898 ftrace_event_name(call)); 1899 } 1900 } 1901 1902 struct ftrace_event_file * 1903 find_event_file(struct trace_array *tr, const char *system, const char *event) 1904 { 1905 struct ftrace_event_file *file; 1906 struct ftrace_event_call *call; 1907 const char *name; 1908 1909 list_for_each_entry(file, &tr->events, list) { 1910 1911 call = file->event_call; 1912 name = ftrace_event_name(call); 1913 1914 if (!name || !call->class || !call->class->reg) 1915 continue; 1916 1917 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) 1918 continue; 1919 1920 if (strcmp(event, name) == 0 && 1921 strcmp(system, call->class->system) == 0) 1922 return file; 1923 } 1924 return NULL; 1925 } 1926 1927 #ifdef CONFIG_DYNAMIC_FTRACE 1928 1929 /* Avoid typos */ 1930 #define ENABLE_EVENT_STR "enable_event" 1931 #define DISABLE_EVENT_STR "disable_event" 1932 1933 struct event_probe_data { 1934 struct ftrace_event_file *file; 1935 unsigned long count; 1936 int ref; 1937 bool enable; 1938 }; 1939 1940 static void 1941 event_enable_probe(unsigned long ip, unsigned long parent_ip, void **_data) 1942 { 1943 struct event_probe_data **pdata = (struct event_probe_data **)_data; 1944 struct event_probe_data *data = *pdata; 1945 1946 if (!data) 1947 return; 1948 1949 if (data->enable) 1950 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags); 1951 else 1952 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags); 1953 } 1954 1955 static void 1956 event_enable_count_probe(unsigned long ip, unsigned long parent_ip, void **_data) 1957 { 1958 struct event_probe_data **pdata = (struct event_probe_data **)_data; 1959 struct event_probe_data *data = *pdata; 1960 1961 if (!data) 1962 return; 1963 1964 if (!data->count) 1965 return; 1966 1967 /* Skip if the event is in a state we want to switch to */ 1968 if (data->enable == !(data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED)) 1969 return; 1970 1971 if (data->count != -1) 1972 (data->count)--; 1973 1974 event_enable_probe(ip, parent_ip, _data); 1975 } 1976 1977 static int 1978 event_enable_print(struct seq_file *m, unsigned long ip, 1979 struct ftrace_probe_ops *ops, void *_data) 1980 { 1981 struct event_probe_data *data = _data; 1982 1983 seq_printf(m, "%ps:", (void *)ip); 1984 1985 seq_printf(m, "%s:%s:%s", 1986 data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR, 1987 data->file->event_call->class->system, 1988 ftrace_event_name(data->file->event_call)); 1989 1990 if (data->count == -1) 1991 seq_printf(m, ":unlimited\n"); 1992 else 1993 seq_printf(m, ":count=%ld\n", data->count); 1994 1995 return 0; 1996 } 1997 1998 static int 1999 event_enable_init(struct ftrace_probe_ops *ops, unsigned long ip, 2000 void **_data) 2001 { 2002 struct event_probe_data **pdata = (struct event_probe_data **)_data; 2003 struct event_probe_data *data = *pdata; 2004 2005 data->ref++; 2006 return 0; 2007 } 2008 2009 static void 2010 event_enable_free(struct ftrace_probe_ops *ops, unsigned long ip, 2011 void **_data) 2012 { 2013 struct event_probe_data **pdata = (struct event_probe_data **)_data; 2014 struct event_probe_data *data = *pdata; 2015 2016 if (WARN_ON_ONCE(data->ref <= 0)) 2017 return; 2018 2019 data->ref--; 2020 if (!data->ref) { 2021 /* Remove the SOFT_MODE flag */ 2022 __ftrace_event_enable_disable(data->file, 0, 1); 2023 module_put(data->file->event_call->mod); 2024 kfree(data); 2025 } 2026 *pdata = NULL; 2027 } 2028 2029 static struct ftrace_probe_ops event_enable_probe_ops = { 2030 .func = event_enable_probe, 2031 .print = event_enable_print, 2032 .init = event_enable_init, 2033 .free = event_enable_free, 2034 }; 2035 2036 static struct ftrace_probe_ops event_enable_count_probe_ops = { 2037 .func = event_enable_count_probe, 2038 .print = event_enable_print, 2039 .init = event_enable_init, 2040 .free = event_enable_free, 2041 }; 2042 2043 static struct ftrace_probe_ops event_disable_probe_ops = { 2044 .func = event_enable_probe, 2045 .print = event_enable_print, 2046 .init = event_enable_init, 2047 .free = event_enable_free, 2048 }; 2049 2050 static struct ftrace_probe_ops event_disable_count_probe_ops = { 2051 .func = event_enable_count_probe, 2052 .print = event_enable_print, 2053 .init = event_enable_init, 2054 .free = event_enable_free, 2055 }; 2056 2057 static int 2058 event_enable_func(struct ftrace_hash *hash, 2059 char *glob, char *cmd, char *param, int enabled) 2060 { 2061 struct trace_array *tr = top_trace_array(); 2062 struct ftrace_event_file *file; 2063 struct ftrace_probe_ops *ops; 2064 struct event_probe_data *data; 2065 const char *system; 2066 const char *event; 2067 char *number; 2068 bool enable; 2069 int ret; 2070 2071 if (!tr) 2072 return -ENODEV; 2073 2074 /* hash funcs only work with set_ftrace_filter */ 2075 if (!enabled || !param) 2076 return -EINVAL; 2077 2078 system = strsep(¶m, ":"); 2079 if (!param) 2080 return -EINVAL; 2081 2082 event = strsep(¶m, ":"); 2083 2084 mutex_lock(&event_mutex); 2085 2086 ret = -EINVAL; 2087 file = find_event_file(tr, system, event); 2088 if (!file) 2089 goto out; 2090 2091 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0; 2092 2093 if (enable) 2094 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops; 2095 else 2096 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops; 2097 2098 if (glob[0] == '!') { 2099 unregister_ftrace_function_probe_func(glob+1, ops); 2100 ret = 0; 2101 goto out; 2102 } 2103 2104 ret = -ENOMEM; 2105 data = kzalloc(sizeof(*data), GFP_KERNEL); 2106 if (!data) 2107 goto out; 2108 2109 data->enable = enable; 2110 data->count = -1; 2111 data->file = file; 2112 2113 if (!param) 2114 goto out_reg; 2115 2116 number = strsep(¶m, ":"); 2117 2118 ret = -EINVAL; 2119 if (!strlen(number)) 2120 goto out_free; 2121 2122 /* 2123 * We use the callback data field (which is a pointer) 2124 * as our counter. 2125 */ 2126 ret = kstrtoul(number, 0, &data->count); 2127 if (ret) 2128 goto out_free; 2129 2130 out_reg: 2131 /* Don't let event modules unload while probe registered */ 2132 ret = try_module_get(file->event_call->mod); 2133 if (!ret) { 2134 ret = -EBUSY; 2135 goto out_free; 2136 } 2137 2138 ret = __ftrace_event_enable_disable(file, 1, 1); 2139 if (ret < 0) 2140 goto out_put; 2141 ret = register_ftrace_function_probe(glob, ops, data); 2142 /* 2143 * The above returns on success the # of functions enabled, 2144 * but if it didn't find any functions it returns zero. 2145 * Consider no functions a failure too. 2146 */ 2147 if (!ret) { 2148 ret = -ENOENT; 2149 goto out_disable; 2150 } else if (ret < 0) 2151 goto out_disable; 2152 /* Just return zero, not the number of enabled functions */ 2153 ret = 0; 2154 out: 2155 mutex_unlock(&event_mutex); 2156 return ret; 2157 2158 out_disable: 2159 __ftrace_event_enable_disable(file, 0, 1); 2160 out_put: 2161 module_put(file->event_call->mod); 2162 out_free: 2163 kfree(data); 2164 goto out; 2165 } 2166 2167 static struct ftrace_func_command event_enable_cmd = { 2168 .name = ENABLE_EVENT_STR, 2169 .func = event_enable_func, 2170 }; 2171 2172 static struct ftrace_func_command event_disable_cmd = { 2173 .name = DISABLE_EVENT_STR, 2174 .func = event_enable_func, 2175 }; 2176 2177 static __init int register_event_cmds(void) 2178 { 2179 int ret; 2180 2181 ret = register_ftrace_command(&event_enable_cmd); 2182 if (WARN_ON(ret < 0)) 2183 return ret; 2184 ret = register_ftrace_command(&event_disable_cmd); 2185 if (WARN_ON(ret < 0)) 2186 unregister_ftrace_command(&event_enable_cmd); 2187 return ret; 2188 } 2189 #else 2190 static inline int register_event_cmds(void) { return 0; } 2191 #endif /* CONFIG_DYNAMIC_FTRACE */ 2192 2193 /* 2194 * The top level array has already had its ftrace_event_file 2195 * descriptors created in order to allow for early events to 2196 * be recorded. This function is called after the debugfs has been 2197 * initialized, and we now have to create the files associated 2198 * to the events. 2199 */ 2200 static __init void 2201 __trace_early_add_event_dirs(struct trace_array *tr) 2202 { 2203 struct ftrace_event_file *file; 2204 int ret; 2205 2206 2207 list_for_each_entry(file, &tr->events, list) { 2208 ret = event_create_dir(tr->event_dir, file); 2209 if (ret < 0) 2210 pr_warning("Could not create directory for event %s\n", 2211 ftrace_event_name(file->event_call)); 2212 } 2213 } 2214 2215 /* 2216 * For early boot up, the top trace array requires to have 2217 * a list of events that can be enabled. This must be done before 2218 * the filesystem is set up in order to allow events to be traced 2219 * early. 2220 */ 2221 static __init void 2222 __trace_early_add_events(struct trace_array *tr) 2223 { 2224 struct ftrace_event_call *call; 2225 int ret; 2226 2227 list_for_each_entry(call, &ftrace_events, list) { 2228 /* Early boot up should not have any modules loaded */ 2229 if (WARN_ON_ONCE(call->mod)) 2230 continue; 2231 2232 ret = __trace_early_add_new_event(call, tr); 2233 if (ret < 0) 2234 pr_warning("Could not create early event %s\n", 2235 ftrace_event_name(call)); 2236 } 2237 } 2238 2239 /* Remove the event directory structure for a trace directory. */ 2240 static void 2241 __trace_remove_event_dirs(struct trace_array *tr) 2242 { 2243 struct ftrace_event_file *file, *next; 2244 2245 list_for_each_entry_safe(file, next, &tr->events, list) 2246 remove_event_file_dir(file); 2247 } 2248 2249 static void __add_event_to_tracers(struct ftrace_event_call *call) 2250 { 2251 struct trace_array *tr; 2252 2253 list_for_each_entry(tr, &ftrace_trace_arrays, list) 2254 __trace_add_new_event(call, tr); 2255 } 2256 2257 extern struct ftrace_event_call *__start_ftrace_events[]; 2258 extern struct ftrace_event_call *__stop_ftrace_events[]; 2259 2260 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata; 2261 2262 static __init int setup_trace_event(char *str) 2263 { 2264 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE); 2265 ring_buffer_expanded = true; 2266 tracing_selftest_disabled = true; 2267 2268 return 1; 2269 } 2270 __setup("trace_event=", setup_trace_event); 2271 2272 /* Expects to have event_mutex held when called */ 2273 static int 2274 create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) 2275 { 2276 struct dentry *d_events; 2277 struct dentry *entry; 2278 2279 entry = debugfs_create_file("set_event", 0644, parent, 2280 tr, &ftrace_set_event_fops); 2281 if (!entry) { 2282 pr_warning("Could not create debugfs 'set_event' entry\n"); 2283 return -ENOMEM; 2284 } 2285 2286 d_events = debugfs_create_dir("events", parent); 2287 if (!d_events) { 2288 pr_warning("Could not create debugfs 'events' directory\n"); 2289 return -ENOMEM; 2290 } 2291 2292 /* ring buffer internal formats */ 2293 trace_create_file("header_page", 0444, d_events, 2294 ring_buffer_print_page_header, 2295 &ftrace_show_header_fops); 2296 2297 trace_create_file("header_event", 0444, d_events, 2298 ring_buffer_print_entry_header, 2299 &ftrace_show_header_fops); 2300 2301 trace_create_file("enable", 0644, d_events, 2302 tr, &ftrace_tr_enable_fops); 2303 2304 tr->event_dir = d_events; 2305 2306 return 0; 2307 } 2308 2309 /** 2310 * event_trace_add_tracer - add a instance of a trace_array to events 2311 * @parent: The parent dentry to place the files/directories for events in 2312 * @tr: The trace array associated with these events 2313 * 2314 * When a new instance is created, it needs to set up its events 2315 * directory, as well as other files associated with events. It also 2316 * creates the event hierachry in the @parent/events directory. 2317 * 2318 * Returns 0 on success. 2319 */ 2320 int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr) 2321 { 2322 int ret; 2323 2324 mutex_lock(&event_mutex); 2325 2326 ret = create_event_toplevel_files(parent, tr); 2327 if (ret) 2328 goto out_unlock; 2329 2330 down_write(&trace_event_sem); 2331 __trace_add_event_dirs(tr); 2332 up_write(&trace_event_sem); 2333 2334 out_unlock: 2335 mutex_unlock(&event_mutex); 2336 2337 return ret; 2338 } 2339 2340 /* 2341 * The top trace array already had its file descriptors created. 2342 * Now the files themselves need to be created. 2343 */ 2344 static __init int 2345 early_event_add_tracer(struct dentry *parent, struct trace_array *tr) 2346 { 2347 int ret; 2348 2349 mutex_lock(&event_mutex); 2350 2351 ret = create_event_toplevel_files(parent, tr); 2352 if (ret) 2353 goto out_unlock; 2354 2355 down_write(&trace_event_sem); 2356 __trace_early_add_event_dirs(tr); 2357 up_write(&trace_event_sem); 2358 2359 out_unlock: 2360 mutex_unlock(&event_mutex); 2361 2362 return ret; 2363 } 2364 2365 int event_trace_del_tracer(struct trace_array *tr) 2366 { 2367 mutex_lock(&event_mutex); 2368 2369 /* Disable any event triggers and associated soft-disabled events */ 2370 clear_event_triggers(tr); 2371 2372 /* Disable any running events */ 2373 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0); 2374 2375 /* Access to events are within rcu_read_lock_sched() */ 2376 synchronize_sched(); 2377 2378 down_write(&trace_event_sem); 2379 __trace_remove_event_dirs(tr); 2380 debugfs_remove_recursive(tr->event_dir); 2381 up_write(&trace_event_sem); 2382 2383 tr->event_dir = NULL; 2384 2385 mutex_unlock(&event_mutex); 2386 2387 return 0; 2388 } 2389 2390 static __init int event_trace_memsetup(void) 2391 { 2392 field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC); 2393 file_cachep = KMEM_CACHE(ftrace_event_file, SLAB_PANIC); 2394 return 0; 2395 } 2396 2397 static __init int event_trace_enable(void) 2398 { 2399 struct trace_array *tr = top_trace_array(); 2400 struct ftrace_event_call **iter, *call; 2401 char *buf = bootup_event_buf; 2402 char *token; 2403 int ret; 2404 2405 if (!tr) 2406 return -ENODEV; 2407 2408 for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) { 2409 2410 call = *iter; 2411 ret = event_init(call); 2412 if (!ret) 2413 list_add(&call->list, &ftrace_events); 2414 } 2415 2416 /* 2417 * We need the top trace array to have a working set of trace 2418 * points at early init, before the debug files and directories 2419 * are created. Create the file entries now, and attach them 2420 * to the actual file dentries later. 2421 */ 2422 __trace_early_add_events(tr); 2423 2424 while (true) { 2425 token = strsep(&buf, ","); 2426 2427 if (!token) 2428 break; 2429 if (!*token) 2430 continue; 2431 2432 ret = ftrace_set_clr_event(tr, token, 1); 2433 if (ret) 2434 pr_warn("Failed to enable trace event: %s\n", token); 2435 } 2436 2437 trace_printk_start_comm(); 2438 2439 register_event_cmds(); 2440 2441 register_trigger_cmds(); 2442 2443 return 0; 2444 } 2445 2446 static __init int event_trace_init(void) 2447 { 2448 struct trace_array *tr; 2449 struct dentry *d_tracer; 2450 struct dentry *entry; 2451 int ret; 2452 2453 tr = top_trace_array(); 2454 if (!tr) 2455 return -ENODEV; 2456 2457 d_tracer = tracing_init_dentry(); 2458 if (!d_tracer) 2459 return 0; 2460 2461 entry = debugfs_create_file("available_events", 0444, d_tracer, 2462 tr, &ftrace_avail_fops); 2463 if (!entry) 2464 pr_warning("Could not create debugfs " 2465 "'available_events' entry\n"); 2466 2467 if (trace_define_common_fields()) 2468 pr_warning("tracing: Failed to allocate common fields"); 2469 2470 ret = early_event_add_tracer(d_tracer, tr); 2471 if (ret) 2472 return ret; 2473 2474 #ifdef CONFIG_MODULES 2475 ret = register_module_notifier(&trace_module_nb); 2476 if (ret) 2477 pr_warning("Failed to register trace events module notifier\n"); 2478 #endif 2479 return 0; 2480 } 2481 early_initcall(event_trace_memsetup); 2482 core_initcall(event_trace_enable); 2483 fs_initcall(event_trace_init); 2484 2485 #ifdef CONFIG_FTRACE_STARTUP_TEST 2486 2487 static DEFINE_SPINLOCK(test_spinlock); 2488 static DEFINE_SPINLOCK(test_spinlock_irq); 2489 static DEFINE_MUTEX(test_mutex); 2490 2491 static __init void test_work(struct work_struct *dummy) 2492 { 2493 spin_lock(&test_spinlock); 2494 spin_lock_irq(&test_spinlock_irq); 2495 udelay(1); 2496 spin_unlock_irq(&test_spinlock_irq); 2497 spin_unlock(&test_spinlock); 2498 2499 mutex_lock(&test_mutex); 2500 msleep(1); 2501 mutex_unlock(&test_mutex); 2502 } 2503 2504 static __init int event_test_thread(void *unused) 2505 { 2506 void *test_malloc; 2507 2508 test_malloc = kmalloc(1234, GFP_KERNEL); 2509 if (!test_malloc) 2510 pr_info("failed to kmalloc\n"); 2511 2512 schedule_on_each_cpu(test_work); 2513 2514 kfree(test_malloc); 2515 2516 set_current_state(TASK_INTERRUPTIBLE); 2517 while (!kthread_should_stop()) 2518 schedule(); 2519 2520 return 0; 2521 } 2522 2523 /* 2524 * Do various things that may trigger events. 2525 */ 2526 static __init void event_test_stuff(void) 2527 { 2528 struct task_struct *test_thread; 2529 2530 test_thread = kthread_run(event_test_thread, NULL, "test-events"); 2531 msleep(1); 2532 kthread_stop(test_thread); 2533 } 2534 2535 /* 2536 * For every trace event defined, we will test each trace point separately, 2537 * and then by groups, and finally all trace points. 2538 */ 2539 static __init void event_trace_self_tests(void) 2540 { 2541 struct ftrace_subsystem_dir *dir; 2542 struct ftrace_event_file *file; 2543 struct ftrace_event_call *call; 2544 struct event_subsystem *system; 2545 struct trace_array *tr; 2546 int ret; 2547 2548 tr = top_trace_array(); 2549 if (!tr) 2550 return; 2551 2552 pr_info("Running tests on trace events:\n"); 2553 2554 list_for_each_entry(file, &tr->events, list) { 2555 2556 call = file->event_call; 2557 2558 /* Only test those that have a probe */ 2559 if (!call->class || !call->class->probe) 2560 continue; 2561 2562 /* 2563 * Testing syscall events here is pretty useless, but 2564 * we still do it if configured. But this is time consuming. 2565 * What we really need is a user thread to perform the 2566 * syscalls as we test. 2567 */ 2568 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS 2569 if (call->class->system && 2570 strcmp(call->class->system, "syscalls") == 0) 2571 continue; 2572 #endif 2573 2574 pr_info("Testing event %s: ", ftrace_event_name(call)); 2575 2576 /* 2577 * If an event is already enabled, someone is using 2578 * it and the self test should not be on. 2579 */ 2580 if (file->flags & FTRACE_EVENT_FL_ENABLED) { 2581 pr_warning("Enabled event during self test!\n"); 2582 WARN_ON_ONCE(1); 2583 continue; 2584 } 2585 2586 ftrace_event_enable_disable(file, 1); 2587 event_test_stuff(); 2588 ftrace_event_enable_disable(file, 0); 2589 2590 pr_cont("OK\n"); 2591 } 2592 2593 /* Now test at the sub system level */ 2594 2595 pr_info("Running tests on trace event systems:\n"); 2596 2597 list_for_each_entry(dir, &tr->systems, list) { 2598 2599 system = dir->subsystem; 2600 2601 /* the ftrace system is special, skip it */ 2602 if (strcmp(system->name, "ftrace") == 0) 2603 continue; 2604 2605 pr_info("Testing event system %s: ", system->name); 2606 2607 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1); 2608 if (WARN_ON_ONCE(ret)) { 2609 pr_warning("error enabling system %s\n", 2610 system->name); 2611 continue; 2612 } 2613 2614 event_test_stuff(); 2615 2616 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0); 2617 if (WARN_ON_ONCE(ret)) { 2618 pr_warning("error disabling system %s\n", 2619 system->name); 2620 continue; 2621 } 2622 2623 pr_cont("OK\n"); 2624 } 2625 2626 /* Test with all events enabled */ 2627 2628 pr_info("Running tests on all trace events:\n"); 2629 pr_info("Testing all events: "); 2630 2631 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1); 2632 if (WARN_ON_ONCE(ret)) { 2633 pr_warning("error enabling all events\n"); 2634 return; 2635 } 2636 2637 event_test_stuff(); 2638 2639 /* reset sysname */ 2640 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0); 2641 if (WARN_ON_ONCE(ret)) { 2642 pr_warning("error disabling all events\n"); 2643 return; 2644 } 2645 2646 pr_cont("OK\n"); 2647 } 2648 2649 #ifdef CONFIG_FUNCTION_TRACER 2650 2651 static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable); 2652 2653 static void 2654 function_test_events_call(unsigned long ip, unsigned long parent_ip, 2655 struct ftrace_ops *op, struct pt_regs *pt_regs) 2656 { 2657 struct ring_buffer_event *event; 2658 struct ring_buffer *buffer; 2659 struct ftrace_entry *entry; 2660 unsigned long flags; 2661 long disabled; 2662 int cpu; 2663 int pc; 2664 2665 pc = preempt_count(); 2666 preempt_disable_notrace(); 2667 cpu = raw_smp_processor_id(); 2668 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu)); 2669 2670 if (disabled != 1) 2671 goto out; 2672 2673 local_save_flags(flags); 2674 2675 event = trace_current_buffer_lock_reserve(&buffer, 2676 TRACE_FN, sizeof(*entry), 2677 flags, pc); 2678 if (!event) 2679 goto out; 2680 entry = ring_buffer_event_data(event); 2681 entry->ip = ip; 2682 entry->parent_ip = parent_ip; 2683 2684 trace_buffer_unlock_commit(buffer, event, flags, pc); 2685 2686 out: 2687 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu)); 2688 preempt_enable_notrace(); 2689 } 2690 2691 static struct ftrace_ops trace_ops __initdata = 2692 { 2693 .func = function_test_events_call, 2694 .flags = FTRACE_OPS_FL_RECURSION_SAFE, 2695 }; 2696 2697 static __init void event_trace_self_test_with_function(void) 2698 { 2699 int ret; 2700 ret = register_ftrace_function(&trace_ops); 2701 if (WARN_ON(ret < 0)) { 2702 pr_info("Failed to enable function tracer for event tests\n"); 2703 return; 2704 } 2705 pr_info("Running tests again, along with the function tracer\n"); 2706 event_trace_self_tests(); 2707 unregister_ftrace_function(&trace_ops); 2708 } 2709 #else 2710 static __init void event_trace_self_test_with_function(void) 2711 { 2712 } 2713 #endif 2714 2715 static __init int event_trace_self_tests_init(void) 2716 { 2717 if (!tracing_selftest_disabled) { 2718 event_trace_self_tests(); 2719 event_trace_self_test_with_function(); 2720 } 2721 2722 return 0; 2723 } 2724 2725 late_initcall(event_trace_self_tests_init); 2726 2727 #endif 2728