4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
6 * - Added format output of fields of the trace point.
7 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
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>
21 #include <asm/setup.h>
23 #include "trace_output.h"
26 #define TRACE_SYSTEM "TRACE_SYSTEM"
28 DEFINE_MUTEX(event_mutex
);
30 DEFINE_MUTEX(event_storage_mutex
);
31 EXPORT_SYMBOL_GPL(event_storage_mutex
);
33 char event_storage
[EVENT_STORAGE_SIZE
];
34 EXPORT_SYMBOL_GPL(event_storage
);
36 LIST_HEAD(ftrace_events
);
37 LIST_HEAD(ftrace_common_fields
);
40 trace_get_fields(struct ftrace_event_call
*event_call
)
42 if (!event_call
->class->get_fields
)
43 return &event_call
->class->fields
;
44 return event_call
->class->get_fields(event_call
);
47 static int __trace_define_field(struct list_head
*head
, const char *type
,
48 const char *name
, int offset
, int size
,
49 int is_signed
, int filter_type
)
51 struct ftrace_event_field
*field
;
53 field
= kzalloc(sizeof(*field
), GFP_KERNEL
);
57 field
->name
= kstrdup(name
, GFP_KERNEL
);
61 field
->type
= kstrdup(type
, GFP_KERNEL
);
65 if (filter_type
== FILTER_OTHER
)
66 field
->filter_type
= filter_assign_type(type
);
68 field
->filter_type
= filter_type
;
70 field
->offset
= offset
;
72 field
->is_signed
= is_signed
;
74 list_add(&field
->link
, head
);
86 int trace_define_field(struct ftrace_event_call
*call
, const char *type
,
87 const char *name
, int offset
, int size
, int is_signed
,
90 struct list_head
*head
;
92 if (WARN_ON(!call
->class))
95 head
= trace_get_fields(call
);
96 return __trace_define_field(head
, type
, name
, offset
, size
,
97 is_signed
, filter_type
);
99 EXPORT_SYMBOL_GPL(trace_define_field
);
101 #define __common_field(type, item) \
102 ret = __trace_define_field(&ftrace_common_fields, #type, \
104 offsetof(typeof(ent), item), \
106 is_signed_type(type), FILTER_OTHER); \
110 static int trace_define_common_fields(void)
113 struct trace_entry ent
;
115 __common_field(unsigned short, type
);
116 __common_field(unsigned char, flags
);
117 __common_field(unsigned char, preempt_count
);
118 __common_field(int, pid
);
119 __common_field(int, lock_depth
);
124 void trace_destroy_fields(struct ftrace_event_call
*call
)
126 struct ftrace_event_field
*field
, *next
;
127 struct list_head
*head
;
129 head
= trace_get_fields(call
);
130 list_for_each_entry_safe(field
, next
, head
, link
) {
131 list_del(&field
->link
);
138 int trace_event_raw_init(struct ftrace_event_call
*call
)
142 id
= register_ftrace_event(&call
->event
);
148 EXPORT_SYMBOL_GPL(trace_event_raw_init
);
150 int ftrace_event_reg(struct ftrace_event_call
*call
, enum trace_reg type
)
153 case TRACE_REG_REGISTER
:
154 return tracepoint_probe_register(call
->name
,
157 case TRACE_REG_UNREGISTER
:
158 tracepoint_probe_unregister(call
->name
,
163 #ifdef CONFIG_PERF_EVENTS
164 case TRACE_REG_PERF_REGISTER
:
165 return tracepoint_probe_register(call
->name
,
166 call
->class->perf_probe
,
168 case TRACE_REG_PERF_UNREGISTER
:
169 tracepoint_probe_unregister(call
->name
,
170 call
->class->perf_probe
,
177 EXPORT_SYMBOL_GPL(ftrace_event_reg
);
179 void trace_event_enable_cmd_record(bool enable
)
181 struct ftrace_event_call
*call
;
183 mutex_lock(&event_mutex
);
184 list_for_each_entry(call
, &ftrace_events
, list
) {
185 if (!(call
->flags
& TRACE_EVENT_FL_ENABLED
))
189 tracing_start_cmdline_record();
190 call
->flags
|= TRACE_EVENT_FL_RECORDED_CMD
;
192 tracing_stop_cmdline_record();
193 call
->flags
&= ~TRACE_EVENT_FL_RECORDED_CMD
;
196 mutex_unlock(&event_mutex
);
199 static int ftrace_event_enable_disable(struct ftrace_event_call
*call
,
206 if (call
->flags
& TRACE_EVENT_FL_ENABLED
) {
207 call
->flags
&= ~TRACE_EVENT_FL_ENABLED
;
208 if (call
->flags
& TRACE_EVENT_FL_RECORDED_CMD
) {
209 tracing_stop_cmdline_record();
210 call
->flags
&= ~TRACE_EVENT_FL_RECORDED_CMD
;
212 call
->class->reg(call
, TRACE_REG_UNREGISTER
);
216 if (!(call
->flags
& TRACE_EVENT_FL_ENABLED
)) {
217 if (trace_flags
& TRACE_ITER_RECORD_CMD
) {
218 tracing_start_cmdline_record();
219 call
->flags
|= TRACE_EVENT_FL_RECORDED_CMD
;
221 ret
= call
->class->reg(call
, TRACE_REG_REGISTER
);
223 tracing_stop_cmdline_record();
224 pr_info("event trace: Could not enable event "
228 call
->flags
|= TRACE_EVENT_FL_ENABLED
;
236 static void ftrace_clear_events(void)
238 struct ftrace_event_call
*call
;
240 mutex_lock(&event_mutex
);
241 list_for_each_entry(call
, &ftrace_events
, list
) {
242 ftrace_event_enable_disable(call
, 0);
244 mutex_unlock(&event_mutex
);
248 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
250 static int __ftrace_set_clr_event(const char *match
, const char *sub
,
251 const char *event
, int set
)
253 struct ftrace_event_call
*call
;
256 mutex_lock(&event_mutex
);
257 list_for_each_entry(call
, &ftrace_events
, list
) {
259 if (!call
->name
|| !call
->class || !call
->class->reg
)
263 strcmp(match
, call
->name
) != 0 &&
264 strcmp(match
, call
->class->system
) != 0)
267 if (sub
&& strcmp(sub
, call
->class->system
) != 0)
270 if (event
&& strcmp(event
, call
->name
) != 0)
273 ftrace_event_enable_disable(call
, set
);
277 mutex_unlock(&event_mutex
);
282 static int ftrace_set_clr_event(char *buf
, int set
)
284 char *event
= NULL
, *sub
= NULL
, *match
;
287 * The buf format can be <subsystem>:<event-name>
288 * *:<event-name> means any event by that name.
289 * :<event-name> is the same.
291 * <subsystem>:* means all events in that subsystem
292 * <subsystem>: means the same.
294 * <name> (no ':') means all events in a subsystem with
295 * the name <name> or any event that matches <name>
298 match
= strsep(&buf
, ":");
304 if (!strlen(sub
) || strcmp(sub
, "*") == 0)
306 if (!strlen(event
) || strcmp(event
, "*") == 0)
310 return __ftrace_set_clr_event(match
, sub
, event
, set
);
314 * trace_set_clr_event - enable or disable an event
315 * @system: system name to match (NULL for any system)
316 * @event: event name to match (NULL for all events, within system)
317 * @set: 1 to enable, 0 to disable
319 * This is a way for other parts of the kernel to enable or disable
322 * Returns 0 on success, -EINVAL if the parameters do not match any
325 int trace_set_clr_event(const char *system
, const char *event
, int set
)
327 return __ftrace_set_clr_event(NULL
, system
, event
, set
);
330 /* 128 should be much more than enough */
331 #define EVENT_BUF_SIZE 127
334 ftrace_event_write(struct file
*file
, const char __user
*ubuf
,
335 size_t cnt
, loff_t
*ppos
)
337 struct trace_parser parser
;
343 ret
= tracing_update_buffers();
347 if (trace_parser_get_init(&parser
, EVENT_BUF_SIZE
+ 1))
350 read
= trace_get_user(&parser
, ubuf
, cnt
, ppos
);
352 if (read
>= 0 && trace_parser_loaded((&parser
))) {
355 if (*parser
.buffer
== '!')
358 parser
.buffer
[parser
.idx
] = 0;
360 ret
= ftrace_set_clr_event(parser
.buffer
+ !set
, set
);
368 trace_parser_put(&parser
);
374 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
376 struct ftrace_event_call
*call
= v
;
380 list_for_each_entry_continue(call
, &ftrace_events
, list
) {
382 * The ftrace subsystem is for showing formats only.
383 * They can not be enabled or disabled via the event files.
385 if (call
->class && call
->class->reg
)
392 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
394 struct ftrace_event_call
*call
;
397 mutex_lock(&event_mutex
);
399 call
= list_entry(&ftrace_events
, struct ftrace_event_call
, list
);
400 for (l
= 0; l
<= *pos
; ) {
401 call
= t_next(m
, call
, &l
);
409 s_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
411 struct ftrace_event_call
*call
= v
;
415 list_for_each_entry_continue(call
, &ftrace_events
, list
) {
416 if (call
->flags
& TRACE_EVENT_FL_ENABLED
)
423 static void *s_start(struct seq_file
*m
, loff_t
*pos
)
425 struct ftrace_event_call
*call
;
428 mutex_lock(&event_mutex
);
430 call
= list_entry(&ftrace_events
, struct ftrace_event_call
, list
);
431 for (l
= 0; l
<= *pos
; ) {
432 call
= s_next(m
, call
, &l
);
439 static int t_show(struct seq_file
*m
, void *v
)
441 struct ftrace_event_call
*call
= v
;
443 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0)
444 seq_printf(m
, "%s:", call
->class->system
);
445 seq_printf(m
, "%s\n", call
->name
);
450 static void t_stop(struct seq_file
*m
, void *p
)
452 mutex_unlock(&event_mutex
);
456 ftrace_event_seq_open(struct inode
*inode
, struct file
*file
)
458 const struct seq_operations
*seq_ops
;
460 if ((file
->f_mode
& FMODE_WRITE
) &&
461 (file
->f_flags
& O_TRUNC
))
462 ftrace_clear_events();
464 seq_ops
= inode
->i_private
;
465 return seq_open(file
, seq_ops
);
469 event_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
472 struct ftrace_event_call
*call
= filp
->private_data
;
475 if (call
->flags
& TRACE_EVENT_FL_ENABLED
)
480 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, 2);
484 event_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
487 struct ftrace_event_call
*call
= filp
->private_data
;
492 if (cnt
>= sizeof(buf
))
495 if (copy_from_user(&buf
, ubuf
, cnt
))
500 ret
= strict_strtoul(buf
, 10, &val
);
504 ret
= tracing_update_buffers();
511 mutex_lock(&event_mutex
);
512 ret
= ftrace_event_enable_disable(call
, val
);
513 mutex_unlock(&event_mutex
);
522 return ret
? ret
: cnt
;
526 system_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
529 const char set_to_char
[4] = { '?', '0', '1', 'X' };
530 const char *system
= filp
->private_data
;
531 struct ftrace_event_call
*call
;
536 mutex_lock(&event_mutex
);
537 list_for_each_entry(call
, &ftrace_events
, list
) {
538 if (!call
->name
|| !call
->class || !call
->class->reg
)
541 if (system
&& strcmp(call
->class->system
, system
) != 0)
545 * We need to find out if all the events are set
546 * or if all events or cleared, or if we have
549 set
|= (1 << !!(call
->flags
& TRACE_EVENT_FL_ENABLED
));
552 * If we have a mixture, no need to look further.
557 mutex_unlock(&event_mutex
);
559 buf
[0] = set_to_char
[set
];
562 ret
= simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, 2);
568 system_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
571 const char *system
= filp
->private_data
;
576 if (cnt
>= sizeof(buf
))
579 if (copy_from_user(&buf
, ubuf
, cnt
))
584 ret
= strict_strtoul(buf
, 10, &val
);
588 ret
= tracing_update_buffers();
592 if (val
!= 0 && val
!= 1)
595 ret
= __ftrace_set_clr_event(NULL
, system
, NULL
, val
);
609 FORMAT_FIELD_SEPERATOR
= 2,
613 static void *f_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
615 struct ftrace_event_call
*call
= m
->private;
616 struct ftrace_event_field
*field
;
617 struct list_head
*common_head
= &ftrace_common_fields
;
618 struct list_head
*head
= trace_get_fields(call
);
622 switch ((unsigned long)v
) {
624 if (unlikely(list_empty(common_head
)))
627 field
= list_entry(common_head
->prev
,
628 struct ftrace_event_field
, link
);
631 case FORMAT_FIELD_SEPERATOR
:
632 if (unlikely(list_empty(head
)))
635 field
= list_entry(head
->prev
, struct ftrace_event_field
, link
);
638 case FORMAT_PRINTFMT
:
644 if (field
->link
.prev
== common_head
)
645 return (void *)FORMAT_FIELD_SEPERATOR
;
646 else if (field
->link
.prev
== head
)
647 return (void *)FORMAT_PRINTFMT
;
649 field
= list_entry(field
->link
.prev
, struct ftrace_event_field
, link
);
654 static void *f_start(struct seq_file
*m
, loff_t
*pos
)
659 /* Start by showing the header */
661 return (void *)FORMAT_HEADER
;
663 p
= (void *)FORMAT_HEADER
;
665 p
= f_next(m
, p
, &l
);
666 } while (p
&& l
< *pos
);
671 static int f_show(struct seq_file
*m
, void *v
)
673 struct ftrace_event_call
*call
= m
->private;
674 struct ftrace_event_field
*field
;
675 const char *array_descriptor
;
677 switch ((unsigned long)v
) {
679 seq_printf(m
, "name: %s\n", call
->name
);
680 seq_printf(m
, "ID: %d\n", call
->event
.type
);
681 seq_printf(m
, "format:\n");
684 case FORMAT_FIELD_SEPERATOR
:
688 case FORMAT_PRINTFMT
:
689 seq_printf(m
, "\nprint fmt: %s\n",
697 * Smartly shows the array type(except dynamic array).
700 * If TYPE := TYPE[LEN], it is shown:
701 * field:TYPE VAR[LEN]
703 array_descriptor
= strchr(field
->type
, '[');
705 if (!strncmp(field
->type
, "__data_loc", 10))
706 array_descriptor
= NULL
;
708 if (!array_descriptor
)
709 seq_printf(m
, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
710 field
->type
, field
->name
, field
->offset
,
711 field
->size
, !!field
->is_signed
);
713 seq_printf(m
, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
714 (int)(array_descriptor
- field
->type
),
715 field
->type
, field
->name
,
716 array_descriptor
, field
->offset
,
717 field
->size
, !!field
->is_signed
);
722 static void f_stop(struct seq_file
*m
, void *p
)
726 static const struct seq_operations trace_format_seq_ops
= {
733 static int trace_format_open(struct inode
*inode
, struct file
*file
)
735 struct ftrace_event_call
*call
= inode
->i_private
;
739 ret
= seq_open(file
, &trace_format_seq_ops
);
743 m
= file
->private_data
;
750 event_id_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
752 struct ftrace_event_call
*call
= filp
->private_data
;
759 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
764 trace_seq_printf(s
, "%d\n", call
->event
.type
);
766 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
773 event_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
776 struct ftrace_event_call
*call
= filp
->private_data
;
783 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
789 print_event_filter(call
, s
);
790 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
798 event_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
801 struct ftrace_event_call
*call
= filp
->private_data
;
805 if (cnt
>= PAGE_SIZE
)
808 buf
= (char *)__get_free_page(GFP_TEMPORARY
);
812 if (copy_from_user(buf
, ubuf
, cnt
)) {
813 free_page((unsigned long) buf
);
818 err
= apply_event_filter(call
, buf
);
819 free_page((unsigned long) buf
);
829 subsystem_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
832 struct event_subsystem
*system
= filp
->private_data
;
839 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
845 print_subsystem_event_filter(system
, s
);
846 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
854 subsystem_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
857 struct event_subsystem
*system
= filp
->private_data
;
861 if (cnt
>= PAGE_SIZE
)
864 buf
= (char *)__get_free_page(GFP_TEMPORARY
);
868 if (copy_from_user(buf
, ubuf
, cnt
)) {
869 free_page((unsigned long) buf
);
874 err
= apply_subsystem_event_filter(system
, buf
);
875 free_page((unsigned long) buf
);
885 show_header(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
887 int (*func
)(struct trace_seq
*s
) = filp
->private_data
;
894 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
901 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
908 static const struct seq_operations show_event_seq_ops
= {
915 static const struct seq_operations show_set_event_seq_ops
= {
922 static const struct file_operations ftrace_avail_fops
= {
923 .open
= ftrace_event_seq_open
,
926 .release
= seq_release
,
929 static const struct file_operations ftrace_set_event_fops
= {
930 .open
= ftrace_event_seq_open
,
932 .write
= ftrace_event_write
,
934 .release
= seq_release
,
937 static const struct file_operations ftrace_enable_fops
= {
938 .open
= tracing_open_generic
,
939 .read
= event_enable_read
,
940 .write
= event_enable_write
,
941 .llseek
= default_llseek
,
944 static const struct file_operations ftrace_event_format_fops
= {
945 .open
= trace_format_open
,
948 .release
= seq_release
,
951 static const struct file_operations ftrace_event_id_fops
= {
952 .open
= tracing_open_generic
,
953 .read
= event_id_read
,
954 .llseek
= default_llseek
,
957 static const struct file_operations ftrace_event_filter_fops
= {
958 .open
= tracing_open_generic
,
959 .read
= event_filter_read
,
960 .write
= event_filter_write
,
961 .llseek
= default_llseek
,
964 static const struct file_operations ftrace_subsystem_filter_fops
= {
965 .open
= tracing_open_generic
,
966 .read
= subsystem_filter_read
,
967 .write
= subsystem_filter_write
,
968 .llseek
= default_llseek
,
971 static const struct file_operations ftrace_system_enable_fops
= {
972 .open
= tracing_open_generic
,
973 .read
= system_enable_read
,
974 .write
= system_enable_write
,
975 .llseek
= default_llseek
,
978 static const struct file_operations ftrace_show_header_fops
= {
979 .open
= tracing_open_generic
,
981 .llseek
= default_llseek
,
984 static struct dentry
*event_trace_events_dir(void)
986 static struct dentry
*d_tracer
;
987 static struct dentry
*d_events
;
992 d_tracer
= tracing_init_dentry();
996 d_events
= debugfs_create_dir("events", d_tracer
);
998 pr_warning("Could not create debugfs "
999 "'events' directory\n");
1004 static LIST_HEAD(event_subsystems
);
1006 static struct dentry
*
1007 event_subsystem_dir(const char *name
, struct dentry
*d_events
)
1009 struct event_subsystem
*system
;
1010 struct dentry
*entry
;
1012 /* First see if we did not already create this dir */
1013 list_for_each_entry(system
, &event_subsystems
, list
) {
1014 if (strcmp(system
->name
, name
) == 0) {
1015 system
->nr_events
++;
1016 return system
->entry
;
1020 /* need to create new entry */
1021 system
= kmalloc(sizeof(*system
), GFP_KERNEL
);
1023 pr_warning("No memory to create event subsystem %s\n",
1028 system
->entry
= debugfs_create_dir(name
, d_events
);
1029 if (!system
->entry
) {
1030 pr_warning("Could not create event subsystem %s\n",
1036 system
->nr_events
= 1;
1037 system
->name
= kstrdup(name
, GFP_KERNEL
);
1038 if (!system
->name
) {
1039 debugfs_remove(system
->entry
);
1044 list_add(&system
->list
, &event_subsystems
);
1046 system
->filter
= NULL
;
1048 system
->filter
= kzalloc(sizeof(struct event_filter
), GFP_KERNEL
);
1049 if (!system
->filter
) {
1050 pr_warning("Could not allocate filter for subsystem "
1052 return system
->entry
;
1055 entry
= debugfs_create_file("filter", 0644, system
->entry
, system
,
1056 &ftrace_subsystem_filter_fops
);
1058 kfree(system
->filter
);
1059 system
->filter
= NULL
;
1060 pr_warning("Could not create debugfs "
1061 "'%s/filter' entry\n", name
);
1064 trace_create_file("enable", 0644, system
->entry
,
1065 (void *)system
->name
,
1066 &ftrace_system_enable_fops
);
1068 return system
->entry
;
1072 event_create_dir(struct ftrace_event_call
*call
, struct dentry
*d_events
,
1073 const struct file_operations
*id
,
1074 const struct file_operations
*enable
,
1075 const struct file_operations
*filter
,
1076 const struct file_operations
*format
)
1078 struct list_head
*head
;
1082 * If the trace point header did not define TRACE_SYSTEM
1083 * then the system would be called "TRACE_SYSTEM".
1085 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0)
1086 d_events
= event_subsystem_dir(call
->class->system
, d_events
);
1088 call
->dir
= debugfs_create_dir(call
->name
, d_events
);
1090 pr_warning("Could not create debugfs "
1091 "'%s' directory\n", call
->name
);
1095 if (call
->class->reg
)
1096 trace_create_file("enable", 0644, call
->dir
, call
,
1099 #ifdef CONFIG_PERF_EVENTS
1100 if (call
->event
.type
&& call
->class->reg
)
1101 trace_create_file("id", 0444, call
->dir
, call
,
1106 * Other events may have the same class. Only update
1107 * the fields if they are not already defined.
1109 head
= trace_get_fields(call
);
1110 if (list_empty(head
)) {
1111 ret
= call
->class->define_fields(call
);
1113 pr_warning("Could not initialize trace point"
1114 " events/%s\n", call
->name
);
1118 trace_create_file("filter", 0644, call
->dir
, call
,
1121 trace_create_file("format", 0444, call
->dir
, call
,
1128 __trace_add_event_call(struct ftrace_event_call
*call
, struct module
*mod
,
1129 const struct file_operations
*id
,
1130 const struct file_operations
*enable
,
1131 const struct file_operations
*filter
,
1132 const struct file_operations
*format
)
1134 struct dentry
*d_events
;
1137 /* The linker may leave blanks */
1141 if (call
->class->raw_init
) {
1142 ret
= call
->class->raw_init(call
);
1145 pr_warning("Could not initialize trace events/%s\n",
1151 d_events
= event_trace_events_dir();
1155 ret
= event_create_dir(call
, d_events
, id
, enable
, filter
, format
);
1157 list_add(&call
->list
, &ftrace_events
);
1163 /* Add an additional event_call dynamically */
1164 int trace_add_event_call(struct ftrace_event_call
*call
)
1167 mutex_lock(&event_mutex
);
1168 ret
= __trace_add_event_call(call
, NULL
, &ftrace_event_id_fops
,
1169 &ftrace_enable_fops
,
1170 &ftrace_event_filter_fops
,
1171 &ftrace_event_format_fops
);
1172 mutex_unlock(&event_mutex
);
1176 static void remove_subsystem_dir(const char *name
)
1178 struct event_subsystem
*system
;
1180 if (strcmp(name
, TRACE_SYSTEM
) == 0)
1183 list_for_each_entry(system
, &event_subsystems
, list
) {
1184 if (strcmp(system
->name
, name
) == 0) {
1185 if (!--system
->nr_events
) {
1186 struct event_filter
*filter
= system
->filter
;
1188 debugfs_remove_recursive(system
->entry
);
1189 list_del(&system
->list
);
1191 kfree(filter
->filter_string
);
1194 kfree(system
->name
);
1203 * Must be called under locking both of event_mutex and trace_event_mutex.
1205 static void __trace_remove_event_call(struct ftrace_event_call
*call
)
1207 ftrace_event_enable_disable(call
, 0);
1208 if (call
->event
.funcs
)
1209 __unregister_ftrace_event(&call
->event
);
1210 debugfs_remove_recursive(call
->dir
);
1211 list_del(&call
->list
);
1212 trace_destroy_fields(call
);
1213 destroy_preds(call
);
1214 remove_subsystem_dir(call
->class->system
);
1217 /* Remove an event_call */
1218 void trace_remove_event_call(struct ftrace_event_call
*call
)
1220 mutex_lock(&event_mutex
);
1221 down_write(&trace_event_mutex
);
1222 __trace_remove_event_call(call
);
1223 up_write(&trace_event_mutex
);
1224 mutex_unlock(&event_mutex
);
1227 #define for_each_event(event, start, end) \
1228 for (event = start; \
1229 (unsigned long)event < (unsigned long)end; \
1232 #ifdef CONFIG_MODULES
1234 static LIST_HEAD(ftrace_module_file_list
);
1237 * Modules must own their file_operations to keep up with
1238 * reference counting.
1240 struct ftrace_module_file_ops
{
1241 struct list_head list
;
1243 struct file_operations id
;
1244 struct file_operations enable
;
1245 struct file_operations format
;
1246 struct file_operations filter
;
1249 static struct ftrace_module_file_ops
*
1250 trace_create_file_ops(struct module
*mod
)
1252 struct ftrace_module_file_ops
*file_ops
;
1255 * This is a bit of a PITA. To allow for correct reference
1256 * counting, modules must "own" their file_operations.
1257 * To do this, we allocate the file operations that will be
1258 * used in the event directory.
1261 file_ops
= kmalloc(sizeof(*file_ops
), GFP_KERNEL
);
1265 file_ops
->mod
= mod
;
1267 file_ops
->id
= ftrace_event_id_fops
;
1268 file_ops
->id
.owner
= mod
;
1270 file_ops
->enable
= ftrace_enable_fops
;
1271 file_ops
->enable
.owner
= mod
;
1273 file_ops
->filter
= ftrace_event_filter_fops
;
1274 file_ops
->filter
.owner
= mod
;
1276 file_ops
->format
= ftrace_event_format_fops
;
1277 file_ops
->format
.owner
= mod
;
1279 list_add(&file_ops
->list
, &ftrace_module_file_list
);
1284 static void trace_module_add_events(struct module
*mod
)
1286 struct ftrace_module_file_ops
*file_ops
= NULL
;
1287 struct ftrace_event_call
**call
, **start
, **end
;
1289 start
= mod
->trace_events
;
1290 end
= mod
->trace_events
+ mod
->num_trace_events
;
1295 file_ops
= trace_create_file_ops(mod
);
1299 for_each_event(call
, start
, end
) {
1300 __trace_add_event_call(*call
, mod
,
1301 &file_ops
->id
, &file_ops
->enable
,
1302 &file_ops
->filter
, &file_ops
->format
);
1306 static void trace_module_remove_events(struct module
*mod
)
1308 struct ftrace_module_file_ops
*file_ops
;
1309 struct ftrace_event_call
*call
, *p
;
1312 down_write(&trace_event_mutex
);
1313 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
1314 if (call
->mod
== mod
) {
1316 __trace_remove_event_call(call
);
1320 /* Now free the file_operations */
1321 list_for_each_entry(file_ops
, &ftrace_module_file_list
, list
) {
1322 if (file_ops
->mod
== mod
)
1325 if (&file_ops
->list
!= &ftrace_module_file_list
) {
1326 list_del(&file_ops
->list
);
1331 * It is safest to reset the ring buffer if the module being unloaded
1332 * registered any events.
1335 tracing_reset_current_online_cpus();
1336 up_write(&trace_event_mutex
);
1339 static int trace_module_notify(struct notifier_block
*self
,
1340 unsigned long val
, void *data
)
1342 struct module
*mod
= data
;
1344 mutex_lock(&event_mutex
);
1346 case MODULE_STATE_COMING
:
1347 trace_module_add_events(mod
);
1349 case MODULE_STATE_GOING
:
1350 trace_module_remove_events(mod
);
1353 mutex_unlock(&event_mutex
);
1358 static int trace_module_notify(struct notifier_block
*self
,
1359 unsigned long val
, void *data
)
1363 #endif /* CONFIG_MODULES */
1365 static struct notifier_block trace_module_nb
= {
1366 .notifier_call
= trace_module_notify
,
1370 extern struct ftrace_event_call
*__start_ftrace_events
[];
1371 extern struct ftrace_event_call
*__stop_ftrace_events
[];
1373 static char bootup_event_buf
[COMMAND_LINE_SIZE
] __initdata
;
1375 static __init
int setup_trace_event(char *str
)
1377 strlcpy(bootup_event_buf
, str
, COMMAND_LINE_SIZE
);
1378 ring_buffer_expanded
= 1;
1379 tracing_selftest_disabled
= 1;
1383 __setup("trace_event=", setup_trace_event
);
1385 static __init
int event_trace_init(void)
1387 struct ftrace_event_call
**call
;
1388 struct dentry
*d_tracer
;
1389 struct dentry
*entry
;
1390 struct dentry
*d_events
;
1392 char *buf
= bootup_event_buf
;
1395 d_tracer
= tracing_init_dentry();
1399 entry
= debugfs_create_file("available_events", 0444, d_tracer
,
1400 (void *)&show_event_seq_ops
,
1401 &ftrace_avail_fops
);
1403 pr_warning("Could not create debugfs "
1404 "'available_events' entry\n");
1406 entry
= debugfs_create_file("set_event", 0644, d_tracer
,
1407 (void *)&show_set_event_seq_ops
,
1408 &ftrace_set_event_fops
);
1410 pr_warning("Could not create debugfs "
1411 "'set_event' entry\n");
1413 d_events
= event_trace_events_dir();
1417 /* ring buffer internal formats */
1418 trace_create_file("header_page", 0444, d_events
,
1419 ring_buffer_print_page_header
,
1420 &ftrace_show_header_fops
);
1422 trace_create_file("header_event", 0444, d_events
,
1423 ring_buffer_print_entry_header
,
1424 &ftrace_show_header_fops
);
1426 trace_create_file("enable", 0644, d_events
,
1427 NULL
, &ftrace_system_enable_fops
);
1429 if (trace_define_common_fields())
1430 pr_warning("tracing: Failed to allocate common fields");
1432 for_each_event(call
, __start_ftrace_events
, __stop_ftrace_events
) {
1433 __trace_add_event_call(*call
, NULL
, &ftrace_event_id_fops
,
1434 &ftrace_enable_fops
,
1435 &ftrace_event_filter_fops
,
1436 &ftrace_event_format_fops
);
1440 token
= strsep(&buf
, ",");
1447 ret
= ftrace_set_clr_event(token
, 1);
1449 pr_warning("Failed to enable trace event: %s\n", token
);
1452 ret
= register_module_notifier(&trace_module_nb
);
1454 pr_warning("Failed to register trace events module notifier\n");
1458 fs_initcall(event_trace_init
);
1460 #ifdef CONFIG_FTRACE_STARTUP_TEST
1462 static DEFINE_SPINLOCK(test_spinlock
);
1463 static DEFINE_SPINLOCK(test_spinlock_irq
);
1464 static DEFINE_MUTEX(test_mutex
);
1466 static __init
void test_work(struct work_struct
*dummy
)
1468 spin_lock(&test_spinlock
);
1469 spin_lock_irq(&test_spinlock_irq
);
1471 spin_unlock_irq(&test_spinlock_irq
);
1472 spin_unlock(&test_spinlock
);
1474 mutex_lock(&test_mutex
);
1476 mutex_unlock(&test_mutex
);
1479 static __init
int event_test_thread(void *unused
)
1483 test_malloc
= kmalloc(1234, GFP_KERNEL
);
1485 pr_info("failed to kmalloc\n");
1487 schedule_on_each_cpu(test_work
);
1491 set_current_state(TASK_INTERRUPTIBLE
);
1492 while (!kthread_should_stop())
1499 * Do various things that may trigger events.
1501 static __init
void event_test_stuff(void)
1503 struct task_struct
*test_thread
;
1505 test_thread
= kthread_run(event_test_thread
, NULL
, "test-events");
1507 kthread_stop(test_thread
);
1511 * For every trace event defined, we will test each trace point separately,
1512 * and then by groups, and finally all trace points.
1514 static __init
void event_trace_self_tests(void)
1516 struct ftrace_event_call
*call
;
1517 struct event_subsystem
*system
;
1520 pr_info("Running tests on trace events:\n");
1522 list_for_each_entry(call
, &ftrace_events
, list
) {
1524 /* Only test those that have a probe */
1525 if (!call
->class || !call
->class->probe
)
1529 * Testing syscall events here is pretty useless, but
1530 * we still do it if configured. But this is time consuming.
1531 * What we really need is a user thread to perform the
1532 * syscalls as we test.
1534 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
1535 if (call
->class->system
&&
1536 strcmp(call
->class->system
, "syscalls") == 0)
1540 pr_info("Testing event %s: ", call
->name
);
1543 * If an event is already enabled, someone is using
1544 * it and the self test should not be on.
1546 if (call
->flags
& TRACE_EVENT_FL_ENABLED
) {
1547 pr_warning("Enabled event during self test!\n");
1552 ftrace_event_enable_disable(call
, 1);
1554 ftrace_event_enable_disable(call
, 0);
1559 /* Now test at the sub system level */
1561 pr_info("Running tests on trace event systems:\n");
1563 list_for_each_entry(system
, &event_subsystems
, list
) {
1565 /* the ftrace system is special, skip it */
1566 if (strcmp(system
->name
, "ftrace") == 0)
1569 pr_info("Testing event system %s: ", system
->name
);
1571 ret
= __ftrace_set_clr_event(NULL
, system
->name
, NULL
, 1);
1572 if (WARN_ON_ONCE(ret
)) {
1573 pr_warning("error enabling system %s\n",
1580 ret
= __ftrace_set_clr_event(NULL
, system
->name
, NULL
, 0);
1581 if (WARN_ON_ONCE(ret
))
1582 pr_warning("error disabling system %s\n",
1588 /* Test with all events enabled */
1590 pr_info("Running tests on all trace events:\n");
1591 pr_info("Testing all events: ");
1593 ret
= __ftrace_set_clr_event(NULL
, NULL
, NULL
, 1);
1594 if (WARN_ON_ONCE(ret
)) {
1595 pr_warning("error enabling all events\n");
1602 ret
= __ftrace_set_clr_event(NULL
, NULL
, NULL
, 0);
1603 if (WARN_ON_ONCE(ret
)) {
1604 pr_warning("error disabling all events\n");
1611 #ifdef CONFIG_FUNCTION_TRACER
1613 static DEFINE_PER_CPU(atomic_t
, ftrace_test_event_disable
);
1616 function_test_events_call(unsigned long ip
, unsigned long parent_ip
)
1618 struct ring_buffer_event
*event
;
1619 struct ring_buffer
*buffer
;
1620 struct ftrace_entry
*entry
;
1621 unsigned long flags
;
1626 pc
= preempt_count();
1627 preempt_disable_notrace();
1628 cpu
= raw_smp_processor_id();
1629 disabled
= atomic_inc_return(&per_cpu(ftrace_test_event_disable
, cpu
));
1634 local_save_flags(flags
);
1636 event
= trace_current_buffer_lock_reserve(&buffer
,
1637 TRACE_FN
, sizeof(*entry
),
1641 entry
= ring_buffer_event_data(event
);
1643 entry
->parent_ip
= parent_ip
;
1645 trace_nowake_buffer_unlock_commit(buffer
, event
, flags
, pc
);
1648 atomic_dec(&per_cpu(ftrace_test_event_disable
, cpu
));
1649 preempt_enable_notrace();
1652 static struct ftrace_ops trace_ops __initdata
=
1654 .func
= function_test_events_call
,
1657 static __init
void event_trace_self_test_with_function(void)
1659 register_ftrace_function(&trace_ops
);
1660 pr_info("Running tests again, along with the function tracer\n");
1661 event_trace_self_tests();
1662 unregister_ftrace_function(&trace_ops
);
1665 static __init
void event_trace_self_test_with_function(void)
1670 static __init
int event_trace_self_tests_init(void)
1672 if (!tracing_selftest_disabled
) {
1673 event_trace_self_tests();
1674 event_trace_self_test_with_function();
1680 late_initcall(event_trace_self_tests_init
);