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