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