git.oblomov.eu Git - linux-2.6/blob - kernel/trace/trace_events.c

   1 /*
   2  * event tracer
   3  *
   4  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   5  *
   6  *  - Added format output of fields of the trace point.
   7  *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
   8  *
   9  */
  10
  11 #include <linux/debugfs.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/module.h>
  14 #include <linux/ctype.h>
  15
  16 #include "trace_output.h"
  17
  18 #define TRACE_SYSTEM "TRACE_SYSTEM"
  19
  20 static DEFINE_MUTEX(event_mutex);
  21
  22 #define events_for_each(event)                                          \
  23         for (event = __start_ftrace_events;                             \
  24              (unsigned long)event < (unsigned long)__stop_ftrace_events; \
  25              event++)
  26
  27 void event_trace_printk(unsigned long ip, const char *fmt, ...)
  28 {
  29         va_list ap;
  30
  31         va_start(ap, fmt);
  32         tracing_record_cmdline(current);
  33         trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
  34         va_end(ap);
  35 }
  36
  37 static void ftrace_clear_events(void)
  38 {
  39         struct ftrace_event_call *call = (void *)__start_ftrace_events;
  40
  41
  42         while ((unsigned long)call < (unsigned long)__stop_ftrace_events) {
  43
  44                 if (call->enabled) {
  45                         call->enabled = 0;
  46                         call->unregfunc();
  47                 }
  48                 call++;
  49         }
  50 }
  51
  52 static void ftrace_event_enable_disable(struct ftrace_event_call *call,
  53                                         int enable)
  54 {
  55
  56         switch (enable) {
  57         case 0:
  58                 if (call->enabled) {
  59                         call->enabled = 0;
  60                         call->unregfunc();
  61                 }
  62                 break;
  63         case 1:
  64                 if (!call->enabled) {
  65                         call->enabled = 1;
  66                         call->regfunc();
  67                 }
  68                 break;
  69         }
  70 }
  71
  72 static int ftrace_set_clr_event(char *buf, int set)
  73 {
  74         struct ftrace_event_call *call = __start_ftrace_events;
  75         char *event = NULL, *sub = NULL, *match;
  76         int ret = -EINVAL;
  77
  78         /*
  79          * The buf format can be <subsystem>:<event-name>
  80          *  *:<event-name> means any event by that name.
  81          *  :<event-name> is the same.
  82          *
  83          *  <subsystem>:* means all events in that subsystem
  84          *  <subsystem>: means the same.
  85          *
  86          *  <name> (no ':') means all events in a subsystem with
  87          *  the name <name> or any event that matches <name>
  88          */
  89
  90         match = strsep(&buf, ":");
  91         if (buf) {
  92                 sub = match;
  93                 event = buf;
  94                 match = NULL;
  95
  96                 if (!strlen(sub) || strcmp(sub, "*") == 0)
  97                         sub = NULL;
  98                 if (!strlen(event) || strcmp(event, "*") == 0)
  99                         event = NULL;
 100         }
 101
 102         mutex_lock(&event_mutex);
 103         events_for_each(call) {
 104
 105                 if (!call->name || !call->regfunc)
 106                         continue;
 107
 108                 if (match &&
 109                     strcmp(match, call->name) != 0 &&
 110                     strcmp(match, call->system) != 0)
 111                         continue;
 112
 113                 if (sub && strcmp(sub, call->system) != 0)
 114                         continue;
 115
 116                 if (event && strcmp(event, call->name) != 0)
 117                         continue;
 118
 119                 ftrace_event_enable_disable(call, set);
 120
 121                 ret = 0;
 122         }
 123         mutex_unlock(&event_mutex);
 124
 125         return ret;
 126 }
 127
 128 /* 128 should be much more than enough */
 129 #define EVENT_BUF_SIZE          127
 130
 131 static ssize_t
 132 ftrace_event_write(struct file *file, const char __user *ubuf,
 133                    size_t cnt, loff_t *ppos)
 134 {
 135         size_t read = 0;
 136         int i, set = 1;
 137         ssize_t ret;
 138         char *buf;
 139         char ch;
 140
 141         if (!cnt || cnt < 0)
 142                 return 0;
 143
 144         ret = get_user(ch, ubuf++);
 145         if (ret)
 146                 return ret;
 147         read++;
 148         cnt--;
 149
 150         /* skip white space */
 151         while (cnt && isspace(ch)) {
 152                 ret = get_user(ch, ubuf++);
 153                 if (ret)
 154                         return ret;
 155                 read++;
 156                 cnt--;
 157         }
 158
 159         /* Only white space found? */
 160         if (isspace(ch)) {
 161                 file->f_pos += read;
 162                 ret = read;
 163                 return ret;
 164         }
 165
 166         buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
 167         if (!buf)
 168                 return -ENOMEM;
 169
 170         if (cnt > EVENT_BUF_SIZE)
 171                 cnt = EVENT_BUF_SIZE;
 172
 173         i = 0;
 174         while (cnt && !isspace(ch)) {
 175                 if (!i && ch == '!')
 176                         set = 0;
 177                 else
 178                         buf[i++] = ch;
 179
 180                 ret = get_user(ch, ubuf++);
 181                 if (ret)
 182                         goto out_free;
 183                 read++;
 184                 cnt--;
 185         }
 186         buf[i] = 0;
 187
 188         file->f_pos += read;
 189
 190         ret = ftrace_set_clr_event(buf, set);
 191         if (ret)
 192                 goto out_free;
 193
 194         ret = read;
 195
 196  out_free:
 197         kfree(buf);
 198
 199         return ret;
 200 }
 201
 202 static void *
 203 t_next(struct seq_file *m, void *v, loff_t *pos)
 204 {
 205         struct ftrace_event_call *call = m->private;
 206         struct ftrace_event_call *next = call;
 207
 208         (*pos)++;
 209
 210         for (;;) {
 211                 if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
 212                         return NULL;
 213
 214                 /*
 215                  * The ftrace subsystem is for showing formats only.
 216                  * They can not be enabled or disabled via the event files.
 217                  */
 218                 if (call->regfunc)
 219                         break;
 220
 221                 call++;
 222                 next = call;
 223         }
 224
 225         m->private = ++next;
 226
 227         return call;
 228 }
 229
 230 static void *t_start(struct seq_file *m, loff_t *pos)
 231 {
 232         return t_next(m, NULL, pos);
 233 }
 234
 235 static void *
 236 s_next(struct seq_file *m, void *v, loff_t *pos)
 237 {
 238         struct ftrace_event_call *call = m->private;
 239         struct ftrace_event_call *next;
 240
 241         (*pos)++;
 242
 243  retry:
 244         if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
 245                 return NULL;
 246
 247         if (!call->enabled) {
 248                 call++;
 249                 goto retry;
 250         }
 251
 252         next = call;
 253         m->private = ++next;
 254
 255         return call;
 256 }
 257
 258 static void *s_start(struct seq_file *m, loff_t *pos)
 259 {
 260         return s_next(m, NULL, pos);
 261 }
 262
 263 static int t_show(struct seq_file *m, void *v)
 264 {
 265         struct ftrace_event_call *call = v;
 266
 267         if (strcmp(call->system, TRACE_SYSTEM) != 0)
 268                 seq_printf(m, "%s:", call->system);
 269         seq_printf(m, "%s\n", call->name);
 270
 271         return 0;
 272 }
 273
 274 static void t_stop(struct seq_file *m, void *p)
 275 {
 276 }
 277
 278 static int
 279 ftrace_event_seq_open(struct inode *inode, struct file *file)
 280 {
 281         int ret;
 282         const struct seq_operations *seq_ops;
 283
 284         if ((file->f_mode & FMODE_WRITE) &&
 285             !(file->f_flags & O_APPEND))
 286                 ftrace_clear_events();
 287
 288         seq_ops = inode->i_private;
 289         ret = seq_open(file, seq_ops);
 290         if (!ret) {
 291                 struct seq_file *m = file->private_data;
 292
 293                 m->private = __start_ftrace_events;
 294         }
 295         return ret;
 296 }
 297
 298 static ssize_t
 299 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 300                   loff_t *ppos)
 301 {
 302         struct ftrace_event_call *call = filp->private_data;
 303         char *buf;
 304
 305         if (call->enabled)
 306                 buf = "1\n";
 307         else
 308                 buf = "0\n";
 309
 310         return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
 311 }
 312
 313 static ssize_t
 314 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 315                    loff_t *ppos)
 316 {
 317         struct ftrace_event_call *call = filp->private_data;
 318         char buf[64];
 319         unsigned long val;
 320         int ret;
 321
 322         if (cnt >= sizeof(buf))
 323                 return -EINVAL;
 324
 325         if (copy_from_user(&buf, ubuf, cnt))
 326                 return -EFAULT;
 327
 328         buf[cnt] = 0;
 329
 330         ret = strict_strtoul(buf, 10, &val);
 331         if (ret < 0)
 332                 return ret;
 333
 334         switch (val) {
 335         case 0:
 336         case 1:
 337                 mutex_lock(&event_mutex);
 338                 ftrace_event_enable_disable(call, val);
 339                 mutex_unlock(&event_mutex);
 340                 break;
 341
 342         default:
 343                 return -EINVAL;
 344         }
 345
 346         *ppos += cnt;
 347
 348         return cnt;
 349 }
 350
 351 #undef FIELD
 352 #define FIELD(type, name)                                               \
 353         #type, #name, offsetof(typeof(field), name), sizeof(field.name)
 354
 355 static int trace_write_header(struct trace_seq *s)
 356 {
 357         struct trace_entry field;
 358
 359         /* struct trace_entry */
 360         return trace_seq_printf(s,
 361                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 362                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 363                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 364                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 365                                 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
 366                                 "\n",
 367                                 FIELD(unsigned char, type),
 368                                 FIELD(unsigned char, flags),
 369                                 FIELD(unsigned char, preempt_count),
 370                                 FIELD(int, pid),
 371                                 FIELD(int, tgid));
 372 }
 373
 374 static ssize_t
 375 event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
 376                   loff_t *ppos)
 377 {
 378         struct ftrace_event_call *call = filp->private_data;
 379         struct trace_seq *s;
 380         char *buf;
 381         int r;
 382
 383         s = kmalloc(sizeof(*s), GFP_KERNEL);
 384         if (!s)
 385                 return -ENOMEM;
 386
 387         trace_seq_init(s);
 388
 389         if (*ppos)
 390                 return 0;
 391
 392         /* If any of the first writes fail, so will the show_format. */
 393
 394         trace_seq_printf(s, "name: %s\n", call->name);
 395         trace_seq_printf(s, "ID: %d\n", call->id);
 396         trace_seq_printf(s, "format:\n");
 397         trace_write_header(s);
 398
 399         r = call->show_format(s);
 400         if (!r) {
 401                 /*
 402                  * ug!  The format output is bigger than a PAGE!!
 403                  */
 404                 buf = "FORMAT TOO BIG\n";
 405                 r = simple_read_from_buffer(ubuf, cnt, ppos,
 406                                               buf, strlen(buf));
 407                 goto out;
 408         }
 409
 410         r = simple_read_from_buffer(ubuf, cnt, ppos,
 411                                     s->buffer, s->len);
 412  out:
 413         kfree(s);
 414         return r;
 415 }
 416
 417 static const struct seq_operations show_event_seq_ops = {
 418         .start = t_start,
 419         .next = t_next,
 420         .show = t_show,
 421         .stop = t_stop,
 422 };
 423
 424 static const struct seq_operations show_set_event_seq_ops = {
 425         .start = s_start,
 426         .next = s_next,
 427         .show = t_show,
 428         .stop = t_stop,
 429 };
 430
 431 static const struct file_operations ftrace_avail_fops = {
 432         .open = ftrace_event_seq_open,
 433         .read = seq_read,
 434         .llseek = seq_lseek,
 435         .release = seq_release,
 436 };
 437
 438 static const struct file_operations ftrace_set_event_fops = {
 439         .open = ftrace_event_seq_open,
 440         .read = seq_read,
 441         .write = ftrace_event_write,
 442         .llseek = seq_lseek,
 443         .release = seq_release,
 444 };
 445
 446 static const struct file_operations ftrace_enable_fops = {
 447         .open = tracing_open_generic,
 448         .read = event_enable_read,
 449         .write = event_enable_write,
 450 };
 451
 452 static const struct file_operations ftrace_event_format_fops = {
 453         .open = tracing_open_generic,
 454         .read = event_format_read,
 455 };
 456
 457 static struct dentry *event_trace_events_dir(void)
 458 {
 459         static struct dentry *d_tracer;
 460         static struct dentry *d_events;
 461
 462         if (d_events)
 463                 return d_events;
 464
 465         d_tracer = tracing_init_dentry();
 466         if (!d_tracer)
 467                 return NULL;
 468
 469         d_events = debugfs_create_dir("events", d_tracer);
 470         if (!d_events)
 471                 pr_warning("Could not create debugfs "
 472                            "'events' directory\n");
 473
 474         return d_events;
 475 }
 476
 477 struct event_subsystem {
 478         struct list_head        list;
 479         const char              *name;
 480         struct dentry           *entry;
 481 };
 482
 483 static LIST_HEAD(event_subsystems);
 484
 485 static struct dentry *
 486 event_subsystem_dir(const char *name, struct dentry *d_events)
 487 {
 488         struct event_subsystem *system;
 489
 490         /* First see if we did not already create this dir */
 491         list_for_each_entry(system, &event_subsystems, list) {
 492                 if (strcmp(system->name, name) == 0)
 493                         return system->entry;
 494         }
 495
 496         /* need to create new entry */
 497         system = kmalloc(sizeof(*system), GFP_KERNEL);
 498         if (!system) {
 499                 pr_warning("No memory to create event subsystem %s\n",
 500                            name);
 501                 return d_events;
 502         }
 503
 504         system->entry = debugfs_create_dir(name, d_events);
 505         if (!system->entry) {
 506                 pr_warning("Could not create event subsystem %s\n",
 507                            name);
 508                 kfree(system);
 509                 return d_events;
 510         }
 511
 512         system->name = name;
 513         list_add(&system->list, &event_subsystems);
 514
 515         return system->entry;
 516 }
 517
 518 static int
 519 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
 520 {
 521         struct dentry *entry;
 522         int ret;
 523
 524         /*
 525          * If the trace point header did not define TRACE_SYSTEM
 526          * then the system would be called "TRACE_SYSTEM".
 527          */
 528         if (strcmp(call->system, "TRACE_SYSTEM") != 0)
 529                 d_events = event_subsystem_dir(call->system, d_events);
 530
 531         if (call->raw_init) {
 532                 ret = call->raw_init();
 533                 if (ret < 0) {
 534                         pr_warning("Could not initialize trace point"
 535                                    " events/%s\n", call->name);
 536                         return ret;
 537                 }
 538         }
 539
 540         call->dir = debugfs_create_dir(call->name, d_events);
 541         if (!call->dir) {
 542                 pr_warning("Could not create debugfs "
 543                            "'%s' directory\n", call->name);
 544                 return -1;
 545         }
 546
 547         if (call->regfunc) {
 548                 entry = debugfs_create_file("enable", 0644, call->dir, call,
 549                                             &ftrace_enable_fops);
 550                 if (!entry)
 551                         pr_warning("Could not create debugfs "
 552                                    "'%s/enable' entry\n", call->name);
 553         }
 554
 555         /* A trace may not want to export its format */
 556         if (!call->show_format)
 557                 return 0;
 558
 559         entry = debugfs_create_file("format", 0444, call->dir, call,
 560                                     &ftrace_event_format_fops);
 561         if (!entry)
 562                 pr_warning("Could not create debugfs "
 563                            "'%s/format' entry\n", call->name);
 564
 565         return 0;
 566 }
 567
 568 static __init int event_trace_init(void)
 569 {
 570         struct ftrace_event_call *call = __start_ftrace_events;
 571         struct dentry *d_tracer;
 572         struct dentry *entry;
 573         struct dentry *d_events;
 574
 575         d_tracer = tracing_init_dentry();
 576         if (!d_tracer)
 577                 return 0;
 578
 579         entry = debugfs_create_file("available_events", 0444, d_tracer,
 580                                     (void *)&show_event_seq_ops,
 581                                     &ftrace_avail_fops);
 582         if (!entry)
 583                 pr_warning("Could not create debugfs "
 584                            "'available_events' entry\n");
 585
 586         entry = debugfs_create_file("set_event", 0644, d_tracer,
 587                                     (void *)&show_set_event_seq_ops,
 588                                     &ftrace_set_event_fops);
 589         if (!entry)
 590                 pr_warning("Could not create debugfs "
 591                            "'set_event' entry\n");
 592
 593         d_events = event_trace_events_dir();
 594         if (!d_events)
 595                 return 0;
 596
 597         events_for_each(call) {
 598                 /* The linker may leave blanks */
 599                 if (!call->name)
 600                         continue;
 601                 event_create_dir(call, d_events);
 602         }
 603
 604         return 0;
 605 }
 606 fs_initcall(event_trace_init);