kernel/trace/trace_events.c

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