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/tracefs.h> 17 #include <linux/uaccess.h> 18 #include <linux/module.h> 19 #include <linux/ctype.h> 20 #include <linux/sort.h> 21 #include <linux/slab.h> 22 #include <linux/delay.h> 23 24 #include <trace/events/sched.h> 25 26 #include <asm/setup.h> 27 28 #include "trace_output.h" 29 30 #undef TRACE_SYSTEM 31 #define TRACE_SYSTEM "TRACE_SYSTEM" 32 33 DEFINE_MUTEX(event_mutex); 34 35 LIST_HEAD(ftrace_events); 36 static LIST_HEAD(ftrace_generic_fields); 37 static LIST_HEAD(ftrace_common_fields); 38 39 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO) 40 41 static struct kmem_cache *field_cachep; 42 static struct kmem_cache *file_cachep; 43 44 static inline int system_refcount(struct event_subsystem *system) 45 { 46 return system->ref_count; 47 } 48 49 static int system_refcount_inc(struct event_subsystem *system) 50 { 51 return system->ref_count++; 52 } 53 54 static int system_refcount_dec(struct event_subsystem *system) 55 { 56 return --system->ref_count; 57 } 58 59 /* Double loops, do not use break, only goto's work */ 60 #define do_for_each_event_file(tr, file) \ 61 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 62 list_for_each_entry(file, &tr->events, list) 63 64 #define do_for_each_event_file_safe(tr, file) \ 65 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \ 66 struct trace_event_file *___n; \ 67 list_for_each_entry_safe(file, ___n, &tr->events, list) 68 69 #define while_for_each_event_file() \ 70 } 71 72 static struct list_head * 73 trace_get_fields(struct trace_event_call *event_call) 74 { 75 if (!event_call->class->get_fields) 76 return &event_call->class->fields; 77 return event_call->class->get_fields(event_call); 78 } 79 80 static struct ftrace_event_field * 81 __find_event_field(struct list_head *head, char *name) 82 { 83 struct ftrace_event_field *field; 84 85 list_for_each_entry(field, head, link) { 86 if (!strcmp(field->name, name)) 87 return field; 88 } 89 90 return NULL; 91 } 92 93 struct ftrace_event_field * 94 trace_find_event_field(struct trace_event_call *call, char *name) 95 { 96 struct ftrace_event_field *field; 97 struct list_head *head; 98 99 head = trace_get_fields(call); 100 field = __find_event_field(head, name); 101 if (field) 102 return field; 103 104 field = __find_event_field(&ftrace_generic_fields, name); 105 if (field) 106 return field; 107 108 return __find_event_field(&ftrace_common_fields, name); 109 } 110 111 static int __trace_define_field(struct list_head *head, const char *type, 112 const char *name, int offset, int size, 113 int is_signed, int filter_type) 114 { 115 struct ftrace_event_field *field; 116 117 field = kmem_cache_alloc(field_cachep, GFP_TRACE); 118 if (!field) 119 return -ENOMEM; 120 121 field->name = name; 122 field->type = type; 123 124 if (filter_type == FILTER_OTHER) 125 field->filter_type = filter_assign_type(type); 126 else 127 field->filter_type = filter_type; 128 129 field->offset = offset; 130 field->size = size; 131 field->is_signed = is_signed; 132 133 list_add(&field->link, head); 134 135 return 0; 136 } 137 138 int trace_define_field(struct trace_event_call *call, const char *type, 139 const char *name, int offset, int size, int is_signed, 140 int filter_type) 141 { 142 struct list_head *head; 143 144 if (WARN_ON(!call->class)) 145 return 0; 146 147 head = trace_get_fields(call); 148 return __trace_define_field(head, type, name, offset, size, 149 is_signed, filter_type); 150 } 151 EXPORT_SYMBOL_GPL(trace_define_field); 152 153 #define __generic_field(type, item, filter_type) \ 154 ret = __trace_define_field(&ftrace_generic_fields, #type, \ 155 #item, 0, 0, is_signed_type(type), \ 156 filter_type); \ 157 if (ret) \ 158 return ret; 159 160 #define __common_field(type, item) \ 161 ret = __trace_define_field(&ftrace_common_fields, #type, \ 162 "common_" #item, \ 163 offsetof(typeof(ent), item), \ 164 sizeof(ent.item), \ 165 is_signed_type(type), FILTER_OTHER); \ 166 if (ret) \ 167 return ret; 168 169 static int trace_define_generic_fields(void) 170 { 171 int ret; 172 173 __generic_field(int, CPU, FILTER_CPU); 174 __generic_field(int, cpu, FILTER_CPU); 175 __generic_field(char *, COMM, FILTER_COMM); 176 __generic_field(char *, comm, FILTER_COMM); 177 178 return ret; 179 } 180 181 static int trace_define_common_fields(void) 182 { 183 int ret; 184 struct trace_entry ent; 185 186 __common_field(unsigned short, type); 187 __common_field(unsigned char, flags); 188 __common_field(unsigned char, preempt_count); 189 __common_field(int, pid); 190 191 return ret; 192 } 193 194 static void trace_destroy_fields(struct trace_event_call *call) 195 { 196 struct ftrace_event_field *field, *next; 197 struct list_head *head; 198 199 head = trace_get_fields(call); 200 list_for_each_entry_safe(field, next, head, link) { 201 list_del(&field->link); 202 kmem_cache_free(field_cachep, field); 203 } 204 } 205 206 /* 207 * run-time version of trace_event_get_offsets_<call>() that returns the last 208 * accessible offset of trace fields excluding __dynamic_array bytes 209 */ 210 int trace_event_get_offsets(struct trace_event_call *call) 211 { 212 struct ftrace_event_field *tail; 213 struct list_head *head; 214 215 head = trace_get_fields(call); 216 /* 217 * head->next points to the last field with the largest offset, 218 * since it was added last by trace_define_field() 219 */ 220 tail = list_first_entry(head, struct ftrace_event_field, link); 221 return tail->offset + tail->size; 222 } 223 224 int trace_event_raw_init(struct trace_event_call *call) 225 { 226 int id; 227 228 id = register_trace_event(&call->event); 229 if (!id) 230 return -ENODEV; 231 232 return 0; 233 } 234 EXPORT_SYMBOL_GPL(trace_event_raw_init); 235 236 bool trace_event_ignore_this_pid(struct trace_event_file *trace_file) 237 { 238 struct trace_array *tr = trace_file->tr; 239 struct trace_array_cpu *data; 240 struct trace_pid_list *pid_list; 241 242 pid_list = rcu_dereference_sched(tr->filtered_pids); 243 if (!pid_list) 244 return false; 245 246 data = this_cpu_ptr(tr->trace_buffer.data); 247 248 return data->ignore_pid; 249 } 250 EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid); 251 252 void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer, 253 struct trace_event_file *trace_file, 254 unsigned long len) 255 { 256 struct trace_event_call *event_call = trace_file->event_call; 257 258 if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) && 259 trace_event_ignore_this_pid(trace_file)) 260 return NULL; 261 262 local_save_flags(fbuffer->flags); 263 fbuffer->pc = preempt_count(); 264 /* 265 * If CONFIG_PREEMPT is enabled, then the tracepoint itself disables 266 * preemption (adding one to the preempt_count). Since we are 267 * interested in the preempt_count at the time the tracepoint was 268 * hit, we need to subtract one to offset the increment. 269 */ 270 if (IS_ENABLED(CONFIG_PREEMPT)) 271 fbuffer->pc--; 272 fbuffer->trace_file = trace_file; 273 274 fbuffer->event = 275 trace_event_buffer_lock_reserve(&fbuffer->buffer, trace_file, 276 event_call->event.type, len, 277 fbuffer->flags, fbuffer->pc); 278 if (!fbuffer->event) 279 return NULL; 280 281 fbuffer->entry = ring_buffer_event_data(fbuffer->event); 282 return fbuffer->entry; 283 } 284 EXPORT_SYMBOL_GPL(trace_event_buffer_reserve); 285 286 int trace_event_reg(struct trace_event_call *call, 287 enum trace_reg type, void *data) 288 { 289 struct trace_event_file *file = data; 290 291 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT)); 292 switch (type) { 293 case TRACE_REG_REGISTER: 294 return tracepoint_probe_register(call->tp, 295 call->class->probe, 296 file); 297 case TRACE_REG_UNREGISTER: 298 tracepoint_probe_unregister(call->tp, 299 call->class->probe, 300 file); 301 return 0; 302 303 #ifdef CONFIG_PERF_EVENTS 304 case TRACE_REG_PERF_REGISTER: 305 return tracepoint_probe_register(call->tp, 306 call->class->perf_probe, 307 call); 308 case TRACE_REG_PERF_UNREGISTER: 309 tracepoint_probe_unregister(call->tp, 310 call->class->perf_probe, 311 call); 312 return 0; 313 case TRACE_REG_PERF_OPEN: 314 case TRACE_REG_PERF_CLOSE: 315 case TRACE_REG_PERF_ADD: 316 case TRACE_REG_PERF_DEL: 317 return 0; 318 #endif 319 } 320 return 0; 321 } 322 EXPORT_SYMBOL_GPL(trace_event_reg); 323 324 void trace_event_enable_cmd_record(bool enable) 325 { 326 struct trace_event_file *file; 327 struct trace_array *tr; 328 329 mutex_lock(&event_mutex); 330 do_for_each_event_file(tr, file) { 331 332 if (!(file->flags & EVENT_FILE_FL_ENABLED)) 333 continue; 334 335 if (enable) { 336 tracing_start_cmdline_record(); 337 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags); 338 } else { 339 tracing_stop_cmdline_record(); 340 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags); 341 } 342 } while_for_each_event_file(); 343 mutex_unlock(&event_mutex); 344 } 345 346 void trace_event_enable_tgid_record(bool enable) 347 { 348 struct trace_event_file *file; 349 struct trace_array *tr; 350 351 mutex_lock(&event_mutex); 352 do_for_each_event_file(tr, file) { 353 if (!(file->flags & EVENT_FILE_FL_ENABLED)) 354 continue; 355 356 if (enable) { 357 tracing_start_tgid_record(); 358 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags); 359 } else { 360 tracing_stop_tgid_record(); 361 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, 362 &file->flags); 363 } 364 } while_for_each_event_file(); 365 mutex_unlock(&event_mutex); 366 } 367 368 static int __ftrace_event_enable_disable(struct trace_event_file *file, 369 int enable, int soft_disable) 370 { 371 struct trace_event_call *call = file->event_call; 372 struct trace_array *tr = file->tr; 373 unsigned long file_flags = file->flags; 374 int ret = 0; 375 int disable; 376 377 switch (enable) { 378 case 0: 379 /* 380 * When soft_disable is set and enable is cleared, the sm_ref 381 * reference counter is decremented. If it reaches 0, we want 382 * to clear the SOFT_DISABLED flag but leave the event in the 383 * state that it was. That is, if the event was enabled and 384 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED 385 * is set we do not want the event to be enabled before we 386 * clear the bit. 387 * 388 * When soft_disable is not set but the SOFT_MODE flag is, 389 * we do nothing. Do not disable the tracepoint, otherwise 390 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work. 391 */ 392 if (soft_disable) { 393 if (atomic_dec_return(&file->sm_ref) > 0) 394 break; 395 disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED; 396 clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags); 397 } else 398 disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE); 399 400 if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) { 401 clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags); 402 if (file->flags & EVENT_FILE_FL_RECORDED_CMD) { 403 tracing_stop_cmdline_record(); 404 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags); 405 } 406 407 if (file->flags & EVENT_FILE_FL_RECORDED_TGID) { 408 tracing_stop_tgid_record(); 409 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags); 410 } 411 412 call->class->reg(call, TRACE_REG_UNREGISTER, file); 413 } 414 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */ 415 if (file->flags & EVENT_FILE_FL_SOFT_MODE) 416 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); 417 else 418 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); 419 break; 420 case 1: 421 /* 422 * When soft_disable is set and enable is set, we want to 423 * register the tracepoint for the event, but leave the event 424 * as is. That means, if the event was already enabled, we do 425 * nothing (but set SOFT_MODE). If the event is disabled, we 426 * set SOFT_DISABLED before enabling the event tracepoint, so 427 * it still seems to be disabled. 428 */ 429 if (!soft_disable) 430 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); 431 else { 432 if (atomic_inc_return(&file->sm_ref) > 1) 433 break; 434 set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags); 435 } 436 437 if (!(file->flags & EVENT_FILE_FL_ENABLED)) { 438 bool cmd = false, tgid = false; 439 440 /* Keep the event disabled, when going to SOFT_MODE. */ 441 if (soft_disable) 442 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags); 443 444 if (tr->trace_flags & TRACE_ITER_RECORD_CMD) { 445 cmd = true; 446 tracing_start_cmdline_record(); 447 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags); 448 } 449 450 if (tr->trace_flags & TRACE_ITER_RECORD_TGID) { 451 tgid = true; 452 tracing_start_tgid_record(); 453 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags); 454 } 455 456 ret = call->class->reg(call, TRACE_REG_REGISTER, file); 457 if (ret) { 458 if (cmd) 459 tracing_stop_cmdline_record(); 460 if (tgid) 461 tracing_stop_tgid_record(); 462 pr_info("event trace: Could not enable event " 463 "%s\n", trace_event_name(call)); 464 break; 465 } 466 set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags); 467 468 /* WAS_ENABLED gets set but never cleared. */ 469 set_bit(EVENT_FILE_FL_WAS_ENABLED_BIT, &file->flags); 470 } 471 break; 472 } 473 474 /* Enable or disable use of trace_buffered_event */ 475 if ((file_flags & EVENT_FILE_FL_SOFT_DISABLED) != 476 (file->flags & EVENT_FILE_FL_SOFT_DISABLED)) { 477 if (file->flags & EVENT_FILE_FL_SOFT_DISABLED) 478 trace_buffered_event_enable(); 479 else 480 trace_buffered_event_disable(); 481 } 482 483 return ret; 484 } 485 486 int trace_event_enable_disable(struct trace_event_file *file, 487 int enable, int soft_disable) 488 { 489 return __ftrace_event_enable_disable(file, enable, soft_disable); 490 } 491 492 static int ftrace_event_enable_disable(struct trace_event_file *file, 493 int enable) 494 { 495 return __ftrace_event_enable_disable(file, enable, 0); 496 } 497 498 static void ftrace_clear_events(struct trace_array *tr) 499 { 500 struct trace_event_file *file; 501 502 mutex_lock(&event_mutex); 503 list_for_each_entry(file, &tr->events, list) { 504 ftrace_event_enable_disable(file, 0); 505 } 506 mutex_unlock(&event_mutex); 507 } 508 509 static void 510 event_filter_pid_sched_process_exit(void *data, struct task_struct *task) 511 { 512 struct trace_pid_list *pid_list; 513 struct trace_array *tr = data; 514 515 pid_list = rcu_dereference_sched(tr->filtered_pids); 516 trace_filter_add_remove_task(pid_list, NULL, task); 517 } 518 519 static void 520 event_filter_pid_sched_process_fork(void *data, 521 struct task_struct *self, 522 struct task_struct *task) 523 { 524 struct trace_pid_list *pid_list; 525 struct trace_array *tr = data; 526 527 pid_list = rcu_dereference_sched(tr->filtered_pids); 528 trace_filter_add_remove_task(pid_list, self, task); 529 } 530 531 void trace_event_follow_fork(struct trace_array *tr, bool enable) 532 { 533 if (enable) { 534 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork, 535 tr, INT_MIN); 536 register_trace_prio_sched_process_exit(event_filter_pid_sched_process_exit, 537 tr, INT_MAX); 538 } else { 539 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork, 540 tr); 541 unregister_trace_sched_process_exit(event_filter_pid_sched_process_exit, 542 tr); 543 } 544 } 545 546 static void 547 event_filter_pid_sched_switch_probe_pre(void *data, bool preempt, 548 struct task_struct *prev, struct task_struct *next) 549 { 550 struct trace_array *tr = data; 551 struct trace_pid_list *pid_list; 552 553 pid_list = rcu_dereference_sched(tr->filtered_pids); 554 555 this_cpu_write(tr->trace_buffer.data->ignore_pid, 556 trace_ignore_this_task(pid_list, prev) && 557 trace_ignore_this_task(pid_list, next)); 558 } 559 560 static void 561 event_filter_pid_sched_switch_probe_post(void *data, bool preempt, 562 struct task_struct *prev, struct task_struct *next) 563 { 564 struct trace_array *tr = data; 565 struct trace_pid_list *pid_list; 566 567 pid_list = rcu_dereference_sched(tr->filtered_pids); 568 569 this_cpu_write(tr->trace_buffer.data->ignore_pid, 570 trace_ignore_this_task(pid_list, next)); 571 } 572 573 static void 574 event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task) 575 { 576 struct trace_array *tr = data; 577 struct trace_pid_list *pid_list; 578 579 /* Nothing to do if we are already tracing */ 580 if (!this_cpu_read(tr->trace_buffer.data->ignore_pid)) 581 return; 582 583 pid_list = rcu_dereference_sched(tr->filtered_pids); 584 585 this_cpu_write(tr->trace_buffer.data->ignore_pid, 586 trace_ignore_this_task(pid_list, task)); 587 } 588 589 static void 590 event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task) 591 { 592 struct trace_array *tr = data; 593 struct trace_pid_list *pid_list; 594 595 /* Nothing to do if we are not tracing */ 596 if (this_cpu_read(tr->trace_buffer.data->ignore_pid)) 597 return; 598 599 pid_list = rcu_dereference_sched(tr->filtered_pids); 600 601 /* Set tracing if current is enabled */ 602 this_cpu_write(tr->trace_buffer.data->ignore_pid, 603 trace_ignore_this_task(pid_list, current)); 604 } 605 606 static void __ftrace_clear_event_pids(struct trace_array *tr) 607 { 608 struct trace_pid_list *pid_list; 609 struct trace_event_file *file; 610 int cpu; 611 612 pid_list = rcu_dereference_protected(tr->filtered_pids, 613 lockdep_is_held(&event_mutex)); 614 if (!pid_list) 615 return; 616 617 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre, tr); 618 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post, tr); 619 620 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, tr); 621 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, tr); 622 623 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, tr); 624 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, tr); 625 626 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre, tr); 627 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post, tr); 628 629 list_for_each_entry(file, &tr->events, list) { 630 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags); 631 } 632 633 for_each_possible_cpu(cpu) 634 per_cpu_ptr(tr->trace_buffer.data, cpu)->ignore_pid = false; 635 636 rcu_assign_pointer(tr->filtered_pids, NULL); 637 638 /* Wait till all users are no longer using pid filtering */ 639 synchronize_sched(); 640 641 trace_free_pid_list(pid_list); 642 } 643 644 static void ftrace_clear_event_pids(struct trace_array *tr) 645 { 646 mutex_lock(&event_mutex); 647 __ftrace_clear_event_pids(tr); 648 mutex_unlock(&event_mutex); 649 } 650 651 static void __put_system(struct event_subsystem *system) 652 { 653 struct event_filter *filter = system->filter; 654 655 WARN_ON_ONCE(system_refcount(system) == 0); 656 if (system_refcount_dec(system)) 657 return; 658 659 list_del(&system->list); 660 661 if (filter) { 662 kfree(filter->filter_string); 663 kfree(filter); 664 } 665 kfree_const(system->name); 666 kfree(system); 667 } 668 669 static void __get_system(struct event_subsystem *system) 670 { 671 WARN_ON_ONCE(system_refcount(system) == 0); 672 system_refcount_inc(system); 673 } 674 675 static void __get_system_dir(struct trace_subsystem_dir *dir) 676 { 677 WARN_ON_ONCE(dir->ref_count == 0); 678 dir->ref_count++; 679 __get_system(dir->subsystem); 680 } 681 682 static void __put_system_dir(struct trace_subsystem_dir *dir) 683 { 684 WARN_ON_ONCE(dir->ref_count == 0); 685 /* If the subsystem is about to be freed, the dir must be too */ 686 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1); 687 688 __put_system(dir->subsystem); 689 if (!--dir->ref_count) 690 kfree(dir); 691 } 692 693 static void put_system(struct trace_subsystem_dir *dir) 694 { 695 mutex_lock(&event_mutex); 696 __put_system_dir(dir); 697 mutex_unlock(&event_mutex); 698 } 699 700 static void remove_subsystem(struct trace_subsystem_dir *dir) 701 { 702 if (!dir) 703 return; 704 705 if (!--dir->nr_events) { 706 tracefs_remove_recursive(dir->entry); 707 list_del(&dir->list); 708 __put_system_dir(dir); 709 } 710 } 711 712 static void remove_event_file_dir(struct trace_event_file *file) 713 { 714 struct dentry *dir = file->dir; 715 struct dentry *child; 716 717 if (dir) { 718 spin_lock(&dir->d_lock); /* probably unneeded */ 719 list_for_each_entry(child, &dir->d_subdirs, d_child) { 720 if (d_really_is_positive(child)) /* probably unneeded */ 721 d_inode(child)->i_private = NULL; 722 } 723 spin_unlock(&dir->d_lock); 724 725 tracefs_remove_recursive(dir); 726 } 727 728 list_del(&file->list); 729 remove_subsystem(file->system); 730 free_event_filter(file->filter); 731 kmem_cache_free(file_cachep, file); 732 } 733 734 /* 735 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events. 736 */ 737 static int 738 __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match, 739 const char *sub, const char *event, int set) 740 { 741 struct trace_event_file *file; 742 struct trace_event_call *call; 743 const char *name; 744 int ret = -EINVAL; 745 int eret = 0; 746 747 list_for_each_entry(file, &tr->events, list) { 748 749 call = file->event_call; 750 name = trace_event_name(call); 751 752 if (!name || !call->class || !call->class->reg) 753 continue; 754 755 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) 756 continue; 757 758 if (match && 759 strcmp(match, name) != 0 && 760 strcmp(match, call->class->system) != 0) 761 continue; 762 763 if (sub && strcmp(sub, call->class->system) != 0) 764 continue; 765 766 if (event && strcmp(event, name) != 0) 767 continue; 768 769 ret = ftrace_event_enable_disable(file, set); 770 771 /* 772 * Save the first error and return that. Some events 773 * may still have been enabled, but let the user 774 * know that something went wrong. 775 */ 776 if (ret && !eret) 777 eret = ret; 778 779 ret = eret; 780 } 781 782 return ret; 783 } 784 785 static int __ftrace_set_clr_event(struct trace_array *tr, const char *match, 786 const char *sub, const char *event, int set) 787 { 788 int ret; 789 790 mutex_lock(&event_mutex); 791 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set); 792 mutex_unlock(&event_mutex); 793 794 return ret; 795 } 796 797 static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set) 798 { 799 char *event = NULL, *sub = NULL, *match; 800 int ret; 801 802 /* 803 * The buf format can be <subsystem>:<event-name> 804 * *:<event-name> means any event by that name. 805 * :<event-name> is the same. 806 * 807 * <subsystem>:* means all events in that subsystem 808 * <subsystem>: means the same. 809 * 810 * <name> (no ':') means all events in a subsystem with 811 * the name <name> or any event that matches <name> 812 */ 813 814 match = strsep(&buf, ":"); 815 if (buf) { 816 sub = match; 817 event = buf; 818 match = NULL; 819 820 if (!strlen(sub) || strcmp(sub, "*") == 0) 821 sub = NULL; 822 if (!strlen(event) || strcmp(event, "*") == 0) 823 event = NULL; 824 } 825 826 ret = __ftrace_set_clr_event(tr, match, sub, event, set); 827 828 /* Put back the colon to allow this to be called again */ 829 if (buf) 830 *(buf - 1) = ':'; 831 832 return ret; 833 } 834 835 /** 836 * trace_set_clr_event - enable or disable an event 837 * @system: system name to match (NULL for any system) 838 * @event: event name to match (NULL for all events, within system) 839 * @set: 1 to enable, 0 to disable 840 * 841 * This is a way for other parts of the kernel to enable or disable 842 * event recording. 843 * 844 * Returns 0 on success, -EINVAL if the parameters do not match any 845 * registered events. 846 */ 847 int trace_set_clr_event(const char *system, const char *event, int set) 848 { 849 struct trace_array *tr = top_trace_array(); 850 851 if (!tr) 852 return -ENODEV; 853 854 return __ftrace_set_clr_event(tr, NULL, system, event, set); 855 } 856 EXPORT_SYMBOL_GPL(trace_set_clr_event); 857 858 /* 128 should be much more than enough */ 859 #define EVENT_BUF_SIZE 127 860 861 static ssize_t 862 ftrace_event_write(struct file *file, const char __user *ubuf, 863 size_t cnt, loff_t *ppos) 864 { 865 struct trace_parser parser; 866 struct seq_file *m = file->private_data; 867 struct trace_array *tr = m->private; 868 ssize_t read, ret; 869 870 if (!cnt) 871 return 0; 872 873 ret = tracing_update_buffers(); 874 if (ret < 0) 875 return ret; 876 877 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1)) 878 return -ENOMEM; 879 880 read = trace_get_user(&parser, ubuf, cnt, ppos); 881 882 if (read >= 0 && trace_parser_loaded((&parser))) { 883 int set = 1; 884 885 if (*parser.buffer == '!') 886 set = 0; 887 888 parser.buffer[parser.idx] = 0; 889 890 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set); 891 if (ret) 892 goto out_put; 893 } 894 895 ret = read; 896 897 out_put: 898 trace_parser_put(&parser); 899 900 return ret; 901 } 902 903 static void * 904 t_next(struct seq_file *m, void *v, loff_t *pos) 905 { 906 struct trace_event_file *file = v; 907 struct trace_event_call *call; 908 struct trace_array *tr = m->private; 909 910 (*pos)++; 911 912 list_for_each_entry_continue(file, &tr->events, list) { 913 call = file->event_call; 914 /* 915 * The ftrace subsystem is for showing formats only. 916 * They can not be enabled or disabled via the event files. 917 */ 918 if (call->class && call->class->reg && 919 !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) 920 return file; 921 } 922 923 return NULL; 924 } 925 926 static void *t_start(struct seq_file *m, loff_t *pos) 927 { 928 struct trace_event_file *file; 929 struct trace_array *tr = m->private; 930 loff_t l; 931 932 mutex_lock(&event_mutex); 933 934 file = list_entry(&tr->events, struct trace_event_file, list); 935 for (l = 0; l <= *pos; ) { 936 file = t_next(m, file, &l); 937 if (!file) 938 break; 939 } 940 return file; 941 } 942 943 static void * 944 s_next(struct seq_file *m, void *v, loff_t *pos) 945 { 946 struct trace_event_file *file = v; 947 struct trace_array *tr = m->private; 948 949 (*pos)++; 950 951 list_for_each_entry_continue(file, &tr->events, list) { 952 if (file->flags & EVENT_FILE_FL_ENABLED) 953 return file; 954 } 955 956 return NULL; 957 } 958 959 static void *s_start(struct seq_file *m, loff_t *pos) 960 { 961 struct trace_event_file *file; 962 struct trace_array *tr = m->private; 963 loff_t l; 964 965 mutex_lock(&event_mutex); 966 967 file = list_entry(&tr->events, struct trace_event_file, list); 968 for (l = 0; l <= *pos; ) { 969 file = s_next(m, file, &l); 970 if (!file) 971 break; 972 } 973 return file; 974 } 975 976 static int t_show(struct seq_file *m, void *v) 977 { 978 struct trace_event_file *file = v; 979 struct trace_event_call *call = file->event_call; 980 981 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) 982 seq_printf(m, "%s:", call->class->system); 983 seq_printf(m, "%s\n", trace_event_name(call)); 984 985 return 0; 986 } 987 988 static void t_stop(struct seq_file *m, void *p) 989 { 990 mutex_unlock(&event_mutex); 991 } 992 993 static void * 994 p_next(struct seq_file *m, void *v, loff_t *pos) 995 { 996 struct trace_array *tr = m->private; 997 struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids); 998 999 return trace_pid_next(pid_list, v, pos); 1000 } 1001 1002 static void *p_start(struct seq_file *m, loff_t *pos) 1003 __acquires(RCU) 1004 { 1005 struct trace_pid_list *pid_list; 1006 struct trace_array *tr = m->private; 1007 1008 /* 1009 * Grab the mutex, to keep calls to p_next() having the same 1010 * tr->filtered_pids as p_start() has. 1011 * If we just passed the tr->filtered_pids around, then RCU would 1012 * have been enough, but doing that makes things more complex. 1013 */ 1014 mutex_lock(&event_mutex); 1015 rcu_read_lock_sched(); 1016 1017 pid_list = rcu_dereference_sched(tr->filtered_pids); 1018 1019 if (!pid_list) 1020 return NULL; 1021 1022 return trace_pid_start(pid_list, pos); 1023 } 1024 1025 static void p_stop(struct seq_file *m, void *p) 1026 __releases(RCU) 1027 { 1028 rcu_read_unlock_sched(); 1029 mutex_unlock(&event_mutex); 1030 } 1031 1032 static ssize_t 1033 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 1034 loff_t *ppos) 1035 { 1036 struct trace_event_file *file; 1037 unsigned long flags; 1038 char buf[4] = "0"; 1039 1040 mutex_lock(&event_mutex); 1041 file = event_file_data(filp); 1042 if (likely(file)) 1043 flags = file->flags; 1044 mutex_unlock(&event_mutex); 1045 1046 if (!file) 1047 return -ENODEV; 1048 1049 if (flags & EVENT_FILE_FL_ENABLED && 1050 !(flags & EVENT_FILE_FL_SOFT_DISABLED)) 1051 strcpy(buf, "1"); 1052 1053 if (flags & EVENT_FILE_FL_SOFT_DISABLED || 1054 flags & EVENT_FILE_FL_SOFT_MODE) 1055 strcat(buf, "*"); 1056 1057 strcat(buf, "\n"); 1058 1059 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf)); 1060 } 1061 1062 static ssize_t 1063 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 1064 loff_t *ppos) 1065 { 1066 struct trace_event_file *file; 1067 unsigned long val; 1068 int ret; 1069 1070 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 1071 if (ret) 1072 return ret; 1073 1074 ret = tracing_update_buffers(); 1075 if (ret < 0) 1076 return ret; 1077 1078 switch (val) { 1079 case 0: 1080 case 1: 1081 ret = -ENODEV; 1082 mutex_lock(&event_mutex); 1083 file = event_file_data(filp); 1084 if (likely(file)) 1085 ret = ftrace_event_enable_disable(file, val); 1086 mutex_unlock(&event_mutex); 1087 break; 1088 1089 default: 1090 return -EINVAL; 1091 } 1092 1093 *ppos += cnt; 1094 1095 return ret ? ret : cnt; 1096 } 1097 1098 static ssize_t 1099 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt, 1100 loff_t *ppos) 1101 { 1102 const char set_to_char[4] = { '?', '0', '1', 'X' }; 1103 struct trace_subsystem_dir *dir = filp->private_data; 1104 struct event_subsystem *system = dir->subsystem; 1105 struct trace_event_call *call; 1106 struct trace_event_file *file; 1107 struct trace_array *tr = dir->tr; 1108 char buf[2]; 1109 int set = 0; 1110 int ret; 1111 1112 mutex_lock(&event_mutex); 1113 list_for_each_entry(file, &tr->events, list) { 1114 call = file->event_call; 1115 if (!trace_event_name(call) || !call->class || !call->class->reg) 1116 continue; 1117 1118 if (system && strcmp(call->class->system, system->name) != 0) 1119 continue; 1120 1121 /* 1122 * We need to find out if all the events are set 1123 * or if all events or cleared, or if we have 1124 * a mixture. 1125 */ 1126 set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED)); 1127 1128 /* 1129 * If we have a mixture, no need to look further. 1130 */ 1131 if (set == 3) 1132 break; 1133 } 1134 mutex_unlock(&event_mutex); 1135 1136 buf[0] = set_to_char[set]; 1137 buf[1] = '\n'; 1138 1139 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2); 1140 1141 return ret; 1142 } 1143 1144 static ssize_t 1145 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt, 1146 loff_t *ppos) 1147 { 1148 struct trace_subsystem_dir *dir = filp->private_data; 1149 struct event_subsystem *system = dir->subsystem; 1150 const char *name = NULL; 1151 unsigned long val; 1152 ssize_t ret; 1153 1154 ret = kstrtoul_from_user(ubuf, cnt, 10, &val); 1155 if (ret) 1156 return ret; 1157 1158 ret = tracing_update_buffers(); 1159 if (ret < 0) 1160 return ret; 1161 1162 if (val != 0 && val != 1) 1163 return -EINVAL; 1164 1165 /* 1166 * Opening of "enable" adds a ref count to system, 1167 * so the name is safe to use. 1168 */ 1169 if (system) 1170 name = system->name; 1171 1172 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val); 1173 if (ret) 1174 goto out; 1175 1176 ret = cnt; 1177 1178 out: 1179 *ppos += cnt; 1180 1181 return ret; 1182 } 1183 1184 enum { 1185 FORMAT_HEADER = 1, 1186 FORMAT_FIELD_SEPERATOR = 2, 1187 FORMAT_PRINTFMT = 3, 1188 }; 1189 1190 static void *f_next(struct seq_file *m, void *v, loff_t *pos) 1191 { 1192 struct trace_event_call *call = event_file_data(m->private); 1193 struct list_head *common_head = &ftrace_common_fields; 1194 struct list_head *head = trace_get_fields(call); 1195 struct list_head *node = v; 1196 1197 (*pos)++; 1198 1199 switch ((unsigned long)v) { 1200 case FORMAT_HEADER: 1201 node = common_head; 1202 break; 1203 1204 case FORMAT_FIELD_SEPERATOR: 1205 node = head; 1206 break; 1207 1208 case FORMAT_PRINTFMT: 1209 /* all done */ 1210 return NULL; 1211 } 1212 1213 node = node->prev; 1214 if (node == common_head) 1215 return (void *)FORMAT_FIELD_SEPERATOR; 1216 else if (node == head) 1217 return (void *)FORMAT_PRINTFMT; 1218 else 1219 return node; 1220 } 1221 1222 static int f_show(struct seq_file *m, void *v) 1223 { 1224 struct trace_event_call *call = event_file_data(m->private); 1225 struct ftrace_event_field *field; 1226 const char *array_descriptor; 1227 1228 switch ((unsigned long)v) { 1229 case FORMAT_HEADER: 1230 seq_printf(m, "name: %s\n", trace_event_name(call)); 1231 seq_printf(m, "ID: %d\n", call->event.type); 1232 seq_puts(m, "format:\n"); 1233 return 0; 1234 1235 case FORMAT_FIELD_SEPERATOR: 1236 seq_putc(m, '\n'); 1237 return 0; 1238 1239 case FORMAT_PRINTFMT: 1240 seq_printf(m, "\nprint fmt: %s\n", 1241 call->print_fmt); 1242 return 0; 1243 } 1244 1245 field = list_entry(v, struct ftrace_event_field, link); 1246 /* 1247 * Smartly shows the array type(except dynamic array). 1248 * Normal: 1249 * field:TYPE VAR 1250 * If TYPE := TYPE[LEN], it is shown: 1251 * field:TYPE VAR[LEN] 1252 */ 1253 array_descriptor = strchr(field->type, '['); 1254 1255 if (!strncmp(field->type, "__data_loc", 10)) 1256 array_descriptor = NULL; 1257 1258 if (!array_descriptor) 1259 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 1260 field->type, field->name, field->offset, 1261 field->size, !!field->is_signed); 1262 else 1263 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n", 1264 (int)(array_descriptor - field->type), 1265 field->type, field->name, 1266 array_descriptor, field->offset, 1267 field->size, !!field->is_signed); 1268 1269 return 0; 1270 } 1271 1272 static void *f_start(struct seq_file *m, loff_t *pos) 1273 { 1274 void *p = (void *)FORMAT_HEADER; 1275 loff_t l = 0; 1276 1277 /* ->stop() is called even if ->start() fails */ 1278 mutex_lock(&event_mutex); 1279 if (!event_file_data(m->private)) 1280 return ERR_PTR(-ENODEV); 1281 1282 while (l < *pos && p) 1283 p = f_next(m, p, &l); 1284 1285 return p; 1286 } 1287 1288 static void f_stop(struct seq_file *m, void *p) 1289 { 1290 mutex_unlock(&event_mutex); 1291 } 1292 1293 static const struct seq_operations trace_format_seq_ops = { 1294 .start = f_start, 1295 .next = f_next, 1296 .stop = f_stop, 1297 .show = f_show, 1298 }; 1299 1300 static int trace_format_open(struct inode *inode, struct file *file) 1301 { 1302 struct seq_file *m; 1303 int ret; 1304 1305 ret = seq_open(file, &trace_format_seq_ops); 1306 if (ret < 0) 1307 return ret; 1308 1309 m = file->private_data; 1310 m->private = file; 1311 1312 return 0; 1313 } 1314 1315 static ssize_t 1316 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1317 { 1318 int id = (long)event_file_data(filp); 1319 char buf[32]; 1320 int len; 1321 1322 if (*ppos) 1323 return 0; 1324 1325 if (unlikely(!id)) 1326 return -ENODEV; 1327 1328 len = sprintf(buf, "%d\n", id); 1329 1330 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len); 1331 } 1332 1333 static ssize_t 1334 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1335 loff_t *ppos) 1336 { 1337 struct trace_event_file *file; 1338 struct trace_seq *s; 1339 int r = -ENODEV; 1340 1341 if (*ppos) 1342 return 0; 1343 1344 s = kmalloc(sizeof(*s), GFP_KERNEL); 1345 1346 if (!s) 1347 return -ENOMEM; 1348 1349 trace_seq_init(s); 1350 1351 mutex_lock(&event_mutex); 1352 file = event_file_data(filp); 1353 if (file) 1354 print_event_filter(file, s); 1355 mutex_unlock(&event_mutex); 1356 1357 if (file) 1358 r = simple_read_from_buffer(ubuf, cnt, ppos, 1359 s->buffer, trace_seq_used(s)); 1360 1361 kfree(s); 1362 1363 return r; 1364 } 1365 1366 static ssize_t 1367 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1368 loff_t *ppos) 1369 { 1370 struct trace_event_file *file; 1371 char *buf; 1372 int err = -ENODEV; 1373 1374 if (cnt >= PAGE_SIZE) 1375 return -EINVAL; 1376 1377 buf = memdup_user_nul(ubuf, cnt); 1378 if (IS_ERR(buf)) 1379 return PTR_ERR(buf); 1380 1381 mutex_lock(&event_mutex); 1382 file = event_file_data(filp); 1383 if (file) 1384 err = apply_event_filter(file, buf); 1385 mutex_unlock(&event_mutex); 1386 1387 kfree(buf); 1388 if (err < 0) 1389 return err; 1390 1391 *ppos += cnt; 1392 1393 return cnt; 1394 } 1395 1396 static LIST_HEAD(event_subsystems); 1397 1398 static int subsystem_open(struct inode *inode, struct file *filp) 1399 { 1400 struct event_subsystem *system = NULL; 1401 struct trace_subsystem_dir *dir = NULL; /* Initialize for gcc */ 1402 struct trace_array *tr; 1403 int ret; 1404 1405 if (tracing_is_disabled()) 1406 return -ENODEV; 1407 1408 /* Make sure the system still exists */ 1409 mutex_lock(&event_mutex); 1410 mutex_lock(&trace_types_lock); 1411 list_for_each_entry(tr, &ftrace_trace_arrays, list) { 1412 list_for_each_entry(dir, &tr->systems, list) { 1413 if (dir == inode->i_private) { 1414 /* Don't open systems with no events */ 1415 if (dir->nr_events) { 1416 __get_system_dir(dir); 1417 system = dir->subsystem; 1418 } 1419 goto exit_loop; 1420 } 1421 } 1422 } 1423 exit_loop: 1424 mutex_unlock(&trace_types_lock); 1425 mutex_unlock(&event_mutex); 1426 1427 if (!system) 1428 return -ENODEV; 1429 1430 /* Some versions of gcc think dir can be uninitialized here */ 1431 WARN_ON(!dir); 1432 1433 /* Still need to increment the ref count of the system */ 1434 if (trace_array_get(tr) < 0) { 1435 put_system(dir); 1436 return -ENODEV; 1437 } 1438 1439 ret = tracing_open_generic(inode, filp); 1440 if (ret < 0) { 1441 trace_array_put(tr); 1442 put_system(dir); 1443 } 1444 1445 return ret; 1446 } 1447 1448 static int system_tr_open(struct inode *inode, struct file *filp) 1449 { 1450 struct trace_subsystem_dir *dir; 1451 struct trace_array *tr = inode->i_private; 1452 int ret; 1453 1454 if (tracing_is_disabled()) 1455 return -ENODEV; 1456 1457 if (trace_array_get(tr) < 0) 1458 return -ENODEV; 1459 1460 /* Make a temporary dir that has no system but points to tr */ 1461 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1462 if (!dir) { 1463 trace_array_put(tr); 1464 return -ENOMEM; 1465 } 1466 1467 dir->tr = tr; 1468 1469 ret = tracing_open_generic(inode, filp); 1470 if (ret < 0) { 1471 trace_array_put(tr); 1472 kfree(dir); 1473 return ret; 1474 } 1475 1476 filp->private_data = dir; 1477 1478 return 0; 1479 } 1480 1481 static int subsystem_release(struct inode *inode, struct file *file) 1482 { 1483 struct trace_subsystem_dir *dir = file->private_data; 1484 1485 trace_array_put(dir->tr); 1486 1487 /* 1488 * If dir->subsystem is NULL, then this is a temporary 1489 * descriptor that was made for a trace_array to enable 1490 * all subsystems. 1491 */ 1492 if (dir->subsystem) 1493 put_system(dir); 1494 else 1495 kfree(dir); 1496 1497 return 0; 1498 } 1499 1500 static ssize_t 1501 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt, 1502 loff_t *ppos) 1503 { 1504 struct trace_subsystem_dir *dir = filp->private_data; 1505 struct event_subsystem *system = dir->subsystem; 1506 struct trace_seq *s; 1507 int r; 1508 1509 if (*ppos) 1510 return 0; 1511 1512 s = kmalloc(sizeof(*s), GFP_KERNEL); 1513 if (!s) 1514 return -ENOMEM; 1515 1516 trace_seq_init(s); 1517 1518 print_subsystem_event_filter(system, s); 1519 r = simple_read_from_buffer(ubuf, cnt, ppos, 1520 s->buffer, trace_seq_used(s)); 1521 1522 kfree(s); 1523 1524 return r; 1525 } 1526 1527 static ssize_t 1528 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt, 1529 loff_t *ppos) 1530 { 1531 struct trace_subsystem_dir *dir = filp->private_data; 1532 char *buf; 1533 int err; 1534 1535 if (cnt >= PAGE_SIZE) 1536 return -EINVAL; 1537 1538 buf = memdup_user_nul(ubuf, cnt); 1539 if (IS_ERR(buf)) 1540 return PTR_ERR(buf); 1541 1542 err = apply_subsystem_event_filter(dir, buf); 1543 kfree(buf); 1544 if (err < 0) 1545 return err; 1546 1547 *ppos += cnt; 1548 1549 return cnt; 1550 } 1551 1552 static ssize_t 1553 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) 1554 { 1555 int (*func)(struct trace_seq *s) = filp->private_data; 1556 struct trace_seq *s; 1557 int r; 1558 1559 if (*ppos) 1560 return 0; 1561 1562 s = kmalloc(sizeof(*s), GFP_KERNEL); 1563 if (!s) 1564 return -ENOMEM; 1565 1566 trace_seq_init(s); 1567 1568 func(s); 1569 r = simple_read_from_buffer(ubuf, cnt, ppos, 1570 s->buffer, trace_seq_used(s)); 1571 1572 kfree(s); 1573 1574 return r; 1575 } 1576 1577 static void ignore_task_cpu(void *data) 1578 { 1579 struct trace_array *tr = data; 1580 struct trace_pid_list *pid_list; 1581 1582 /* 1583 * This function is called by on_each_cpu() while the 1584 * event_mutex is held. 1585 */ 1586 pid_list = rcu_dereference_protected(tr->filtered_pids, 1587 mutex_is_locked(&event_mutex)); 1588 1589 this_cpu_write(tr->trace_buffer.data->ignore_pid, 1590 trace_ignore_this_task(pid_list, current)); 1591 } 1592 1593 static ssize_t 1594 ftrace_event_pid_write(struct file *filp, const char __user *ubuf, 1595 size_t cnt, loff_t *ppos) 1596 { 1597 struct seq_file *m = filp->private_data; 1598 struct trace_array *tr = m->private; 1599 struct trace_pid_list *filtered_pids = NULL; 1600 struct trace_pid_list *pid_list; 1601 struct trace_event_file *file; 1602 ssize_t ret; 1603 1604 if (!cnt) 1605 return 0; 1606 1607 ret = tracing_update_buffers(); 1608 if (ret < 0) 1609 return ret; 1610 1611 mutex_lock(&event_mutex); 1612 1613 filtered_pids = rcu_dereference_protected(tr->filtered_pids, 1614 lockdep_is_held(&event_mutex)); 1615 1616 ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt); 1617 if (ret < 0) 1618 goto out; 1619 1620 rcu_assign_pointer(tr->filtered_pids, pid_list); 1621 1622 list_for_each_entry(file, &tr->events, list) { 1623 set_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags); 1624 } 1625 1626 if (filtered_pids) { 1627 synchronize_sched(); 1628 trace_free_pid_list(filtered_pids); 1629 } else if (pid_list) { 1630 /* 1631 * Register a probe that is called before all other probes 1632 * to set ignore_pid if next or prev do not match. 1633 * Register a probe this is called after all other probes 1634 * to only keep ignore_pid set if next pid matches. 1635 */ 1636 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre, 1637 tr, INT_MAX); 1638 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post, 1639 tr, 0); 1640 1641 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, 1642 tr, INT_MAX); 1643 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, 1644 tr, 0); 1645 1646 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, 1647 tr, INT_MAX); 1648 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, 1649 tr, 0); 1650 1651 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre, 1652 tr, INT_MAX); 1653 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post, 1654 tr, 0); 1655 } 1656 1657 /* 1658 * Ignoring of pids is done at task switch. But we have to 1659 * check for those tasks that are currently running. 1660 * Always do this in case a pid was appended or removed. 1661 */ 1662 on_each_cpu(ignore_task_cpu, tr, 1); 1663 1664 out: 1665 mutex_unlock(&event_mutex); 1666 1667 if (ret > 0) 1668 *ppos += ret; 1669 1670 return ret; 1671 } 1672 1673 static int ftrace_event_avail_open(struct inode *inode, struct file *file); 1674 static int ftrace_event_set_open(struct inode *inode, struct file *file); 1675 static int ftrace_event_set_pid_open(struct inode *inode, struct file *file); 1676 static int ftrace_event_release(struct inode *inode, struct file *file); 1677 1678 static const struct seq_operations show_event_seq_ops = { 1679 .start = t_start, 1680 .next = t_next, 1681 .show = t_show, 1682 .stop = t_stop, 1683 }; 1684 1685 static const struct seq_operations show_set_event_seq_ops = { 1686 .start = s_start, 1687 .next = s_next, 1688 .show = t_show, 1689 .stop = t_stop, 1690 }; 1691 1692 static const struct seq_operations show_set_pid_seq_ops = { 1693 .start = p_start, 1694 .next = p_next, 1695 .show = trace_pid_show, 1696 .stop = p_stop, 1697 }; 1698 1699 static const struct file_operations ftrace_avail_fops = { 1700 .open = ftrace_event_avail_open, 1701 .read = seq_read, 1702 .llseek = seq_lseek, 1703 .release = seq_release, 1704 }; 1705 1706 static const struct file_operations ftrace_set_event_fops = { 1707 .open = ftrace_event_set_open, 1708 .read = seq_read, 1709 .write = ftrace_event_write, 1710 .llseek = seq_lseek, 1711 .release = ftrace_event_release, 1712 }; 1713 1714 static const struct file_operations ftrace_set_event_pid_fops = { 1715 .open = ftrace_event_set_pid_open, 1716 .read = seq_read, 1717 .write = ftrace_event_pid_write, 1718 .llseek = seq_lseek, 1719 .release = ftrace_event_release, 1720 }; 1721 1722 static const struct file_operations ftrace_enable_fops = { 1723 .open = tracing_open_generic, 1724 .read = event_enable_read, 1725 .write = event_enable_write, 1726 .llseek = default_llseek, 1727 }; 1728 1729 static const struct file_operations ftrace_event_format_fops = { 1730 .open = trace_format_open, 1731 .read = seq_read, 1732 .llseek = seq_lseek, 1733 .release = seq_release, 1734 }; 1735 1736 static const struct file_operations ftrace_event_id_fops = { 1737 .read = event_id_read, 1738 .llseek = default_llseek, 1739 }; 1740 1741 static const struct file_operations ftrace_event_filter_fops = { 1742 .open = tracing_open_generic, 1743 .read = event_filter_read, 1744 .write = event_filter_write, 1745 .llseek = default_llseek, 1746 }; 1747 1748 static const struct file_operations ftrace_subsystem_filter_fops = { 1749 .open = subsystem_open, 1750 .read = subsystem_filter_read, 1751 .write = subsystem_filter_write, 1752 .llseek = default_llseek, 1753 .release = subsystem_release, 1754 }; 1755 1756 static const struct file_operations ftrace_system_enable_fops = { 1757 .open = subsystem_open, 1758 .read = system_enable_read, 1759 .write = system_enable_write, 1760 .llseek = default_llseek, 1761 .release = subsystem_release, 1762 }; 1763 1764 static const struct file_operations ftrace_tr_enable_fops = { 1765 .open = system_tr_open, 1766 .read = system_enable_read, 1767 .write = system_enable_write, 1768 .llseek = default_llseek, 1769 .release = subsystem_release, 1770 }; 1771 1772 static const struct file_operations ftrace_show_header_fops = { 1773 .open = tracing_open_generic, 1774 .read = show_header, 1775 .llseek = default_llseek, 1776 }; 1777 1778 static int 1779 ftrace_event_open(struct inode *inode, struct file *file, 1780 const struct seq_operations *seq_ops) 1781 { 1782 struct seq_file *m; 1783 int ret; 1784 1785 ret = seq_open(file, seq_ops); 1786 if (ret < 0) 1787 return ret; 1788 m = file->private_data; 1789 /* copy tr over to seq ops */ 1790 m->private = inode->i_private; 1791 1792 return ret; 1793 } 1794 1795 static int ftrace_event_release(struct inode *inode, struct file *file) 1796 { 1797 struct trace_array *tr = inode->i_private; 1798 1799 trace_array_put(tr); 1800 1801 return seq_release(inode, file); 1802 } 1803 1804 static int 1805 ftrace_event_avail_open(struct inode *inode, struct file *file) 1806 { 1807 const struct seq_operations *seq_ops = &show_event_seq_ops; 1808 1809 return ftrace_event_open(inode, file, seq_ops); 1810 } 1811 1812 static int 1813 ftrace_event_set_open(struct inode *inode, struct file *file) 1814 { 1815 const struct seq_operations *seq_ops = &show_set_event_seq_ops; 1816 struct trace_array *tr = inode->i_private; 1817 int ret; 1818 1819 if (trace_array_get(tr) < 0) 1820 return -ENODEV; 1821 1822 if ((file->f_mode & FMODE_WRITE) && 1823 (file->f_flags & O_TRUNC)) 1824 ftrace_clear_events(tr); 1825 1826 ret = ftrace_event_open(inode, file, seq_ops); 1827 if (ret < 0) 1828 trace_array_put(tr); 1829 return ret; 1830 } 1831 1832 static int 1833 ftrace_event_set_pid_open(struct inode *inode, struct file *file) 1834 { 1835 const struct seq_operations *seq_ops = &show_set_pid_seq_ops; 1836 struct trace_array *tr = inode->i_private; 1837 int ret; 1838 1839 if (trace_array_get(tr) < 0) 1840 return -ENODEV; 1841 1842 if ((file->f_mode & FMODE_WRITE) && 1843 (file->f_flags & O_TRUNC)) 1844 ftrace_clear_event_pids(tr); 1845 1846 ret = ftrace_event_open(inode, file, seq_ops); 1847 if (ret < 0) 1848 trace_array_put(tr); 1849 return ret; 1850 } 1851 1852 static struct event_subsystem * 1853 create_new_subsystem(const char *name) 1854 { 1855 struct event_subsystem *system; 1856 1857 /* need to create new entry */ 1858 system = kmalloc(sizeof(*system), GFP_KERNEL); 1859 if (!system) 1860 return NULL; 1861 1862 system->ref_count = 1; 1863 1864 /* Only allocate if dynamic (kprobes and modules) */ 1865 system->name = kstrdup_const(name, GFP_KERNEL); 1866 if (!system->name) 1867 goto out_free; 1868 1869 system->filter = NULL; 1870 1871 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL); 1872 if (!system->filter) 1873 goto out_free; 1874 1875 list_add(&system->list, &event_subsystems); 1876 1877 return system; 1878 1879 out_free: 1880 kfree_const(system->name); 1881 kfree(system); 1882 return NULL; 1883 } 1884 1885 static struct dentry * 1886 event_subsystem_dir(struct trace_array *tr, const char *name, 1887 struct trace_event_file *file, struct dentry *parent) 1888 { 1889 struct trace_subsystem_dir *dir; 1890 struct event_subsystem *system; 1891 struct dentry *entry; 1892 1893 /* First see if we did not already create this dir */ 1894 list_for_each_entry(dir, &tr->systems, list) { 1895 system = dir->subsystem; 1896 if (strcmp(system->name, name) == 0) { 1897 dir->nr_events++; 1898 file->system = dir; 1899 return dir->entry; 1900 } 1901 } 1902 1903 /* Now see if the system itself exists. */ 1904 list_for_each_entry(system, &event_subsystems, list) { 1905 if (strcmp(system->name, name) == 0) 1906 break; 1907 } 1908 /* Reset system variable when not found */ 1909 if (&system->list == &event_subsystems) 1910 system = NULL; 1911 1912 dir = kmalloc(sizeof(*dir), GFP_KERNEL); 1913 if (!dir) 1914 goto out_fail; 1915 1916 if (!system) { 1917 system = create_new_subsystem(name); 1918 if (!system) 1919 goto out_free; 1920 } else 1921 __get_system(system); 1922 1923 dir->entry = tracefs_create_dir(name, parent); 1924 if (!dir->entry) { 1925 pr_warn("Failed to create system directory %s\n", name); 1926 __put_system(system); 1927 goto out_free; 1928 } 1929 1930 dir->tr = tr; 1931 dir->ref_count = 1; 1932 dir->nr_events = 1; 1933 dir->subsystem = system; 1934 file->system = dir; 1935 1936 entry = tracefs_create_file("filter", 0644, dir->entry, dir, 1937 &ftrace_subsystem_filter_fops); 1938 if (!entry) { 1939 kfree(system->filter); 1940 system->filter = NULL; 1941 pr_warn("Could not create tracefs '%s/filter' entry\n", name); 1942 } 1943 1944 trace_create_file("enable", 0644, dir->entry, dir, 1945 &ftrace_system_enable_fops); 1946 1947 list_add(&dir->list, &tr->systems); 1948 1949 return dir->entry; 1950 1951 out_free: 1952 kfree(dir); 1953 out_fail: 1954 /* Only print this message if failed on memory allocation */ 1955 if (!dir || !system) 1956 pr_warn("No memory to create event subsystem %s\n", name); 1957 return NULL; 1958 } 1959 1960 static int 1961 event_create_dir(struct dentry *parent, struct trace_event_file *file) 1962 { 1963 struct trace_event_call *call = file->event_call; 1964 struct trace_array *tr = file->tr; 1965 struct list_head *head; 1966 struct dentry *d_events; 1967 const char *name; 1968 int ret; 1969 1970 /* 1971 * If the trace point header did not define TRACE_SYSTEM 1972 * then the system would be called "TRACE_SYSTEM". 1973 */ 1974 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) { 1975 d_events = event_subsystem_dir(tr, call->class->system, file, parent); 1976 if (!d_events) 1977 return -ENOMEM; 1978 } else 1979 d_events = parent; 1980 1981 name = trace_event_name(call); 1982 file->dir = tracefs_create_dir(name, d_events); 1983 if (!file->dir) { 1984 pr_warn("Could not create tracefs '%s' directory\n", name); 1985 return -1; 1986 } 1987 1988 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) 1989 trace_create_file("enable", 0644, file->dir, file, 1990 &ftrace_enable_fops); 1991 1992 #ifdef CONFIG_PERF_EVENTS 1993 if (call->event.type && call->class->reg) 1994 trace_create_file("id", 0444, file->dir, 1995 (void *)(long)call->event.type, 1996 &ftrace_event_id_fops); 1997 #endif 1998 1999 /* 2000 * Other events may have the same class. Only update 2001 * the fields if they are not already defined. 2002 */ 2003 head = trace_get_fields(call); 2004 if (list_empty(head)) { 2005 ret = call->class->define_fields(call); 2006 if (ret < 0) { 2007 pr_warn("Could not initialize trace point events/%s\n", 2008 name); 2009 return -1; 2010 } 2011 } 2012 trace_create_file("filter", 0644, file->dir, file, 2013 &ftrace_event_filter_fops); 2014 2015 /* 2016 * Only event directories that can be enabled should have 2017 * triggers. 2018 */ 2019 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) 2020 trace_create_file("trigger", 0644, file->dir, file, 2021 &event_trigger_fops); 2022 2023 #ifdef CONFIG_HIST_TRIGGERS 2024 trace_create_file("hist", 0444, file->dir, file, 2025 &event_hist_fops); 2026 #endif 2027 trace_create_file("format", 0444, file->dir, call, 2028 &ftrace_event_format_fops); 2029 2030 return 0; 2031 } 2032 2033 static void remove_event_from_tracers(struct trace_event_call *call) 2034 { 2035 struct trace_event_file *file; 2036 struct trace_array *tr; 2037 2038 do_for_each_event_file_safe(tr, file) { 2039 if (file->event_call != call) 2040 continue; 2041 2042 remove_event_file_dir(file); 2043 /* 2044 * The do_for_each_event_file_safe() is 2045 * a double loop. After finding the call for this 2046 * trace_array, we use break to jump to the next 2047 * trace_array. 2048 */ 2049 break; 2050 } while_for_each_event_file(); 2051 } 2052 2053 static void event_remove(struct trace_event_call *call) 2054 { 2055 struct trace_array *tr; 2056 struct trace_event_file *file; 2057 2058 do_for_each_event_file(tr, file) { 2059 if (file->event_call != call) 2060 continue; 2061 2062 if (file->flags & EVENT_FILE_FL_WAS_ENABLED) 2063 tr->clear_trace = true; 2064 2065 ftrace_event_enable_disable(file, 0); 2066 /* 2067 * The do_for_each_event_file() is 2068 * a double loop. After finding the call for this 2069 * trace_array, we use break to jump to the next 2070 * trace_array. 2071 */ 2072 break; 2073 } while_for_each_event_file(); 2074 2075 if (call->event.funcs) 2076 __unregister_trace_event(&call->event); 2077 remove_event_from_tracers(call); 2078 list_del(&call->list); 2079 } 2080 2081 static int event_init(struct trace_event_call *call) 2082 { 2083 int ret = 0; 2084 const char *name; 2085 2086 name = trace_event_name(call); 2087 if (WARN_ON(!name)) 2088 return -EINVAL; 2089 2090 if (call->class->raw_init) { 2091 ret = call->class->raw_init(call); 2092 if (ret < 0 && ret != -ENOSYS) 2093 pr_warn("Could not initialize trace events/%s\n", name); 2094 } 2095 2096 return ret; 2097 } 2098 2099 static int 2100 __register_event(struct trace_event_call *call, struct module *mod) 2101 { 2102 int ret; 2103 2104 ret = event_init(call); 2105 if (ret < 0) 2106 return ret; 2107 2108 list_add(&call->list, &ftrace_events); 2109 call->mod = mod; 2110 2111 return 0; 2112 } 2113 2114 static char *eval_replace(char *ptr, struct trace_eval_map *map, int len) 2115 { 2116 int rlen; 2117 int elen; 2118 2119 /* Find the length of the eval value as a string */ 2120 elen = snprintf(ptr, 0, "%ld", map->eval_value); 2121 /* Make sure there's enough room to replace the string with the value */ 2122 if (len < elen) 2123 return NULL; 2124 2125 snprintf(ptr, elen + 1, "%ld", map->eval_value); 2126 2127 /* Get the rest of the string of ptr */ 2128 rlen = strlen(ptr + len); 2129 memmove(ptr + elen, ptr + len, rlen); 2130 /* Make sure we end the new string */ 2131 ptr[elen + rlen] = 0; 2132 2133 return ptr + elen; 2134 } 2135 2136 static void update_event_printk(struct trace_event_call *call, 2137 struct trace_eval_map *map) 2138 { 2139 char *ptr; 2140 int quote = 0; 2141 int len = strlen(map->eval_string); 2142 2143 for (ptr = call->print_fmt; *ptr; ptr++) { 2144 if (*ptr == '\\') { 2145 ptr++; 2146 /* paranoid */ 2147 if (!*ptr) 2148 break; 2149 continue; 2150 } 2151 if (*ptr == '"') { 2152 quote ^= 1; 2153 continue; 2154 } 2155 if (quote) 2156 continue; 2157 if (isdigit(*ptr)) { 2158 /* skip numbers */ 2159 do { 2160 ptr++; 2161 /* Check for alpha chars like ULL */ 2162 } while (isalnum(*ptr)); 2163 if (!*ptr) 2164 break; 2165 /* 2166 * A number must have some kind of delimiter after 2167 * it, and we can ignore that too. 2168 */ 2169 continue; 2170 } 2171 if (isalpha(*ptr) || *ptr == '_') { 2172 if (strncmp(map->eval_string, ptr, len) == 0 && 2173 !isalnum(ptr[len]) && ptr[len] != '_') { 2174 ptr = eval_replace(ptr, map, len); 2175 /* enum/sizeof string smaller than value */ 2176 if (WARN_ON_ONCE(!ptr)) 2177 return; 2178 /* 2179 * No need to decrement here, as eval_replace() 2180 * returns the pointer to the character passed 2181 * the eval, and two evals can not be placed 2182 * back to back without something in between. 2183 * We can skip that something in between. 2184 */ 2185 continue; 2186 } 2187 skip_more: 2188 do { 2189 ptr++; 2190 } while (isalnum(*ptr) || *ptr == '_'); 2191 if (!*ptr) 2192 break; 2193 /* 2194 * If what comes after this variable is a '.' or 2195 * '->' then we can continue to ignore that string. 2196 */ 2197 if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) { 2198 ptr += *ptr == '.' ? 1 : 2; 2199 if (!*ptr) 2200 break; 2201 goto skip_more; 2202 } 2203 /* 2204 * Once again, we can skip the delimiter that came 2205 * after the string. 2206 */ 2207 continue; 2208 } 2209 } 2210 } 2211 2212 void trace_event_eval_update(struct trace_eval_map **map, int len) 2213 { 2214 struct trace_event_call *call, *p; 2215 const char *last_system = NULL; 2216 int last_i; 2217 int i; 2218 2219 down_write(&trace_event_sem); 2220 list_for_each_entry_safe(call, p, &ftrace_events, list) { 2221 /* events are usually grouped together with systems */ 2222 if (!last_system || call->class->system != last_system) { 2223 last_i = 0; 2224 last_system = call->class->system; 2225 } 2226 2227 for (i = last_i; i < len; i++) { 2228 if (call->class->system == map[i]->system) { 2229 /* Save the first system if need be */ 2230 if (!last_i) 2231 last_i = i; 2232 update_event_printk(call, map[i]); 2233 } 2234 } 2235 } 2236 up_write(&trace_event_sem); 2237 } 2238 2239 static struct trace_event_file * 2240 trace_create_new_event(struct trace_event_call *call, 2241 struct trace_array *tr) 2242 { 2243 struct trace_event_file *file; 2244 2245 file = kmem_cache_alloc(file_cachep, GFP_TRACE); 2246 if (!file) 2247 return NULL; 2248 2249 file->event_call = call; 2250 file->tr = tr; 2251 atomic_set(&file->sm_ref, 0); 2252 atomic_set(&file->tm_ref, 0); 2253 INIT_LIST_HEAD(&file->triggers); 2254 list_add(&file->list, &tr->events); 2255 2256 return file; 2257 } 2258 2259 /* Add an event to a trace directory */ 2260 static int 2261 __trace_add_new_event(struct trace_event_call *call, struct trace_array *tr) 2262 { 2263 struct trace_event_file *file; 2264 2265 file = trace_create_new_event(call, tr); 2266 if (!file) 2267 return -ENOMEM; 2268 2269 return event_create_dir(tr->event_dir, file); 2270 } 2271 2272 /* 2273 * Just create a decriptor for early init. A descriptor is required 2274 * for enabling events at boot. We want to enable events before 2275 * the filesystem is initialized. 2276 */ 2277 static __init int 2278 __trace_early_add_new_event(struct trace_event_call *call, 2279 struct trace_array *tr) 2280 { 2281 struct trace_event_file *file; 2282 2283 file = trace_create_new_event(call, tr); 2284 if (!file) 2285 return -ENOMEM; 2286 2287 return 0; 2288 } 2289 2290 struct ftrace_module_file_ops; 2291 static void __add_event_to_tracers(struct trace_event_call *call); 2292 2293 /* Add an additional event_call dynamically */ 2294 int trace_add_event_call(struct trace_event_call *call) 2295 { 2296 int ret; 2297 mutex_lock(&event_mutex); 2298 mutex_lock(&trace_types_lock); 2299 2300 ret = __register_event(call, NULL); 2301 if (ret >= 0) 2302 __add_event_to_tracers(call); 2303 2304 mutex_unlock(&trace_types_lock); 2305 mutex_unlock(&event_mutex); 2306 return ret; 2307 } 2308 2309 /* 2310 * Must be called under locking of trace_types_lock, event_mutex and 2311 * trace_event_sem. 2312 */ 2313 static void __trace_remove_event_call(struct trace_event_call *call) 2314 { 2315 event_remove(call); 2316 trace_destroy_fields(call); 2317 free_event_filter(call->filter); 2318 call->filter = NULL; 2319 } 2320 2321 static int probe_remove_event_call(struct trace_event_call *call) 2322 { 2323 struct trace_array *tr; 2324 struct trace_event_file *file; 2325 2326 #ifdef CONFIG_PERF_EVENTS 2327 if (call->perf_refcount) 2328 return -EBUSY; 2329 #endif 2330 do_for_each_event_file(tr, file) { 2331 if (file->event_call != call) 2332 continue; 2333 /* 2334 * We can't rely on ftrace_event_enable_disable(enable => 0) 2335 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress 2336 * TRACE_REG_UNREGISTER. 2337 */ 2338 if (file->flags & EVENT_FILE_FL_ENABLED) 2339 return -EBUSY; 2340 /* 2341 * The do_for_each_event_file_safe() is 2342 * a double loop. After finding the call for this 2343 * trace_array, we use break to jump to the next 2344 * trace_array. 2345 */ 2346 break; 2347 } while_for_each_event_file(); 2348 2349 __trace_remove_event_call(call); 2350 2351 return 0; 2352 } 2353 2354 /* Remove an event_call */ 2355 int trace_remove_event_call(struct trace_event_call *call) 2356 { 2357 int ret; 2358 2359 mutex_lock(&event_mutex); 2360 mutex_lock(&trace_types_lock); 2361 down_write(&trace_event_sem); 2362 ret = probe_remove_event_call(call); 2363 up_write(&trace_event_sem); 2364 mutex_unlock(&trace_types_lock); 2365 mutex_unlock(&event_mutex); 2366 2367 return ret; 2368 } 2369 2370 #define for_each_event(event, start, end) \ 2371 for (event = start; \ 2372 (unsigned long)event < (unsigned long)end; \ 2373 event++) 2374 2375 #ifdef CONFIG_MODULES 2376 2377 static void trace_module_add_events(struct module *mod) 2378 { 2379 struct trace_event_call **call, **start, **end; 2380 2381 if (!mod->num_trace_events) 2382 return; 2383 2384 /* Don't add infrastructure for mods without tracepoints */ 2385 if (trace_module_has_bad_taint(mod)) { 2386 pr_err("%s: module has bad taint, not creating trace events\n", 2387 mod->name); 2388 return; 2389 } 2390 2391 start = mod->trace_events; 2392 end = mod->trace_events + mod->num_trace_events; 2393 2394 for_each_event(call, start, end) { 2395 __register_event(*call, mod); 2396 __add_event_to_tracers(*call); 2397 } 2398 } 2399 2400 static void trace_module_remove_events(struct module *mod) 2401 { 2402 struct trace_event_call *call, *p; 2403 2404 down_write(&trace_event_sem); 2405 list_for_each_entry_safe(call, p, &ftrace_events, list) { 2406 if (call->mod == mod) 2407 __trace_remove_event_call(call); 2408 } 2409 up_write(&trace_event_sem); 2410 2411 /* 2412 * It is safest to reset the ring buffer if the module being unloaded 2413 * registered any events that were used. The only worry is if 2414 * a new module gets loaded, and takes on the same id as the events 2415 * of this module. When printing out the buffer, traced events left 2416 * over from this module may be passed to the new module events and 2417 * unexpected results may occur. 2418 */ 2419 tracing_reset_all_online_cpus(); 2420 } 2421 2422 static int trace_module_notify(struct notifier_block *self, 2423 unsigned long val, void *data) 2424 { 2425 struct module *mod = data; 2426 2427 mutex_lock(&event_mutex); 2428 mutex_lock(&trace_types_lock); 2429 switch (val) { 2430 case MODULE_STATE_COMING: 2431 trace_module_add_events(mod); 2432 break; 2433 case MODULE_STATE_GOING: 2434 trace_module_remove_events(mod); 2435 break; 2436 } 2437 mutex_unlock(&trace_types_lock); 2438 mutex_unlock(&event_mutex); 2439 2440 return 0; 2441 } 2442 2443 static struct notifier_block trace_module_nb = { 2444 .notifier_call = trace_module_notify, 2445 .priority = 1, /* higher than trace.c module notify */ 2446 }; 2447 #endif /* CONFIG_MODULES */ 2448 2449 /* Create a new event directory structure for a trace directory. */ 2450 static void 2451 __trace_add_event_dirs(struct trace_array *tr) 2452 { 2453 struct trace_event_call *call; 2454 int ret; 2455 2456 list_for_each_entry(call, &ftrace_events, list) { 2457 ret = __trace_add_new_event(call, tr); 2458 if (ret < 0) 2459 pr_warn("Could not create directory for event %s\n", 2460 trace_event_name(call)); 2461 } 2462 } 2463 2464 struct trace_event_file * 2465 find_event_file(struct trace_array *tr, const char *system, const char *event) 2466 { 2467 struct trace_event_file *file; 2468 struct trace_event_call *call; 2469 const char *name; 2470 2471 list_for_each_entry(file, &tr->events, list) { 2472 2473 call = file->event_call; 2474 name = trace_event_name(call); 2475 2476 if (!name || !call->class || !call->class->reg) 2477 continue; 2478 2479 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) 2480 continue; 2481 2482 if (strcmp(event, name) == 0 && 2483 strcmp(system, call->class->system) == 0) 2484 return file; 2485 } 2486 return NULL; 2487 } 2488 2489 #ifdef CONFIG_DYNAMIC_FTRACE 2490 2491 /* Avoid typos */ 2492 #define ENABLE_EVENT_STR "enable_event" 2493 #define DISABLE_EVENT_STR "disable_event" 2494 2495 struct event_probe_data { 2496 struct trace_event_file *file; 2497 unsigned long count; 2498 int ref; 2499 bool enable; 2500 }; 2501 2502 static void update_event_probe(struct event_probe_data *data) 2503 { 2504 if (data->enable) 2505 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags); 2506 else 2507 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags); 2508 } 2509 2510 static void 2511 event_enable_probe(unsigned long ip, unsigned long parent_ip, 2512 struct trace_array *tr, struct ftrace_probe_ops *ops, 2513 void *data) 2514 { 2515 struct ftrace_func_mapper *mapper = data; 2516 struct event_probe_data *edata; 2517 void **pdata; 2518 2519 pdata = ftrace_func_mapper_find_ip(mapper, ip); 2520 if (!pdata || !*pdata) 2521 return; 2522 2523 edata = *pdata; 2524 update_event_probe(edata); 2525 } 2526 2527 static void 2528 event_enable_count_probe(unsigned long ip, unsigned long parent_ip, 2529 struct trace_array *tr, struct ftrace_probe_ops *ops, 2530 void *data) 2531 { 2532 struct ftrace_func_mapper *mapper = data; 2533 struct event_probe_data *edata; 2534 void **pdata; 2535 2536 pdata = ftrace_func_mapper_find_ip(mapper, ip); 2537 if (!pdata || !*pdata) 2538 return; 2539 2540 edata = *pdata; 2541 2542 if (!edata->count) 2543 return; 2544 2545 /* Skip if the event is in a state we want to switch to */ 2546 if (edata->enable == !(edata->file->flags & EVENT_FILE_FL_SOFT_DISABLED)) 2547 return; 2548 2549 if (edata->count != -1) 2550 (edata->count)--; 2551 2552 update_event_probe(edata); 2553 } 2554 2555 static int 2556 event_enable_print(struct seq_file *m, unsigned long ip, 2557 struct ftrace_probe_ops *ops, void *data) 2558 { 2559 struct ftrace_func_mapper *mapper = data; 2560 struct event_probe_data *edata; 2561 void **pdata; 2562 2563 pdata = ftrace_func_mapper_find_ip(mapper, ip); 2564 2565 if (WARN_ON_ONCE(!pdata || !*pdata)) 2566 return 0; 2567 2568 edata = *pdata; 2569 2570 seq_printf(m, "%ps:", (void *)ip); 2571 2572 seq_printf(m, "%s:%s:%s", 2573 edata->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR, 2574 edata->file->event_call->class->system, 2575 trace_event_name(edata->file->event_call)); 2576 2577 if (edata->count == -1) 2578 seq_puts(m, ":unlimited\n"); 2579 else 2580 seq_printf(m, ":count=%ld\n", edata->count); 2581 2582 return 0; 2583 } 2584 2585 static int 2586 event_enable_init(struct ftrace_probe_ops *ops, struct trace_array *tr, 2587 unsigned long ip, void *init_data, void **data) 2588 { 2589 struct ftrace_func_mapper *mapper = *data; 2590 struct event_probe_data *edata = init_data; 2591 int ret; 2592 2593 if (!mapper) { 2594 mapper = allocate_ftrace_func_mapper(); 2595 if (!mapper) 2596 return -ENODEV; 2597 *data = mapper; 2598 } 2599 2600 ret = ftrace_func_mapper_add_ip(mapper, ip, edata); 2601 if (ret < 0) 2602 return ret; 2603 2604 edata->ref++; 2605 2606 return 0; 2607 } 2608 2609 static int free_probe_data(void *data) 2610 { 2611 struct event_probe_data *edata = data; 2612 2613 edata->ref--; 2614 if (!edata->ref) { 2615 /* Remove the SOFT_MODE flag */ 2616 __ftrace_event_enable_disable(edata->file, 0, 1); 2617 module_put(edata->file->event_call->mod); 2618 kfree(edata); 2619 } 2620 return 0; 2621 } 2622 2623 static void 2624 event_enable_free(struct ftrace_probe_ops *ops, struct trace_array *tr, 2625 unsigned long ip, void *data) 2626 { 2627 struct ftrace_func_mapper *mapper = data; 2628 struct event_probe_data *edata; 2629 2630 if (!ip) { 2631 if (!mapper) 2632 return; 2633 free_ftrace_func_mapper(mapper, free_probe_data); 2634 return; 2635 } 2636 2637 edata = ftrace_func_mapper_remove_ip(mapper, ip); 2638 2639 if (WARN_ON_ONCE(!edata)) 2640 return; 2641 2642 if (WARN_ON_ONCE(edata->ref <= 0)) 2643 return; 2644 2645 free_probe_data(edata); 2646 } 2647 2648 static struct ftrace_probe_ops event_enable_probe_ops = { 2649 .func = event_enable_probe, 2650 .print = event_enable_print, 2651 .init = event_enable_init, 2652 .free = event_enable_free, 2653 }; 2654 2655 static struct ftrace_probe_ops event_enable_count_probe_ops = { 2656 .func = event_enable_count_probe, 2657 .print = event_enable_print, 2658 .init = event_enable_init, 2659 .free = event_enable_free, 2660 }; 2661 2662 static struct ftrace_probe_ops event_disable_probe_ops = { 2663 .func = event_enable_probe, 2664 .print = event_enable_print, 2665 .init = event_enable_init, 2666 .free = event_enable_free, 2667 }; 2668 2669 static struct ftrace_probe_ops event_disable_count_probe_ops = { 2670 .func = event_enable_count_probe, 2671 .print = event_enable_print, 2672 .init = event_enable_init, 2673 .free = event_enable_free, 2674 }; 2675 2676 static int 2677 event_enable_func(struct trace_array *tr, struct ftrace_hash *hash, 2678 char *glob, char *cmd, char *param, int enabled) 2679 { 2680 struct trace_event_file *file; 2681 struct ftrace_probe_ops *ops; 2682 struct event_probe_data *data; 2683 const char *system; 2684 const char *event; 2685 char *number; 2686 bool enable; 2687 int ret; 2688 2689 if (!tr) 2690 return -ENODEV; 2691 2692 /* hash funcs only work with set_ftrace_filter */ 2693 if (!enabled || !param) 2694 return -EINVAL; 2695 2696 system = strsep(¶m, ":"); 2697 if (!param) 2698 return -EINVAL; 2699 2700 event = strsep(¶m, ":"); 2701 2702 mutex_lock(&event_mutex); 2703 2704 ret = -EINVAL; 2705 file = find_event_file(tr, system, event); 2706 if (!file) 2707 goto out; 2708 2709 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0; 2710 2711 if (enable) 2712 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops; 2713 else 2714 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops; 2715 2716 if (glob[0] == '!') { 2717 ret = unregister_ftrace_function_probe_func(glob+1, tr, ops); 2718 goto out; 2719 } 2720 2721 ret = -ENOMEM; 2722 2723 data = kzalloc(sizeof(*data), GFP_KERNEL); 2724 if (!data) 2725 goto out; 2726 2727 data->enable = enable; 2728 data->count = -1; 2729 data->file = file; 2730 2731 if (!param) 2732 goto out_reg; 2733 2734 number = strsep(¶m, ":"); 2735 2736 ret = -EINVAL; 2737 if (!strlen(number)) 2738 goto out_free; 2739 2740 /* 2741 * We use the callback data field (which is a pointer) 2742 * as our counter. 2743 */ 2744 ret = kstrtoul(number, 0, &data->count); 2745 if (ret) 2746 goto out_free; 2747 2748 out_reg: 2749 /* Don't let event modules unload while probe registered */ 2750 ret = try_module_get(file->event_call->mod); 2751 if (!ret) { 2752 ret = -EBUSY; 2753 goto out_free; 2754 } 2755 2756 ret = __ftrace_event_enable_disable(file, 1, 1); 2757 if (ret < 0) 2758 goto out_put; 2759 2760 ret = register_ftrace_function_probe(glob, tr, ops, data); 2761 /* 2762 * The above returns on success the # of functions enabled, 2763 * but if it didn't find any functions it returns zero. 2764 * Consider no functions a failure too. 2765 */ 2766 if (!ret) { 2767 ret = -ENOENT; 2768 goto out_disable; 2769 } else if (ret < 0) 2770 goto out_disable; 2771 /* Just return zero, not the number of enabled functions */ 2772 ret = 0; 2773 out: 2774 mutex_unlock(&event_mutex); 2775 return ret; 2776 2777 out_disable: 2778 __ftrace_event_enable_disable(file, 0, 1); 2779 out_put: 2780 module_put(file->event_call->mod); 2781 out_free: 2782 kfree(data); 2783 goto out; 2784 } 2785 2786 static struct ftrace_func_command event_enable_cmd = { 2787 .name = ENABLE_EVENT_STR, 2788 .func = event_enable_func, 2789 }; 2790 2791 static struct ftrace_func_command event_disable_cmd = { 2792 .name = DISABLE_EVENT_STR, 2793 .func = event_enable_func, 2794 }; 2795 2796 static __init int register_event_cmds(void) 2797 { 2798 int ret; 2799 2800 ret = register_ftrace_command(&event_enable_cmd); 2801 if (WARN_ON(ret < 0)) 2802 return ret; 2803 ret = register_ftrace_command(&event_disable_cmd); 2804 if (WARN_ON(ret < 0)) 2805 unregister_ftrace_command(&event_enable_cmd); 2806 return ret; 2807 } 2808 #else 2809 static inline int register_event_cmds(void) { return 0; } 2810 #endif /* CONFIG_DYNAMIC_FTRACE */ 2811 2812 /* 2813 * The top level array has already had its trace_event_file 2814 * descriptors created in order to allow for early events to 2815 * be recorded. This function is called after the tracefs has been 2816 * initialized, and we now have to create the files associated 2817 * to the events. 2818 */ 2819 static __init void 2820 __trace_early_add_event_dirs(struct trace_array *tr) 2821 { 2822 struct trace_event_file *file; 2823 int ret; 2824 2825 2826 list_for_each_entry(file, &tr->events, list) { 2827 ret = event_create_dir(tr->event_dir, file); 2828 if (ret < 0) 2829 pr_warn("Could not create directory for event %s\n", 2830 trace_event_name(file->event_call)); 2831 } 2832 } 2833 2834 /* 2835 * For early boot up, the top trace array requires to have 2836 * a list of events that can be enabled. This must be done before 2837 * the filesystem is set up in order to allow events to be traced 2838 * early. 2839 */ 2840 static __init void 2841 __trace_early_add_events(struct trace_array *tr) 2842 { 2843 struct trace_event_call *call; 2844 int ret; 2845 2846 list_for_each_entry(call, &ftrace_events, list) { 2847 /* Early boot up should not have any modules loaded */ 2848 if (WARN_ON_ONCE(call->mod)) 2849 continue; 2850 2851 ret = __trace_early_add_new_event(call, tr); 2852 if (ret < 0) 2853 pr_warn("Could not create early event %s\n", 2854 trace_event_name(call)); 2855 } 2856 } 2857 2858 /* Remove the event directory structure for a trace directory. */ 2859 static void 2860 __trace_remove_event_dirs(struct trace_array *tr) 2861 { 2862 struct trace_event_file *file, *next; 2863 2864 list_for_each_entry_safe(file, next, &tr->events, list) 2865 remove_event_file_dir(file); 2866 } 2867 2868 static void __add_event_to_tracers(struct trace_event_call *call) 2869 { 2870 struct trace_array *tr; 2871 2872 list_for_each_entry(tr, &ftrace_trace_arrays, list) 2873 __trace_add_new_event(call, tr); 2874 } 2875 2876 extern struct trace_event_call *__start_ftrace_events[]; 2877 extern struct trace_event_call *__stop_ftrace_events[]; 2878 2879 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata; 2880 2881 static __init int setup_trace_event(char *str) 2882 { 2883 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE); 2884 ring_buffer_expanded = true; 2885 tracing_selftest_disabled = true; 2886 2887 return 1; 2888 } 2889 __setup("trace_event=", setup_trace_event); 2890 2891 /* Expects to have event_mutex held when called */ 2892 static int 2893 create_event_toplevel_files(struct dentry *parent, struct trace_array *tr) 2894 { 2895 struct dentry *d_events; 2896 struct dentry *entry; 2897 2898 entry = tracefs_create_file("set_event", 0644, parent, 2899 tr, &ftrace_set_event_fops); 2900 if (!entry) { 2901 pr_warn("Could not create tracefs 'set_event' entry\n"); 2902 return -ENOMEM; 2903 } 2904 2905 d_events = tracefs_create_dir("events", parent); 2906 if (!d_events) { 2907 pr_warn("Could not create tracefs 'events' directory\n"); 2908 return -ENOMEM; 2909 } 2910 2911 entry = trace_create_file("enable", 0644, d_events, 2912 tr, &ftrace_tr_enable_fops); 2913 if (!entry) { 2914 pr_warn("Could not create tracefs 'enable' entry\n"); 2915 return -ENOMEM; 2916 } 2917 2918 /* There are not as crucial, just warn if they are not created */ 2919 2920 entry = tracefs_create_file("set_event_pid", 0644, parent, 2921 tr, &ftrace_set_event_pid_fops); 2922 if (!entry) 2923 pr_warn("Could not create tracefs 'set_event_pid' entry\n"); 2924 2925 /* ring buffer internal formats */ 2926 entry = trace_create_file("header_page", 0444, d_events, 2927 ring_buffer_print_page_header, 2928 &ftrace_show_header_fops); 2929 if (!entry) 2930 pr_warn("Could not create tracefs 'header_page' entry\n"); 2931 2932 entry = trace_create_file("header_event", 0444, d_events, 2933 ring_buffer_print_entry_header, 2934 &ftrace_show_header_fops); 2935 if (!entry) 2936 pr_warn("Could not create tracefs 'header_event' entry\n"); 2937 2938 tr->event_dir = d_events; 2939 2940 return 0; 2941 } 2942 2943 /** 2944 * event_trace_add_tracer - add a instance of a trace_array to events 2945 * @parent: The parent dentry to place the files/directories for events in 2946 * @tr: The trace array associated with these events 2947 * 2948 * When a new instance is created, it needs to set up its events 2949 * directory, as well as other files associated with events. It also 2950 * creates the event hierachry in the @parent/events directory. 2951 * 2952 * Returns 0 on success. 2953 * 2954 * Must be called with event_mutex held. 2955 */ 2956 int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr) 2957 { 2958 int ret; 2959 2960 lockdep_assert_held(&event_mutex); 2961 2962 ret = create_event_toplevel_files(parent, tr); 2963 if (ret) 2964 goto out; 2965 2966 down_write(&trace_event_sem); 2967 __trace_add_event_dirs(tr); 2968 up_write(&trace_event_sem); 2969 2970 out: 2971 return ret; 2972 } 2973 2974 /* 2975 * The top trace array already had its file descriptors created. 2976 * Now the files themselves need to be created. 2977 */ 2978 static __init int 2979 early_event_add_tracer(struct dentry *parent, struct trace_array *tr) 2980 { 2981 int ret; 2982 2983 mutex_lock(&event_mutex); 2984 2985 ret = create_event_toplevel_files(parent, tr); 2986 if (ret) 2987 goto out_unlock; 2988 2989 down_write(&trace_event_sem); 2990 __trace_early_add_event_dirs(tr); 2991 up_write(&trace_event_sem); 2992 2993 out_unlock: 2994 mutex_unlock(&event_mutex); 2995 2996 return ret; 2997 } 2998 2999 /* Must be called with event_mutex held */ 3000 int event_trace_del_tracer(struct trace_array *tr) 3001 { 3002 lockdep_assert_held(&event_mutex); 3003 3004 /* Disable any event triggers and associated soft-disabled events */ 3005 clear_event_triggers(tr); 3006 3007 /* Clear the pid list */ 3008 __ftrace_clear_event_pids(tr); 3009 3010 /* Disable any running events */ 3011 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0); 3012 3013 /* Access to events are within rcu_read_lock_sched() */ 3014 synchronize_sched(); 3015 3016 down_write(&trace_event_sem); 3017 __trace_remove_event_dirs(tr); 3018 tracefs_remove_recursive(tr->event_dir); 3019 up_write(&trace_event_sem); 3020 3021 tr->event_dir = NULL; 3022 3023 return 0; 3024 } 3025 3026 static __init int event_trace_memsetup(void) 3027 { 3028 field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC); 3029 file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC); 3030 return 0; 3031 } 3032 3033 static __init void 3034 early_enable_events(struct trace_array *tr, bool disable_first) 3035 { 3036 char *buf = bootup_event_buf; 3037 char *token; 3038 int ret; 3039 3040 while (true) { 3041 token = strsep(&buf, ","); 3042 3043 if (!token) 3044 break; 3045 3046 if (*token) { 3047 /* Restarting syscalls requires that we stop them first */ 3048 if (disable_first) 3049 ftrace_set_clr_event(tr, token, 0); 3050 3051 ret = ftrace_set_clr_event(tr, token, 1); 3052 if (ret) 3053 pr_warn("Failed to enable trace event: %s\n", token); 3054 } 3055 3056 /* Put back the comma to allow this to be called again */ 3057 if (buf) 3058 *(buf - 1) = ','; 3059 } 3060 } 3061 3062 static __init int event_trace_enable(void) 3063 { 3064 struct trace_array *tr = top_trace_array(); 3065 struct trace_event_call **iter, *call; 3066 int ret; 3067 3068 if (!tr) 3069 return -ENODEV; 3070 3071 for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) { 3072 3073 call = *iter; 3074 ret = event_init(call); 3075 if (!ret) 3076 list_add(&call->list, &ftrace_events); 3077 } 3078 3079 /* 3080 * We need the top trace array to have a working set of trace 3081 * points at early init, before the debug files and directories 3082 * are created. Create the file entries now, and attach them 3083 * to the actual file dentries later. 3084 */ 3085 __trace_early_add_events(tr); 3086 3087 early_enable_events(tr, false); 3088 3089 trace_printk_start_comm(); 3090 3091 register_event_cmds(); 3092 3093 register_trigger_cmds(); 3094 3095 return 0; 3096 } 3097 3098 /* 3099 * event_trace_enable() is called from trace_event_init() first to 3100 * initialize events and perhaps start any events that are on the 3101 * command line. Unfortunately, there are some events that will not 3102 * start this early, like the system call tracepoints that need 3103 * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable() 3104 * is called before pid 1 starts, and this flag is never set, making 3105 * the syscall tracepoint never get reached, but the event is enabled 3106 * regardless (and not doing anything). 3107 */ 3108 static __init int event_trace_enable_again(void) 3109 { 3110 struct trace_array *tr; 3111 3112 tr = top_trace_array(); 3113 if (!tr) 3114 return -ENODEV; 3115 3116 early_enable_events(tr, true); 3117 3118 return 0; 3119 } 3120 3121 early_initcall(event_trace_enable_again); 3122 3123 static __init int event_trace_init(void) 3124 { 3125 struct trace_array *tr; 3126 struct dentry *d_tracer; 3127 struct dentry *entry; 3128 int ret; 3129 3130 tr = top_trace_array(); 3131 if (!tr) 3132 return -ENODEV; 3133 3134 d_tracer = tracing_init_dentry(); 3135 if (IS_ERR(d_tracer)) 3136 return 0; 3137 3138 entry = tracefs_create_file("available_events", 0444, d_tracer, 3139 tr, &ftrace_avail_fops); 3140 if (!entry) 3141 pr_warn("Could not create tracefs 'available_events' entry\n"); 3142 3143 if (trace_define_generic_fields()) 3144 pr_warn("tracing: Failed to allocated generic fields"); 3145 3146 if (trace_define_common_fields()) 3147 pr_warn("tracing: Failed to allocate common fields"); 3148 3149 ret = early_event_add_tracer(d_tracer, tr); 3150 if (ret) 3151 return ret; 3152 3153 #ifdef CONFIG_MODULES 3154 ret = register_module_notifier(&trace_module_nb); 3155 if (ret) 3156 pr_warn("Failed to register trace events module notifier\n"); 3157 #endif 3158 return 0; 3159 } 3160 3161 void __init trace_event_init(void) 3162 { 3163 event_trace_memsetup(); 3164 init_ftrace_syscalls(); 3165 event_trace_enable(); 3166 } 3167 3168 fs_initcall(event_trace_init); 3169 3170 #ifdef CONFIG_FTRACE_STARTUP_TEST 3171 3172 static DEFINE_SPINLOCK(test_spinlock); 3173 static DEFINE_SPINLOCK(test_spinlock_irq); 3174 static DEFINE_MUTEX(test_mutex); 3175 3176 static __init void test_work(struct work_struct *dummy) 3177 { 3178 spin_lock(&test_spinlock); 3179 spin_lock_irq(&test_spinlock_irq); 3180 udelay(1); 3181 spin_unlock_irq(&test_spinlock_irq); 3182 spin_unlock(&test_spinlock); 3183 3184 mutex_lock(&test_mutex); 3185 msleep(1); 3186 mutex_unlock(&test_mutex); 3187 } 3188 3189 static __init int event_test_thread(void *unused) 3190 { 3191 void *test_malloc; 3192 3193 test_malloc = kmalloc(1234, GFP_KERNEL); 3194 if (!test_malloc) 3195 pr_info("failed to kmalloc\n"); 3196 3197 schedule_on_each_cpu(test_work); 3198 3199 kfree(test_malloc); 3200 3201 set_current_state(TASK_INTERRUPTIBLE); 3202 while (!kthread_should_stop()) { 3203 schedule(); 3204 set_current_state(TASK_INTERRUPTIBLE); 3205 } 3206 __set_current_state(TASK_RUNNING); 3207 3208 return 0; 3209 } 3210 3211 /* 3212 * Do various things that may trigger events. 3213 */ 3214 static __init void event_test_stuff(void) 3215 { 3216 struct task_struct *test_thread; 3217 3218 test_thread = kthread_run(event_test_thread, NULL, "test-events"); 3219 msleep(1); 3220 kthread_stop(test_thread); 3221 } 3222 3223 /* 3224 * For every trace event defined, we will test each trace point separately, 3225 * and then by groups, and finally all trace points. 3226 */ 3227 static __init void event_trace_self_tests(void) 3228 { 3229 struct trace_subsystem_dir *dir; 3230 struct trace_event_file *file; 3231 struct trace_event_call *call; 3232 struct event_subsystem *system; 3233 struct trace_array *tr; 3234 int ret; 3235 3236 tr = top_trace_array(); 3237 if (!tr) 3238 return; 3239 3240 pr_info("Running tests on trace events:\n"); 3241 3242 list_for_each_entry(file, &tr->events, list) { 3243 3244 call = file->event_call; 3245 3246 /* Only test those that have a probe */ 3247 if (!call->class || !call->class->probe) 3248 continue; 3249 3250 /* 3251 * Testing syscall events here is pretty useless, but 3252 * we still do it if configured. But this is time consuming. 3253 * What we really need is a user thread to perform the 3254 * syscalls as we test. 3255 */ 3256 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS 3257 if (call->class->system && 3258 strcmp(call->class->system, "syscalls") == 0) 3259 continue; 3260 #endif 3261 3262 pr_info("Testing event %s: ", trace_event_name(call)); 3263 3264 /* 3265 * If an event is already enabled, someone is using 3266 * it and the self test should not be on. 3267 */ 3268 if (file->flags & EVENT_FILE_FL_ENABLED) { 3269 pr_warn("Enabled event during self test!\n"); 3270 WARN_ON_ONCE(1); 3271 continue; 3272 } 3273 3274 ftrace_event_enable_disable(file, 1); 3275 event_test_stuff(); 3276 ftrace_event_enable_disable(file, 0); 3277 3278 pr_cont("OK\n"); 3279 } 3280 3281 /* Now test at the sub system level */ 3282 3283 pr_info("Running tests on trace event systems:\n"); 3284 3285 list_for_each_entry(dir, &tr->systems, list) { 3286 3287 system = dir->subsystem; 3288 3289 /* the ftrace system is special, skip it */ 3290 if (strcmp(system->name, "ftrace") == 0) 3291 continue; 3292 3293 pr_info("Testing event system %s: ", system->name); 3294 3295 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1); 3296 if (WARN_ON_ONCE(ret)) { 3297 pr_warn("error enabling system %s\n", 3298 system->name); 3299 continue; 3300 } 3301 3302 event_test_stuff(); 3303 3304 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0); 3305 if (WARN_ON_ONCE(ret)) { 3306 pr_warn("error disabling system %s\n", 3307 system->name); 3308 continue; 3309 } 3310 3311 pr_cont("OK\n"); 3312 } 3313 3314 /* Test with all events enabled */ 3315 3316 pr_info("Running tests on all trace events:\n"); 3317 pr_info("Testing all events: "); 3318 3319 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1); 3320 if (WARN_ON_ONCE(ret)) { 3321 pr_warn("error enabling all events\n"); 3322 return; 3323 } 3324 3325 event_test_stuff(); 3326 3327 /* reset sysname */ 3328 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0); 3329 if (WARN_ON_ONCE(ret)) { 3330 pr_warn("error disabling all events\n"); 3331 return; 3332 } 3333 3334 pr_cont("OK\n"); 3335 } 3336 3337 #ifdef CONFIG_FUNCTION_TRACER 3338 3339 static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable); 3340 3341 static struct trace_event_file event_trace_file __initdata; 3342 3343 static void __init 3344 function_test_events_call(unsigned long ip, unsigned long parent_ip, 3345 struct ftrace_ops *op, struct pt_regs *pt_regs) 3346 { 3347 struct ring_buffer_event *event; 3348 struct ring_buffer *buffer; 3349 struct ftrace_entry *entry; 3350 unsigned long flags; 3351 long disabled; 3352 int cpu; 3353 int pc; 3354 3355 pc = preempt_count(); 3356 preempt_disable_notrace(); 3357 cpu = raw_smp_processor_id(); 3358 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu)); 3359 3360 if (disabled != 1) 3361 goto out; 3362 3363 local_save_flags(flags); 3364 3365 event = trace_event_buffer_lock_reserve(&buffer, &event_trace_file, 3366 TRACE_FN, sizeof(*entry), 3367 flags, pc); 3368 if (!event) 3369 goto out; 3370 entry = ring_buffer_event_data(event); 3371 entry->ip = ip; 3372 entry->parent_ip = parent_ip; 3373 3374 event_trigger_unlock_commit(&event_trace_file, buffer, event, 3375 entry, flags, pc); 3376 out: 3377 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu)); 3378 preempt_enable_notrace(); 3379 } 3380 3381 static struct ftrace_ops trace_ops __initdata = 3382 { 3383 .func = function_test_events_call, 3384 .flags = FTRACE_OPS_FL_RECURSION_SAFE, 3385 }; 3386 3387 static __init void event_trace_self_test_with_function(void) 3388 { 3389 int ret; 3390 3391 event_trace_file.tr = top_trace_array(); 3392 if (WARN_ON(!event_trace_file.tr)) 3393 return; 3394 3395 ret = register_ftrace_function(&trace_ops); 3396 if (WARN_ON(ret < 0)) { 3397 pr_info("Failed to enable function tracer for event tests\n"); 3398 return; 3399 } 3400 pr_info("Running tests again, along with the function tracer\n"); 3401 event_trace_self_tests(); 3402 unregister_ftrace_function(&trace_ops); 3403 } 3404 #else 3405 static __init void event_trace_self_test_with_function(void) 3406 { 3407 } 3408 #endif 3409 3410 static __init int event_trace_self_tests_init(void) 3411 { 3412 if (!tracing_selftest_disabled) { 3413 event_trace_self_tests(); 3414 event_trace_self_test_with_function(); 3415 } 3416 3417 return 0; 3418 } 3419 3420 late_initcall(event_trace_self_tests_init); 3421 3422 #endif 3423