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/debugfs.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/module.h>
  14 #include <linux/ctype.h>
  15
  16 #include "trace_output.h"
  17
  18 #define TRACE_SYSTEM "TRACE_SYSTEM"
  19
  20 static DEFINE_MUTEX(event_mutex);
  21
  22 int trace_define_field(struct ftrace_event_call *call, char *type,
  23                        char *name, int offset, int size)
  24 {
  25         struct ftrace_event_field *field;
  26
  27         field = kzalloc(sizeof(*field), GFP_KERNEL);
  28         if (!field)
  29                 goto err;
  30
  31         field->name = kstrdup(name, GFP_KERNEL);
  32         if (!field->name)
  33                 goto err;
  34
  35         field->type = kstrdup(type, GFP_KERNEL);
  36         if (!field->type)
  37                 goto err;
  38
  39         field->offset = offset;
  40         field->size = size;
  41         list_add(&field->link, &call->fields);
  42
  43         return 0;
  44
  45 err:
  46         if (field) {
  47                 kfree(field->name);
  48                 kfree(field->type);
  49         }
  50         kfree(field);
  51
  52         return -ENOMEM;
  53 }
  54
  55 static void ftrace_clear_events(void)
  56 {
  57         struct ftrace_event_call *call = (void *)__start_ftrace_events;
  58
  59
  60         while ((unsigned long)call < (unsigned long)__stop_ftrace_events) {
  61
  62                 if (call->enabled) {
  63                         call->enabled = 0;
  64                         call->unregfunc();
  65                 }
  66                 call++;
  67         }
  68 }
  69
  70 static void ftrace_event_enable_disable(struct ftrace_event_call *call,
  71                                         int enable)
  72 {
  73
  74         switch (enable) {
  75         case 0:
  76                 if (call->enabled) {
  77                         call->enabled = 0;
  78                         call->unregfunc();
  79                 }
  80                 break;
  81         case 1:
  82                 if (!call->enabled) {
  83                         call->enabled = 1;
  84                         call->regfunc();
  85                 }
  86                 break;
  87         }
  88 }
  89
  90 static int ftrace_set_clr_event(char *buf, int set)
  91 {
  92         struct ftrace_event_call *call = __start_ftrace_events;
  93         char *event = NULL, *sub = NULL, *match;
  94         int ret = -EINVAL;
  95
  96         /*
  97          * The buf format can be <subsystem>:<event-name>
  98          *  *:<event-name> means any event by that name.
  99          *  :<event-name> is the same.
 100          *
 101          *  <subsystem>:* means all events in that subsystem
 102          *  <subsystem>: means the same.
 103          *
 104          *  <name> (no ':') means all events in a subsystem with
 105          *  the name <name> or any event that matches <name>
 106          */
 107
 108         match = strsep(&buf, ":");
 109         if (buf) {
 110                 sub = match;
 111                 event = buf;
 112                 match = NULL;
 113
 114                 if (!strlen(sub) || strcmp(sub, "*") == 0)
 115                         sub = NULL;
 116                 if (!strlen(event) || strcmp(event, "*") == 0)
 117                         event = NULL;
 118         }
 119
 120         mutex_lock(&event_mutex);
 121         for_each_event(call) {
 122
 123                 if (!call->name || !call->regfunc)
 124                         continue;
 125
 126                 if (match &&
 127                     strcmp(match, call->name) != 0 &&
 128                     strcmp(match, call->system) != 0)
 129                         continue;
 130
 131                 if (sub && strcmp(sub, call->system) != 0)
 132                         continue;
 133
 134                 if (event && strcmp(event, call->name) != 0)
 135                         continue;
 136
 137                 ftrace_event_enable_disable(call, set);
 138
 139                 ret = 0;
 140         }
 141         mutex_unlock(&event_mutex);
 142
 143         return ret;
 144 }
 145
 146 /* 128 should be much more than enough */
 147 #define EVENT_BUF_SIZE          127
 148
 149 static ssize_t
 150 ftrace_event_write(struct file *file, const char __user *ubuf,
 151                    size_t cnt, loff_t *ppos)
 152 {
 153         size_t read = 0;
 154         int i, set = 1;
 155         ssize_t ret;
 156         char *buf;
 157         char ch;
 158
 159         if (!cnt || cnt < 0)
 160                 return 0;
 161
 162         ret = tracing_update_buffers();
 163         if (ret < 0)
 164                 return ret;
 165
 166         ret = get_user(ch, ubuf++);
 167         if (ret)
 168                 return ret;
 169         read++;
 170         cnt--;
 171
 172         /* skip white space */
 173         while (cnt && isspace(ch)) {
 174                 ret = get_user(ch, ubuf++);
 175                 if (ret)
 176                         return ret;
 177                 read++;
 178                 cnt--;
 179         }
 180
 181         /* Only white space found? */
 182         if (isspace(ch)) {
 183                 file->f_pos += read;
 184                 ret = read;
 185                 return ret;
 186         }
 187
 188         buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
 189         if (!buf)
 190                 return -ENOMEM;
 191
 192         if (cnt > EVENT_BUF_SIZE)
 193                 cnt = EVENT_BUF_SIZE;
 194
 195         i = 0;
 196         while (cnt && !isspace(ch)) {
 197                 if (!i && ch == '!')
 198                         set = 0;
 199                 else
 200                         buf[i++] = ch;
 201
 202                 ret = get_user(ch, ubuf++);
 203                 if (ret)
 204                         goto out_free;
 205                 read++;
 206                 cnt--;
 207         }
 208         buf[i] = 0;
 209
 210         file->f_pos += read;
 211
 212         ret = ftrace_set_clr_event(buf, set);
 213         if (ret)
 214                 goto out_free;
 215
 216         ret = read;
 217
 218  out_free:
 219         kfree(buf);
 220
 221         return ret;
 222 }
 223
 224 static void *
 225 t_next(struct seq_file *m, void *v, loff_t *pos)
 226 {
 227         struct ftrace_event_call *call = m->private;
 228         struct ftrace_event_call *next = call;
 229
 230         (*pos)++;
 231
 232         for (;;) {
 233                 if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
 234                         return NULL;
 235
 236                 /*
 237                  * The ftrace subsystem is for showing formats only.
 238                  * They can not be enabled or disabled via the event files.
 239                  */
 240                 if (call->regfunc)
 241                         break;
 242
 243                 call++;
 244                 next = call;
 245         }
 246
 247         m->private = ++next;
 248
 249         return call;
 250 }
 251
 252 static void *t_start(struct seq_file *m, loff_t *pos)
 253 {
 254         return t_next(m, NULL, pos);
 255 }
 256
 257 static void *
 258 s_next(struct seq_file *m, void *v, loff_t *pos)
 259 {
 260         struct ftrace_event_call *call = m->private;
 261         struct ftrace_event_call *next;
 262
 263         (*pos)++;
 264
 265  retry:
 266         if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
 267                 return NULL;
 268
 269         if (!call->enabled) {
 270                 call++;
 271                 goto retry;
 272         }
 273
 274         next = call;
 275         m->private = ++next;
 276
 277         return call;
 278 }
 279
 280 static void *s_start(struct seq_file *m, loff_t *pos)
 281 {
 282         return s_next(m, NULL, pos);
 283 }
 284
 285 static int t_show(struct seq_file *m, void *v)
 286 {
 287         struct ftrace_event_call *call = v;
 288
 289         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 290                 seq_printf(m, "%s:", call->system);
 291         seq_printf(m, "%s\n", call->name);
 292
 293         return 0;
 294 }
 295
 296 static void t_stop(struct seq_file *m, void *p)
 297 {
 298 }
 299
 300 static int
 301 ftrace_event_seq_open(struct inode *inode, struct file *file)
 302 {
 303         int ret;
 304         const struct seq_operations *seq_ops;
 305
 306         if ((file->f_mode & FMODE_WRITE) &&
 307             !(file->f_flags & O_APPEND))
 308                 ftrace_clear_events();
 309
 310         seq_ops = inode->i_private;
 311         ret = seq_open(file, seq_ops);
 312         if (!ret) {
 313                 struct seq_file *m = file->private_data;
 314
 315                 m->private = __start_ftrace_events;
 316         }
 317         return ret;
 318 }
 319
 320 static ssize_t
 321 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 322                   loff_t *ppos)
 323 {
 324         struct ftrace_event_call *call = filp->private_data;
 325         char *buf;
 326
 327         if (call->enabled)
 328                 buf = "1\n";
 329         else
 330                 buf = "0\n";
 331
 332         return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
 333 }
 334
 335 static ssize_t
 336 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 337                    loff_t *ppos)
 338 {
 339         struct ftrace_event_call *call = filp->private_data;
 340         char buf[64];
 341         unsigned long val;
 342         int ret;
 343
 344         if (cnt >= sizeof(buf))
 345                 return -EINVAL;
 346
 347         if (copy_from_user(&buf, ubuf, cnt))
 348                 return -EFAULT;
 349
 350         buf[cnt] = 0;
 351
 352         ret = strict_strtoul(buf, 10, &val);
 353         if (ret < 0)
 354                 return ret;
 355
 356         ret = tracing_update_buffers();
 357         if (ret < 0)
 358                 return ret;
 359
 360         switch (val) {
 361         case 0:
 362         case 1:
 363                 mutex_lock(&event_mutex);
 364                 ftrace_event_enable_disable(call, val);
 365                 mutex_unlock(&event_mutex);
 366                 break;
 367
 368         default:
 369                 return -EINVAL;
 370         }
 371
 372         *ppos += cnt;
 373
 374         return cnt;
 375 }
 376
 377 #undef FIELD
 378 #define FIELD(type, name)                                               \
 379         #type, "common_" #name, offsetof(typeof(field), name),          \
 380                 sizeof(field.name)
 381
 382 static int trace_write_header(struct trace_seq *s)
 383 {
 384         struct trace_entry field;
 385
 386         /* struct trace_entry */
 387         return trace_seq_printf(s,
 388                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 389                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 390                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 391                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 392                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 393                                 "\n",
 394                                 FIELD(unsigned char, type),
 395                                 FIELD(unsigned char, flags),
 396                                 FIELD(unsigned char, preempt_count),
 397                                 FIELD(int, pid),
 398                                 FIELD(int, tgid));
 399 }
 400
 401 static ssize_t
 402 event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
 403                   loff_t *ppos)
 404 {
 405         struct ftrace_event_call *call = filp->private_data;
 406         struct trace_seq *s;
 407         char *buf;
 408         int r;
 409
 410         if (*ppos)
 411                 return 0;
 412
 413         s = kmalloc(sizeof(*s), GFP_KERNEL);
 414         if (!s)
 415                 return -ENOMEM;
 416
 417         trace_seq_init(s);
 418
 419         /* If any of the first writes fail, so will the show_format. */
 420
 421         trace_seq_printf(s, "name: %s\n", call->name);
 422         trace_seq_printf(s, "ID: %d\n", call->id);
 423         trace_seq_printf(s, "format:\n");
 424         trace_write_header(s);
 425
 426         r = call->show_format(s);
 427         if (!r) {
 428                 /*
 429                  * ug!  The format output is bigger than a PAGE!!
 430                  */
 431                 buf = "FORMAT TOO BIG\n";
 432                 r = simple_read_from_buffer(ubuf, cnt, ppos,
 433                                               buf, strlen(buf));
 434                 goto out;
 435         }
 436
 437         r = simple_read_from_buffer(ubuf, cnt, ppos,
 438                                     s->buffer, s->len);
 439  out:
 440         kfree(s);
 441         return r;
 442 }
 443
 444 static ssize_t
 445 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
 446 {
 447         struct ftrace_event_call *call = filp->private_data;
 448         struct trace_seq *s;
 449         int r;
 450
 451         if (*ppos)
 452                 return 0;
 453
 454         s = kmalloc(sizeof(*s), GFP_KERNEL);
 455         if (!s)
 456                 return -ENOMEM;
 457
 458         trace_seq_init(s);
 459         trace_seq_printf(s, "%d\n", call->id);
 460
 461         r = simple_read_from_buffer(ubuf, cnt, ppos,
 462                                     s->buffer, s->len);
 463         kfree(s);
 464         return r;
 465 }
 466
 467 static ssize_t
 468 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 469                   loff_t *ppos)
 470 {
 471         struct ftrace_event_call *call = filp->private_data;
 472         struct trace_seq *s;
 473         int r;
 474
 475         if (*ppos)
 476                 return 0;
 477
 478         s = kmalloc(sizeof(*s), GFP_KERNEL);
 479         if (!s)
 480                 return -ENOMEM;
 481
 482         trace_seq_init(s);
 483
 484         filter_print_preds(call->preds, s);
 485         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 486
 487         kfree(s);
 488
 489         return r;
 490 }
 491
 492 static ssize_t
 493 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 494                    loff_t *ppos)
 495 {
 496         struct ftrace_event_call *call = filp->private_data;
 497         char buf[64], *pbuf = buf;
 498         struct filter_pred *pred;
 499         int err;
 500
 501         if (cnt >= sizeof(buf))
 502                 return -EINVAL;
 503
 504         if (copy_from_user(&buf, ubuf, cnt))
 505                 return -EFAULT;
 506         buf[cnt] = '\0';
 507
 508         pred = kzalloc(sizeof(*pred), GFP_KERNEL);
 509         if (!pred)
 510                 return -ENOMEM;
 511
 512         err = filter_parse(&pbuf, pred);
 513         if (err < 0) {
 514                 filter_free_pred(pred);
 515                 return err;
 516         }
 517
 518         if (pred->clear) {
 519                 filter_free_preds(call);
 520                 filter_free_pred(pred);
 521                 return cnt;
 522         }
 523
 524         err = filter_add_pred(call, pred);
 525         if (err < 0) {
 526                 filter_free_pred(pred);
 527                 return err;
 528         }
 529
 530         *ppos += cnt;
 531
 532         return cnt;
 533 }
 534
 535 static ssize_t
 536 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
 537                       loff_t *ppos)
 538 {
 539         struct event_subsystem *system = filp->private_data;
 540         struct trace_seq *s;
 541         int r;
 542
 543         if (*ppos)
 544                 return 0;
 545
 546         s = kmalloc(sizeof(*s), GFP_KERNEL);
 547         if (!s)
 548                 return -ENOMEM;
 549
 550         trace_seq_init(s);
 551
 552         filter_print_preds(system->preds, s);
 553         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 554
 555         kfree(s);
 556
 557         return r;
 558 }
 559
 560 static ssize_t
 561 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
 562                        loff_t *ppos)
 563 {
 564         struct event_subsystem *system = filp->private_data;
 565         char buf[64], *pbuf = buf;
 566         struct filter_pred *pred;
 567         int err;
 568
 569         if (cnt >= sizeof(buf))
 570                 return -EINVAL;
 571
 572         if (copy_from_user(&buf, ubuf, cnt))
 573                 return -EFAULT;
 574         buf[cnt] = '\0';
 575
 576         pred = kzalloc(sizeof(*pred), GFP_KERNEL);
 577         if (!pred)
 578                 return -ENOMEM;
 579
 580         err = filter_parse(&pbuf, pred);
 581         if (err < 0) {
 582                 filter_free_pred(pred);
 583                 return err;
 584         }
 585
 586         if (pred->clear) {
 587                 filter_free_subsystem_preds(system);
 588                 filter_free_pred(pred);
 589                 return cnt;
 590         }
 591
 592         err = filter_add_subsystem_pred(system, pred);
 593         if (err < 0) {
 594                 filter_free_subsystem_preds(system);
 595                 filter_free_pred(pred);
 596                 return err;
 597         }
 598
 599         *ppos += cnt;
 600
 601         return cnt;
 602 }
 603
 604 static const struct seq_operations show_event_seq_ops = {
 605         .start = t_start,
 606         .next = t_next,
 607         .show = t_show,
 608         .stop = t_stop,
 609 };
 610
 611 static const struct seq_operations show_set_event_seq_ops = {
 612         .start = s_start,
 613         .next = s_next,
 614         .show = t_show,
 615         .stop = t_stop,
 616 };
 617
 618 static const struct file_operations ftrace_avail_fops = {
 619         .open = ftrace_event_seq_open,
 620         .read = seq_read,
 621         .llseek = seq_lseek,
 622         .release = seq_release,
 623 };
 624
 625 static const struct file_operations ftrace_set_event_fops = {
 626         .open = ftrace_event_seq_open,
 627         .read = seq_read,
 628         .write = ftrace_event_write,
 629         .llseek = seq_lseek,
 630         .release = seq_release,
 631 };
 632
 633 static const struct file_operations ftrace_enable_fops = {
 634         .open = tracing_open_generic,
 635         .read = event_enable_read,
 636         .write = event_enable_write,
 637 };
 638
 639 static const struct file_operations ftrace_event_format_fops = {
 640         .open = tracing_open_generic,
 641         .read = event_format_read,
 642 };
 643
 644 static const struct file_operations ftrace_event_id_fops = {
 645         .open = tracing_open_generic,
 646         .read = event_id_read,
 647 };
 648
 649 static const struct file_operations ftrace_event_filter_fops = {
 650         .open = tracing_open_generic,
 651         .read = event_filter_read,
 652         .write = event_filter_write,
 653 };
 654
 655 static const struct file_operations ftrace_subsystem_filter_fops = {
 656         .open = tracing_open_generic,
 657         .read = subsystem_filter_read,
 658         .write = subsystem_filter_write,
 659 };
 660
 661 static struct dentry *event_trace_events_dir(void)
 662 {
 663         static struct dentry *d_tracer;
 664         static struct dentry *d_events;
 665
 666         if (d_events)
 667                 return d_events;
 668
 669         d_tracer = tracing_init_dentry();
 670         if (!d_tracer)
 671                 return NULL;
 672
 673         d_events = debugfs_create_dir("events", d_tracer);
 674         if (!d_events)
 675                 pr_warning("Could not create debugfs "
 676                            "'events' directory\n");
 677
 678         return d_events;
 679 }
 680
 681 static LIST_HEAD(event_subsystems);
 682
 683 static struct dentry *
 684 event_subsystem_dir(const char *name, struct dentry *d_events)
 685 {
 686         struct event_subsystem *system;
 687         struct dentry *entry;
 688
 689         /* First see if we did not already create this dir */
 690         list_for_each_entry(system, &event_subsystems, list) {
 691                 if (strcmp(system->name, name) == 0)
 692                         return system->entry;
 693         }
 694
 695         /* need to create new entry */
 696         system = kmalloc(sizeof(*system), GFP_KERNEL);
 697         if (!system) {
 698                 pr_warning("No memory to create event subsystem %s\n",
 699                            name);
 700                 return d_events;
 701         }
 702
 703         system->entry = debugfs_create_dir(name, d_events);
 704         if (!system->entry) {
 705                 pr_warning("Could not create event subsystem %s\n",
 706                            name);
 707                 kfree(system);
 708                 return d_events;
 709         }
 710
 711         system->name = name;
 712         list_add(&system->list, &event_subsystems);
 713
 714         system->preds = NULL;
 715
 716         entry = debugfs_create_file("filter", 0644, system->entry, system,
 717                                     &ftrace_subsystem_filter_fops);
 718         if (!entry)
 719                 pr_warning("Could not create debugfs "
 720                            "'%s/filter' entry\n", name);
 721
 722         return system->entry;
 723 }
 724
 725 static int
 726 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
 727 {
 728         struct dentry *entry;
 729         int ret;
 730
 731         /*
 732          * If the trace point header did not define TRACE_SYSTEM
 733          * then the system would be called "TRACE_SYSTEM".
 734          */
 735         if (strcmp(call->system, "TRACE_SYSTEM") != 0)
 736                 d_events = event_subsystem_dir(call->system, d_events);
 737
 738         if (call->raw_init) {
 739                 ret = call->raw_init();
 740                 if (ret < 0) {
 741                         pr_warning("Could not initialize trace point"
 742                                    " events/%s\n", call->name);
 743                         return ret;
 744                 }
 745         }
 746
 747         call->dir = debugfs_create_dir(call->name, d_events);
 748         if (!call->dir) {
 749                 pr_warning("Could not create debugfs "
 750                            "'%s' directory\n", call->name);
 751                 return -1;
 752         }
 753
 754         if (call->regfunc) {
 755                 entry = debugfs_create_file("enable", 0644, call->dir, call,
 756                                             &ftrace_enable_fops);
 757                 if (!entry)
 758                         pr_warning("Could not create debugfs "
 759                                    "'%s/enable' entry\n", call->name);
 760         }
 761
 762         if (call->id) {
 763                 entry = debugfs_create_file("id", 0444, call->dir, call,
 764                                 &ftrace_event_id_fops);
 765                 if (!entry)
 766                         pr_warning("Could not create debugfs '%s/id' entry\n",
 767                                         call->name);
 768         }
 769
 770         if (call->define_fields) {
 771                 ret = call->define_fields();
 772                 if (ret < 0) {
 773                         pr_warning("Could not initialize trace point"
 774                                    " events/%s\n", call->name);
 775                         return ret;
 776                 }
 777                 entry = debugfs_create_file("filter", 0644, call->dir, call,
 778                                             &ftrace_event_filter_fops);
 779                 if (!entry)
 780                         pr_warning("Could not create debugfs "
 781                                    "'%s/filter' entry\n", call->name);
 782         }
 783
 784         /* A trace may not want to export its format */
 785         if (!call->show_format)
 786                 return 0;
 787
 788         entry = debugfs_create_file("format", 0444, call->dir, call,
 789                                     &ftrace_event_format_fops);
 790         if (!entry)
 791                 pr_warning("Could not create debugfs "
 792                            "'%s/format' entry\n", call->name);
 793
 794         return 0;
 795 }
 796
 797 static __init int event_trace_init(void)
 798 {
 799         struct ftrace_event_call *call = __start_ftrace_events;
 800         struct dentry *d_tracer;
 801         struct dentry *entry;
 802         struct dentry *d_events;
 803
 804         d_tracer = tracing_init_dentry();
 805         if (!d_tracer)
 806                 return 0;
 807
 808         entry = debugfs_create_file("available_events", 0444, d_tracer,
 809                                     (void *)&show_event_seq_ops,
 810                                     &ftrace_avail_fops);
 811         if (!entry)
 812                 pr_warning("Could not create debugfs "
 813                            "'available_events' entry\n");
 814
 815         entry = debugfs_create_file("set_event", 0644, d_tracer,
 816                                     (void *)&show_set_event_seq_ops,
 817                                     &ftrace_set_event_fops);
 818         if (!entry)
 819                 pr_warning("Could not create debugfs "
 820                            "'set_event' entry\n");
 821
 822         d_events = event_trace_events_dir();
 823         if (!d_events)
 824                 return 0;
 825
 826         for_each_event(call) {
 827                 /* The linker may leave blanks */
 828                 if (!call->name)
 829                         continue;
 830                 event_create_dir(call, d_events);
 831         }
 832
 833         return 0;
 834 }
 835 fs_initcall(event_trace_init);