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