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 static 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)
  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         list_add(&field->link, &call->fields);
  48
  49         return 0;
  50
  51 err:
  52         if (field) {
  53                 kfree(field->name);
  54                 kfree(field->type);
  55         }
  56         kfree(field);
  57
  58         return -ENOMEM;
  59 }
  60 EXPORT_SYMBOL_GPL(trace_define_field);
  61
  62 static void ftrace_clear_events(void)
  63 {
  64         struct ftrace_event_call *call;
  65
  66         list_for_each_entry(call, &ftrace_events, list) {
  67
  68                 if (call->enabled) {
  69                         call->enabled = 0;
  70                         call->unregfunc();
  71                 }
  72         }
  73 }
  74
  75 static void ftrace_event_enable_disable(struct ftrace_event_call *call,
  76                                         int enable)
  77 {
  78
  79         switch (enable) {
  80         case 0:
  81                 if (call->enabled) {
  82                         call->enabled = 0;
  83                         call->unregfunc();
  84                 }
  85                 break;
  86         case 1:
  87                 if (!call->enabled) {
  88                         call->enabled = 1;
  89                         call->regfunc();
  90                 }
  91                 break;
  92         }
  93 }
  94
  95 static int ftrace_set_clr_event(char *buf, int set)
  96 {
  97         struct ftrace_event_call *call;
  98         char *event = NULL, *sub = NULL, *match;
  99         int ret = -EINVAL;
 100
 101         /*
 102          * The buf format can be <subsystem>:<event-name>
 103          *  *:<event-name> means any event by that name.
 104          *  :<event-name> is the same.
 105          *
 106          *  <subsystem>:* means all events in that subsystem
 107          *  <subsystem>: means the same.
 108          *
 109          *  <name> (no ':') means all events in a subsystem with
 110          *  the name <name> or any event that matches <name>
 111          */
 112
 113         match = strsep(&buf, ":");
 114         if (buf) {
 115                 sub = match;
 116                 event = buf;
 117                 match = NULL;
 118
 119                 if (!strlen(sub) || strcmp(sub, "*") == 0)
 120                         sub = NULL;
 121                 if (!strlen(event) || strcmp(event, "*") == 0)
 122                         event = NULL;
 123         }
 124
 125         mutex_lock(&event_mutex);
 126         list_for_each_entry(call, &ftrace_events, list) {
 127
 128                 if (!call->name || !call->regfunc)
 129                         continue;
 130
 131                 if (match &&
 132                     strcmp(match, call->name) != 0 &&
 133                     strcmp(match, call->system) != 0)
 134                         continue;
 135
 136                 if (sub && strcmp(sub, call->system) != 0)
 137                         continue;
 138
 139                 if (event && strcmp(event, call->name) != 0)
 140                         continue;
 141
 142                 ftrace_event_enable_disable(call, set);
 143
 144                 ret = 0;
 145         }
 146         mutex_unlock(&event_mutex);
 147
 148         return ret;
 149 }
 150
 151 /* 128 should be much more than enough */
 152 #define EVENT_BUF_SIZE          127
 153
 154 static ssize_t
 155 ftrace_event_write(struct file *file, const char __user *ubuf,
 156                    size_t cnt, loff_t *ppos)
 157 {
 158         size_t read = 0;
 159         int i, set = 1;
 160         ssize_t ret;
 161         char *buf;
 162         char ch;
 163
 164         if (!cnt || cnt < 0)
 165                 return 0;
 166
 167         ret = tracing_update_buffers();
 168         if (ret < 0)
 169                 return ret;
 170
 171         ret = get_user(ch, ubuf++);
 172         if (ret)
 173                 return ret;
 174         read++;
 175         cnt--;
 176
 177         /* skip white space */
 178         while (cnt && isspace(ch)) {
 179                 ret = get_user(ch, ubuf++);
 180                 if (ret)
 181                         return ret;
 182                 read++;
 183                 cnt--;
 184         }
 185
 186         /* Only white space found? */
 187         if (isspace(ch)) {
 188                 file->f_pos += read;
 189                 ret = read;
 190                 return ret;
 191         }
 192
 193         buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
 194         if (!buf)
 195                 return -ENOMEM;
 196
 197         if (cnt > EVENT_BUF_SIZE)
 198                 cnt = EVENT_BUF_SIZE;
 199
 200         i = 0;
 201         while (cnt && !isspace(ch)) {
 202                 if (!i && ch == '!')
 203                         set = 0;
 204                 else
 205                         buf[i++] = ch;
 206
 207                 ret = get_user(ch, ubuf++);
 208                 if (ret)
 209                         goto out_free;
 210                 read++;
 211                 cnt--;
 212         }
 213         buf[i] = 0;
 214
 215         file->f_pos += read;
 216
 217         ret = ftrace_set_clr_event(buf, set);
 218         if (ret)
 219                 goto out_free;
 220
 221         ret = read;
 222
 223  out_free:
 224         kfree(buf);
 225
 226         return ret;
 227 }
 228
 229 static void *
 230 t_next(struct seq_file *m, void *v, loff_t *pos)
 231 {
 232         struct list_head *list = m->private;
 233         struct ftrace_event_call *call;
 234
 235         (*pos)++;
 236
 237         for (;;) {
 238                 if (list == &ftrace_events)
 239                         return NULL;
 240
 241                 call = list_entry(list, struct ftrace_event_call, list);
 242
 243                 /*
 244                  * The ftrace subsystem is for showing formats only.
 245                  * They can not be enabled or disabled via the event files.
 246                  */
 247                 if (call->regfunc)
 248                         break;
 249
 250                 list = list->next;
 251         }
 252
 253         m->private = list->next;
 254
 255         return call;
 256 }
 257
 258 static void *t_start(struct seq_file *m, loff_t *pos)
 259 {
 260         return t_next(m, NULL, pos);
 261 }
 262
 263 static void *
 264 s_next(struct seq_file *m, void *v, loff_t *pos)
 265 {
 266         struct list_head *list = m->private;
 267         struct ftrace_event_call *call;
 268
 269         (*pos)++;
 270
 271  retry:
 272         if (list == &ftrace_events)
 273                 return NULL;
 274
 275         call = list_entry(list, struct ftrace_event_call, list);
 276
 277         if (!call->enabled) {
 278                 list = list->next;
 279                 goto retry;
 280         }
 281
 282         m->private = list->next;
 283
 284         return call;
 285 }
 286
 287 static void *s_start(struct seq_file *m, loff_t *pos)
 288 {
 289         return s_next(m, NULL, pos);
 290 }
 291
 292 static int t_show(struct seq_file *m, void *v)
 293 {
 294         struct ftrace_event_call *call = v;
 295
 296         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 297                 seq_printf(m, "%s:", call->system);
 298         seq_printf(m, "%s\n", call->name);
 299
 300         return 0;
 301 }
 302
 303 static void t_stop(struct seq_file *m, void *p)
 304 {
 305 }
 306
 307 static int
 308 ftrace_event_seq_open(struct inode *inode, struct file *file)
 309 {
 310         int ret;
 311         const struct seq_operations *seq_ops;
 312
 313         if ((file->f_mode & FMODE_WRITE) &&
 314             !(file->f_flags & O_APPEND))
 315                 ftrace_clear_events();
 316
 317         seq_ops = inode->i_private;
 318         ret = seq_open(file, seq_ops);
 319         if (!ret) {
 320                 struct seq_file *m = file->private_data;
 321
 322                 m->private = ftrace_events.next;
 323         }
 324         return ret;
 325 }
 326
 327 static ssize_t
 328 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 329                   loff_t *ppos)
 330 {
 331         struct ftrace_event_call *call = filp->private_data;
 332         char *buf;
 333
 334         if (call->enabled)
 335                 buf = "1\n";
 336         else
 337                 buf = "0\n";
 338
 339         return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
 340 }
 341
 342 static ssize_t
 343 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 344                    loff_t *ppos)
 345 {
 346         struct ftrace_event_call *call = filp->private_data;
 347         char buf[64];
 348         unsigned long val;
 349         int ret;
 350
 351         if (cnt >= sizeof(buf))
 352                 return -EINVAL;
 353
 354         if (copy_from_user(&buf, ubuf, cnt))
 355                 return -EFAULT;
 356
 357         buf[cnt] = 0;
 358
 359         ret = strict_strtoul(buf, 10, &val);
 360         if (ret < 0)
 361                 return ret;
 362
 363         ret = tracing_update_buffers();
 364         if (ret < 0)
 365                 return ret;
 366
 367         switch (val) {
 368         case 0:
 369         case 1:
 370                 mutex_lock(&event_mutex);
 371                 ftrace_event_enable_disable(call, val);
 372                 mutex_unlock(&event_mutex);
 373                 break;
 374
 375         default:
 376                 return -EINVAL;
 377         }
 378
 379         *ppos += cnt;
 380
 381         return cnt;
 382 }
 383
 384 #undef FIELD
 385 #define FIELD(type, name)                                               \
 386         #type, "common_" #name, offsetof(typeof(field), name),          \
 387                 sizeof(field.name)
 388
 389 static int trace_write_header(struct trace_seq *s)
 390 {
 391         struct trace_entry field;
 392
 393         /* struct trace_entry */
 394         return trace_seq_printf(s,
 395                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 396                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 397                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 398                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 399                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 400                                 "\n",
 401                                 FIELD(unsigned char, type),
 402                                 FIELD(unsigned char, flags),
 403                                 FIELD(unsigned char, preempt_count),
 404                                 FIELD(int, pid),
 405                                 FIELD(int, tgid));
 406 }
 407
 408 static ssize_t
 409 event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
 410                   loff_t *ppos)
 411 {
 412         struct ftrace_event_call *call = filp->private_data;
 413         struct trace_seq *s;
 414         char *buf;
 415         int r;
 416
 417         if (*ppos)
 418                 return 0;
 419
 420         s = kmalloc(sizeof(*s), GFP_KERNEL);
 421         if (!s)
 422                 return -ENOMEM;
 423
 424         trace_seq_init(s);
 425
 426         /* If any of the first writes fail, so will the show_format. */
 427
 428         trace_seq_printf(s, "name: %s\n", call->name);
 429         trace_seq_printf(s, "ID: %d\n", call->id);
 430         trace_seq_printf(s, "format:\n");
 431         trace_write_header(s);
 432
 433         r = call->show_format(s);
 434         if (!r) {
 435                 /*
 436                  * ug!  The format output is bigger than a PAGE!!
 437                  */
 438                 buf = "FORMAT TOO BIG\n";
 439                 r = simple_read_from_buffer(ubuf, cnt, ppos,
 440                                               buf, strlen(buf));
 441                 goto out;
 442         }
 443
 444         r = simple_read_from_buffer(ubuf, cnt, ppos,
 445                                     s->buffer, s->len);
 446  out:
 447         kfree(s);
 448         return r;
 449 }
 450
 451 static ssize_t
 452 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
 453 {
 454         struct ftrace_event_call *call = filp->private_data;
 455         struct trace_seq *s;
 456         int r;
 457
 458         if (*ppos)
 459                 return 0;
 460
 461         s = kmalloc(sizeof(*s), GFP_KERNEL);
 462         if (!s)
 463                 return -ENOMEM;
 464
 465         trace_seq_init(s);
 466         trace_seq_printf(s, "%d\n", call->id);
 467
 468         r = simple_read_from_buffer(ubuf, cnt, ppos,
 469                                     s->buffer, s->len);
 470         kfree(s);
 471         return r;
 472 }
 473
 474 static ssize_t
 475 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 476                   loff_t *ppos)
 477 {
 478         struct ftrace_event_call *call = filp->private_data;
 479         struct trace_seq *s;
 480         int r;
 481
 482         if (*ppos)
 483                 return 0;
 484
 485         s = kmalloc(sizeof(*s), GFP_KERNEL);
 486         if (!s)
 487                 return -ENOMEM;
 488
 489         trace_seq_init(s);
 490
 491         filter_print_preds(call->preds, call->n_preds, s);
 492         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 493
 494         kfree(s);
 495
 496         return r;
 497 }
 498
 499 static ssize_t
 500 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 501                    loff_t *ppos)
 502 {
 503         struct ftrace_event_call *call = filp->private_data;
 504         char buf[64], *pbuf = buf;
 505         struct filter_pred *pred;
 506         int err;
 507
 508         if (cnt >= sizeof(buf))
 509                 return -EINVAL;
 510
 511         if (copy_from_user(&buf, ubuf, cnt))
 512                 return -EFAULT;
 513         buf[cnt] = '\0';
 514
 515         pred = kzalloc(sizeof(*pred), GFP_KERNEL);
 516         if (!pred)
 517                 return -ENOMEM;
 518
 519         err = filter_parse(&pbuf, pred);
 520         if (err < 0) {
 521                 filter_free_pred(pred);
 522                 return err;
 523         }
 524
 525         if (pred->clear) {
 526                 filter_disable_preds(call);
 527                 filter_free_pred(pred);
 528                 return cnt;
 529         }
 530
 531         err = filter_add_pred(call, pred);
 532         if (err < 0) {
 533                 filter_free_pred(pred);
 534                 return err;
 535         }
 536
 537         filter_free_pred(pred);
 538
 539         *ppos += cnt;
 540
 541         return cnt;
 542 }
 543
 544 static ssize_t
 545 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 546                       loff_t *ppos)
 547 {
 548         struct event_subsystem *system = filp->private_data;
 549         struct trace_seq *s;
 550         int r;
 551
 552         if (*ppos)
 553                 return 0;
 554
 555         s = kmalloc(sizeof(*s), GFP_KERNEL);
 556         if (!s)
 557                 return -ENOMEM;
 558
 559         trace_seq_init(s);
 560
 561         filter_print_preds(system->preds, system->n_preds, s);
 562         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 563
 564         kfree(s);
 565
 566         return r;
 567 }
 568
 569 static ssize_t
 570 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 571                        loff_t *ppos)
 572 {
 573         struct event_subsystem *system = filp->private_data;
 574         char buf[64], *pbuf = buf;
 575         struct filter_pred *pred;
 576         int err;
 577
 578         if (cnt >= sizeof(buf))
 579                 return -EINVAL;
 580
 581         if (copy_from_user(&buf, ubuf, cnt))
 582                 return -EFAULT;
 583         buf[cnt] = '\0';
 584
 585         pred = kzalloc(sizeof(*pred), GFP_KERNEL);
 586         if (!pred)
 587                 return -ENOMEM;
 588
 589         err = filter_parse(&pbuf, pred);
 590         if (err < 0) {
 591                 filter_free_pred(pred);
 592                 return err;
 593         }
 594
 595         if (pred->clear) {
 596                 filter_free_subsystem_preds(system);
 597                 filter_free_pred(pred);
 598                 return cnt;
 599         }
 600
 601         err = filter_add_subsystem_pred(system, pred);
 602         if (err < 0) {
 603                 filter_free_subsystem_preds(system);
 604                 filter_free_pred(pred);
 605                 return err;
 606         }
 607
 608         *ppos += cnt;
 609
 610         return cnt;
 611 }
 612
 613 static const struct seq_operations show_event_seq_ops = {
 614         .start = t_start,
 615         .next = t_next,
 616         .show = t_show,
 617         .stop = t_stop,
 618 };
 619
 620 static const struct seq_operations show_set_event_seq_ops = {
 621         .start = s_start,
 622         .next = s_next,
 623         .show = t_show,
 624         .stop = t_stop,
 625 };
 626
 627 static const struct file_operations ftrace_avail_fops = {
 628         .open = ftrace_event_seq_open,
 629         .read = seq_read,
 630         .llseek = seq_lseek,
 631         .release = seq_release,
 632 };
 633
 634 static const struct file_operations ftrace_set_event_fops = {
 635         .open = ftrace_event_seq_open,
 636         .read = seq_read,
 637         .write = ftrace_event_write,
 638         .llseek = seq_lseek,
 639         .release = seq_release,
 640 };
 641
 642 static const struct file_operations ftrace_enable_fops = {
 643         .open = tracing_open_generic,
 644         .read = event_enable_read,
 645         .write = event_enable_write,
 646 };
 647
 648 static const struct file_operations ftrace_event_format_fops = {
 649         .open = tracing_open_generic,
 650         .read = event_format_read,
 651 };
 652
 653 static const struct file_operations ftrace_event_id_fops = {
 654         .open = tracing_open_generic,
 655         .read = event_id_read,
 656 };
 657
 658 static const struct file_operations ftrace_event_filter_fops = {
 659         .open = tracing_open_generic,
 660         .read = event_filter_read,
 661         .write = event_filter_write,
 662 };
 663
 664 static const struct file_operations ftrace_subsystem_filter_fops = {
 665         .open = tracing_open_generic,
 666         .read = subsystem_filter_read,
 667         .write = subsystem_filter_write,
 668 };
 669
 670 static struct dentry *event_trace_events_dir(void)
 671 {
 672         static struct dentry *d_tracer;
 673         static struct dentry *d_events;
 674
 675         if (d_events)
 676                 return d_events;
 677
 678         d_tracer = tracing_init_dentry();
 679         if (!d_tracer)
 680                 return NULL;
 681
 682         d_events = debugfs_create_dir("events", d_tracer);
 683         if (!d_events)
 684                 pr_warning("Could not create debugfs "
 685                            "'events' directory\n");
 686
 687         return d_events;
 688 }
 689
 690 static LIST_HEAD(event_subsystems);
 691
 692 static struct dentry *
 693 event_subsystem_dir(const char *name, struct dentry *d_events)
 694 {
 695         struct event_subsystem *system;
 696         struct dentry *entry;
 697
 698         /* First see if we did not already create this dir */
 699         list_for_each_entry(system, &event_subsystems, list) {
 700                 if (strcmp(system->name, name) == 0)
 701                         return system->entry;
 702         }
 703
 704         /* need to create new entry */
 705         system = kmalloc(sizeof(*system), GFP_KERNEL);
 706         if (!system) {
 707                 pr_warning("No memory to create event subsystem %s\n",
 708                            name);
 709                 return d_events;
 710         }
 711
 712         system->entry = debugfs_create_dir(name, d_events);
 713         if (!system->entry) {
 714                 pr_warning("Could not create event subsystem %s\n",
 715                            name);
 716                 kfree(system);
 717                 return d_events;
 718         }
 719
 720         system->name = kstrdup(name, GFP_KERNEL);
 721         if (!system->name) {
 722                 debugfs_remove(system->entry);
 723                 kfree(system);
 724                 return d_events;
 725         }
 726
 727         list_add(&system->list, &event_subsystems);
 728
 729         system->preds = NULL;
 730         system->n_preds = 0;
 731
 732         entry = debugfs_create_file("filter", 0644, system->entry, system,
 733                                     &ftrace_subsystem_filter_fops);
 734         if (!entry)
 735                 pr_warning("Could not create debugfs "
 736                            "'%s/filter' entry\n", name);
 737
 738         return system->entry;
 739 }
 740
 741 static int
 742 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
 743 {
 744         struct dentry *entry;
 745         int ret;
 746
 747         /*
 748          * If the trace point header did not define TRACE_SYSTEM
 749          * then the system would be called "TRACE_SYSTEM".
 750          */
 751         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 752                 d_events = event_subsystem_dir(call->system, d_events);
 753
 754         if (call->raw_init) {
 755                 ret = call->raw_init();
 756                 if (ret < 0) {
 757                         pr_warning("Could not initialize trace point"
 758                                    " events/%s\n", call->name);
 759                         return ret;
 760                 }
 761         }
 762
 763         call->dir = debugfs_create_dir(call->name, d_events);
 764         if (!call->dir) {
 765                 pr_warning("Could not create debugfs "
 766                            "'%s' directory\n", call->name);
 767                 return -1;
 768         }
 769
 770         if (call->regfunc)
 771                 entry = trace_create_file("enable", 0644, call->dir, call,
 772                                           &ftrace_enable_fops);
 773
 774         if (call->id)
 775                 entry = trace_create_file("id", 0444, call->dir, call,
 776                                           &ftrace_event_id_fops);
 777
 778         if (call->define_fields) {
 779                 ret = call->define_fields();
 780                 if (ret < 0) {
 781                         pr_warning("Could not initialize trace point"
 782                                    " events/%s\n", call->name);
 783                         return ret;
 784                 }
 785                 entry = trace_create_file("filter", 0644, call->dir, call,
 786                                           &ftrace_event_filter_fops);
 787         }
 788
 789         /* A trace may not want to export its format */
 790         if (!call->show_format)
 791                 return 0;
 792
 793         entry = trace_create_file("format", 0444, call->dir, call,
 794                                   &ftrace_event_format_fops);
 795
 796         return 0;
 797 }
 798
 799 #define for_each_event(event, start, end)                       \
 800         for (event = start;                                     \
 801              (unsigned long)event < (unsigned long)end;         \
 802              event++)
 803
 804 #ifdef CONFIG_MODULES
 805 static void trace_module_add_events(struct module *mod)
 806 {
 807         struct ftrace_event_call *call, *start, *end;
 808         struct dentry *d_events;
 809
 810         start = mod->trace_events;
 811         end = mod->trace_events + mod->num_trace_events;
 812
 813         if (start == end)
 814                 return;
 815
 816         d_events = event_trace_events_dir();
 817         if (!d_events)
 818                 return;
 819
 820         for_each_event(call, start, end) {
 821                 /* The linker may leave blanks */
 822                 if (!call->name)
 823                         continue;
 824                 call->mod = mod;
 825                 list_add(&call->list, &ftrace_events);
 826                 event_create_dir(call, d_events);
 827         }
 828 }
 829
 830 static void trace_module_remove_events(struct module *mod)
 831 {
 832         struct ftrace_event_call *call, *p;
 833
 834         list_for_each_entry_safe(call, p, &ftrace_events, list) {
 835                 if (call->mod == mod) {
 836                         if (call->enabled) {
 837                                 call->enabled = 0;
 838                                 call->unregfunc();
 839                         }
 840                         if (call->event)
 841                                 unregister_ftrace_event(call->event);
 842                         debugfs_remove_recursive(call->dir);
 843                         list_del(&call->list);
 844                 }
 845         }
 846 }
 847
 848 static int trace_module_notify(struct notifier_block *self,
 849                                unsigned long val, void *data)
 850 {
 851         struct module *mod = data;
 852
 853         mutex_lock(&event_mutex);
 854         switch (val) {
 855         case MODULE_STATE_COMING:
 856                 trace_module_add_events(mod);
 857                 break;
 858         case MODULE_STATE_GOING:
 859                 trace_module_remove_events(mod);
 860                 break;
 861         }
 862         mutex_unlock(&event_mutex);
 863
 864         return 0;
 865 }
 866 #else
 867 static int trace_module_notify(struct notifier_block *self,
 868                                unsigned long val, void *data)
 869 {
 870         return 0;
 871 }
 872 #endif /* CONFIG_MODULES */
 873
 874 struct notifier_block trace_module_nb = {
 875         .notifier_call = trace_module_notify,
 876         .priority = 0,
 877 };
 878
 879 extern struct ftrace_event_call __start_ftrace_events[];
 880 extern struct ftrace_event_call __stop_ftrace_events[];
 881
 882 static __init int event_trace_init(void)
 883 {
 884         struct ftrace_event_call *call;
 885         struct dentry *d_tracer;
 886         struct dentry *entry;
 887         struct dentry *d_events;
 888         int ret;
 889
 890         d_tracer = tracing_init_dentry();
 891         if (!d_tracer)
 892                 return 0;
 893
 894         entry = debugfs_create_file("available_events", 0444, d_tracer,
 895                                     (void *)&show_event_seq_ops,
 896                                     &ftrace_avail_fops);
 897         if (!entry)
 898                 pr_warning("Could not create debugfs "
 899                            "'available_events' entry\n");
 900
 901         entry = debugfs_create_file("set_event", 0644, d_tracer,
 902                                     (void *)&show_set_event_seq_ops,
 903                                     &ftrace_set_event_fops);
 904         if (!entry)
 905                 pr_warning("Could not create debugfs "
 906                            "'set_event' entry\n");
 907
 908         d_events = event_trace_events_dir();
 909         if (!d_events)
 910                 return 0;
 911
 912         for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
 913                 /* The linker may leave blanks */
 914                 if (!call->name)
 915                         continue;
 916                 list_add(&call->list, &ftrace_events);
 917                 event_create_dir(call, d_events);
 918         }
 919
 920         ret = register_module_notifier(&trace_module_nb);
 921         if (!ret)
 922                 pr_warning("Failed to register trace events module notifier\n");
 923
 924         return 0;
 925 }
 926 fs_initcall(event_trace_init);
 927
 928 #ifdef CONFIG_FTRACE_STARTUP_TEST
 929
 930 static DEFINE_SPINLOCK(test_spinlock);
 931 static DEFINE_SPINLOCK(test_spinlock_irq);
 932 static DEFINE_MUTEX(test_mutex);
 933
 934 static __init void test_work(struct work_struct *dummy)
 935 {
 936         spin_lock(&test_spinlock);
 937         spin_lock_irq(&test_spinlock_irq);
 938         udelay(1);
 939         spin_unlock_irq(&test_spinlock_irq);
 940         spin_unlock(&test_spinlock);
 941
 942         mutex_lock(&test_mutex);
 943         msleep(1);
 944         mutex_unlock(&test_mutex);
 945 }
 946
 947 static __init int event_test_thread(void *unused)
 948 {
 949         void *test_malloc;
 950
 951         test_malloc = kmalloc(1234, GFP_KERNEL);
 952         if (!test_malloc)
 953                 pr_info("failed to kmalloc\n");
 954
 955         schedule_on_each_cpu(test_work);
 956
 957         kfree(test_malloc);
 958
 959         set_current_state(TASK_INTERRUPTIBLE);
 960         while (!kthread_should_stop())
 961                 schedule();
 962
 963         return 0;
 964 }
 965
 966 /*
 967  * Do various things that may trigger events.
 968  */
 969 static __init void event_test_stuff(void)
 970 {
 971         struct task_struct *test_thread;
 972
 973         test_thread = kthread_run(event_test_thread, NULL, "test-events");
 974         msleep(1);
 975         kthread_stop(test_thread);
 976 }
 977
 978 /*
 979  * For every trace event defined, we will test each trace point separately,
 980  * and then by groups, and finally all trace points.
 981  */
 982 static __init int event_trace_self_tests(void)
 983 {
 984         struct ftrace_event_call *call;
 985         struct event_subsystem *system;
 986         char *sysname;
 987         int ret;
 988
 989         pr_info("Running tests on trace events:\n");
 990
 991         list_for_each_entry(call, &ftrace_events, list) {
 992
 993                 /* Only test those that have a regfunc */
 994                 if (!call->regfunc)
 995                         continue;
 996
 997                 pr_info("Testing event %s: ", call->name);
 998
 999                 /*
1000                  * If an event is already enabled, someone is using
1001                  * it and the self test should not be on.
1002                  */
1003                 if (call->enabled) {
1004                         pr_warning("Enabled event during self test!\n");
1005                         WARN_ON_ONCE(1);
1006                         continue;
1007                 }
1008
1009                 call->enabled = 1;
1010                 call->regfunc();
1011
1012                 event_test_stuff();
1013
1014                 call->unregfunc();
1015                 call->enabled = 0;
1016
1017                 pr_cont("OK\n");
1018         }
1019
1020         /* Now test at the sub system level */
1021
1022         pr_info("Running tests on trace event systems:\n");
1023
1024         list_for_each_entry(system, &event_subsystems, list) {
1025
1026                 /* the ftrace system is special, skip it */
1027                 if (strcmp(system->name, "ftrace") == 0)
1028                         continue;
1029
1030                 pr_info("Testing event system %s: ", system->name);
1031
1032                 /* ftrace_set_clr_event can modify the name passed in. */
1033                 sysname = kstrdup(system->name, GFP_KERNEL);
1034                 if (WARN_ON(!sysname)) {
1035                         pr_warning("Can't allocate memory, giving up!\n");
1036                         return 0;
1037                 }
1038                 ret = ftrace_set_clr_event(sysname, 1);
1039                 kfree(sysname);
1040                 if (WARN_ON_ONCE(ret)) {
1041                         pr_warning("error enabling system %s\n",
1042                                    system->name);
1043                         continue;
1044                 }
1045
1046                 event_test_stuff();
1047
1048                 sysname = kstrdup(system->name, GFP_KERNEL);
1049                 if (WARN_ON(!sysname)) {
1050                         pr_warning("Can't allocate memory, giving up!\n");
1051                         return 0;
1052                 }
1053                 ret = ftrace_set_clr_event(sysname, 0);
1054                 kfree(sysname);
1055
1056                 if (WARN_ON_ONCE(ret))
1057                         pr_warning("error disabling system %s\n",
1058                                    system->name);
1059
1060                 pr_cont("OK\n");
1061         }
1062
1063         /* Test with all events enabled */
1064
1065         pr_info("Running tests on all trace events:\n");
1066         pr_info("Testing all events: ");
1067
1068         sysname = kmalloc(4, GFP_KERNEL);
1069         if (WARN_ON(!sysname)) {
1070                 pr_warning("Can't allocate memory, giving up!\n");
1071                 return 0;
1072         }
1073         memcpy(sysname, "*:*", 4);
1074         ret = ftrace_set_clr_event(sysname, 1);
1075         if (WARN_ON_ONCE(ret)) {
1076                 kfree(sysname);
1077                 pr_warning("error enabling all events\n");
1078                 return 0;
1079         }
1080
1081         event_test_stuff();
1082
1083         /* reset sysname */
1084         memcpy(sysname, "*:*", 4);
1085         ret = ftrace_set_clr_event(sysname, 0);
1086         kfree(sysname);
1087
1088         if (WARN_ON_ONCE(ret)) {
1089                 pr_warning("error disabling all events\n");
1090                 return 0;
1091         }
1092
1093         pr_cont("OK\n");
1094
1095         return 0;
1096 }
1097
1098 late_initcall(event_trace_self_tests);
1099
1100 #endif