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#define pr_fmt(fmt) fmt 12 13#include <linux/workqueue.h> 14#include <linux/spinlock.h> 15#include <linux/kthread.h> 16#include <linux/debugfs.h> 17#include <linux/uaccess.h> 18#include <linux/module.h> 19#include <linux/ctype.h> 20#include <linux/slab.h> 21#include <linux/delay.h> 22 23#include <asm/setup.h> 24 25#include "trace_output.h" 26 27#undef TRACE_SYSTEM 28#define TRACE_SYSTEM "TRACE_SYSTEM" 29 30DEFINE_MUTEX(event_mutex); 31 32LIST_HEAD(ftrace_events); 33static LIST_HEAD(ftrace_common_fields); 34 35#define GFP_TRACE (GFP_KERNEL | __GFP_ZERO) 36 37static struct kmem_cache *field_cachep; 38static struct kmem_cache *file_cachep; 39 40#define SYSTEM_FL_FREE_NAME (1 << 31) 41 42static inline int system_refcount(struct event_subsystem *system) 43{ 44 return system->ref_count & ~SYSTEM_FL_FREE_NAME; 45} 46 47static int system_refcount_inc(struct event_subsystem *system) 48{ 49 return (system->ref_count++) & ~SYSTEM_FL_FREE_NAME; 50} 51 52static int system_refcount_dec(struct event_subsystem *system) 53{ 54 return (--system->ref_count) & ~SYSTEM_FL_FREE_NAME; 55} 56 57/* Double loops, do not use break, only goto's work */ 58#define do_for_each_event_file(tr, file) \ 59 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 60 list_for_each_entry(file, &tr->events, list) 61 62#define do_for_each_event_file_safe(tr, file) \ 63 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 64 struct ftrace_event_file *___n; \ 65 list_for_each_entry_safe(file, ___n, &tr->events, list) 66 67#define while_for_each_event_file() \ 68 } 69 70static struct list_head * 71trace_get_fields(struct ftrace_event_call *event_call) 72{ 73 if (!event_call->class->get_fields) 74 return &event_call->class->fields; 75 return event_call->class->get_fields(event_call); 76} 77 78static struct ftrace_event_field * 79__find_event_field(struct list_head *head, char *name) 80{ 81 struct ftrace_event_field *field; 82 83 list_for_each_entry(field, head, link) { 84 if (!strcmp(field->name, name)) 85 return field; 86 } 87 88 return NULL; 89} 90 91struct ftrace_event_field * 92trace_find_event_field(struct ftrace_event_call *call, char *name) 93{ 94 struct ftrace_event_field *field; 95 struct list_head *head; 96 97 field = __find_event_field(&ftrace_common_fields, name); 98 if (field) 99 return field; 100 101 head = trace_get_fields(call); 102 return __find_event_field(head, name); 103} 104 105static int __trace_define_field(struct list_head *head, const char *type, 106 const char *name, int offset, int size, 107 int is_signed, int filter_type) 108{ 109 struct ftrace_event_field *field; 110 111 field = kmem_cache_alloc(field_cachep, GFP_TRACE); 112 if (!field) 113 return -ENOMEM; 114 115 field->name = name; 116 field->type = type; 117 118 if (filter_type == FILTER_OTHER) 119 field->filter_type = filter_assign_type(type); 120 else 121 field->filter_type = filter_type; 122 123 field->offset = offset; 124 field->size = size; 125 field->is_signed = is_signed; 126 127 list_add(&field->link, head); 128 129 return 0; 130} 131 132int trace_define_field(struct ftrace_event_call *call, const char *type, 133 const char *name, int offset, int size, int is_signed, 134 int filter_type) 135{ 136 struct list_head *head; 137 138 if (WARN_ON(!call->class)) 139 return 0; 140 141 head = trace_get_fields(call); 142 return __trace_define_field(head, type, name, offset, size, 143 is_signed, filter_type); 144} 145EXPORT_SYMBOL_GPL(trace_define_field); 146 147#define __common_field(type, item) \ 148 ret = __trace_define_field(&ftrace_common_fields, #type, \ 149 "common_" #item, \ 150 offsetof(typeof(ent), item), \ 151 sizeof(ent.item), \ 152 is_signed_type(type), FILTER_OTHER); \ 153 if (ret) \ 154 return ret; 155 156static int trace_define_common_fields(void) 157{ 158 int ret; 159 struct trace_entry ent; 160 161 __common_field(unsigned short, type); 162 __common_field(unsigned char, flags); 163 __common_field(unsigned char, preempt_count); 164 __common_field(int, pid); 165 166 return ret; 167} 168 169static void trace_destroy_fields(struct ftrace_event_call *call) 170{ 171 struct ftrace_event_field *field, *next; 172 struct list_head *head; 173 174 head = trace_get_fields(call); 175 list_for_each_entry_safe(field, next, head, link) { 176 list_del(&field->link); 177 kmem_cache_free(field_cachep, field); 178 } 179} 180 181int trace_event_raw_init(struct ftrace_event_call *call) 182{ 183 int id; 184 185 id = register_ftrace_event(&call->event); 186 if (!id) 187 return -ENODEV; 188 189 return 0; 190} 191EXPORT_SYMBOL_GPL(trace_event_raw_init); 192 193void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer, 194 struct ftrace_event_file *ftrace_file, 195 unsigned long len) 196{ 197 struct ftrace_event_call *event_call = ftrace_file->event_call; 198 199 local_save_flags(fbuffer->flags); 200 fbuffer->pc = preempt_count(); 201 fbuffer->ftrace_file = ftrace_file; 202 203 fbuffer->event = 204 trace_event_buffer_lock_reserve(&fbuffer->buffer, ftrace_file, 205 event_call->event.type, len, 206 fbuffer->flags, fbuffer->pc); 207 if (!fbuffer->event) 208 return NULL; 209 210 fbuffer->entry = ring_buffer_event_data(fbuffer->event); 211 return fbuffer->entry; 212} 213EXPORT_SYMBOL_GPL(ftrace_event_buffer_reserve); 214 215void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer) 216{ 217 event_trigger_unlock_commit(fbuffer->ftrace_file, fbuffer->buffer, 218 fbuffer->event, fbuffer->entry, 219 fbuffer->flags, fbuffer->pc); 220} 221EXPORT_SYMBOL_GPL(ftrace_event_buffer_commit); 222 223int ftrace_event_reg(struct ftrace_event_call *call, 224 enum trace_reg type, void *data) 225{ 226 struct ftrace_event_file *file = data; 227 228 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT)); 229 switch (type) { 230 case TRACE_REG_REGISTER: 231 return tracepoint_probe_register(call->tp, 232 call->class->probe, 233 file); 234 case TRACE_REG_UNREGISTER: 235 tracepoint_probe_unregister(call->tp, 236 call->class->probe, 237 file); 238 return 0; 239 240#ifdef CONFIG_PERF_EVENTS 241 case TRACE_REG_PERF_REGISTER: 242 return tracepoint_probe_register(call->tp, 243 call->class->perf_probe, 244 call); 245 case TRACE_REG_PERF_UNREGISTER: 246 tracepoint_probe_unregister(call->tp, 247 call->class->perf_probe, 248 call); 249 return 0; 250 case TRACE_REG_PERF_OPEN: 251 case TRACE_REG_PERF_CLOSE: 252 case TRACE_REG_PERF_ADD: 253 case TRACE_REG_PERF_DEL: 254 return 0; 255#endif 256 } 257 return 0; 258} 259EXPORT_SYMBOL_GPL(ftrace_event_reg); 260 261void trace_event_enable_cmd_record(bool enable) 262{ 263 struct ftrace_event_file *file; 264 struct trace_array *tr; 265 266 mutex_lock(&event_mutex); 267 do_for_each_event_file(tr, file) { 268 269 if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) 270 continue; 271 272 if (enable) { 273 tracing_start_cmdline_record(); 274 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 275 } else { 276 tracing_stop_cmdline_record(); 277 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 278 } 279 } while_for_each_event_file(); 280 mutex_unlock(&event_mutex); 281} 282 283static int __ftrace_event_enable_disable(struct ftrace_event_file *file, 284 int enable, int soft_disable) 285{ 286 struct ftrace_event_call *call = file->event_call; 287 int ret = 0; 288 int disable; 289 290 switch (enable) { 291 case 0: 292 /* 293 * When soft_disable is set and enable is cleared, the sm_ref 294 * reference counter is decremented. If it reaches 0, we want 295 * to clear the SOFT_DISABLED flag but leave the event in the 296 * state that it was. That is, if the event was enabled and 297 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED 298 * is set we do not want the event to be enabled before we 299 * clear the bit. 300 * 301 * When soft_disable is not set but the SOFT_MODE flag is, 302 * we do nothing. Do not disable the tracepoint, otherwise 303 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work. 304 */ 305 if (soft_disable) { 306 if (atomic_dec_return(&file->sm_ref) > 0) 307 break; 308 disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED; 309 clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags); 310 } else 311 disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE); 312 313 if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) { 314 clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags); 315 if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) { 316 tracing_stop_cmdline_record(); 317 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 318 } 319 call->class->reg(call, TRACE_REG_UNREGISTER, file); 320 } 321 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */ 322 if (file->flags & FTRACE_EVENT_FL_SOFT_MODE) 323 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 324 else 325 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 326 break; 327 case 1: 328 /* 329 * When soft_disable is set and enable is set, we want to 330 * register the tracepoint for the event, but leave the event 331 * as is. That means, if the event was already enabled, we do 332 * nothing (but set SOFT_MODE). If the event is disabled, we 333 * set SOFT_DISABLED before enabling the event tracepoint, so 334 * it still seems to be disabled. 335 */ 336 if (!soft_disable) 337 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 338 else { 339 if (atomic_inc_return(&file->sm_ref) > 1) 340 break; 341 set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags); 342 } 343 344 if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) { 345 346 /* Keep the event disabled, when going to SOFT_MODE. */ 347 if (soft_disable) 348 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags); 349 350 if (trace_flags & TRACE_ITER_RECORD_CMD) { 351 tracing_start_cmdline_record(); 352 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags); 353 } 354 ret = call->class->reg(call, TRACE_REG_REGISTER, file); 355 if (ret) { 356 tracing_stop_cmdline_record(); 357 pr_info("event trace: Could not enable event " 358 "%s\n", ftrace_event_name(call)); 359 break; 360 } 361 set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags); 362 363 /* WAS_ENABLED gets set but never cleared. */ 364 call->flags |= TRACE_EVENT_FL_WAS_ENABLED; 365 } 366 break; 367 } 368 369 return ret; 370} 371 372int trace_event_enable_disable(struct ftrace_event_file *file, 373 int enable, int soft_disable) 374{ 375 return __ftrace_event_enable_disable(file, enable, soft_disable); 376} 377 378static int ftrace_event_enable_disable(struct ftrace_event_file *file, 379 int enable) 380{ 381 return __ftrace_event_enable_disable(file, enable, 0); 382} 383 384static void ftrace_clear_events(struct trace_array *tr) 385{ 386 struct ftrace_event_file *file; 387 388 mutex_lock(&event_mutex); 389 list_for_each_entry(file, &tr->events, list) { 390 ftrace_event_enable_disable(file, 0); 391 } 392 mutex_unlock(&event_mutex); 393} 394 395static void __put_system(struct event_subsystem *system) 396{ 397 struct event_filter *filter = system->filter; 398 399 WARN_ON_ONCE(system_refcount(system) == 0); 400 if (system_refcount_dec(system)) 401 return; 402 403 list_del(&system->list); 404 405 if (filter) { 406 kfree(filter->filter_string); 407 kfree(filter); 408 } 409 if (system->ref_count & SYSTEM_FL_FREE_NAME) 410 kfree(system->name); 411 kfree(system); 412} 413 414static void __get_system(struct event_subsystem *system) 415{ 416 WARN_ON_ONCE(system_refcount(system) == 0); 417 system_refcount_inc(system); 418} 419 420static void __get_system_dir(struct ftrace_subsystem_dir *dir) 421{ 422 WARN_ON_ONCE(dir->ref_count == 0); 423 dir->ref_count++; 424 __get_system(dir->subsystem); 425} 426 427static void __put_system_dir(struct ftrace_subsystem_dir *dir) 428{ 429 WARN_ON_ONCE(dir->ref_count == 0); 430 /* If the subsystem is about to be freed, the dir must be too */ 431 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1); 432 433 __put_system(dir->subsystem); 434 if (!--dir->ref_count) 435 kfree(dir); 436} 437 438static void put_system(struct ftrace_subsystem_dir *dir) 439{ 440 mutex_lock(&event_mutex); 441 __put_system_dir(dir); 442 mutex_unlock(&event_mutex); 443} 444 445static void remove_subsystem(struct ftrace_subsystem_dir *dir) 446{ 447 if (!dir) 448 return; 449 450 if (!--dir->nr_events) { 451 debugfs_remove_recursive(dir->entry); 452 list_del(&dir->list); 453 __put_system_dir(dir); 454 } 455} 456 457static void remove_event_file_dir(struct ftrace_event_file *file) 458{ 459 struct dentry *dir = file->dir; 460 struct dentry *child; 461 462 if (dir) { 463 spin_lock(&dir->d_lock); /* probably unneeded */ 464 list_for_each_entry(child, &dir->d_subdirs, d_u.d_child) { 465 if (child->d_inode) /* probably unneeded */ 466 child->d_inode->i_private = NULL; 467 } 468 spin_unlock(&dir->d_lock); 469 470 debugfs_remove_recursive(dir); 471 } 472 473 list_del(&file->list); 474 remove_subsystem(file->system); 475 free_event_filter(file->filter); 476 kmem_cache_free(file_cachep, file); 477} 478 479/* 480 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events. 481 */ 482static int 483__ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match, 484 const char *sub, const char *event, int set) 485{ 486 struct ftrace_event_file *file; 487 struct ftrace_event_call *call; 488 const char *name; 489 int ret = -EINVAL; 490 491 list_for_each_entry(file, &tr->events, list) { 492 493 call = file->event_call; 494 name = ftrace_event_name(call); 495 496 if (!name || !call->class || !call->class->reg) 497 continue; 498 499 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) 500 continue; 501 502 if (match && 503 strcmp(match, name) != 0 && 504 strcmp(match, call->class->system) != 0) 505 continue; 506 507 if (sub && strcmp(sub, call->class->system) != 0) 508 continue; 509 510 if (event && strcmp(event, name) != 0) 511 continue; 512 513 ftrace_event_enable_disable(file, set); 514 515 ret = 0; 516 } 517 518 return ret; 519} 520 521static int __ftrace_set_clr_event(struct trace_array *tr, const char *match, 522 const char *sub, const char *event, int set) 523{ 524 int ret; 525 526 mutex_lock(&event_mutex); 527 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set); 528 mutex_unlock(&event_mutex); 529 530 return ret; 531} 532 533static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set) 534{ 535 char *event = NULL, *sub = NULL, *match; 536 537 /* 538 * The buf format can be <subsystem>:<event-name> 539 * *:<event-name> means any event by that name. 540 * :<event-name> is the same. 541 * 542 * <subsystem>:* means all events in that subsystem 543 * <subsystem>: means the same. 544 * 545 * <name> (no ':') means all events in a subsystem with 546 * the name <name> or any event that matches <name> 547 */ 548 549 match = strsep(&buf, ":"); 550 if (buf) { 551 sub = match; 552 event = buf; 553 match = NULL; 554 555 if (!strlen(sub) || strcmp(sub, "*") == 0) 556 sub = NULL; 557 if (!strlen(event) || strcmp(event, "*") == 0) 558 event = NULL; 559 } 560 561 return __ftrace_set_clr_event(tr, match, sub, event, set); 562} 563 564/** 565 * trace_set_clr_event - enable or disable an event 566 * @system: system name to match (NULL for any system) 567 * @event: event name to match (NULL for all events, within system) 568 * @set: 1 to enable, 0 to disable 569 * 570 * This is a way for other parts of the kernel to enable or disable 571 * event recording. 572 * 573 * Returns 0 on success, -EINVAL if the parameters do not match any 574 * registered events. 575 */ 576int trace_set_clr_event(const char *system, const char *event, int set) 577{ 578 struct trace_array *tr = top_trace_array(); 579 580 if (!tr) 581 return -ENODEV; 582 583 return __ftrace_set_clr_event(tr, NULL, system, event, set); 584} 585EXPORT_SYMBOL_GPL(trace_set_clr_event); 586 587/* 128 should be much more than enough */ 588#define EVENT_BUF_SIZE 127 589 590static ssize_t 591ftrace_event_write(struct file *file, const char __user *ubuf, 592 size_t cnt, loff_t *ppos) 593{ 594 struct trace_parser parser; 595 struct seq_file *m = file->private_data; 596 struct trace_array *tr = m->private; 597 ssize_t read, ret; 598 599 if (!cnt) 600 return 0; 601 602 ret = tracing_update_buffers(); 603 if (ret < 0) 604 return ret; 605 606 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1)) 607 return -ENOMEM; 608 609 read = trace_get_user(&parser, ubuf, cnt, ppos); 610 611 if (read >= 0 && trace_parser_loaded((&parser))) { 612 int set = 1; 613 614 if (*parser.buffer == '!') 615 set = 0; 616 617 parser.buffer[parser.idx] = 0; 618 619 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set); 620 if (ret) 621 goto out_put; 622 } 623 624 ret = read; 625 626 out_put: 627 trace_parser_put(&parser); 628 629 return ret; 630} 631 632static void * 633t_next(struct seq_file *m, void *v, loff_t *pos) 634{ 635 struct ftrace_event_file *file = v; 636 struct ftrace_event_call *call; 637 struct trace_array *tr = m->private; 638 639 (*pos)++; 640 641 list_for_each_entry_continue(file, &tr->events, list) { 642 call = file->event_call; 643 /* 644 * The ftrace subsystem is for showing formats only. 645 * They can not be enabled or disabled via the event files. 646 */ 647 if (call->class && call->class->reg) 648 return file; 649 } 650 651 return NULL; 652} 653 654static void *t_start(struct seq_file *m, loff_t *pos) 655{ 656 struct ftrace_event_file *file; 657 struct trace_array *tr = m->private; 658 loff_t l; 659 660 mutex_lock(&event_mutex); 661 662 file = list_entry(&tr->events, struct ftrace_event_file, list); 663 for (l = 0; l <= *pos; ) { 664 file = t_next(m, file, &l); 665 if (!file) 666 break; 667 } 668 return file; 669} 670 671static void * 672s_next(struct seq_file *m, void *v, loff_t *pos) 673{ 674 struct ftrace_event_file *file = v; 675 struct trace_array *tr = m->private; 676 677 (*pos)++; 678 679 list_for_each_entry_continue(file, &tr->events, list) { 680 if (file->flags & FTRACE_EVENT_FL_ENABLED) 681 return file; 682 } 683 684 return NULL; 685} 686 687static void *s_start(struct seq_file *m, loff_t *pos) 688{ 689 struct ftrace_event_file *file; 690 struct trace_array *tr = m->private; 691 loff_t l; 692 693 mutex_lock(&event_mutex); 694 695 file = list_entry(&tr->events, struct ftrace_event_file, list); 696 for (l = 0; l <= *pos; ) { 697 file = s_next(m, file, &l); 698 if (!file) 699 break; 700 } 701 return file; 702} 703 704static int t_show(struct seq_file *m, void *v) 705{ 706 struct ftrace_event_file *file = v; 707 struct ftrace_event_call *call = file->event_call; 708 709 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) 710 seq_printf(m, "%s:", call->class->system); 711 seq_printf(m, "%s\n", ftrace_event_name(call)); 712 713 return 0; 714} 715 716static void t_stop(struct seq_file *m, void *p) 717{ 718 mutex_unlock(&event_mutex); 719} 720 721static ssize_t 722event_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 723 loff_t *ppos) 724{ 725 struct ftrace_event_file *file; 726 unsigned long flags; 727 char buf[4] = "0"; 728 729 mutex_lock(&event_mutex); 730 file = event_file_data(filp); 731 if (likely(file)) 732 flags = file->flags; 733 mutex_unlock(&event_mutex); 734 735 if (!file) 736 return -ENODEV; 737 738 if (flags & FTRACE_EVENT_FL_ENABLED && 739 !(flags & FTRACE_EVENT_FL_SOFT_DISABLED)) 740 strcpy(buf, "1"); 741 742 if (flags & FTRACE_EVENT_FL_SOFT_DISABLED || 743 flags & FTRACE_EVENT_FL_SOFT_MODE) 744 strcat(buf, "*"); 745 746 strcat(buf, "\n"); 747 748 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf)); 749} 750 751static ssize_t 752event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 753 loff_t *ppos) 754{ 755 struct ftrace_event_file *file; 756 unsigned long val; 757 int ret; 758 759 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 760 if (ret) 761 return ret; 762 763 ret = tracing_update_buffers(); 764 if (ret < 0) 765 return ret; 766 767 switch (val) { 768 case 0: 769 case 1: 770 ret = -ENODEV; 771 mutex_lock(&event_mutex); 772 file = event_file_data(filp); 773 if (likely(file)) 774 ret = ftrace_event_enable_disable(file, val); 775 mutex_unlock(&event_mutex); 776 break; 777 778 default: 779 return -EINVAL; 780 } 781 782 *ppos += cnt; 783 784 return ret ? ret : cnt; 785} 786 787static ssize_t 788system_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 789 loff_t *ppos) 790{ 791 const char set_to_char[4] = { '?', '0', '1', 'X' }; 792 struct ftrace_subsystem_dir *dir = filp->private_data; 793 struct event_subsystem *system = dir->subsystem; 794 struct ftrace_event_call *call; 795 struct ftrace_event_file *file; 796 struct trace_array *tr = dir->tr; 797 char buf[2]; 798 int set = 0; 799 int ret; 800 801 mutex_lock(&event_mutex); 802 list_for_each_entry(file, &tr->events, list) { 803 call = file->event_call; 804 if (!ftrace_event_name(call) || !call->class || !call->class->reg) 805 continue; 806 807 if (system && strcmp(call->class->system, system->name) != 0) 808 continue; 809 810 /* 811 * We need to find out if all the events are set 812 * or if all events or cleared, or if we have 813 * a mixture. 814 */ 815 set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED)); 816 817 /* 818 * If we have a mixture, no need to look further. 819 */ 820 if (set == 3) 821 break; 822 } 823 mutex_unlock(&event_mutex); 824 825 buf[0] = set_to_char[set]; 826 buf[1] = '\n'; 827 828 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2); 829 830 return ret; 831} 832 833static ssize_t 834system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 835 loff_t *ppos) 836{ 837 struct ftrace_subsystem_dir *dir = filp->private_data; 838 struct event_subsystem *system = dir->subsystem; 839 const char *name = NULL; 840 unsigned long val; 841 ssize_t ret; 842 843 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 844 if (ret) 845 return ret; 846 847 ret = tracing_update_buffers(); 848 if (ret < 0) 849 return ret; 850 851 if (val != 0 && val != 1) 852 return -EINVAL; 853 854 /* 855 * Opening of "enable" adds a ref count to system, 856 * so the name is safe to use. 857 */ 858 if (system) 859 name = system->name; 860 861 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val); 862 if (ret) 863 goto out; 864 865 ret = cnt; 866 867out: 868 *ppos += cnt; 869 870 return ret; 871} 872 873enum { 874 FORMAT_HEADER = 1, 875 FORMAT_FIELD_SEPERATOR = 2, 876 FORMAT_PRINTFMT = 3, 877}; 878 879static void *f_next(struct seq_file *m, void *v, loff_t *pos) 880{ 881 struct ftrace_event_call *call = event_file_data(m->private); 882 struct list_head *common_head = &ftrace_common_fields; 883 struct list_head *head = trace_get_fields(call); 884 struct list_head *node = v; 885 886 (*pos)++; 887 888 switch ((unsigned long)v) { 889 case FORMAT_HEADER: 890 node = common_head; 891 break; 892 893 case FORMAT_FIELD_SEPERATOR: 894 node = head; 895 break; 896 897 case FORMAT_PRINTFMT: 898 /* all done */ 899 return NULL; 900 } 901 902 node = node->prev; 903 if (node == common_head) 904 return (void *)FORMAT_FIELD_SEPERATOR; 905 else if (node == head) 906 return (void *)FORMAT_PRINTFMT; 907 else 908 return node; 909} 910 911static int f_show(struct seq_file *m, void *v) 912{ 913 struct ftrace_event_call *call = event_file_data(m->private); 914 struct ftrace_event_field *field; 915 const char *array_descriptor; 916 917 switch ((unsigned long)v) { 918 case FORMAT_HEADER: 919 seq_printf(m, "name: %s\n", ftrace_event_name(call)); 920 seq_printf(m, "ID: %d\n", call->event.type); 921 seq_printf(m, "format:\n"); 922 return 0; 923 924 case FORMAT_FIELD_SEPERATOR: 925 seq_putc(m, '\n'); 926 return 0; 927 928 case FORMAT_PRINTFMT: 929 seq_printf(m, "\nprint fmt: %s\n", 930 call->print_fmt); 931 return 0; 932 } 933 934 field = list_entry(v, struct ftrace_event_field, link); 935 /* 936 * Smartly shows the array type(except dynamic array). 937 * Normal: 938 * field:TYPE VAR 939 * If TYPE := TYPE[LEN], it is shown: 940 * field:TYPE VAR[LEN] 941 */ 942 array_descriptor = strchr(field->type, '['); 943 944 if (!strncmp(field->type, "__data_loc", 10)) 945 array_descriptor = NULL; 946 947 if (!array_descriptor) 948 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 949 field->type, field->name, field->offset, 950 field->size, !!field->is_signed); 951 else 952 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 953 (int)(array_descriptor - field->type), 954 field->type, field->name, 955 array_descriptor, field->offset, 956 field->size, !!field->is_signed); 957 958 return 0; 959} 960 961static void *f_start(struct seq_file *m, loff_t *pos) 962{ 963 void *p = (void *)FORMAT_HEADER; 964 loff_t l = 0; 965 966 /* ->stop() is called even if ->start() fails */ 967 mutex_lock(&event_mutex); 968 if (!event_file_data(m->private)) 969 return ERR_PTR(-ENODEV); 970 971 while (l < *pos && p) 972 p = f_next(m, p, &l); 973 974 return p; 975} 976 977static void f_stop(struct seq_file *m, void *p) 978{ 979 mutex_unlock(&event_mutex); 980} 981 982static const struct seq_operations trace_format_seq_ops = { 983 .start = f_start, 984 .next = f_next, 985 .stop = f_stop, 986 .show = f_show, 987}; 988 989static int trace_format_open(struct inode *inode, struct file *file) 990{ 991 struct seq_file *m; 992 int ret; 993 994 ret = seq_open(file, &trace_format_seq_ops); 995 if (ret < 0) 996 return ret; 997 998 m = file->private_data; 999 m->private = file; 1000 1001 return 0; 1002} 1003 1004static ssize_t 1005event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1006{ 1007 int id = (long)event_file_data(filp); 1008 char buf[32]; 1009 int len; 1010 1011 if (*ppos) 1012 return 0; 1013 1014 if (unlikely(!id)) 1015 return -ENODEV; 1016 1017 len = sprintf(buf, "%d\n", id); 1018 1019 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len); 1020} 1021 1022static ssize_t 1023event_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1024 loff_t *ppos) 1025{ 1026 struct ftrace_event_file *file; 1027 struct trace_seq *s; 1028 int r = -ENODEV; 1029 1030 if (*ppos) 1031 return 0; 1032 1033 s = kmalloc(sizeof(*s), GFP_KERNEL); 1034 1035 if (!s) 1036 return -ENOMEM; 1037 1038 trace_seq_init(s); 1039 1040 mutex_lock(&event_mutex); 1041 file = event_file_data(filp); 1042 if (file) 1043 print_event_filter(file, s); 1044 mutex_unlock(&event_mutex); 1045 1046 if (file) 1047 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1048 1049 kfree(s); 1050 1051 return r; 1052} 1053 1054static ssize_t 1055event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1056 loff_t *ppos) 1057{ 1058 struct ftrace_event_file *file; 1059 char *buf; 1060 int err = -ENODEV; 1061 1062 if (cnt >= PAGE_SIZE) 1063 return -EINVAL; 1064 1065 buf = (char *)__get_free_page(GFP_TEMPORARY); 1066 if (!buf) 1067 return -ENOMEM; 1068 1069 if (copy_from_user(buf, ubuf, cnt)) { 1070 free_page((unsigned long) buf); 1071 return -EFAULT; 1072 } 1073 buf[cnt] = '\0'; 1074 1075 mutex_lock(&event_mutex); 1076 file = event_file_data(filp); 1077 if (file) 1078 err = apply_event_filter(file, buf); 1079 mutex_unlock(&event_mutex); 1080 1081 free_page((unsigned long) buf); 1082 if (err < 0) 1083 return err; 1084 1085 *ppos += cnt; 1086 1087 return cnt; 1088} 1089 1090static LIST_HEAD(event_subsystems); 1091 1092static int subsystem_open(struct inode *inode, struct file *filp) 1093{ 1094 struct event_subsystem *system = NULL; 1095 struct ftrace_subsystem_dir *dir = NULL; /* Initialize for gcc */ 1096 struct trace_array *tr; 1097 int ret; 1098 1099 if (tracing_is_disabled()) 1100 return -ENODEV; 1101 1102 /* Make sure the system still exists */ 1103 mutex_lock(&trace_types_lock); 1104 mutex_lock(&event_mutex); 1105 list_for_each_entry(tr, &ftrace_trace_arrays, list) { 1106 list_for_each_entry(dir, &tr->systems, list) { 1107 if (dir == inode->i_private) { 1108 /* Don't open systems with no events */ 1109 if (dir->nr_events) { 1110 __get_system_dir(dir); 1111 system = dir->subsystem; 1112 } 1113 goto exit_loop; 1114 } 1115 } 1116 } 1117 exit_loop: 1118 mutex_unlock(&event_mutex); 1119 mutex_unlock(&trace_types_lock); 1120 1121 if (!system) 1122 return -ENODEV; 1123 1124 /* Some versions of gcc think dir can be uninitialized here */ 1125 WARN_ON(!dir); 1126 1127 /* Still need to increment the ref count of the system */ 1128 if (trace_array_get(tr) < 0) { 1129 put_system(dir); 1130 return -ENODEV; 1131 } 1132 1133 ret = tracing_open_generic(inode, filp); 1134 if (ret < 0) { 1135 trace_array_put(tr); 1136 put_system(dir); 1137 } 1138 1139 return ret; 1140} 1141 1142static int system_tr_open(struct inode *inode, struct file *filp) 1143{ 1144 struct ftrace_subsystem_dir *dir; 1145 struct trace_array *tr = inode->i_private; 1146 int ret; 1147 1148 if (tracing_is_disabled()) 1149 return -ENODEV; 1150 1151 if (trace_array_get(tr) < 0) 1152 return -ENODEV; 1153 1154 /* Make a temporary dir that has no system but points to tr */ 1155 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1156 if (!dir) { 1157 trace_array_put(tr); 1158 return -ENOMEM; 1159 } 1160 1161 dir->tr = tr; 1162 1163 ret = tracing_open_generic(inode, filp); 1164 if (ret < 0) { 1165 trace_array_put(tr); 1166 kfree(dir); 1167 return ret; 1168 } 1169 1170 filp->private_data = dir; 1171 1172 return 0; 1173} 1174 1175static int subsystem_release(struct inode *inode, struct file *file) 1176{ 1177 struct ftrace_subsystem_dir *dir = file->private_data; 1178 1179 trace_array_put(dir->tr); 1180 1181 /* 1182 * If dir->subsystem is NULL, then this is a temporary 1183 * descriptor that was made for a trace_array to enable 1184 * all subsystems. 1185 */ 1186 if (dir->subsystem) 1187 put_system(dir); 1188 else 1189 kfree(dir); 1190 1191 return 0; 1192} 1193 1194static ssize_t 1195subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1196 loff_t *ppos) 1197{ 1198 struct ftrace_subsystem_dir *dir = filp->private_data; 1199 struct event_subsystem *system = dir->subsystem; 1200 struct trace_seq *s; 1201 int r; 1202 1203 if (*ppos) 1204 return 0; 1205 1206 s = kmalloc(sizeof(*s), GFP_KERNEL); 1207 if (!s) 1208 return -ENOMEM; 1209 1210 trace_seq_init(s); 1211 1212 print_subsystem_event_filter(system, s); 1213 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1214 1215 kfree(s); 1216 1217 return r; 1218} 1219 1220static ssize_t 1221subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1222 loff_t *ppos) 1223{ 1224 struct ftrace_subsystem_dir *dir = filp->private_data; 1225 char *buf; 1226 int err; 1227 1228 if (cnt >= PAGE_SIZE) 1229 return -EINVAL; 1230 1231 buf = (char *)__get_free_page(GFP_TEMPORARY); 1232 if (!buf) 1233 return -ENOMEM; 1234 1235 if (copy_from_user(buf, ubuf, cnt)) { 1236 free_page((unsigned long) buf); 1237 return -EFAULT; 1238 } 1239 buf[cnt] = '\0'; 1240 1241 err = apply_subsystem_event_filter(dir, buf); 1242 free_page((unsigned long) buf); 1243 if (err < 0) 1244 return err; 1245 1246 *ppos += cnt; 1247 1248 return cnt; 1249} 1250 1251static ssize_t 1252show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1253{ 1254 int (*func)(struct trace_seq *s) = filp->private_data; 1255 struct trace_seq *s; 1256 int r; 1257 1258 if (*ppos) 1259 return 0; 1260 1261 s = kmalloc(sizeof(*s), GFP_KERNEL); 1262 if (!s) 1263 return -ENOMEM; 1264 1265 trace_seq_init(s); 1266 1267 func(s); 1268 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len); 1269 1270 kfree(s); 1271 1272 return r; 1273} 1274 1275static int ftrace_event_avail_open(struct inode *inode, struct file *file); 1276static int ftrace_event_set_open(struct inode *inode, struct file *file); 1277static int ftrace_event_release(struct inode *inode, struct file *file); 1278 1279static const struct seq_operations show_event_seq_ops = { 1280 .start = t_start, 1281 .next = t_next, 1282 .show = t_show, 1283 .stop = t_stop, 1284}; 1285 1286static const struct seq_operations show_set_event_seq_ops = { 1287 .start = s_start, 1288 .next = s_next, 1289 .show = t_show, 1290 .stop = t_stop, 1291}; 1292 1293static const struct file_operations ftrace_avail_fops = { 1294 .open = ftrace_event_avail_open, 1295 .read = seq_read, 1296 .llseek = seq_lseek, 1297 .release = seq_release, 1298}; 1299 1300static const struct file_operations ftrace_set_event_fops = { 1301 .open = ftrace_event_set_open, 1302 .read = seq_read, 1303 .write = ftrace_event_write, 1304 .llseek = seq_lseek, 1305 .release = ftrace_event_release, 1306}; 1307 1308static const struct file_operations ftrace_enable_fops = { 1309 .open = tracing_open_generic, 1310 .read = event_enable_read, 1311 .write = event_enable_write, 1312 .llseek = default_llseek, 1313}; 1314 1315static const struct file_operations ftrace_event_format_fops = { 1316 .open = trace_format_open, 1317 .read = seq_read, 1318 .llseek = seq_lseek, 1319 .release = seq_release, 1320}; 1321 1322static const struct file_operations ftrace_event_id_fops = { 1323 .read = event_id_read, 1324 .llseek = default_llseek, 1325}; 1326 1327static const struct file_operations ftrace_event_filter_fops = { 1328 .open = tracing_open_generic, 1329 .read = event_filter_read, 1330 .write = event_filter_write, 1331 .llseek = default_llseek, 1332}; 1333 1334static const struct file_operations ftrace_subsystem_filter_fops = { 1335 .open = subsystem_open, 1336 .read = subsystem_filter_read, 1337 .write = subsystem_filter_write, 1338 .llseek = default_llseek, 1339 .release = subsystem_release, 1340}; 1341 1342static const struct file_operations ftrace_system_enable_fops = { 1343 .open = subsystem_open, 1344 .read = system_enable_read, 1345 .write = system_enable_write, 1346 .llseek = default_llseek, 1347 .release = subsystem_release, 1348}; 1349 1350static const struct file_operations ftrace_tr_enable_fops = { 1351 .open = system_tr_open, 1352 .read = system_enable_read, 1353 .write = system_enable_write, 1354 .llseek = default_llseek, 1355 .release = subsystem_release, 1356}; 1357 1358static const struct file_operations ftrace_show_header_fops = { 1359 .open = tracing_open_generic, 1360 .read = show_header, 1361 .llseek = default_llseek, 1362}; 1363 1364static int 1365ftrace_event_open(struct inode *inode, struct file *file, 1366 const struct seq_operations *seq_ops) 1367{ 1368 struct seq_file *m; 1369 int ret; 1370 1371 ret = seq_open(file, seq_ops); 1372 if (ret < 0) 1373 return ret; 1374 m = file->private_data; 1375 /* copy tr over to seq ops */ 1376 m->private = inode->i_private; 1377 1378 return ret; 1379} 1380 1381static int ftrace_event_release(struct inode *inode, struct file *file) 1382{ 1383 struct trace_array *tr = inode->i_private; 1384 1385 trace_array_put(tr); 1386 1387 return seq_release(inode, file); 1388} 1389 1390static int 1391ftrace_event_avail_open(struct inode *inode, struct file *file) 1392{ 1393 const struct seq_operations *seq_ops = &show_event_seq_ops; 1394 1395 return ftrace_event_open(inode, file, seq_ops); 1396} 1397 1398static int 1399ftrace_event_set_open(struct inode *inode, struct file *file) 1400{ 1401 const struct seq_operations *seq_ops = &show_set_event_seq_ops; 1402 struct trace_array *tr = inode->i_private; 1403 int ret; 1404 1405 if (trace_array_get(tr) < 0) 1406 return -ENODEV; 1407 1408 if ((file->f_mode & FMODE_WRITE) && 1409 (file->f_flags & O_TRUNC)) 1410 ftrace_clear_events(tr); 1411 1412 ret = ftrace_event_open(inode, file, seq_ops); 1413 if (ret < 0) 1414 trace_array_put(tr); 1415 return ret; 1416} 1417 1418static struct event_subsystem * 1419create_new_subsystem(const char *name) 1420{ 1421 struct event_subsystem *system; 1422 1423 /* need to create new entry */ 1424 system = kmalloc(sizeof(*system), GFP_KERNEL); 1425 if (!system) 1426 return NULL; 1427 1428 system->ref_count = 1; 1429 1430 /* Only allocate if dynamic (kprobes and modules) */ 1431 if (!core_kernel_data((unsigned long)name)) { 1432 system->ref_count |= SYSTEM_FL_FREE_NAME; 1433 system->name = kstrdup(name, GFP_KERNEL); 1434 if (!system->name) 1435 goto out_free; 1436 } else 1437 system->name = name; 1438 1439 system->filter = NULL; 1440 1441 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL); 1442 if (!system->filter) 1443 goto out_free; 1444 1445 list_add(&system->list, &event_subsystems); 1446 1447 return system; 1448 1449 out_free: 1450 if (system->ref_count & SYSTEM_FL_FREE_NAME) 1451 kfree(system->name); 1452 kfree(system); 1453 return NULL; 1454} 1455 1456static struct dentry * 1457event_subsystem_dir(struct trace_array *tr, const char *name, 1458 struct ftrace_event_file *file, struct dentry *parent) 1459{ 1460 struct ftrace_subsystem_dir *dir; 1461 struct event_subsystem *system; 1462 struct dentry *entry; 1463 1464 /* First see if we did not already create this dir */ 1465 list_for_each_entry(dir, &tr->systems, list) { 1466 system = dir->subsystem; 1467 if (strcmp(system->name, name) == 0) { 1468 dir->nr_events++; 1469 file->system = dir; 1470 return dir->entry; 1471 } 1472 } 1473 1474 /* Now see if the system itself exists. */ 1475 list_for_each_entry(system, &event_subsystems, list) { 1476 if (strcmp(system->name, name) == 0) 1477 break; 1478 } 1479 /* Reset system variable when not found */ 1480 if (&system->list == &event_subsystems) 1481 system = NULL; 1482 1483 dir = kmalloc(sizeof(*dir), GFP_KERNEL); 1484 if (!dir) 1485 goto out_fail; 1486 1487 if (!system) { 1488 system = create_new_subsystem(name); 1489 if (!system) 1490 goto out_free; 1491 } else 1492 __get_system(system); 1493 1494 dir->entry = debugfs_create_dir(name, parent); 1495 if (!dir->entry) { 1496 pr_warn("Failed to create system directory %s\n", name); 1497 __put_system(system); 1498 goto out_free; 1499 } 1500 1501 dir->tr = tr; 1502 dir->ref_count = 1; 1503 dir->nr_events = 1; 1504 dir->subsystem = system; 1505 file->system = dir; 1506 1507 entry = debugfs_create_file("filter", 0644, dir->entry, dir, 1508 &ftrace_subsystem_filter_fops); 1509 if (!entry) { 1510 kfree(system->filter); 1511 system->filter = NULL; 1512 pr_warn("Could not create debugfs '%s/filter' entry\n", name); 1513 } 1514 1515 trace_create_file("enable", 0644, dir->entry, dir, 1516 &ftrace_system_enable_fops); 1517 1518 list_add(&dir->list, &tr->systems); 1519 1520 return dir->entry; 1521 1522 out_free: 1523 kfree(dir); 1524 out_fail: 1525 /* Only print this message if failed on memory allocation */ 1526 if (!dir || !system) 1527 pr_warn("No memory to create event subsystem %s\n", name); 1528 return NULL; 1529} 1530 1531static int 1532event_create_dir(struct dentry *parent, struct ftrace_event_file *file) 1533{ 1534 struct ftrace_event_call *call = file->event_call; 1535 struct trace_array *tr = file->tr; 1536 struct list_head *head; 1537 struct dentry *d_events; 1538 const char *name; 1539 int ret; 1540 1541 /* 1542 * If the trace point header did not define TRACE_SYSTEM 1543 * then the system would be called "TRACE_SYSTEM". 1544 */ 1545 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) { 1546 d_events = event_subsystem_dir(tr, call->class->system, file, parent); 1547 if (!d_events) 1548 return -ENOMEM; 1549 } else 1550 d_events = parent; 1551 1552 name = ftrace_event_name(call); 1553 file->dir = debugfs_create_dir(name, d_events); 1554 if (!file->dir) { 1555 pr_warn("Could not create debugfs '%s' directory\n", name); 1556 return -1; 1557 } 1558 1559 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) 1560 trace_create_file("enable", 0644, file->dir, file, 1561 &ftrace_enable_fops); 1562 1563#ifdef CONFIG_PERF_EVENTS 1564 if (call->event.type && call->class->reg) 1565 trace_create_file("id", 0444, file->dir, 1566 (void *)(long)call->event.type, 1567 &ftrace_event_id_fops); 1568#endif 1569 1570 /* 1571 * Other events may have the same class. Only update 1572 * the fields if they are not already defined. 1573 */ 1574 head = trace_get_fields(call); 1575 if (list_empty(head)) { 1576 ret = call->class->define_fields(call); 1577 if (ret < 0) { 1578 pr_warn("Could not initialize trace point events/%s\n", 1579 name); 1580 return -1; 1581 } 1582 } 1583 trace_create_file("filter", 0644, file->dir, file, 1584 &ftrace_event_filter_fops); 1585 1586 trace_create_file("trigger", 0644, file->dir, file, 1587 &event_trigger_fops); 1588 1589 trace_create_file("format", 0444, file->dir, call, 1590 &ftrace_event_format_fops); 1591 1592 return 0; 1593} 1594 1595static void remove_event_from_tracers(struct ftrace_event_call *call) 1596{ 1597 struct ftrace_event_file *file; 1598 struct trace_array *tr; 1599 1600 do_for_each_event_file_safe(tr, file) { 1601 if (file->event_call != call) 1602 continue; 1603 1604 remove_event_file_dir(file); 1605 /* 1606 * The do_for_each_event_file_safe() is 1607 * a double loop. After finding the call for this 1608 * trace_array, we use break to jump to the next 1609 * trace_array. 1610 */ 1611 break; 1612 } while_for_each_event_file(); 1613} 1614 1615static void event_remove(struct ftrace_event_call *call) 1616{ 1617 struct trace_array *tr; 1618 struct ftrace_event_file *file; 1619 1620 do_for_each_event_file(tr, file) { 1621 if (file->event_call != call) 1622 continue; 1623 ftrace_event_enable_disable(file, 0); 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 1639static 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", name); 1652 } 1653 1654 return ret; 1655} 1656 1657static int 1658__register_event(struct ftrace_event_call *call, struct module *mod) 1659{ 1660 int ret; 1661 1662 ret = event_init(call); 1663 if (ret < 0) 1664 return ret; 1665 1666 list_add(&call->list, &ftrace_events); 1667 call->mod = mod; 1668 1669 return 0; 1670} 1671 1672static struct ftrace_event_file * 1673trace_create_new_event(struct ftrace_event_call *call, 1674 struct trace_array *tr) 1675{ 1676 struct ftrace_event_file *file; 1677 1678 file = kmem_cache_alloc(file_cachep, GFP_TRACE); 1679 if (!file) 1680 return NULL; 1681 1682 file->event_call = call; 1683 file->tr = tr; 1684 atomic_set(&file->sm_ref, 0); 1685 atomic_set(&file->tm_ref, 0); 1686 INIT_LIST_HEAD(&file->triggers); 1687 list_add(&file->list, &tr->events); 1688 1689 return file; 1690} 1691 1692/* Add an event to a trace directory */ 1693static int 1694__trace_add_new_event(struct ftrace_event_call *call, struct trace_array *tr) 1695{ 1696 struct ftrace_event_file *file; 1697 1698 file = trace_create_new_event(call, tr); 1699 if (!file) 1700 return -ENOMEM; 1701 1702 return event_create_dir(tr->event_dir, file); 1703} 1704 1705/* 1706 * Just create a decriptor for early init. A descriptor is required 1707 * for enabling events at boot. We want to enable events before 1708 * the filesystem is initialized. 1709 */ 1710static __init int 1711__trace_early_add_new_event(struct ftrace_event_call *call, 1712 struct trace_array *tr) 1713{ 1714 struct ftrace_event_file *file; 1715 1716 file = trace_create_new_event(call, tr); 1717 if (!file) 1718 return -ENOMEM; 1719 1720 return 0; 1721} 1722 1723struct ftrace_module_file_ops; 1724static void __add_event_to_tracers(struct ftrace_event_call *call); 1725 1726/* Add an additional event_call dynamically */ 1727int trace_add_event_call(struct ftrace_event_call *call) 1728{ 1729 int ret; 1730 mutex_lock(&trace_types_lock); 1731 mutex_lock(&event_mutex); 1732 1733 ret = __register_event(call, NULL); 1734 if (ret >= 0) 1735 __add_event_to_tracers(call); 1736 1737 mutex_unlock(&event_mutex); 1738 mutex_unlock(&trace_types_lock); 1739 return ret; 1740} 1741 1742/* 1743 * Must be called under locking of trace_types_lock, event_mutex and 1744 * trace_event_sem. 1745 */ 1746static void __trace_remove_event_call(struct ftrace_event_call *call) 1747{ 1748 event_remove(call); 1749 trace_destroy_fields(call); 1750 free_event_filter(call->filter); 1751 call->filter = NULL; 1752} 1753 1754static 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 */ 1788int 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 1810static 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 1833static 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 1860static 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 1881static 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. */ 1888static 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_warn("Could not create directory for event %s\n", 1898 ftrace_event_name(call)); 1899 } 1900} 1901 1902struct ftrace_event_file * 1903find_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 1933struct event_probe_data { 1934 struct ftrace_event_file *file; 1935 unsigned long count; 1936 int ref; 1937 bool enable; 1938}; 1939 1940static void 1941event_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 1955static void 1956event_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 1977static int 1978event_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 1998static int 1999event_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 2009static void 2010event_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 2029static 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 2036static 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 2043static 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 2050static 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 2057static int 2058event_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 2167static struct ftrace_func_command event_enable_cmd = { 2168 .name = ENABLE_EVENT_STR, 2169 .func = event_enable_func, 2170}; 2171 2172static struct ftrace_func_command event_disable_cmd = { 2173 .name = DISABLE_EVENT_STR, 2174 .func = event_enable_func, 2175}; 2176 2177static __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 2190static 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 */ 2200static __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_warn("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 */ 2221static __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_warn("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. */ 2240static 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 2249static 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 2257extern struct ftrace_event_call *__start_ftrace_events[]; 2258extern struct ftrace_event_call *__stop_ftrace_events[]; 2259 2260static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata; 2261 2262static __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 */ 2273static int 2274create_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_warn("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_warn("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 */ 2320int 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 */ 2344static __init int 2345early_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 2365int 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 2390static __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 2397static __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 2446static __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_warn("Could not create debugfs 'available_events' entry\n"); 2465 2466 if (trace_define_common_fields()) 2467 pr_warn("tracing: Failed to allocate common fields"); 2468 2469 ret = early_event_add_tracer(d_tracer, tr); 2470 if (ret) 2471 return ret; 2472 2473#ifdef CONFIG_MODULES 2474 ret = register_module_notifier(&trace_module_nb); 2475 if (ret) 2476 pr_warn("Failed to register trace events module notifier\n"); 2477#endif 2478 return 0; 2479} 2480early_initcall(event_trace_memsetup); 2481core_initcall(event_trace_enable); 2482fs_initcall(event_trace_init); 2483 2484#ifdef CONFIG_FTRACE_STARTUP_TEST 2485 2486static DEFINE_SPINLOCK(test_spinlock); 2487static DEFINE_SPINLOCK(test_spinlock_irq); 2488static DEFINE_MUTEX(test_mutex); 2489 2490static __init void test_work(struct work_struct *dummy) 2491{ 2492 spin_lock(&test_spinlock); 2493 spin_lock_irq(&test_spinlock_irq); 2494 udelay(1); 2495 spin_unlock_irq(&test_spinlock_irq); 2496 spin_unlock(&test_spinlock); 2497 2498 mutex_lock(&test_mutex); 2499 msleep(1); 2500 mutex_unlock(&test_mutex); 2501} 2502 2503static __init int event_test_thread(void *unused) 2504{ 2505 void *test_malloc; 2506 2507 test_malloc = kmalloc(1234, GFP_KERNEL); 2508 if (!test_malloc) 2509 pr_info("failed to kmalloc\n"); 2510 2511 schedule_on_each_cpu(test_work); 2512 2513 kfree(test_malloc); 2514 2515 set_current_state(TASK_INTERRUPTIBLE); 2516 while (!kthread_should_stop()) { 2517 schedule(); 2518 set_current_state(TASK_INTERRUPTIBLE); 2519 } 2520 __set_current_state(TASK_RUNNING); 2521 2522 return 0; 2523} 2524 2525/* 2526 * Do various things that may trigger events. 2527 */ 2528static __init void event_test_stuff(void) 2529{ 2530 struct task_struct *test_thread; 2531 2532 test_thread = kthread_run(event_test_thread, NULL, "test-events"); 2533 msleep(1); 2534 kthread_stop(test_thread); 2535} 2536 2537/* 2538 * For every trace event defined, we will test each trace point separately, 2539 * and then by groups, and finally all trace points. 2540 */ 2541static __init void event_trace_self_tests(void) 2542{ 2543 struct ftrace_subsystem_dir *dir; 2544 struct ftrace_event_file *file; 2545 struct ftrace_event_call *call; 2546 struct event_subsystem *system; 2547 struct trace_array *tr; 2548 int ret; 2549 2550 tr = top_trace_array(); 2551 if (!tr) 2552 return; 2553 2554 pr_info("Running tests on trace events:\n"); 2555 2556 list_for_each_entry(file, &tr->events, list) { 2557 2558 call = file->event_call; 2559 2560 /* Only test those that have a probe */ 2561 if (!call->class || !call->class->probe) 2562 continue; 2563 2564/* 2565 * Testing syscall events here is pretty useless, but 2566 * we still do it if configured. But this is time consuming. 2567 * What we really need is a user thread to perform the 2568 * syscalls as we test. 2569 */ 2570#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS 2571 if (call->class->system && 2572 strcmp(call->class->system, "syscalls") == 0) 2573 continue; 2574#endif 2575 2576 pr_info("Testing event %s: ", ftrace_event_name(call)); 2577 2578 /* 2579 * If an event is already enabled, someone is using 2580 * it and the self test should not be on. 2581 */ 2582 if (file->flags & FTRACE_EVENT_FL_ENABLED) { 2583 pr_warn("Enabled event during self test!\n"); 2584 WARN_ON_ONCE(1); 2585 continue; 2586 } 2587 2588 ftrace_event_enable_disable(file, 1); 2589 event_test_stuff(); 2590 ftrace_event_enable_disable(file, 0); 2591 2592 pr_cont("OK\n"); 2593 } 2594 2595 /* Now test at the sub system level */ 2596 2597 pr_info("Running tests on trace event systems:\n"); 2598 2599 list_for_each_entry(dir, &tr->systems, list) { 2600 2601 system = dir->subsystem; 2602 2603 /* the ftrace system is special, skip it */ 2604 if (strcmp(system->name, "ftrace") == 0) 2605 continue; 2606 2607 pr_info("Testing event system %s: ", system->name); 2608 2609 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1); 2610 if (WARN_ON_ONCE(ret)) { 2611 pr_warn("error enabling system %s\n", 2612 system->name); 2613 continue; 2614 } 2615 2616 event_test_stuff(); 2617 2618 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0); 2619 if (WARN_ON_ONCE(ret)) { 2620 pr_warn("error disabling system %s\n", 2621 system->name); 2622 continue; 2623 } 2624 2625 pr_cont("OK\n"); 2626 } 2627 2628 /* Test with all events enabled */ 2629 2630 pr_info("Running tests on all trace events:\n"); 2631 pr_info("Testing all events: "); 2632 2633 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1); 2634 if (WARN_ON_ONCE(ret)) { 2635 pr_warn("error enabling all events\n"); 2636 return; 2637 } 2638 2639 event_test_stuff(); 2640 2641 /* reset sysname */ 2642 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0); 2643 if (WARN_ON_ONCE(ret)) { 2644 pr_warn("error disabling all events\n"); 2645 return; 2646 } 2647 2648 pr_cont("OK\n"); 2649} 2650 2651#ifdef CONFIG_FUNCTION_TRACER 2652 2653static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable); 2654 2655static void 2656function_test_events_call(unsigned long ip, unsigned long parent_ip, 2657 struct ftrace_ops *op, struct pt_regs *pt_regs) 2658{ 2659 struct ring_buffer_event *event; 2660 struct ring_buffer *buffer; 2661 struct ftrace_entry *entry; 2662 unsigned long flags; 2663 long disabled; 2664 int cpu; 2665 int pc; 2666 2667 pc = preempt_count(); 2668 preempt_disable_notrace(); 2669 cpu = raw_smp_processor_id(); 2670 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu)); 2671 2672 if (disabled != 1) 2673 goto out; 2674 2675 local_save_flags(flags); 2676 2677 event = trace_current_buffer_lock_reserve(&buffer, 2678 TRACE_FN, sizeof(*entry), 2679 flags, pc); 2680 if (!event) 2681 goto out; 2682 entry = ring_buffer_event_data(event); 2683 entry->ip = ip; 2684 entry->parent_ip = parent_ip; 2685 2686 trace_buffer_unlock_commit(buffer, event, flags, pc); 2687 2688 out: 2689 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu)); 2690 preempt_enable_notrace(); 2691} 2692 2693static struct ftrace_ops trace_ops __initdata = 2694{ 2695 .func = function_test_events_call, 2696 .flags = FTRACE_OPS_FL_RECURSION_SAFE, 2697}; 2698 2699static __init void event_trace_self_test_with_function(void) 2700{ 2701 int ret; 2702 ret = register_ftrace_function(&trace_ops); 2703 if (WARN_ON(ret < 0)) { 2704 pr_info("Failed to enable function tracer for event tests\n"); 2705 return; 2706 } 2707 pr_info("Running tests again, along with the function tracer\n"); 2708 event_trace_self_tests(); 2709 unregister_ftrace_function(&trace_ops); 2710} 2711#else 2712static __init void event_trace_self_test_with_function(void) 2713{ 2714} 2715#endif 2716 2717static __init int event_trace_self_tests_init(void) 2718{ 2719 if (!tracing_selftest_disabled) { 2720 event_trace_self_tests(); 2721 event_trace_self_test_with_function(); 2722 } 2723 2724 return 0; 2725} 2726 2727late_initcall(event_trace_self_tests_init); 2728 2729#endif 2730