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                         system->nr_events++;
 856                         return system->entry;
 857                 }
 858         }
 859
 860         /* need to create new entry */
 861         system = kmalloc(sizeof(*system), GFP_KERNEL);
 862         if (!system) {
 863                 pr_warning("No memory to create event subsystem %s\n",
 864                            name);
 865                 return d_events;
 866         }
 867
 868         system->entry = debugfs_create_dir(name, d_events);
 869         if (!system->entry) {
 870                 pr_warning("Could not create event subsystem %s\n",
 871                            name);
 872                 kfree(system);
 873                 return d_events;
 874         }
 875
 876         system->nr_events = 1;
 877         system->name = kstrdup(name, GFP_KERNEL);
 878         if (!system->name) {
 879                 debugfs_remove(system->entry);
 880                 kfree(system);
 881                 return d_events;
 882         }
 883
 884         list_add(&system->list, &event_subsystems);
 885
 886         system->filter = NULL;
 887
 888         system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
 889         if (!system->filter) {
 890                 pr_warning("Could not allocate filter for subsystem "
 891                            "'%s'\n", name);
 892                 return system->entry;
 893         }
 894
 895         entry = debugfs_create_file("filter", 0644, system->entry, system,
 896                                     &ftrace_subsystem_filter_fops);
 897         if (!entry) {
 898                 kfree(system->filter);
 899                 system->filter = NULL;
 900                 pr_warning("Could not create debugfs "
 901                            "'%s/filter' entry\n", name);
 902         }
 903
 904         entry = trace_create_file("enable", 0644, system->entry,
 905                                   (void *)system->name,
 906                                   &ftrace_system_enable_fops);
 907
 908         return system->entry;
 909 }
 910
 911 static void remove_subsystem_dir(const char *name)
 912 {
 913         struct event_subsystem *system;
 914
 915         if (strcmp(name, TRACE_SYSTEM) == 0)
 916                 return;
 917
 918         list_for_each_entry(system, &event_subsystems, list) {
 919                 if (strcmp(system->name, name) == 0) {
 920                         if (!--system->nr_events) {
 921                                 struct event_filter *filter = system->filter;
 922
 923                                 debugfs_remove_recursive(system->entry);
 924                                 list_del(&system->list);
 925                                 if (filter) {
 926                                         kfree(filter->filter_string);
 927                                         kfree(filter);
 928                                 }
 929                                 kfree(system->name);
 930                                 kfree(system);
 931                         }
 932                         break;
 933                 }
 934         }
 935 }
 936
 937 static int
 938 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
 939                  const struct file_operations *id,
 940                  const struct file_operations *enable,
 941                  const struct file_operations *filter,
 942                  const struct file_operations *format)
 943 {
 944         struct dentry *entry;
 945         int ret;
 946
 947         /*
 948          * If the trace point header did not define TRACE_SYSTEM
 949          * then the system would be called "TRACE_SYSTEM".
 950          */
 951         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 952                 d_events = event_subsystem_dir(call->system, d_events);
 953
 954         if (call->raw_init) {
 955                 ret = call->raw_init();
 956                 if (ret < 0) {
 957                         pr_warning("Could not initialize trace point"
 958                                    " events/%s\n", call->name);
 959                         return ret;
 960                 }
 961         }
 962
 963         call->dir = debugfs_create_dir(call->name, d_events);
 964         if (!call->dir) {
 965                 pr_warning("Could not create debugfs "
 966                            "'%s' directory\n", call->name);
 967                 return -1;
 968         }
 969
 970         if (call->regfunc)
 971                 entry = trace_create_file("enable", 0644, call->dir, call,
 972                                           enable);
 973
 974         if (call->id)
 975                 entry = trace_create_file("id", 0444, call->dir, call,
 976                                           id);
 977
 978         if (call->define_fields) {
 979                 ret = call->define_fields();
 980                 if (ret < 0) {
 981                         pr_warning("Could not initialize trace point"
 982                                    " events/%s\n", call->name);
 983                         return ret;
 984                 }
 985                 entry = trace_create_file("filter", 0644, call->dir, call,
 986                                           filter);
 987         }
 988
 989         /* A trace may not want to export its format */
 990         if (!call->show_format)
 991                 return 0;
 992
 993         entry = trace_create_file("format", 0444, call->dir, call,
 994                                   format);
 995
 996         return 0;
 997 }
 998
 999 #define for_each_event(event, start, end)                       \
1000         for (event = start;                                     \
1001              (unsigned long)event < (unsigned long)end;         \
1002              event++)
1003
1004 #ifdef CONFIG_MODULES
1005
1006 static LIST_HEAD(ftrace_module_file_list);
1007
1008 /*
1009  * Modules must own their file_operations to keep up with
1010  * reference counting.
1011  */
1012 struct ftrace_module_file_ops {
1013         struct list_head                list;
1014         struct module                   *mod;
1015         struct file_operations          id;
1016         struct file_operations          enable;
1017         struct file_operations          format;
1018         struct file_operations          filter;
1019 };
1020
1021 static struct ftrace_module_file_ops *
1022 trace_create_file_ops(struct module *mod)
1023 {
1024         struct ftrace_module_file_ops *file_ops;
1025
1026         /*
1027          * This is a bit of a PITA. To allow for correct reference
1028          * counting, modules must "own" their file_operations.
1029          * To do this, we allocate the file operations that will be
1030          * used in the event directory.
1031          */
1032
1033         file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1034         if (!file_ops)
1035                 return NULL;
1036
1037         file_ops->mod = mod;
1038
1039         file_ops->id = ftrace_event_id_fops;
1040         file_ops->id.owner = mod;
1041
1042         file_ops->enable = ftrace_enable_fops;
1043         file_ops->enable.owner = mod;
1044
1045         file_ops->filter = ftrace_event_filter_fops;
1046         file_ops->filter.owner = mod;
1047
1048         file_ops->format = ftrace_event_format_fops;
1049         file_ops->format.owner = mod;
1050
1051         list_add(&file_ops->list, &ftrace_module_file_list);
1052
1053         return file_ops;
1054 }
1055
1056 static void trace_module_add_events(struct module *mod)
1057 {
1058         struct ftrace_module_file_ops *file_ops = NULL;
1059         struct ftrace_event_call *call, *start, *end;
1060         struct dentry *d_events;
1061
1062         start = mod->trace_events;
1063         end = mod->trace_events + mod->num_trace_events;
1064
1065         if (start == end)
1066                 return;
1067
1068         d_events = event_trace_events_dir();
1069         if (!d_events)
1070                 return;
1071
1072         for_each_event(call, start, end) {
1073                 /* The linker may leave blanks */
1074                 if (!call->name)
1075                         continue;
1076
1077                 /*
1078                  * This module has events, create file ops for this module
1079                  * if not already done.
1080                  */
1081                 if (!file_ops) {
1082                         file_ops = trace_create_file_ops(mod);
1083                         if (!file_ops)
1084                                 return;
1085                 }
1086                 call->mod = mod;
1087                 list_add(&call->list, &ftrace_events);
1088                 event_create_dir(call, d_events,
1089                                  &file_ops->id, &file_ops->enable,
1090                                  &file_ops->filter, &file_ops->format);
1091         }
1092 }
1093
1094 static void trace_module_remove_events(struct module *mod)
1095 {
1096         struct ftrace_module_file_ops *file_ops;
1097         struct ftrace_event_call *call, *p;
1098         bool found = false;
1099
1100         down_write(&trace_event_mutex);
1101         list_for_each_entry_safe(call, p, &ftrace_events, list) {
1102                 if (call->mod == mod) {
1103                         found = true;
1104                         ftrace_event_enable_disable(call, 0);
1105                         if (call->event)
1106                                 __unregister_ftrace_event(call->event);
1107                         debugfs_remove_recursive(call->dir);
1108                         list_del(&call->list);
1109                         trace_destroy_fields(call);
1110                         destroy_preds(call);
1111                         remove_subsystem_dir(call->system);
1112                 }
1113         }
1114
1115         /* Now free the file_operations */
1116         list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1117                 if (file_ops->mod == mod)
1118                         break;
1119         }
1120         if (&file_ops->list != &ftrace_module_file_list) {
1121                 list_del(&file_ops->list);
1122                 kfree(file_ops);
1123         }
1124
1125         /*
1126          * It is safest to reset the ring buffer if the module being unloaded
1127          * registered any events.
1128          */
1129         if (found)
1130                 tracing_reset_current_online_cpus();
1131         up_write(&trace_event_mutex);
1132 }
1133
1134 static int trace_module_notify(struct notifier_block *self,
1135                                unsigned long val, void *data)
1136 {
1137         struct module *mod = data;
1138
1139         mutex_lock(&event_mutex);
1140         switch (val) {
1141         case MODULE_STATE_COMING:
1142                 trace_module_add_events(mod);
1143                 break;
1144         case MODULE_STATE_GOING:
1145                 trace_module_remove_events(mod);
1146                 break;
1147         }
1148         mutex_unlock(&event_mutex);
1149
1150         return 0;
1151 }
1152 #else
1153 static int trace_module_notify(struct notifier_block *self,
1154                                unsigned long val, void *data)
1155 {
1156         return 0;
1157 }
1158 #endif /* CONFIG_MODULES */
1159
1160 struct notifier_block trace_module_nb = {
1161         .notifier_call = trace_module_notify,
1162         .priority = 0,
1163 };
1164
1165 extern struct ftrace_event_call __start_ftrace_events[];
1166 extern struct ftrace_event_call __stop_ftrace_events[];
1167
1168 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
1169
1170 static __init int setup_trace_event(char *str)
1171 {
1172         strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
1173         ring_buffer_expanded = 1;
1174         tracing_selftest_disabled = 1;
1175
1176         return 1;
1177 }
1178 __setup("trace_event=", setup_trace_event);
1179
1180 static __init int event_trace_init(void)
1181 {
1182         struct ftrace_event_call *call;
1183         struct dentry *d_tracer;
1184         struct dentry *entry;
1185         struct dentry *d_events;
1186         int ret;
1187         char *buf = bootup_event_buf;
1188         char *token;
1189
1190         d_tracer = tracing_init_dentry();
1191         if (!d_tracer)
1192                 return 0;
1193
1194         entry = debugfs_create_file("available_events", 0444, d_tracer,
1195                                     (void *)&show_event_seq_ops,
1196                                     &ftrace_avail_fops);
1197         if (!entry)
1198                 pr_warning("Could not create debugfs "
1199                            "'available_events' entry\n");
1200
1201         entry = debugfs_create_file("set_event", 0644, d_tracer,
1202                                     (void *)&show_set_event_seq_ops,
1203                                     &ftrace_set_event_fops);
1204         if (!entry)
1205                 pr_warning("Could not create debugfs "
1206                            "'set_event' entry\n");
1207
1208         d_events = event_trace_events_dir();
1209         if (!d_events)
1210                 return 0;
1211
1212         /* ring buffer internal formats */
1213         trace_create_file("header_page", 0444, d_events,
1214                           ring_buffer_print_page_header,
1215                           &ftrace_show_header_fops);
1216
1217         trace_create_file("header_event", 0444, d_events,
1218                           ring_buffer_print_entry_header,
1219                           &ftrace_show_header_fops);
1220
1221         trace_create_file("enable", 0644, d_events,
1222                           NULL, &ftrace_system_enable_fops);
1223
1224         for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
1225                 /* The linker may leave blanks */
1226                 if (!call->name)
1227                         continue;
1228                 list_add(&call->list, &ftrace_events);
1229                 event_create_dir(call, d_events, &ftrace_event_id_fops,
1230                                  &ftrace_enable_fops, &ftrace_event_filter_fops,
1231                                  &ftrace_event_format_fops);
1232         }
1233
1234         while (true) {
1235                 token = strsep(&buf, ",");
1236
1237                 if (!token)
1238                         break;
1239                 if (!*token)
1240                         continue;
1241
1242                 ret = ftrace_set_clr_event(token, 1);
1243                 if (ret)
1244                         pr_warning("Failed to enable trace event: %s\n", token);
1245         }
1246
1247         ret = register_module_notifier(&trace_module_nb);
1248         if (ret)
1249                 pr_warning("Failed to register trace events module notifier\n");
1250
1251         return 0;
1252 }
1253 fs_initcall(event_trace_init);
1254
1255 #ifdef CONFIG_FTRACE_STARTUP_TEST
1256
1257 static DEFINE_SPINLOCK(test_spinlock);
1258 static DEFINE_SPINLOCK(test_spinlock_irq);
1259 static DEFINE_MUTEX(test_mutex);
1260
1261 static __init void test_work(struct work_struct *dummy)
1262 {
1263         spin_lock(&test_spinlock);
1264         spin_lock_irq(&test_spinlock_irq);
1265         udelay(1);
1266         spin_unlock_irq(&test_spinlock_irq);
1267         spin_unlock(&test_spinlock);
1268
1269         mutex_lock(&test_mutex);
1270         msleep(1);
1271         mutex_unlock(&test_mutex);
1272 }
1273
1274 static __init int event_test_thread(void *unused)
1275 {
1276         void *test_malloc;
1277
1278         test_malloc = kmalloc(1234, GFP_KERNEL);
1279         if (!test_malloc)
1280                 pr_info("failed to kmalloc\n");
1281
1282         schedule_on_each_cpu(test_work);
1283
1284         kfree(test_malloc);
1285
1286         set_current_state(TASK_INTERRUPTIBLE);
1287         while (!kthread_should_stop())
1288                 schedule();
1289
1290         return 0;
1291 }
1292
1293 /*
1294  * Do various things that may trigger events.
1295  */
1296 static __init void event_test_stuff(void)
1297 {
1298         struct task_struct *test_thread;
1299
1300         test_thread = kthread_run(event_test_thread, NULL, "test-events");
1301         msleep(1);
1302         kthread_stop(test_thread);
1303 }
1304
1305 /*
1306  * For every trace event defined, we will test each trace point separately,
1307  * and then by groups, and finally all trace points.
1308  */
1309 static __init void event_trace_self_tests(void)
1310 {
1311         struct ftrace_event_call *call;
1312         struct event_subsystem *system;
1313         int ret;
1314
1315         pr_info("Running tests on trace events:\n");
1316
1317         list_for_each_entry(call, &ftrace_events, list) {
1318
1319                 /* Only test those that have a regfunc */
1320                 if (!call->regfunc)
1321                         continue;
1322
1323                 pr_info("Testing event %s: ", call->name);
1324
1325                 /*
1326                  * If an event is already enabled, someone is using
1327                  * it and the self test should not be on.
1328                  */
1329                 if (call->enabled) {
1330                         pr_warning("Enabled event during self test!\n");
1331                         WARN_ON_ONCE(1);
1332                         continue;
1333                 }
1334
1335                 ftrace_event_enable_disable(call, 1);
1336                 event_test_stuff();
1337                 ftrace_event_enable_disable(call, 0);
1338
1339                 pr_cont("OK\n");
1340         }
1341
1342         /* Now test at the sub system level */
1343
1344         pr_info("Running tests on trace event systems:\n");
1345
1346         list_for_each_entry(system, &event_subsystems, list) {
1347
1348                 /* the ftrace system is special, skip it */
1349                 if (strcmp(system->name, "ftrace") == 0)
1350                         continue;
1351
1352                 pr_info("Testing event system %s: ", system->name);
1353
1354                 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 1);
1355                 if (WARN_ON_ONCE(ret)) {
1356                         pr_warning("error enabling system %s\n",
1357                                    system->name);
1358                         continue;
1359                 }
1360
1361                 event_test_stuff();
1362
1363                 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 0);
1364                 if (WARN_ON_ONCE(ret))
1365                         pr_warning("error disabling system %s\n",
1366                                    system->name);
1367
1368                 pr_cont("OK\n");
1369         }
1370
1371         /* Test with all events enabled */
1372
1373         pr_info("Running tests on all trace events:\n");
1374         pr_info("Testing all events: ");
1375
1376         ret = __ftrace_set_clr_event(NULL, NULL, NULL, 1);
1377         if (WARN_ON_ONCE(ret)) {
1378                 pr_warning("error enabling all events\n");
1379                 return;
1380         }
1381
1382         event_test_stuff();
1383
1384         /* reset sysname */
1385         ret = __ftrace_set_clr_event(NULL, NULL, NULL, 0);
1386         if (WARN_ON_ONCE(ret)) {
1387                 pr_warning("error disabling all events\n");
1388                 return;
1389         }
1390
1391         pr_cont("OK\n");
1392 }
1393
1394 #ifdef CONFIG_FUNCTION_TRACER
1395
1396 static DEFINE_PER_CPU(atomic_t, test_event_disable);
1397
1398 static void
1399 function_test_events_call(unsigned long ip, unsigned long parent_ip)
1400 {
1401         struct ring_buffer_event *event;
1402         struct ftrace_entry *entry;
1403         unsigned long flags;
1404         long disabled;
1405         int resched;
1406         int cpu;
1407         int pc;
1408
1409         pc = preempt_count();
1410         resched = ftrace_preempt_disable();
1411         cpu = raw_smp_processor_id();
1412         disabled = atomic_inc_return(&per_cpu(test_event_disable, cpu));
1413
1414         if (disabled != 1)
1415                 goto out;
1416
1417         local_save_flags(flags);
1418
1419         event = trace_current_buffer_lock_reserve(TRACE_FN, sizeof(*entry),
1420                                                   flags, pc);
1421         if (!event)
1422                 goto out;
1423         entry   = ring_buffer_event_data(event);
1424         entry->ip                       = ip;
1425         entry->parent_ip                = parent_ip;
1426
1427         trace_nowake_buffer_unlock_commit(event, flags, pc);
1428
1429  out:
1430         atomic_dec(&per_cpu(test_event_disable, cpu));
1431         ftrace_preempt_enable(resched);
1432 }
1433
1434 static struct ftrace_ops trace_ops __initdata  =
1435 {
1436         .func = function_test_events_call,
1437 };
1438
1439 static __init void event_trace_self_test_with_function(void)
1440 {
1441         register_ftrace_function(&trace_ops);
1442         pr_info("Running tests again, along with the function tracer\n");
1443         event_trace_self_tests();
1444         unregister_ftrace_function(&trace_ops);
1445 }
1446 #else
1447 static __init void event_trace_self_test_with_function(void)
1448 {
1449 }
1450 #endif
1451
1452 static __init int event_trace_self_tests_init(void)
1453 {
1454         if (!tracing_selftest_disabled) {
1455                 event_trace_self_tests();
1456                 event_trace_self_test_with_function();
1457         }
1458
1459         return 0;
1460 }
1461
1462 late_initcall(event_trace_self_tests_init);
1463
1464 #endif