SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/delay.h>
  19
  20 #include "trace_output.h"
  21
  22 #define TRACE_SYSTEM "TRACE_SYSTEM"
  23
  24 DEFINE_MUTEX(event_mutex);
  25
  26 LIST_HEAD(ftrace_events);
  27
  28 int trace_define_field(struct ftrace_event_call *call, char *type,
  29                        char *name, int offset, int size, int is_signed)
  30 {
  31         struct ftrace_event_field *field;
  32
  33         field = kzalloc(sizeof(*field), GFP_KERNEL);
  34         if (!field)
  35                 goto err;
  36
  37         field->name = kstrdup(name, GFP_KERNEL);
  38         if (!field->name)
  39                 goto err;
  40
  41         field->type = kstrdup(type, GFP_KERNEL);
  42         if (!field->type)
  43                 goto err;
  44
  45         field->offset = offset;
  46         field->size = size;
  47         field->is_signed = is_signed;
  48         list_add(&field->link, &call->fields);
  49
  50         return 0;
  51
  52 err:
  53         if (field) {
  54                 kfree(field->name);
  55                 kfree(field->type);
  56         }
  57         kfree(field);
  58
  59         return -ENOMEM;
  60 }
  61 EXPORT_SYMBOL_GPL(trace_define_field);
  62
  63 #ifdef CONFIG_MODULES
  64
  65 static void trace_destroy_fields(struct ftrace_event_call *call)
  66 {
  67         struct ftrace_event_field *field, *next;
  68
  69         list_for_each_entry_safe(field, next, &call->fields, link) {
  70                 list_del(&field->link);
  71                 kfree(field->type);
  72                 kfree(field->name);
  73                 kfree(field);
  74         }
  75 }
  76
  77 #endif /* CONFIG_MODULES */
  78
  79 static void ftrace_clear_events(void)
  80 {
  81         struct ftrace_event_call *call;
  82
  83         mutex_lock(&event_mutex);
  84         list_for_each_entry(call, &ftrace_events, list) {
  85
  86                 if (call->enabled) {
  87                         call->enabled = 0;
  88                         call->unregfunc();
  89                 }
  90         }
  91         mutex_unlock(&event_mutex);
  92 }
  93
  94 static void ftrace_event_enable_disable(struct ftrace_event_call *call,
  95                                         int enable)
  96 {
  97
  98         switch (enable) {
  99         case 0:
 100                 if (call->enabled) {
 101                         call->enabled = 0;
 102                         call->unregfunc();
 103                 }
 104                 break;
 105         case 1:
 106                 if (!call->enabled) {
 107                         call->enabled = 1;
 108                         call->regfunc();
 109                 }
 110                 break;
 111         }
 112 }
 113
 114 static int ftrace_set_clr_event(char *buf, int set)
 115 {
 116         struct ftrace_event_call *call;
 117         char *event = NULL, *sub = NULL, *match;
 118         int ret = -EINVAL;
 119
 120         /*
 121          * The buf format can be <subsystem>:<event-name>
 122          *  *:<event-name> means any event by that name.
 123          *  :<event-name> is the same.
 124          *
 125          *  <subsystem>:* means all events in that subsystem
 126          *  <subsystem>: means the same.
 127          *
 128          *  <name> (no ':') means all events in a subsystem with
 129          *  the name <name> or any event that matches <name>
 130          */
 131
 132         match = strsep(&buf, ":");
 133         if (buf) {
 134                 sub = match;
 135                 event = buf;
 136                 match = NULL;
 137
 138                 if (!strlen(sub) || strcmp(sub, "*") == 0)
 139                         sub = NULL;
 140                 if (!strlen(event) || strcmp(event, "*") == 0)
 141                         event = NULL;
 142         }
 143
 144         mutex_lock(&event_mutex);
 145         list_for_each_entry(call, &ftrace_events, list) {
 146
 147                 if (!call->name || !call->regfunc)
 148                         continue;
 149
 150                 if (match &&
 151                     strcmp(match, call->name) != 0 &&
 152                     strcmp(match, call->system) != 0)
 153                         continue;
 154
 155                 if (sub && strcmp(sub, call->system) != 0)
 156                         continue;
 157
 158                 if (event && strcmp(event, call->name) != 0)
 159                         continue;
 160
 161                 ftrace_event_enable_disable(call, set);
 162
 163                 ret = 0;
 164         }
 165         mutex_unlock(&event_mutex);
 166
 167         return ret;
 168 }
 169
 170 /* 128 should be much more than enough */
 171 #define EVENT_BUF_SIZE          127
 172
 173 static ssize_t
 174 ftrace_event_write(struct file *file, const char __user *ubuf,
 175                    size_t cnt, loff_t *ppos)
 176 {
 177         size_t read = 0;
 178         int i, set = 1;
 179         ssize_t ret;
 180         char *buf;
 181         char ch;
 182
 183         if (!cnt || cnt < 0)
 184                 return 0;
 185
 186         ret = tracing_update_buffers();
 187         if (ret < 0)
 188                 return ret;
 189
 190         ret = get_user(ch, ubuf++);
 191         if (ret)
 192                 return ret;
 193         read++;
 194         cnt--;
 195
 196         /* skip white space */
 197         while (cnt && isspace(ch)) {
 198                 ret = get_user(ch, ubuf++);
 199                 if (ret)
 200                         return ret;
 201                 read++;
 202                 cnt--;
 203         }
 204
 205         /* Only white space found? */
 206         if (isspace(ch)) {
 207                 file->f_pos += read;
 208                 ret = read;
 209                 return ret;
 210         }
 211
 212         buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
 213         if (!buf)
 214                 return -ENOMEM;
 215
 216         if (cnt > EVENT_BUF_SIZE)
 217                 cnt = EVENT_BUF_SIZE;
 218
 219         i = 0;
 220         while (cnt && !isspace(ch)) {
 221                 if (!i && ch == '!')
 222                         set = 0;
 223                 else
 224                         buf[i++] = ch;
 225
 226                 ret = get_user(ch, ubuf++);
 227                 if (ret)
 228                         goto out_free;
 229                 read++;
 230                 cnt--;
 231         }
 232         buf[i] = 0;
 233
 234         file->f_pos += read;
 235
 236         ret = ftrace_set_clr_event(buf, set);
 237         if (ret)
 238                 goto out_free;
 239
 240         ret = read;
 241
 242  out_free:
 243         kfree(buf);
 244
 245         return ret;
 246 }
 247
 248 static void *
 249 t_next(struct seq_file *m, void *v, loff_t *pos)
 250 {
 251         struct list_head *list = m->private;
 252         struct ftrace_event_call *call;
 253
 254         (*pos)++;
 255
 256         for (;;) {
 257                 if (list == &ftrace_events)
 258                         return NULL;
 259
 260                 call = list_entry(list, struct ftrace_event_call, list);
 261
 262                 /*
 263                  * The ftrace subsystem is for showing formats only.
 264                  * They can not be enabled or disabled via the event files.
 265                  */
 266                 if (call->regfunc)
 267                         break;
 268
 269                 list = list->next;
 270         }
 271
 272         m->private = list->next;
 273
 274         return call;
 275 }
 276
 277 static void *t_start(struct seq_file *m, loff_t *pos)
 278 {
 279         mutex_lock(&event_mutex);
 280         if (*pos == 0)
 281                 m->private = ftrace_events.next;
 282         return t_next(m, NULL, pos);
 283 }
 284
 285 static void *
 286 s_next(struct seq_file *m, void *v, loff_t *pos)
 287 {
 288         struct list_head *list = m->private;
 289         struct ftrace_event_call *call;
 290
 291         (*pos)++;
 292
 293  retry:
 294         if (list == &ftrace_events)
 295                 return NULL;
 296
 297         call = list_entry(list, struct ftrace_event_call, list);
 298
 299         if (!call->enabled) {
 300                 list = list->next;
 301                 goto retry;
 302         }
 303
 304         m->private = list->next;
 305
 306         return call;
 307 }
 308
 309 static void *s_start(struct seq_file *m, loff_t *pos)
 310 {
 311         mutex_lock(&event_mutex);
 312         if (*pos == 0)
 313                 m->private = ftrace_events.next;
 314         return s_next(m, NULL, pos);
 315 }
 316
 317 static int t_show(struct seq_file *m, void *v)
 318 {
 319         struct ftrace_event_call *call = v;
 320
 321         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 322                 seq_printf(m, "%s:", call->system);
 323         seq_printf(m, "%s\n", call->name);
 324
 325         return 0;
 326 }
 327
 328 static void t_stop(struct seq_file *m, void *p)
 329 {
 330         mutex_unlock(&event_mutex);
 331 }
 332
 333 static int
 334 ftrace_event_seq_open(struct inode *inode, struct file *file)
 335 {
 336         const struct seq_operations *seq_ops;
 337
 338         if ((file->f_mode & FMODE_WRITE) &&
 339             !(file->f_flags & O_APPEND))
 340                 ftrace_clear_events();
 341
 342         seq_ops = inode->i_private;
 343         return seq_open(file, seq_ops);
 344 }
 345
 346 static ssize_t
 347 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 348                   loff_t *ppos)
 349 {
 350         struct ftrace_event_call *call = filp->private_data;
 351         char *buf;
 352
 353         if (call->enabled)
 354                 buf = "1\n";
 355         else
 356                 buf = "0\n";
 357
 358         return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
 359 }
 360
 361 static ssize_t
 362 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 363                    loff_t *ppos)
 364 {
 365         struct ftrace_event_call *call = filp->private_data;
 366         char buf[64];
 367         unsigned long val;
 368         int ret;
 369
 370         if (cnt >= sizeof(buf))
 371                 return -EINVAL;
 372
 373         if (copy_from_user(&buf, ubuf, cnt))
 374                 return -EFAULT;
 375
 376         buf[cnt] = 0;
 377
 378         ret = strict_strtoul(buf, 10, &val);
 379         if (ret < 0)
 380                 return ret;
 381
 382         ret = tracing_update_buffers();
 383         if (ret < 0)
 384                 return ret;
 385
 386         switch (val) {
 387         case 0:
 388         case 1:
 389                 mutex_lock(&event_mutex);
 390                 ftrace_event_enable_disable(call, val);
 391                 mutex_unlock(&event_mutex);
 392                 break;
 393
 394         default:
 395                 return -EINVAL;
 396         }
 397
 398         *ppos += cnt;
 399
 400         return cnt;
 401 }
 402
 403 static ssize_t
 404 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 405                    loff_t *ppos)
 406 {
 407         const char *system = filp->private_data;
 408         struct ftrace_event_call *call;
 409         char buf[2];
 410         int set = -1;
 411         int all = 0;
 412         int ret;
 413
 414         if (system[0] == '*')
 415                 all = 1;
 416
 417         mutex_lock(&event_mutex);
 418         list_for_each_entry(call, &ftrace_events, list) {
 419                 if (!call->name || !call->regfunc)
 420                         continue;
 421
 422                 if (!all && strcmp(call->system, system) != 0)
 423                         continue;
 424
 425                 /*
 426                  * We need to find out if all the events are set
 427                  * or if all events or cleared, or if we have
 428                  * a mixture.
 429                  */
 430                 if (call->enabled) {
 431                         switch (set) {
 432                         case -1:
 433                                 set = 1;
 434                                 break;
 435                         case 0:
 436                                 set = 2;
 437                                 break;
 438                         }
 439                 } else {
 440                         switch (set) {
 441                         case -1:
 442                                 set = 0;
 443                                 break;
 444                         case 1:
 445                                 set = 2;
 446                                 break;
 447                         }
 448                 }
 449                 /*
 450                  * If we have a mixture, no need to look further.
 451                  */
 452                 if (set == 2)
 453                         break;
 454         }
 455         mutex_unlock(&event_mutex);
 456
 457         buf[1] = '\n';
 458         switch (set) {
 459         case 0:
 460                 buf[0] = '0';
 461                 break;
 462         case 1:
 463                 buf[0] = '1';
 464                 break;
 465         case 2:
 466                 buf[0] = 'X';
 467                 break;
 468         default:
 469                 buf[0] = '?';
 470         }
 471
 472         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
 473
 474         return ret;
 475 }
 476
 477 static ssize_t
 478 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 479                     loff_t *ppos)
 480 {
 481         const char *system = filp->private_data;
 482         unsigned long val;
 483         char *command;
 484         char buf[64];
 485         ssize_t ret;
 486
 487         if (cnt >= sizeof(buf))
 488                 return -EINVAL;
 489
 490         if (copy_from_user(&buf, ubuf, cnt))
 491                 return -EFAULT;
 492
 493         buf[cnt] = 0;
 494
 495         ret = strict_strtoul(buf, 10, &val);
 496         if (ret < 0)
 497                 return ret;
 498
 499         ret = tracing_update_buffers();
 500         if (ret < 0)
 501                 return ret;
 502
 503         switch (val) {
 504         case 0:
 505         case 1:
 506                 break;
 507
 508         default:
 509                 return -EINVAL;
 510         }
 511
 512         /* +3 for the ":*\0" */
 513         command = kmalloc(strlen(system)+3, GFP_KERNEL);
 514         if (!command)
 515                 return -ENOMEM;
 516         sprintf(command, "%s:*", system);
 517
 518         ret = ftrace_set_clr_event(command, val);
 519         if (ret)
 520                 goto out_free;
 521
 522         ret = cnt;
 523
 524  out_free:
 525         kfree(command);
 526
 527         *ppos += cnt;
 528
 529         return ret;
 530 }
 531
 532 extern char *__bad_type_size(void);
 533
 534 #undef FIELD
 535 #define FIELD(type, name)                                               \
 536         sizeof(type) != sizeof(field.name) ? __bad_type_size() :        \
 537         #type, "common_" #name, offsetof(typeof(field), name),          \
 538                 sizeof(field.name)
 539
 540 static int trace_write_header(struct trace_seq *s)
 541 {
 542         struct trace_entry field;
 543
 544         /* struct trace_entry */
 545         return trace_seq_printf(s,
 546                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 547                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 548                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 549                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 550                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 551                                 "\n",
 552                                 FIELD(unsigned short, type),
 553                                 FIELD(unsigned char, flags),
 554                                 FIELD(unsigned char, preempt_count),
 555                                 FIELD(int, pid),
 556                                 FIELD(int, tgid));
 557 }
 558
 559 static ssize_t
 560 event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
 561                   loff_t *ppos)
 562 {
 563         struct ftrace_event_call *call = filp->private_data;
 564         struct trace_seq *s;
 565         char *buf;
 566         int r;
 567
 568         if (*ppos)
 569                 return 0;
 570
 571         s = kmalloc(sizeof(*s), GFP_KERNEL);
 572         if (!s)
 573                 return -ENOMEM;
 574
 575         trace_seq_init(s);
 576
 577         /* If any of the first writes fail, so will the show_format. */
 578
 579         trace_seq_printf(s, "name: %s\n", call->name);
 580         trace_seq_printf(s, "ID: %d\n", call->id);
 581         trace_seq_printf(s, "format:\n");
 582         trace_write_header(s);
 583
 584         r = call->show_format(s);
 585         if (!r) {
 586                 /*
 587                  * ug!  The format output is bigger than a PAGE!!
 588                  */
 589                 buf = "FORMAT TOO BIG\n";
 590                 r = simple_read_from_buffer(ubuf, cnt, ppos,
 591                                               buf, strlen(buf));
 592                 goto out;
 593         }
 594
 595         r = simple_read_from_buffer(ubuf, cnt, ppos,
 596                                     s->buffer, s->len);
 597  out:
 598         kfree(s);
 599         return r;
 600 }
 601
 602 static ssize_t
 603 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
 604 {
 605         struct ftrace_event_call *call = filp->private_data;
 606         struct trace_seq *s;
 607         int r;
 608
 609         if (*ppos)
 610                 return 0;
 611
 612         s = kmalloc(sizeof(*s), GFP_KERNEL);
 613         if (!s)
 614                 return -ENOMEM;
 615
 616         trace_seq_init(s);
 617         trace_seq_printf(s, "%d\n", call->id);
 618
 619         r = simple_read_from_buffer(ubuf, cnt, ppos,
 620                                     s->buffer, s->len);
 621         kfree(s);
 622         return r;
 623 }
 624
 625 static ssize_t
 626 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 627                   loff_t *ppos)
 628 {
 629         struct ftrace_event_call *call = filp->private_data;
 630         struct trace_seq *s;
 631         int r;
 632
 633         if (*ppos)
 634                 return 0;
 635
 636         s = kmalloc(sizeof(*s), GFP_KERNEL);
 637         if (!s)
 638                 return -ENOMEM;
 639
 640         trace_seq_init(s);
 641
 642         print_event_filter(call, s);
 643         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 644
 645         kfree(s);
 646
 647         return r;
 648 }
 649
 650 static ssize_t
 651 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 652                    loff_t *ppos)
 653 {
 654         struct ftrace_event_call *call = filp->private_data;
 655         char *buf;
 656         int err;
 657
 658         if (cnt >= PAGE_SIZE)
 659                 return -EINVAL;
 660
 661         buf = (char *)__get_free_page(GFP_TEMPORARY);
 662         if (!buf)
 663                 return -ENOMEM;
 664
 665         if (copy_from_user(buf, ubuf, cnt)) {
 666                 free_page((unsigned long) buf);
 667                 return -EFAULT;
 668         }
 669         buf[cnt] = '\0';
 670
 671         err = apply_event_filter(call, buf);
 672         free_page((unsigned long) buf);
 673         if (err < 0)
 674                 return err;
 675
 676         *ppos += cnt;
 677
 678         return cnt;
 679 }
 680
 681 static ssize_t
 682 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 683                       loff_t *ppos)
 684 {
 685         struct event_subsystem *system = filp->private_data;
 686         struct trace_seq *s;
 687         int r;
 688
 689         if (*ppos)
 690                 return 0;
 691
 692         s = kmalloc(sizeof(*s), GFP_KERNEL);
 693         if (!s)
 694                 return -ENOMEM;
 695
 696         trace_seq_init(s);
 697
 698         print_subsystem_event_filter(system, s);
 699         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 700
 701         kfree(s);
 702
 703         return r;
 704 }
 705
 706 static ssize_t
 707 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 708                        loff_t *ppos)
 709 {
 710         struct event_subsystem *system = filp->private_data;
 711         char *buf;
 712         int err;
 713
 714         if (cnt >= PAGE_SIZE)
 715                 return -EINVAL;
 716
 717         buf = (char *)__get_free_page(GFP_TEMPORARY);
 718         if (!buf)
 719                 return -ENOMEM;
 720
 721         if (copy_from_user(buf, ubuf, cnt)) {
 722                 free_page((unsigned long) buf);
 723                 return -EFAULT;
 724         }
 725         buf[cnt] = '\0';
 726
 727         err = apply_subsystem_event_filter(system, buf);
 728         free_page((unsigned long) buf);
 729         if (err < 0)
 730                 return err;
 731
 732         *ppos += cnt;
 733
 734         return cnt;
 735 }
 736
 737 static ssize_t
 738 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
 739 {
 740         int (*func)(struct trace_seq *s) = filp->private_data;
 741         struct trace_seq *s;
 742         int r;
 743
 744         if (*ppos)
 745                 return 0;
 746
 747         s = kmalloc(sizeof(*s), GFP_KERNEL);
 748         if (!s)
 749                 return -ENOMEM;
 750
 751         trace_seq_init(s);
 752
 753         func(s);
 754         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 755
 756         kfree(s);
 757
 758         return r;
 759 }
 760
 761 static const struct seq_operations show_event_seq_ops = {
 762         .start = t_start,
 763         .next = t_next,
 764         .show = t_show,
 765         .stop = t_stop,
 766 };
 767
 768 static const struct seq_operations show_set_event_seq_ops = {
 769         .start = s_start,
 770         .next = s_next,
 771         .show = t_show,
 772         .stop = t_stop,
 773 };
 774
 775 static const struct file_operations ftrace_avail_fops = {
 776         .open = ftrace_event_seq_open,
 777         .read = seq_read,
 778         .llseek = seq_lseek,
 779         .release = seq_release,
 780 };
 781
 782 static const struct file_operations ftrace_set_event_fops = {
 783         .open = ftrace_event_seq_open,
 784         .read = seq_read,
 785         .write = ftrace_event_write,
 786         .llseek = seq_lseek,
 787         .release = seq_release,
 788 };
 789
 790 static const struct file_operations ftrace_enable_fops = {
 791         .open = tracing_open_generic,
 792         .read = event_enable_read,
 793         .write = event_enable_write,
 794 };
 795
 796 static const struct file_operations ftrace_event_format_fops = {
 797         .open = tracing_open_generic,
 798         .read = event_format_read,
 799 };
 800
 801 static const struct file_operations ftrace_event_id_fops = {
 802         .open = tracing_open_generic,
 803         .read = event_id_read,
 804 };
 805
 806 static const struct file_operations ftrace_event_filter_fops = {
 807         .open = tracing_open_generic,
 808         .read = event_filter_read,
 809         .write = event_filter_write,
 810 };
 811
 812 static const struct file_operations ftrace_subsystem_filter_fops = {
 813         .open = tracing_open_generic,
 814         .read = subsystem_filter_read,
 815         .write = subsystem_filter_write,
 816 };
 817
 818 static const struct file_operations ftrace_system_enable_fops = {
 819         .open = tracing_open_generic,
 820         .read = system_enable_read,
 821         .write = system_enable_write,
 822 };
 823
 824 static const struct file_operations ftrace_show_header_fops = {
 825         .open = tracing_open_generic,
 826         .read = show_header,
 827 };
 828
 829 static struct dentry *event_trace_events_dir(void)
 830 {
 831         static struct dentry *d_tracer;
 832         static struct dentry *d_events;
 833
 834         if (d_events)
 835                 return d_events;
 836
 837         d_tracer = tracing_init_dentry();
 838         if (!d_tracer)
 839                 return NULL;
 840
 841         d_events = debugfs_create_dir("events", d_tracer);
 842         if (!d_events)
 843                 pr_warning("Could not create debugfs "
 844                            "'events' directory\n");
 845
 846         return d_events;
 847 }
 848
 849 static LIST_HEAD(event_subsystems);
 850
 851 static struct dentry *
 852 event_subsystem_dir(const char *name, struct dentry *d_events)
 853 {
 854         struct event_subsystem *system;
 855         struct dentry *entry;
 856
 857         /* First see if we did not already create this dir */
 858         list_for_each_entry(system, &event_subsystems, list) {
 859                 if (strcmp(system->name, name) == 0)
 860                         return system->entry;
 861         }
 862
 863         /* need to create new entry */
 864         system = kmalloc(sizeof(*system), GFP_KERNEL);
 865         if (!system) {
 866                 pr_warning("No memory to create event subsystem %s\n",
 867                            name);
 868                 return d_events;
 869         }
 870
 871         system->entry = debugfs_create_dir(name, d_events);
 872         if (!system->entry) {
 873                 pr_warning("Could not create event subsystem %s\n",
 874                            name);
 875                 kfree(system);
 876                 return d_events;
 877         }
 878
 879         system->name = kstrdup(name, GFP_KERNEL);
 880         if (!system->name) {
 881                 debugfs_remove(system->entry);
 882                 kfree(system);
 883                 return d_events;
 884         }
 885
 886         list_add(&system->list, &event_subsystems);
 887
 888         system->filter = NULL;
 889
 890         system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
 891         if (!system->filter) {
 892                 pr_warning("Could not allocate filter for subsystem "
 893                            "'%s'\n", name);
 894                 return system->entry;
 895         }
 896
 897         entry = debugfs_create_file("filter", 0644, system->entry, system,
 898                                     &ftrace_subsystem_filter_fops);
 899         if (!entry) {
 900                 kfree(system->filter);
 901                 system->filter = NULL;
 902                 pr_warning("Could not create debugfs "
 903                            "'%s/filter' entry\n", name);
 904         }
 905
 906         entry = trace_create_file("enable", 0644, system->entry,
 907                                   (void *)system->name,
 908                                   &ftrace_system_enable_fops);
 909
 910         return system->entry;
 911 }
 912
 913 static int
 914 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
 915                  const struct file_operations *id,
 916                  const struct file_operations *enable,
 917                  const struct file_operations *filter,
 918                  const struct file_operations *format)
 919 {
 920         struct dentry *entry;
 921         int ret;
 922
 923         /*
 924          * If the trace point header did not define TRACE_SYSTEM
 925          * then the system would be called "TRACE_SYSTEM".
 926          */
 927         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 928                 d_events = event_subsystem_dir(call->system, d_events);
 929
 930         if (call->raw_init) {
 931                 ret = call->raw_init();
 932                 if (ret < 0) {
 933                         pr_warning("Could not initialize trace point"
 934                                    " events/%s\n", call->name);
 935                         return ret;
 936                 }
 937         }
 938
 939         call->dir = debugfs_create_dir(call->name, d_events);
 940         if (!call->dir) {
 941                 pr_warning("Could not create debugfs "
 942                            "'%s' directory\n", call->name);
 943                 return -1;
 944         }
 945
 946         if (call->regfunc)
 947                 entry = trace_create_file("enable", 0644, call->dir, call,
 948                                           enable);
 949
 950         if (call->id)
 951                 entry = trace_create_file("id", 0444, call->dir, call,
 952                                           id);
 953
 954         if (call->define_fields) {
 955                 ret = call->define_fields();
 956                 if (ret < 0) {
 957                         pr_warning("Could not initialize trace point"
 958                                    " events/%s\n", call->name);
 959                         return ret;
 960                 }
 961                 entry = trace_create_file("filter", 0644, call->dir, call,
 962                                           filter);
 963         }
 964
 965         /* A trace may not want to export its format */
 966         if (!call->show_format)
 967                 return 0;
 968
 969         entry = trace_create_file("format", 0444, call->dir, call,
 970                                   format);
 971
 972         return 0;
 973 }
 974
 975 #define for_each_event(event, start, end)                       \
 976         for (event = start;                                     \
 977              (unsigned long)event < (unsigned long)end;         \
 978              event++)
 979
 980 #ifdef CONFIG_MODULES
 981
 982 static LIST_HEAD(ftrace_module_file_list);
 983
 984 /*
 985  * Modules must own their file_operations to keep up with
 986  * reference counting.
 987  */
 988 struct ftrace_module_file_ops {
 989         struct list_head                list;
 990         struct module                   *mod;
 991         struct file_operations          id;
 992         struct file_operations          enable;
 993         struct file_operations          format;
 994         struct file_operations          filter;
 995 };
 996
 997 static struct ftrace_module_file_ops *
 998 trace_create_file_ops(struct module *mod)
 999 {
1000         struct ftrace_module_file_ops *file_ops;
1001
1002         /*
1003          * This is a bit of a PITA. To allow for correct reference
1004          * counting, modules must "own" their file_operations.
1005          * To do this, we allocate the file operations that will be
1006          * used in the event directory.
1007          */
1008
1009         file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1010         if (!file_ops)
1011                 return NULL;
1012
1013         file_ops->mod = mod;
1014
1015         file_ops->id = ftrace_event_id_fops;
1016         file_ops->id.owner = mod;
1017
1018         file_ops->enable = ftrace_enable_fops;
1019         file_ops->enable.owner = mod;
1020
1021         file_ops->filter = ftrace_event_filter_fops;
1022         file_ops->filter.owner = mod;
1023
1024         file_ops->format = ftrace_event_format_fops;
1025         file_ops->format.owner = mod;
1026
1027         list_add(&file_ops->list, &ftrace_module_file_list);
1028
1029         return file_ops;
1030 }
1031
1032 static void trace_module_add_events(struct module *mod)
1033 {
1034         struct ftrace_module_file_ops *file_ops = NULL;
1035         struct ftrace_event_call *call, *start, *end;
1036         struct dentry *d_events;
1037
1038         start = mod->trace_events;
1039         end = mod->trace_events + mod->num_trace_events;
1040
1041         if (start == end)
1042                 return;
1043
1044         d_events = event_trace_events_dir();
1045         if (!d_events)
1046                 return;
1047
1048         for_each_event(call, start, end) {
1049                 /* The linker may leave blanks */
1050                 if (!call->name)
1051                         continue;
1052
1053                 /*
1054                  * This module has events, create file ops for this module
1055                  * if not already done.
1056                  */
1057                 if (!file_ops) {
1058                         file_ops = trace_create_file_ops(mod);
1059                         if (!file_ops)
1060                                 return;
1061                 }
1062                 call->mod = mod;
1063                 list_add(&call->list, &ftrace_events);
1064                 event_create_dir(call, d_events,
1065                                  &file_ops->id, &file_ops->enable,
1066                                  &file_ops->filter, &file_ops->format);
1067         }
1068 }
1069
1070 static void trace_module_remove_events(struct module *mod)
1071 {
1072         struct ftrace_module_file_ops *file_ops;
1073         struct ftrace_event_call *call, *p;
1074         bool found = false;
1075
1076         list_for_each_entry_safe(call, p, &ftrace_events, list) {
1077                 if (call->mod == mod) {
1078                         found = true;
1079                         if (call->enabled) {
1080                                 call->enabled = 0;
1081                                 call->unregfunc();
1082                         }
1083                         if (call->event)
1084                                 unregister_ftrace_event(call->event);
1085                         debugfs_remove_recursive(call->dir);
1086                         list_del(&call->list);
1087                         trace_destroy_fields(call);
1088                         destroy_preds(call);
1089                 }
1090         }
1091
1092         /* Now free the file_operations */
1093         list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1094                 if (file_ops->mod == mod)
1095                         break;
1096         }
1097         if (&file_ops->list != &ftrace_module_file_list) {
1098                 list_del(&file_ops->list);
1099                 kfree(file_ops);
1100         }
1101
1102         /*
1103          * It is safest to reset the ring buffer if the module being unloaded
1104          * registered any events.
1105          */
1106         if (found)
1107                 tracing_reset_current_online_cpus();
1108 }
1109
1110 static int trace_module_notify(struct notifier_block *self,
1111                                unsigned long val, void *data)
1112 {
1113         struct module *mod = data;
1114
1115         mutex_lock(&event_mutex);
1116         switch (val) {
1117         case MODULE_STATE_COMING:
1118                 trace_module_add_events(mod);
1119                 break;
1120         case MODULE_STATE_GOING:
1121                 trace_module_remove_events(mod);
1122                 break;
1123         }
1124         mutex_unlock(&event_mutex);
1125
1126         return 0;
1127 }
1128 #else
1129 static int trace_module_notify(struct notifier_block *self,
1130                                unsigned long val, void *data)
1131 {
1132         return 0;
1133 }
1134 #endif /* CONFIG_MODULES */
1135
1136 struct notifier_block trace_module_nb = {
1137         .notifier_call = trace_module_notify,
1138         .priority = 0,
1139 };
1140
1141 extern struct ftrace_event_call __start_ftrace_events[];
1142 extern struct ftrace_event_call __stop_ftrace_events[];
1143
1144 static __init int event_trace_init(void)
1145 {
1146         struct ftrace_event_call *call;
1147         struct dentry *d_tracer;
1148         struct dentry *entry;
1149         struct dentry *d_events;
1150         int ret;
1151
1152         d_tracer = tracing_init_dentry();
1153         if (!d_tracer)
1154                 return 0;
1155
1156         entry = debugfs_create_file("available_events", 0444, d_tracer,
1157                                     (void *)&show_event_seq_ops,
1158                                     &ftrace_avail_fops);
1159         if (!entry)
1160                 pr_warning("Could not create debugfs "
1161                            "'available_events' entry\n");
1162
1163         entry = debugfs_create_file("set_event", 0644, d_tracer,
1164                                     (void *)&show_set_event_seq_ops,
1165                                     &ftrace_set_event_fops);
1166         if (!entry)
1167                 pr_warning("Could not create debugfs "
1168                            "'set_event' entry\n");
1169
1170         d_events = event_trace_events_dir();
1171         if (!d_events)
1172                 return 0;
1173
1174         /* ring buffer internal formats */
1175         trace_create_file("header_page", 0444, d_events,
1176                           ring_buffer_print_page_header,
1177                           &ftrace_show_header_fops);
1178
1179         trace_create_file("header_event", 0444, d_events,
1180                           ring_buffer_print_entry_header,
1181                           &ftrace_show_header_fops);
1182
1183         trace_create_file("enable", 0644, d_events,
1184                           "*", &ftrace_system_enable_fops);
1185
1186         for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
1187                 /* The linker may leave blanks */
1188                 if (!call->name)
1189                         continue;
1190                 list_add(&call->list, &ftrace_events);
1191                 event_create_dir(call, d_events, &ftrace_event_id_fops,
1192                                  &ftrace_enable_fops, &ftrace_event_filter_fops,
1193                                  &ftrace_event_format_fops);
1194         }
1195
1196         ret = register_module_notifier(&trace_module_nb);
1197         if (!ret)
1198                 pr_warning("Failed to register trace events module notifier\n");
1199
1200         return 0;
1201 }
1202 fs_initcall(event_trace_init);
1203
1204 #ifdef CONFIG_FTRACE_STARTUP_TEST
1205
1206 static DEFINE_SPINLOCK(test_spinlock);
1207 static DEFINE_SPINLOCK(test_spinlock_irq);
1208 static DEFINE_MUTEX(test_mutex);
1209
1210 static __init void test_work(struct work_struct *dummy)
1211 {
1212         spin_lock(&test_spinlock);
1213         spin_lock_irq(&test_spinlock_irq);
1214         udelay(1);
1215         spin_unlock_irq(&test_spinlock_irq);
1216         spin_unlock(&test_spinlock);
1217
1218         mutex_lock(&test_mutex);
1219         msleep(1);
1220         mutex_unlock(&test_mutex);
1221 }
1222
1223 static __init int event_test_thread(void *unused)
1224 {
1225         void *test_malloc;
1226
1227         test_malloc = kmalloc(1234, GFP_KERNEL);
1228         if (!test_malloc)
1229                 pr_info("failed to kmalloc\n");
1230
1231         schedule_on_each_cpu(test_work);
1232
1233         kfree(test_malloc);
1234
1235         set_current_state(TASK_INTERRUPTIBLE);
1236         while (!kthread_should_stop())
1237                 schedule();
1238
1239         return 0;
1240 }
1241
1242 /*
1243  * Do various things that may trigger events.
1244  */
1245 static __init void event_test_stuff(void)
1246 {
1247         struct task_struct *test_thread;
1248
1249         test_thread = kthread_run(event_test_thread, NULL, "test-events");
1250         msleep(1);
1251         kthread_stop(test_thread);
1252 }
1253
1254 /*
1255  * For every trace event defined, we will test each trace point separately,
1256  * and then by groups, and finally all trace points.
1257  */
1258 static __init void event_trace_self_tests(void)
1259 {
1260         struct ftrace_event_call *call;
1261         struct event_subsystem *system;
1262         char *sysname;
1263         int ret;
1264
1265         pr_info("Running tests on trace events:\n");
1266
1267         list_for_each_entry(call, &ftrace_events, list) {
1268
1269                 /* Only test those that have a regfunc */
1270                 if (!call->regfunc)
1271                         continue;
1272
1273                 pr_info("Testing event %s: ", call->name);
1274
1275                 /*
1276                  * If an event is already enabled, someone is using
1277                  * it and the self test should not be on.
1278                  */
1279                 if (call->enabled) {
1280                         pr_warning("Enabled event during self test!\n");
1281                         WARN_ON_ONCE(1);
1282                         continue;
1283                 }
1284
1285                 call->enabled = 1;
1286                 call->regfunc();
1287
1288                 event_test_stuff();
1289
1290                 call->unregfunc();
1291                 call->enabled = 0;
1292
1293                 pr_cont("OK\n");
1294         }
1295
1296         /* Now test at the sub system level */
1297
1298         pr_info("Running tests on trace event systems:\n");
1299
1300         list_for_each_entry(system, &event_subsystems, list) {
1301
1302                 /* the ftrace system is special, skip it */
1303                 if (strcmp(system->name, "ftrace") == 0)
1304                         continue;
1305
1306                 pr_info("Testing event system %s: ", system->name);
1307
1308                 /* ftrace_set_clr_event can modify the name passed in. */
1309                 sysname = kstrdup(system->name, GFP_KERNEL);
1310                 if (WARN_ON(!sysname)) {
1311                         pr_warning("Can't allocate memory, giving up!\n");
1312                         return;
1313                 }
1314                 ret = ftrace_set_clr_event(sysname, 1);
1315                 kfree(sysname);
1316                 if (WARN_ON_ONCE(ret)) {
1317                         pr_warning("error enabling system %s\n",
1318                                    system->name);
1319                         continue;
1320                 }
1321
1322                 event_test_stuff();
1323
1324                 sysname = kstrdup(system->name, GFP_KERNEL);
1325                 if (WARN_ON(!sysname)) {
1326                         pr_warning("Can't allocate memory, giving up!\n");
1327                         return;
1328                 }
1329                 ret = ftrace_set_clr_event(sysname, 0);
1330                 kfree(sysname);
1331
1332                 if (WARN_ON_ONCE(ret))
1333                         pr_warning("error disabling system %s\n",
1334                                    system->name);
1335
1336                 pr_cont("OK\n");
1337         }
1338
1339         /* Test with all events enabled */
1340
1341         pr_info("Running tests on all trace events:\n");
1342         pr_info("Testing all events: ");
1343
1344         sysname = kmalloc(4, GFP_KERNEL);
1345         if (WARN_ON(!sysname)) {
1346                 pr_warning("Can't allocate memory, giving up!\n");
1347                 return;
1348         }
1349         memcpy(sysname, "*:*", 4);
1350         ret = ftrace_set_clr_event(sysname, 1);
1351         if (WARN_ON_ONCE(ret)) {
1352                 kfree(sysname);
1353                 pr_warning("error enabling all events\n");
1354                 return;
1355         }
1356
1357         event_test_stuff();
1358
1359         /* reset sysname */
1360         memcpy(sysname, "*:*", 4);
1361         ret = ftrace_set_clr_event(sysname, 0);
1362         kfree(sysname);
1363
1364         if (WARN_ON_ONCE(ret)) {
1365                 pr_warning("error disabling all events\n");
1366                 return;
1367         }
1368
1369         pr_cont("OK\n");
1370 }
1371
1372 #ifdef CONFIG_FUNCTION_TRACER
1373
1374 static DEFINE_PER_CPU(atomic_t, test_event_disable);
1375
1376 static void
1377 function_test_events_call(unsigned long ip, unsigned long parent_ip)
1378 {
1379         struct ring_buffer_event *event;
1380         struct ftrace_entry *entry;
1381         unsigned long flags;
1382         long disabled;
1383         int resched;
1384         int cpu;
1385         int pc;
1386
1387         pc = preempt_count();
1388         resched = ftrace_preempt_disable();
1389         cpu = raw_smp_processor_id();
1390         disabled = atomic_inc_return(&per_cpu(test_event_disable, cpu));
1391
1392         if (disabled != 1)
1393                 goto out;
1394
1395         local_save_flags(flags);
1396
1397         event = trace_current_buffer_lock_reserve(TRACE_FN, sizeof(*entry),
1398                                                   flags, pc);
1399         if (!event)
1400                 goto out;
1401         entry   = ring_buffer_event_data(event);
1402         entry->ip                       = ip;
1403         entry->parent_ip                = parent_ip;
1404
1405         trace_nowake_buffer_unlock_commit(event, flags, pc);
1406
1407  out:
1408         atomic_dec(&per_cpu(test_event_disable, cpu));
1409         ftrace_preempt_enable(resched);
1410 }
1411
1412 static struct ftrace_ops trace_ops __initdata  =
1413 {
1414         .func = function_test_events_call,
1415 };
1416
1417 static __init void event_trace_self_test_with_function(void)
1418 {
1419         register_ftrace_function(&trace_ops);
1420         pr_info("Running tests again, along with the function tracer\n");
1421         event_trace_self_tests();
1422         unregister_ftrace_function(&trace_ops);
1423 }
1424 #else
1425 static __init void event_trace_self_test_with_function(void)
1426 {
1427 }
1428 #endif
1429
1430 static __init int event_trace_self_tests_init(void)
1431 {
1432
1433         event_trace_self_tests();
1434
1435         event_trace_self_test_with_function();
1436
1437         return 0;
1438 }
1439
1440 late_initcall(event_trace_self_tests_init);
1441
1442 #endif