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 static LIST_HEAD(ftrace_common_fields
);
39 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
41 static struct kmem_cache
*field_cachep
;
42 static struct kmem_cache
*file_cachep
;
44 #define SYSTEM_FL_FREE_NAME (1 << 31)
46 static inline int system_refcount(struct event_subsystem
*system
)
48 return system
->ref_count
& ~SYSTEM_FL_FREE_NAME
;
51 static int system_refcount_inc(struct event_subsystem
*system
)
53 return (system
->ref_count
++) & ~SYSTEM_FL_FREE_NAME
;
56 static int system_refcount_dec(struct event_subsystem
*system
)
58 return (--system
->ref_count
) & ~SYSTEM_FL_FREE_NAME
;
61 /* Double loops, do not use break, only goto's work */
62 #define do_for_each_event_file(tr, file) \
63 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
64 list_for_each_entry(file, &tr->events, list)
66 #define do_for_each_event_file_safe(tr, file) \
67 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
68 struct ftrace_event_file *___n; \
69 list_for_each_entry_safe(file, ___n, &tr->events, list)
71 #define while_for_each_event_file() \
74 static struct list_head
*
75 trace_get_fields(struct ftrace_event_call
*event_call
)
77 if (!event_call
->class->get_fields
)
78 return &event_call
->class->fields
;
79 return event_call
->class->get_fields(event_call
);
82 static struct ftrace_event_field
*
83 __find_event_field(struct list_head
*head
, char *name
)
85 struct ftrace_event_field
*field
;
87 list_for_each_entry(field
, head
, link
) {
88 if (!strcmp(field
->name
, name
))
95 struct ftrace_event_field
*
96 trace_find_event_field(struct ftrace_event_call
*call
, char *name
)
98 struct ftrace_event_field
*field
;
99 struct list_head
*head
;
101 field
= __find_event_field(&ftrace_common_fields
, name
);
105 head
= trace_get_fields(call
);
106 return __find_event_field(head
, name
);
109 static int __trace_define_field(struct list_head
*head
, const char *type
,
110 const char *name
, int offset
, int size
,
111 int is_signed
, int filter_type
)
113 struct ftrace_event_field
*field
;
115 field
= kmem_cache_alloc(field_cachep
, GFP_TRACE
);
122 if (filter_type
== FILTER_OTHER
)
123 field
->filter_type
= filter_assign_type(type
);
125 field
->filter_type
= filter_type
;
127 field
->offset
= offset
;
129 field
->is_signed
= is_signed
;
131 list_add(&field
->link
, head
);
136 int trace_define_field(struct ftrace_event_call
*call
, const char *type
,
137 const char *name
, int offset
, int size
, int is_signed
,
140 struct list_head
*head
;
142 if (WARN_ON(!call
->class))
145 head
= trace_get_fields(call
);
146 return __trace_define_field(head
, type
, name
, offset
, size
,
147 is_signed
, filter_type
);
149 EXPORT_SYMBOL_GPL(trace_define_field
);
151 #define __common_field(type, item) \
152 ret = __trace_define_field(&ftrace_common_fields, #type, \
154 offsetof(typeof(ent), item), \
156 is_signed_type(type), FILTER_OTHER); \
160 static int trace_define_common_fields(void)
163 struct trace_entry ent
;
165 __common_field(unsigned short, type
);
166 __common_field(unsigned char, flags
);
167 __common_field(unsigned char, preempt_count
);
168 __common_field(int, pid
);
173 static void trace_destroy_fields(struct ftrace_event_call
*call
)
175 struct ftrace_event_field
*field
, *next
;
176 struct list_head
*head
;
178 head
= trace_get_fields(call
);
179 list_for_each_entry_safe(field
, next
, head
, link
) {
180 list_del(&field
->link
);
181 kmem_cache_free(field_cachep
, field
);
185 int trace_event_raw_init(struct ftrace_event_call
*call
)
189 id
= register_ftrace_event(&call
->event
);
195 EXPORT_SYMBOL_GPL(trace_event_raw_init
);
197 int ftrace_event_reg(struct ftrace_event_call
*call
,
198 enum trace_reg type
, void *data
)
200 struct ftrace_event_file
*file
= data
;
203 case TRACE_REG_REGISTER
:
204 return tracepoint_probe_register(call
->name
,
207 case TRACE_REG_UNREGISTER
:
208 tracepoint_probe_unregister(call
->name
,
213 #ifdef CONFIG_PERF_EVENTS
214 case TRACE_REG_PERF_REGISTER
:
215 return tracepoint_probe_register(call
->name
,
216 call
->class->perf_probe
,
218 case TRACE_REG_PERF_UNREGISTER
:
219 tracepoint_probe_unregister(call
->name
,
220 call
->class->perf_probe
,
223 case TRACE_REG_PERF_OPEN
:
224 case TRACE_REG_PERF_CLOSE
:
225 case TRACE_REG_PERF_ADD
:
226 case TRACE_REG_PERF_DEL
:
232 EXPORT_SYMBOL_GPL(ftrace_event_reg
);
234 void trace_event_enable_cmd_record(bool enable
)
236 struct ftrace_event_file
*file
;
237 struct trace_array
*tr
;
239 mutex_lock(&event_mutex
);
240 do_for_each_event_file(tr
, file
) {
242 if (!(file
->flags
& FTRACE_EVENT_FL_ENABLED
))
246 tracing_start_cmdline_record();
247 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT
, &file
->flags
);
249 tracing_stop_cmdline_record();
250 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT
, &file
->flags
);
252 } while_for_each_event_file();
253 mutex_unlock(&event_mutex
);
256 static int __ftrace_event_enable_disable(struct ftrace_event_file
*file
,
257 int enable
, int soft_disable
)
259 struct ftrace_event_call
*call
= file
->event_call
;
266 * When soft_disable is set and enable is cleared, the sm_ref
267 * reference counter is decremented. If it reaches 0, we want
268 * to clear the SOFT_DISABLED flag but leave the event in the
269 * state that it was. That is, if the event was enabled and
270 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
271 * is set we do not want the event to be enabled before we
274 * When soft_disable is not set but the SOFT_MODE flag is,
275 * we do nothing. Do not disable the tracepoint, otherwise
276 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
279 if (atomic_dec_return(&file
->sm_ref
) > 0)
281 disable
= file
->flags
& FTRACE_EVENT_FL_SOFT_DISABLED
;
282 clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT
, &file
->flags
);
284 disable
= !(file
->flags
& FTRACE_EVENT_FL_SOFT_MODE
);
286 if (disable
&& (file
->flags
& FTRACE_EVENT_FL_ENABLED
)) {
287 clear_bit(FTRACE_EVENT_FL_ENABLED_BIT
, &file
->flags
);
288 if (file
->flags
& FTRACE_EVENT_FL_RECORDED_CMD
) {
289 tracing_stop_cmdline_record();
290 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT
, &file
->flags
);
292 call
->class->reg(call
, TRACE_REG_UNREGISTER
, file
);
294 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
295 if (file
->flags
& FTRACE_EVENT_FL_SOFT_MODE
)
296 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &file
->flags
);
298 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &file
->flags
);
302 * When soft_disable is set and enable is set, we want to
303 * register the tracepoint for the event, but leave the event
304 * as is. That means, if the event was already enabled, we do
305 * nothing (but set SOFT_MODE). If the event is disabled, we
306 * set SOFT_DISABLED before enabling the event tracepoint, so
307 * it still seems to be disabled.
310 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &file
->flags
);
312 if (atomic_inc_return(&file
->sm_ref
) > 1)
314 set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT
, &file
->flags
);
317 if (!(file
->flags
& FTRACE_EVENT_FL_ENABLED
)) {
319 /* Keep the event disabled, when going to SOFT_MODE. */
321 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &file
->flags
);
323 if (trace_flags
& TRACE_ITER_RECORD_CMD
) {
324 tracing_start_cmdline_record();
325 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT
, &file
->flags
);
327 ret
= call
->class->reg(call
, TRACE_REG_REGISTER
, file
);
329 tracing_stop_cmdline_record();
330 pr_info("event trace: Could not enable event "
334 set_bit(FTRACE_EVENT_FL_ENABLED_BIT
, &file
->flags
);
336 /* WAS_ENABLED gets set but never cleared. */
337 call
->flags
|= TRACE_EVENT_FL_WAS_ENABLED
;
345 static int ftrace_event_enable_disable(struct ftrace_event_file
*file
,
348 return __ftrace_event_enable_disable(file
, enable
, 0);
351 static void ftrace_clear_events(struct trace_array
*tr
)
353 struct ftrace_event_file
*file
;
355 mutex_lock(&event_mutex
);
356 list_for_each_entry(file
, &tr
->events
, list
) {
357 ftrace_event_enable_disable(file
, 0);
359 mutex_unlock(&event_mutex
);
362 static void __put_system(struct event_subsystem
*system
)
364 struct event_filter
*filter
= system
->filter
;
366 WARN_ON_ONCE(system_refcount(system
) == 0);
367 if (system_refcount_dec(system
))
370 list_del(&system
->list
);
373 kfree(filter
->filter_string
);
376 if (system
->ref_count
& SYSTEM_FL_FREE_NAME
)
381 static void __get_system(struct event_subsystem
*system
)
383 WARN_ON_ONCE(system_refcount(system
) == 0);
384 system_refcount_inc(system
);
387 static void __get_system_dir(struct ftrace_subsystem_dir
*dir
)
389 WARN_ON_ONCE(dir
->ref_count
== 0);
391 __get_system(dir
->subsystem
);
394 static void __put_system_dir(struct ftrace_subsystem_dir
*dir
)
396 WARN_ON_ONCE(dir
->ref_count
== 0);
397 /* If the subsystem is about to be freed, the dir must be too */
398 WARN_ON_ONCE(system_refcount(dir
->subsystem
) == 1 && dir
->ref_count
!= 1);
400 __put_system(dir
->subsystem
);
401 if (!--dir
->ref_count
)
405 static void put_system(struct ftrace_subsystem_dir
*dir
)
407 mutex_lock(&event_mutex
);
408 __put_system_dir(dir
);
409 mutex_unlock(&event_mutex
);
412 static void remove_subsystem(struct ftrace_subsystem_dir
*dir
)
417 if (!--dir
->nr_events
) {
418 debugfs_remove_recursive(dir
->entry
);
419 list_del(&dir
->list
);
420 __put_system_dir(dir
);
424 static void *event_file_data(struct file
*filp
)
426 return ACCESS_ONCE(file_inode(filp
)->i_private
);
429 static void remove_event_file_dir(struct ftrace_event_file
*file
)
431 struct dentry
*dir
= file
->dir
;
432 struct dentry
*child
;
435 spin_lock(&dir
->d_lock
); /* probably unneeded */
436 list_for_each_entry(child
, &dir
->d_subdirs
, d_u
.d_child
) {
437 if (child
->d_inode
) /* probably unneeded */
438 child
->d_inode
->i_private
= NULL
;
440 spin_unlock(&dir
->d_lock
);
442 debugfs_remove_recursive(dir
);
445 list_del(&file
->list
);
446 remove_subsystem(file
->system
);
447 kmem_cache_free(file_cachep
, file
);
451 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
454 __ftrace_set_clr_event_nolock(struct trace_array
*tr
, const char *match
,
455 const char *sub
, const char *event
, int set
)
457 struct ftrace_event_file
*file
;
458 struct ftrace_event_call
*call
;
461 list_for_each_entry(file
, &tr
->events
, list
) {
463 call
= file
->event_call
;
465 if (!call
->name
|| !call
->class || !call
->class->reg
)
468 if (call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)
472 strcmp(match
, call
->name
) != 0 &&
473 strcmp(match
, call
->class->system
) != 0)
476 if (sub
&& strcmp(sub
, call
->class->system
) != 0)
479 if (event
&& strcmp(event
, call
->name
) != 0)
482 ftrace_event_enable_disable(file
, set
);
490 static int __ftrace_set_clr_event(struct trace_array
*tr
, const char *match
,
491 const char *sub
, const char *event
, int set
)
495 mutex_lock(&event_mutex
);
496 ret
= __ftrace_set_clr_event_nolock(tr
, match
, sub
, event
, set
);
497 mutex_unlock(&event_mutex
);
502 static int ftrace_set_clr_event(struct trace_array
*tr
, char *buf
, int set
)
504 char *event
= NULL
, *sub
= NULL
, *match
;
507 * The buf format can be <subsystem>:<event-name>
508 * *:<event-name> means any event by that name.
509 * :<event-name> is the same.
511 * <subsystem>:* means all events in that subsystem
512 * <subsystem>: means the same.
514 * <name> (no ':') means all events in a subsystem with
515 * the name <name> or any event that matches <name>
518 match
= strsep(&buf
, ":");
524 if (!strlen(sub
) || strcmp(sub
, "*") == 0)
526 if (!strlen(event
) || strcmp(event
, "*") == 0)
530 return __ftrace_set_clr_event(tr
, match
, sub
, event
, set
);
534 * trace_set_clr_event - enable or disable an event
535 * @system: system name to match (NULL for any system)
536 * @event: event name to match (NULL for all events, within system)
537 * @set: 1 to enable, 0 to disable
539 * This is a way for other parts of the kernel to enable or disable
542 * Returns 0 on success, -EINVAL if the parameters do not match any
545 int trace_set_clr_event(const char *system
, const char *event
, int set
)
547 struct trace_array
*tr
= top_trace_array();
549 return __ftrace_set_clr_event(tr
, NULL
, system
, event
, set
);
551 EXPORT_SYMBOL_GPL(trace_set_clr_event
);
553 /* 128 should be much more than enough */
554 #define EVENT_BUF_SIZE 127
557 ftrace_event_write(struct file
*file
, const char __user
*ubuf
,
558 size_t cnt
, loff_t
*ppos
)
560 struct trace_parser parser
;
561 struct seq_file
*m
= file
->private_data
;
562 struct trace_array
*tr
= m
->private;
568 ret
= tracing_update_buffers();
572 if (trace_parser_get_init(&parser
, EVENT_BUF_SIZE
+ 1))
575 read
= trace_get_user(&parser
, ubuf
, cnt
, ppos
);
577 if (read
>= 0 && trace_parser_loaded((&parser
))) {
580 if (*parser
.buffer
== '!')
583 parser
.buffer
[parser
.idx
] = 0;
585 ret
= ftrace_set_clr_event(tr
, parser
.buffer
+ !set
, set
);
593 trace_parser_put(&parser
);
599 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
601 struct ftrace_event_file
*file
= v
;
602 struct ftrace_event_call
*call
;
603 struct trace_array
*tr
= m
->private;
607 list_for_each_entry_continue(file
, &tr
->events
, list
) {
608 call
= file
->event_call
;
610 * The ftrace subsystem is for showing formats only.
611 * They can not be enabled or disabled via the event files.
613 if (call
->class && call
->class->reg
)
620 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
622 struct ftrace_event_file
*file
;
623 struct trace_array
*tr
= m
->private;
626 mutex_lock(&event_mutex
);
628 file
= list_entry(&tr
->events
, struct ftrace_event_file
, list
);
629 for (l
= 0; l
<= *pos
; ) {
630 file
= t_next(m
, file
, &l
);
638 s_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
640 struct ftrace_event_file
*file
= v
;
641 struct trace_array
*tr
= m
->private;
645 list_for_each_entry_continue(file
, &tr
->events
, list
) {
646 if (file
->flags
& FTRACE_EVENT_FL_ENABLED
)
653 static void *s_start(struct seq_file
*m
, loff_t
*pos
)
655 struct ftrace_event_file
*file
;
656 struct trace_array
*tr
= m
->private;
659 mutex_lock(&event_mutex
);
661 file
= list_entry(&tr
->events
, struct ftrace_event_file
, list
);
662 for (l
= 0; l
<= *pos
; ) {
663 file
= s_next(m
, file
, &l
);
670 static int t_show(struct seq_file
*m
, void *v
)
672 struct ftrace_event_file
*file
= v
;
673 struct ftrace_event_call
*call
= file
->event_call
;
675 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0)
676 seq_printf(m
, "%s:", call
->class->system
);
677 seq_printf(m
, "%s\n", call
->name
);
682 static void t_stop(struct seq_file
*m
, void *p
)
684 mutex_unlock(&event_mutex
);
688 event_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
691 struct ftrace_event_file
*file
;
695 mutex_lock(&event_mutex
);
696 file
= event_file_data(filp
);
699 mutex_unlock(&event_mutex
);
704 if (flags
& FTRACE_EVENT_FL_ENABLED
&&
705 !(flags
& FTRACE_EVENT_FL_SOFT_DISABLED
))
708 if (flags
& FTRACE_EVENT_FL_SOFT_DISABLED
||
709 flags
& FTRACE_EVENT_FL_SOFT_MODE
)
714 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, strlen(buf
));
718 event_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
721 struct ftrace_event_file
*file
;
725 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
729 ret
= tracing_update_buffers();
737 mutex_lock(&event_mutex
);
738 file
= event_file_data(filp
);
740 ret
= ftrace_event_enable_disable(file
, val
);
741 mutex_unlock(&event_mutex
);
750 return ret
? ret
: cnt
;
754 system_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
757 const char set_to_char
[4] = { '?', '0', '1', 'X' };
758 struct ftrace_subsystem_dir
*dir
= filp
->private_data
;
759 struct event_subsystem
*system
= dir
->subsystem
;
760 struct ftrace_event_call
*call
;
761 struct ftrace_event_file
*file
;
762 struct trace_array
*tr
= dir
->tr
;
767 mutex_lock(&event_mutex
);
768 list_for_each_entry(file
, &tr
->events
, list
) {
769 call
= file
->event_call
;
770 if (!call
->name
|| !call
->class || !call
->class->reg
)
773 if (system
&& strcmp(call
->class->system
, system
->name
) != 0)
777 * We need to find out if all the events are set
778 * or if all events or cleared, or if we have
781 set
|= (1 << !!(file
->flags
& FTRACE_EVENT_FL_ENABLED
));
784 * If we have a mixture, no need to look further.
789 mutex_unlock(&event_mutex
);
791 buf
[0] = set_to_char
[set
];
794 ret
= simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, 2);
800 system_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
803 struct ftrace_subsystem_dir
*dir
= filp
->private_data
;
804 struct event_subsystem
*system
= dir
->subsystem
;
805 const char *name
= NULL
;
809 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
813 ret
= tracing_update_buffers();
817 if (val
!= 0 && val
!= 1)
821 * Opening of "enable" adds a ref count to system,
822 * so the name is safe to use.
827 ret
= __ftrace_set_clr_event(dir
->tr
, NULL
, name
, NULL
, val
);
841 FORMAT_FIELD_SEPERATOR
= 2,
845 static void *f_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
847 struct ftrace_event_call
*call
= event_file_data(m
->private);
848 struct list_head
*common_head
= &ftrace_common_fields
;
849 struct list_head
*head
= trace_get_fields(call
);
850 struct list_head
*node
= v
;
854 switch ((unsigned long)v
) {
859 case FORMAT_FIELD_SEPERATOR
:
863 case FORMAT_PRINTFMT
:
869 if (node
== common_head
)
870 return (void *)FORMAT_FIELD_SEPERATOR
;
871 else if (node
== head
)
872 return (void *)FORMAT_PRINTFMT
;
877 static int f_show(struct seq_file
*m
, void *v
)
879 struct ftrace_event_call
*call
= event_file_data(m
->private);
880 struct ftrace_event_field
*field
;
881 const char *array_descriptor
;
883 switch ((unsigned long)v
) {
885 seq_printf(m
, "name: %s\n", call
->name
);
886 seq_printf(m
, "ID: %d\n", call
->event
.type
);
887 seq_printf(m
, "format:\n");
890 case FORMAT_FIELD_SEPERATOR
:
894 case FORMAT_PRINTFMT
:
895 seq_printf(m
, "\nprint fmt: %s\n",
900 field
= list_entry(v
, struct ftrace_event_field
, link
);
902 * Smartly shows the array type(except dynamic array).
905 * If TYPE := TYPE[LEN], it is shown:
906 * field:TYPE VAR[LEN]
908 array_descriptor
= strchr(field
->type
, '[');
910 if (!strncmp(field
->type
, "__data_loc", 10))
911 array_descriptor
= NULL
;
913 if (!array_descriptor
)
914 seq_printf(m
, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
915 field
->type
, field
->name
, field
->offset
,
916 field
->size
, !!field
->is_signed
);
918 seq_printf(m
, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
919 (int)(array_descriptor
- field
->type
),
920 field
->type
, field
->name
,
921 array_descriptor
, field
->offset
,
922 field
->size
, !!field
->is_signed
);
927 static void *f_start(struct seq_file
*m
, loff_t
*pos
)
929 void *p
= (void *)FORMAT_HEADER
;
932 /* ->stop() is called even if ->start() fails */
933 mutex_lock(&event_mutex
);
934 if (!event_file_data(m
->private))
935 return ERR_PTR(-ENODEV
);
937 while (l
< *pos
&& p
)
938 p
= f_next(m
, p
, &l
);
943 static void f_stop(struct seq_file
*m
, void *p
)
945 mutex_unlock(&event_mutex
);
948 static const struct seq_operations trace_format_seq_ops
= {
955 static int trace_format_open(struct inode
*inode
, struct file
*file
)
960 ret
= seq_open(file
, &trace_format_seq_ops
);
964 m
= file
->private_data
;
971 event_id_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
973 int id
= (long)event_file_data(filp
);
983 len
= sprintf(buf
, "%d\n", id
);
985 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, len
);
989 event_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
992 struct ftrace_event_file
*file
;
999 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1006 mutex_lock(&event_mutex
);
1007 file
= event_file_data(filp
);
1009 print_event_filter(file
, s
);
1010 mutex_unlock(&event_mutex
);
1013 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
1021 event_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1024 struct ftrace_event_file
*file
;
1028 if (cnt
>= PAGE_SIZE
)
1031 buf
= (char *)__get_free_page(GFP_TEMPORARY
);
1035 if (copy_from_user(buf
, ubuf
, cnt
)) {
1036 free_page((unsigned long) buf
);
1041 mutex_lock(&event_mutex
);
1042 file
= event_file_data(filp
);
1044 err
= apply_event_filter(file
, buf
);
1045 mutex_unlock(&event_mutex
);
1047 free_page((unsigned long) buf
);
1056 static LIST_HEAD(event_subsystems
);
1058 static int subsystem_open(struct inode
*inode
, struct file
*filp
)
1060 struct event_subsystem
*system
= NULL
;
1061 struct ftrace_subsystem_dir
*dir
= NULL
; /* Initialize for gcc */
1062 struct trace_array
*tr
;
1065 if (tracing_is_disabled())
1068 /* Make sure the system still exists */
1069 mutex_lock(&trace_types_lock
);
1070 mutex_lock(&event_mutex
);
1071 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
) {
1072 list_for_each_entry(dir
, &tr
->systems
, list
) {
1073 if (dir
== inode
->i_private
) {
1074 /* Don't open systems with no events */
1075 if (dir
->nr_events
) {
1076 __get_system_dir(dir
);
1077 system
= dir
->subsystem
;
1084 mutex_unlock(&event_mutex
);
1085 mutex_unlock(&trace_types_lock
);
1090 /* Some versions of gcc think dir can be uninitialized here */
1093 /* Still need to increment the ref count of the system */
1094 if (trace_array_get(tr
) < 0) {
1099 ret
= tracing_open_generic(inode
, filp
);
1101 trace_array_put(tr
);
1108 static int system_tr_open(struct inode
*inode
, struct file
*filp
)
1110 struct ftrace_subsystem_dir
*dir
;
1111 struct trace_array
*tr
= inode
->i_private
;
1114 if (tracing_is_disabled())
1117 if (trace_array_get(tr
) < 0)
1120 /* Make a temporary dir that has no system but points to tr */
1121 dir
= kzalloc(sizeof(*dir
), GFP_KERNEL
);
1123 trace_array_put(tr
);
1129 ret
= tracing_open_generic(inode
, filp
);
1131 trace_array_put(tr
);
1136 filp
->private_data
= dir
;
1141 static int subsystem_release(struct inode
*inode
, struct file
*file
)
1143 struct ftrace_subsystem_dir
*dir
= file
->private_data
;
1145 trace_array_put(dir
->tr
);
1148 * If dir->subsystem is NULL, then this is a temporary
1149 * descriptor that was made for a trace_array to enable
1161 subsystem_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1164 struct ftrace_subsystem_dir
*dir
= filp
->private_data
;
1165 struct event_subsystem
*system
= dir
->subsystem
;
1166 struct trace_seq
*s
;
1172 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1178 print_subsystem_event_filter(system
, s
);
1179 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
1187 subsystem_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1190 struct ftrace_subsystem_dir
*dir
= filp
->private_data
;
1194 if (cnt
>= PAGE_SIZE
)
1197 buf
= (char *)__get_free_page(GFP_TEMPORARY
);
1201 if (copy_from_user(buf
, ubuf
, cnt
)) {
1202 free_page((unsigned long) buf
);
1207 err
= apply_subsystem_event_filter(dir
, buf
);
1208 free_page((unsigned long) buf
);
1218 show_header(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
1220 int (*func
)(struct trace_seq
*s
) = filp
->private_data
;
1221 struct trace_seq
*s
;
1227 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1234 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
, s
->buffer
, s
->len
);
1241 static int ftrace_event_avail_open(struct inode
*inode
, struct file
*file
);
1242 static int ftrace_event_set_open(struct inode
*inode
, struct file
*file
);
1243 static int ftrace_event_release(struct inode
*inode
, struct file
*file
);
1245 static const struct seq_operations show_event_seq_ops
= {
1252 static const struct seq_operations show_set_event_seq_ops
= {
1259 static const struct file_operations ftrace_avail_fops
= {
1260 .open
= ftrace_event_avail_open
,
1262 .llseek
= seq_lseek
,
1263 .release
= seq_release
,
1266 static const struct file_operations ftrace_set_event_fops
= {
1267 .open
= ftrace_event_set_open
,
1269 .write
= ftrace_event_write
,
1270 .llseek
= seq_lseek
,
1271 .release
= ftrace_event_release
,
1274 static const struct file_operations ftrace_enable_fops
= {
1275 .open
= tracing_open_generic
,
1276 .read
= event_enable_read
,
1277 .write
= event_enable_write
,
1278 .llseek
= default_llseek
,
1281 static const struct file_operations ftrace_event_format_fops
= {
1282 .open
= trace_format_open
,
1284 .llseek
= seq_lseek
,
1285 .release
= seq_release
,
1288 static const struct file_operations ftrace_event_id_fops
= {
1289 .read
= event_id_read
,
1290 .llseek
= default_llseek
,
1293 static const struct file_operations ftrace_event_filter_fops
= {
1294 .open
= tracing_open_generic
,
1295 .read
= event_filter_read
,
1296 .write
= event_filter_write
,
1297 .llseek
= default_llseek
,
1300 static const struct file_operations ftrace_subsystem_filter_fops
= {
1301 .open
= subsystem_open
,
1302 .read
= subsystem_filter_read
,
1303 .write
= subsystem_filter_write
,
1304 .llseek
= default_llseek
,
1305 .release
= subsystem_release
,
1308 static const struct file_operations ftrace_system_enable_fops
= {
1309 .open
= subsystem_open
,
1310 .read
= system_enable_read
,
1311 .write
= system_enable_write
,
1312 .llseek
= default_llseek
,
1313 .release
= subsystem_release
,
1316 static const struct file_operations ftrace_tr_enable_fops
= {
1317 .open
= system_tr_open
,
1318 .read
= system_enable_read
,
1319 .write
= system_enable_write
,
1320 .llseek
= default_llseek
,
1321 .release
= subsystem_release
,
1324 static const struct file_operations ftrace_show_header_fops
= {
1325 .open
= tracing_open_generic
,
1326 .read
= show_header
,
1327 .llseek
= default_llseek
,
1331 ftrace_event_open(struct inode
*inode
, struct file
*file
,
1332 const struct seq_operations
*seq_ops
)
1337 ret
= seq_open(file
, seq_ops
);
1340 m
= file
->private_data
;
1341 /* copy tr over to seq ops */
1342 m
->private = inode
->i_private
;
1347 static int ftrace_event_release(struct inode
*inode
, struct file
*file
)
1349 struct trace_array
*tr
= inode
->i_private
;
1351 trace_array_put(tr
);
1353 return seq_release(inode
, file
);
1357 ftrace_event_avail_open(struct inode
*inode
, struct file
*file
)
1359 const struct seq_operations
*seq_ops
= &show_event_seq_ops
;
1361 return ftrace_event_open(inode
, file
, seq_ops
);
1365 ftrace_event_set_open(struct inode
*inode
, struct file
*file
)
1367 const struct seq_operations
*seq_ops
= &show_set_event_seq_ops
;
1368 struct trace_array
*tr
= inode
->i_private
;
1371 if (trace_array_get(tr
) < 0)
1374 if ((file
->f_mode
& FMODE_WRITE
) &&
1375 (file
->f_flags
& O_TRUNC
))
1376 ftrace_clear_events(tr
);
1378 ret
= ftrace_event_open(inode
, file
, seq_ops
);
1380 trace_array_put(tr
);
1384 static struct event_subsystem
*
1385 create_new_subsystem(const char *name
)
1387 struct event_subsystem
*system
;
1389 /* need to create new entry */
1390 system
= kmalloc(sizeof(*system
), GFP_KERNEL
);
1394 system
->ref_count
= 1;
1396 /* Only allocate if dynamic (kprobes and modules) */
1397 if (!core_kernel_data((unsigned long)name
)) {
1398 system
->ref_count
|= SYSTEM_FL_FREE_NAME
;
1399 system
->name
= kstrdup(name
, GFP_KERNEL
);
1403 system
->name
= name
;
1405 system
->filter
= NULL
;
1407 system
->filter
= kzalloc(sizeof(struct event_filter
), GFP_KERNEL
);
1408 if (!system
->filter
)
1411 list_add(&system
->list
, &event_subsystems
);
1416 if (system
->ref_count
& SYSTEM_FL_FREE_NAME
)
1417 kfree(system
->name
);
1422 static struct dentry
*
1423 event_subsystem_dir(struct trace_array
*tr
, const char *name
,
1424 struct ftrace_event_file
*file
, struct dentry
*parent
)
1426 struct ftrace_subsystem_dir
*dir
;
1427 struct event_subsystem
*system
;
1428 struct dentry
*entry
;
1430 /* First see if we did not already create this dir */
1431 list_for_each_entry(dir
, &tr
->systems
, list
) {
1432 system
= dir
->subsystem
;
1433 if (strcmp(system
->name
, name
) == 0) {
1440 /* Now see if the system itself exists. */
1441 list_for_each_entry(system
, &event_subsystems
, list
) {
1442 if (strcmp(system
->name
, name
) == 0)
1445 /* Reset system variable when not found */
1446 if (&system
->list
== &event_subsystems
)
1449 dir
= kmalloc(sizeof(*dir
), GFP_KERNEL
);
1454 system
= create_new_subsystem(name
);
1458 __get_system(system
);
1460 dir
->entry
= debugfs_create_dir(name
, parent
);
1462 pr_warning("Failed to create system directory %s\n", name
);
1463 __put_system(system
);
1470 dir
->subsystem
= system
;
1473 entry
= debugfs_create_file("filter", 0644, dir
->entry
, dir
,
1474 &ftrace_subsystem_filter_fops
);
1476 kfree(system
->filter
);
1477 system
->filter
= NULL
;
1478 pr_warning("Could not create debugfs '%s/filter' entry\n", name
);
1481 trace_create_file("enable", 0644, dir
->entry
, dir
,
1482 &ftrace_system_enable_fops
);
1484 list_add(&dir
->list
, &tr
->systems
);
1491 /* Only print this message if failed on memory allocation */
1492 if (!dir
|| !system
)
1493 pr_warning("No memory to create event subsystem %s\n",
1499 event_create_dir(struct dentry
*parent
, struct ftrace_event_file
*file
)
1501 struct ftrace_event_call
*call
= file
->event_call
;
1502 struct trace_array
*tr
= file
->tr
;
1503 struct list_head
*head
;
1504 struct dentry
*d_events
;
1508 * If the trace point header did not define TRACE_SYSTEM
1509 * then the system would be called "TRACE_SYSTEM".
1511 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0) {
1512 d_events
= event_subsystem_dir(tr
, call
->class->system
, file
, parent
);
1518 file
->dir
= debugfs_create_dir(call
->name
, d_events
);
1520 pr_warning("Could not create debugfs '%s' directory\n",
1525 if (call
->class->reg
&& !(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
))
1526 trace_create_file("enable", 0644, file
->dir
, file
,
1527 &ftrace_enable_fops
);
1529 #ifdef CONFIG_PERF_EVENTS
1530 if (call
->event
.type
&& call
->class->reg
)
1531 trace_create_file("id", 0444, file
->dir
,
1532 (void *)(long)call
->event
.type
,
1533 &ftrace_event_id_fops
);
1537 * Other events may have the same class. Only update
1538 * the fields if they are not already defined.
1540 head
= trace_get_fields(call
);
1541 if (list_empty(head
)) {
1542 ret
= call
->class->define_fields(call
);
1544 pr_warning("Could not initialize trace point"
1545 " events/%s\n", call
->name
);
1549 trace_create_file("filter", 0644, file
->dir
, file
,
1550 &ftrace_event_filter_fops
);
1552 trace_create_file("format", 0444, file
->dir
, call
,
1553 &ftrace_event_format_fops
);
1558 static void remove_event_from_tracers(struct ftrace_event_call
*call
)
1560 struct ftrace_event_file
*file
;
1561 struct trace_array
*tr
;
1563 do_for_each_event_file_safe(tr
, file
) {
1564 if (file
->event_call
!= call
)
1567 remove_event_file_dir(file
);
1569 * The do_for_each_event_file_safe() is
1570 * a double loop. After finding the call for this
1571 * trace_array, we use break to jump to the next
1575 } while_for_each_event_file();
1578 static void event_remove(struct ftrace_event_call
*call
)
1580 struct trace_array
*tr
;
1581 struct ftrace_event_file
*file
;
1583 do_for_each_event_file(tr
, file
) {
1584 if (file
->event_call
!= call
)
1586 ftrace_event_enable_disable(file
, 0);
1587 destroy_preds(file
);
1589 * The do_for_each_event_file() is
1590 * a double loop. After finding the call for this
1591 * trace_array, we use break to jump to the next
1595 } while_for_each_event_file();
1597 if (call
->event
.funcs
)
1598 __unregister_ftrace_event(&call
->event
);
1599 remove_event_from_tracers(call
);
1600 list_del(&call
->list
);
1603 static int event_init(struct ftrace_event_call
*call
)
1607 if (WARN_ON(!call
->name
))
1610 if (call
->class->raw_init
) {
1611 ret
= call
->class->raw_init(call
);
1612 if (ret
< 0 && ret
!= -ENOSYS
)
1613 pr_warn("Could not initialize trace events/%s\n",
1621 __register_event(struct ftrace_event_call
*call
, struct module
*mod
)
1625 ret
= event_init(call
);
1629 list_add(&call
->list
, &ftrace_events
);
1635 static struct ftrace_event_file
*
1636 trace_create_new_event(struct ftrace_event_call
*call
,
1637 struct trace_array
*tr
)
1639 struct ftrace_event_file
*file
;
1641 file
= kmem_cache_alloc(file_cachep
, GFP_TRACE
);
1645 file
->event_call
= call
;
1647 atomic_set(&file
->sm_ref
, 0);
1648 list_add(&file
->list
, &tr
->events
);
1653 /* Add an event to a trace directory */
1655 __trace_add_new_event(struct ftrace_event_call
*call
, struct trace_array
*tr
)
1657 struct ftrace_event_file
*file
;
1659 file
= trace_create_new_event(call
, tr
);
1663 return event_create_dir(tr
->event_dir
, file
);
1667 * Just create a decriptor for early init. A descriptor is required
1668 * for enabling events at boot. We want to enable events before
1669 * the filesystem is initialized.
1672 __trace_early_add_new_event(struct ftrace_event_call
*call
,
1673 struct trace_array
*tr
)
1675 struct ftrace_event_file
*file
;
1677 file
= trace_create_new_event(call
, tr
);
1684 struct ftrace_module_file_ops
;
1685 static void __add_event_to_tracers(struct ftrace_event_call
*call
);
1687 /* Add an additional event_call dynamically */
1688 int trace_add_event_call(struct ftrace_event_call
*call
)
1691 mutex_lock(&trace_types_lock
);
1692 mutex_lock(&event_mutex
);
1694 ret
= __register_event(call
, NULL
);
1696 __add_event_to_tracers(call
);
1698 mutex_unlock(&event_mutex
);
1699 mutex_unlock(&trace_types_lock
);
1704 * Must be called under locking of trace_types_lock, event_mutex and
1707 static void __trace_remove_event_call(struct ftrace_event_call
*call
)
1710 trace_destroy_fields(call
);
1711 destroy_call_preds(call
);
1714 static int probe_remove_event_call(struct ftrace_event_call
*call
)
1716 struct trace_array
*tr
;
1717 struct ftrace_event_file
*file
;
1719 #ifdef CONFIG_PERF_EVENTS
1720 if (call
->perf_refcount
)
1723 do_for_each_event_file(tr
, file
) {
1724 if (file
->event_call
!= call
)
1727 * We can't rely on ftrace_event_enable_disable(enable => 0)
1728 * we are going to do, FTRACE_EVENT_FL_SOFT_MODE can suppress
1729 * TRACE_REG_UNREGISTER.
1731 if (file
->flags
& FTRACE_EVENT_FL_ENABLED
)
1734 * The do_for_each_event_file_safe() is
1735 * a double loop. After finding the call for this
1736 * trace_array, we use break to jump to the next
1740 } while_for_each_event_file();
1742 __trace_remove_event_call(call
);
1747 /* Remove an event_call */
1748 int trace_remove_event_call(struct ftrace_event_call
*call
)
1752 mutex_lock(&trace_types_lock
);
1753 mutex_lock(&event_mutex
);
1754 down_write(&trace_event_sem
);
1755 ret
= probe_remove_event_call(call
);
1756 up_write(&trace_event_sem
);
1757 mutex_unlock(&event_mutex
);
1758 mutex_unlock(&trace_types_lock
);
1763 #define for_each_event(event, start, end) \
1764 for (event = start; \
1765 (unsigned long)event < (unsigned long)end; \
1768 #ifdef CONFIG_MODULES
1770 static void trace_module_add_events(struct module
*mod
)
1772 struct ftrace_event_call
**call
, **start
, **end
;
1774 start
= mod
->trace_events
;
1775 end
= mod
->trace_events
+ mod
->num_trace_events
;
1777 for_each_event(call
, start
, end
) {
1778 __register_event(*call
, mod
);
1779 __add_event_to_tracers(*call
);
1783 static void trace_module_remove_events(struct module
*mod
)
1785 struct ftrace_event_call
*call
, *p
;
1786 bool clear_trace
= false;
1788 down_write(&trace_event_sem
);
1789 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
1790 if (call
->mod
== mod
) {
1791 if (call
->flags
& TRACE_EVENT_FL_WAS_ENABLED
)
1793 __trace_remove_event_call(call
);
1796 up_write(&trace_event_sem
);
1799 * It is safest to reset the ring buffer if the module being unloaded
1800 * registered any events that were used. The only worry is if
1801 * a new module gets loaded, and takes on the same id as the events
1802 * of this module. When printing out the buffer, traced events left
1803 * over from this module may be passed to the new module events and
1804 * unexpected results may occur.
1807 tracing_reset_all_online_cpus();
1810 static int trace_module_notify(struct notifier_block
*self
,
1811 unsigned long val
, void *data
)
1813 struct module
*mod
= data
;
1815 mutex_lock(&trace_types_lock
);
1816 mutex_lock(&event_mutex
);
1818 case MODULE_STATE_COMING
:
1819 trace_module_add_events(mod
);
1821 case MODULE_STATE_GOING
:
1822 trace_module_remove_events(mod
);
1825 mutex_unlock(&event_mutex
);
1826 mutex_unlock(&trace_types_lock
);
1831 static struct notifier_block trace_module_nb
= {
1832 .notifier_call
= trace_module_notify
,
1835 #endif /* CONFIG_MODULES */
1837 /* Create a new event directory structure for a trace directory. */
1839 __trace_add_event_dirs(struct trace_array
*tr
)
1841 struct ftrace_event_call
*call
;
1844 list_for_each_entry(call
, &ftrace_events
, list
) {
1845 ret
= __trace_add_new_event(call
, tr
);
1847 pr_warning("Could not create directory for event %s\n",
1852 #ifdef CONFIG_DYNAMIC_FTRACE
1855 #define ENABLE_EVENT_STR "enable_event"
1856 #define DISABLE_EVENT_STR "disable_event"
1858 struct event_probe_data
{
1859 struct ftrace_event_file
*file
;
1860 unsigned long count
;
1865 static struct ftrace_event_file
*
1866 find_event_file(struct trace_array
*tr
, const char *system
, const char *event
)
1868 struct ftrace_event_file
*file
;
1869 struct ftrace_event_call
*call
;
1871 list_for_each_entry(file
, &tr
->events
, list
) {
1873 call
= file
->event_call
;
1875 if (!call
->name
|| !call
->class || !call
->class->reg
)
1878 if (call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)
1881 if (strcmp(event
, call
->name
) == 0 &&
1882 strcmp(system
, call
->class->system
) == 0)
1889 event_enable_probe(unsigned long ip
, unsigned long parent_ip
, void **_data
)
1891 struct event_probe_data
**pdata
= (struct event_probe_data
**)_data
;
1892 struct event_probe_data
*data
= *pdata
;
1898 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
1900 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
1904 event_enable_count_probe(unsigned long ip
, unsigned long parent_ip
, void **_data
)
1906 struct event_probe_data
**pdata
= (struct event_probe_data
**)_data
;
1907 struct event_probe_data
*data
= *pdata
;
1915 /* Skip if the event is in a state we want to switch to */
1916 if (data
->enable
== !(data
->file
->flags
& FTRACE_EVENT_FL_SOFT_DISABLED
))
1919 if (data
->count
!= -1)
1922 event_enable_probe(ip
, parent_ip
, _data
);
1926 event_enable_print(struct seq_file
*m
, unsigned long ip
,
1927 struct ftrace_probe_ops
*ops
, void *_data
)
1929 struct event_probe_data
*data
= _data
;
1931 seq_printf(m
, "%ps:", (void *)ip
);
1933 seq_printf(m
, "%s:%s:%s",
1934 data
->enable
? ENABLE_EVENT_STR
: DISABLE_EVENT_STR
,
1935 data
->file
->event_call
->class->system
,
1936 data
->file
->event_call
->name
);
1938 if (data
->count
== -1)
1939 seq_printf(m
, ":unlimited\n");
1941 seq_printf(m
, ":count=%ld\n", data
->count
);
1947 event_enable_init(struct ftrace_probe_ops
*ops
, unsigned long ip
,
1950 struct event_probe_data
**pdata
= (struct event_probe_data
**)_data
;
1951 struct event_probe_data
*data
= *pdata
;
1958 event_enable_free(struct ftrace_probe_ops
*ops
, unsigned long ip
,
1961 struct event_probe_data
**pdata
= (struct event_probe_data
**)_data
;
1962 struct event_probe_data
*data
= *pdata
;
1964 if (WARN_ON_ONCE(data
->ref
<= 0))
1969 /* Remove the SOFT_MODE flag */
1970 __ftrace_event_enable_disable(data
->file
, 0, 1);
1971 module_put(data
->file
->event_call
->mod
);
1977 static struct ftrace_probe_ops event_enable_probe_ops
= {
1978 .func
= event_enable_probe
,
1979 .print
= event_enable_print
,
1980 .init
= event_enable_init
,
1981 .free
= event_enable_free
,
1984 static struct ftrace_probe_ops event_enable_count_probe_ops
= {
1985 .func
= event_enable_count_probe
,
1986 .print
= event_enable_print
,
1987 .init
= event_enable_init
,
1988 .free
= event_enable_free
,
1991 static struct ftrace_probe_ops event_disable_probe_ops
= {
1992 .func
= event_enable_probe
,
1993 .print
= event_enable_print
,
1994 .init
= event_enable_init
,
1995 .free
= event_enable_free
,
1998 static struct ftrace_probe_ops event_disable_count_probe_ops
= {
1999 .func
= event_enable_count_probe
,
2000 .print
= event_enable_print
,
2001 .init
= event_enable_init
,
2002 .free
= event_enable_free
,
2006 event_enable_func(struct ftrace_hash
*hash
,
2007 char *glob
, char *cmd
, char *param
, int enabled
)
2009 struct trace_array
*tr
= top_trace_array();
2010 struct ftrace_event_file
*file
;
2011 struct ftrace_probe_ops
*ops
;
2012 struct event_probe_data
*data
;
2019 /* hash funcs only work with set_ftrace_filter */
2020 if (!enabled
|| !param
)
2023 system
= strsep(¶m
, ":");
2027 event
= strsep(¶m
, ":");
2029 mutex_lock(&event_mutex
);
2032 file
= find_event_file(tr
, system
, event
);
2036 enable
= strcmp(cmd
, ENABLE_EVENT_STR
) == 0;
2039 ops
= param
? &event_enable_count_probe_ops
: &event_enable_probe_ops
;
2041 ops
= param
? &event_disable_count_probe_ops
: &event_disable_probe_ops
;
2043 if (glob
[0] == '!') {
2044 unregister_ftrace_function_probe_func(glob
+1, ops
);
2050 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
2054 data
->enable
= enable
;
2061 number
= strsep(¶m
, ":");
2064 if (!strlen(number
))
2068 * We use the callback data field (which is a pointer)
2071 ret
= kstrtoul(number
, 0, &data
->count
);
2076 /* Don't let event modules unload while probe registered */
2077 ret
= try_module_get(file
->event_call
->mod
);
2083 ret
= __ftrace_event_enable_disable(file
, 1, 1);
2086 ret
= register_ftrace_function_probe(glob
, ops
, data
);
2088 * The above returns on success the # of functions enabled,
2089 * but if it didn't find any functions it returns zero.
2090 * Consider no functions a failure too.
2097 /* Just return zero, not the number of enabled functions */
2100 mutex_unlock(&event_mutex
);
2104 __ftrace_event_enable_disable(file
, 0, 1);
2106 module_put(file
->event_call
->mod
);
2112 static struct ftrace_func_command event_enable_cmd
= {
2113 .name
= ENABLE_EVENT_STR
,
2114 .func
= event_enable_func
,
2117 static struct ftrace_func_command event_disable_cmd
= {
2118 .name
= DISABLE_EVENT_STR
,
2119 .func
= event_enable_func
,
2122 static __init
int register_event_cmds(void)
2126 ret
= register_ftrace_command(&event_enable_cmd
);
2127 if (WARN_ON(ret
< 0))
2129 ret
= register_ftrace_command(&event_disable_cmd
);
2130 if (WARN_ON(ret
< 0))
2131 unregister_ftrace_command(&event_enable_cmd
);
2135 static inline int register_event_cmds(void) { return 0; }
2136 #endif /* CONFIG_DYNAMIC_FTRACE */
2139 * The top level array has already had its ftrace_event_file
2140 * descriptors created in order to allow for early events to
2141 * be recorded. This function is called after the debugfs has been
2142 * initialized, and we now have to create the files associated
2146 __trace_early_add_event_dirs(struct trace_array
*tr
)
2148 struct ftrace_event_file
*file
;
2152 list_for_each_entry(file
, &tr
->events
, list
) {
2153 ret
= event_create_dir(tr
->event_dir
, file
);
2155 pr_warning("Could not create directory for event %s\n",
2156 file
->event_call
->name
);
2161 * For early boot up, the top trace array requires to have
2162 * a list of events that can be enabled. This must be done before
2163 * the filesystem is set up in order to allow events to be traced
2167 __trace_early_add_events(struct trace_array
*tr
)
2169 struct ftrace_event_call
*call
;
2172 list_for_each_entry(call
, &ftrace_events
, list
) {
2173 /* Early boot up should not have any modules loaded */
2174 if (WARN_ON_ONCE(call
->mod
))
2177 ret
= __trace_early_add_new_event(call
, tr
);
2179 pr_warning("Could not create early event %s\n",
2184 /* Remove the event directory structure for a trace directory. */
2186 __trace_remove_event_dirs(struct trace_array
*tr
)
2188 struct ftrace_event_file
*file
, *next
;
2190 list_for_each_entry_safe(file
, next
, &tr
->events
, list
)
2191 remove_event_file_dir(file
);
2194 static void __add_event_to_tracers(struct ftrace_event_call
*call
)
2196 struct trace_array
*tr
;
2198 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
)
2199 __trace_add_new_event(call
, tr
);
2202 extern struct ftrace_event_call
*__start_ftrace_events
[];
2203 extern struct ftrace_event_call
*__stop_ftrace_events
[];
2205 static char bootup_event_buf
[COMMAND_LINE_SIZE
] __initdata
;
2207 static __init
int setup_trace_event(char *str
)
2209 strlcpy(bootup_event_buf
, str
, COMMAND_LINE_SIZE
);
2210 ring_buffer_expanded
= true;
2211 tracing_selftest_disabled
= true;
2215 __setup("trace_event=", setup_trace_event
);
2217 /* Expects to have event_mutex held when called */
2219 create_event_toplevel_files(struct dentry
*parent
, struct trace_array
*tr
)
2221 struct dentry
*d_events
;
2222 struct dentry
*entry
;
2224 entry
= debugfs_create_file("set_event", 0644, parent
,
2225 tr
, &ftrace_set_event_fops
);
2227 pr_warning("Could not create debugfs 'set_event' entry\n");
2231 d_events
= debugfs_create_dir("events", parent
);
2233 pr_warning("Could not create debugfs 'events' directory\n");
2237 /* ring buffer internal formats */
2238 trace_create_file("header_page", 0444, d_events
,
2239 ring_buffer_print_page_header
,
2240 &ftrace_show_header_fops
);
2242 trace_create_file("header_event", 0444, d_events
,
2243 ring_buffer_print_entry_header
,
2244 &ftrace_show_header_fops
);
2246 trace_create_file("enable", 0644, d_events
,
2247 tr
, &ftrace_tr_enable_fops
);
2249 tr
->event_dir
= d_events
;
2255 * event_trace_add_tracer - add a instance of a trace_array to events
2256 * @parent: The parent dentry to place the files/directories for events in
2257 * @tr: The trace array associated with these events
2259 * When a new instance is created, it needs to set up its events
2260 * directory, as well as other files associated with events. It also
2261 * creates the event hierachry in the @parent/events directory.
2263 * Returns 0 on success.
2265 int event_trace_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
2269 mutex_lock(&event_mutex
);
2271 ret
= create_event_toplevel_files(parent
, tr
);
2275 down_write(&trace_event_sem
);
2276 __trace_add_event_dirs(tr
);
2277 up_write(&trace_event_sem
);
2280 mutex_unlock(&event_mutex
);
2286 * The top trace array already had its file descriptors created.
2287 * Now the files themselves need to be created.
2290 early_event_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
2294 mutex_lock(&event_mutex
);
2296 ret
= create_event_toplevel_files(parent
, tr
);
2300 down_write(&trace_event_sem
);
2301 __trace_early_add_event_dirs(tr
);
2302 up_write(&trace_event_sem
);
2305 mutex_unlock(&event_mutex
);
2310 int event_trace_del_tracer(struct trace_array
*tr
)
2312 mutex_lock(&event_mutex
);
2314 /* Disable any running events */
2315 __ftrace_set_clr_event_nolock(tr
, NULL
, NULL
, NULL
, 0);
2317 /* Access to events are within rcu_read_lock_sched() */
2318 synchronize_sched();
2320 down_write(&trace_event_sem
);
2321 __trace_remove_event_dirs(tr
);
2322 debugfs_remove_recursive(tr
->event_dir
);
2323 up_write(&trace_event_sem
);
2325 tr
->event_dir
= NULL
;
2327 mutex_unlock(&event_mutex
);
2332 static __init
int event_trace_memsetup(void)
2334 field_cachep
= KMEM_CACHE(ftrace_event_field
, SLAB_PANIC
);
2335 file_cachep
= KMEM_CACHE(ftrace_event_file
, SLAB_PANIC
);
2339 static __init
int event_trace_enable(void)
2341 struct trace_array
*tr
= top_trace_array();
2342 struct ftrace_event_call
**iter
, *call
;
2343 char *buf
= bootup_event_buf
;
2347 for_each_event(iter
, __start_ftrace_events
, __stop_ftrace_events
) {
2350 ret
= event_init(call
);
2352 list_add(&call
->list
, &ftrace_events
);
2356 * We need the top trace array to have a working set of trace
2357 * points at early init, before the debug files and directories
2358 * are created. Create the file entries now, and attach them
2359 * to the actual file dentries later.
2361 __trace_early_add_events(tr
);
2364 token
= strsep(&buf
, ",");
2371 ret
= ftrace_set_clr_event(tr
, token
, 1);
2373 pr_warn("Failed to enable trace event: %s\n", token
);
2376 trace_printk_start_comm();
2378 register_event_cmds();
2383 static __init
int event_trace_init(void)
2385 struct trace_array
*tr
;
2386 struct dentry
*d_tracer
;
2387 struct dentry
*entry
;
2390 tr
= top_trace_array();
2392 d_tracer
= tracing_init_dentry();
2396 entry
= debugfs_create_file("available_events", 0444, d_tracer
,
2397 tr
, &ftrace_avail_fops
);
2399 pr_warning("Could not create debugfs "
2400 "'available_events' entry\n");
2402 if (trace_define_common_fields())
2403 pr_warning("tracing: Failed to allocate common fields");
2405 ret
= early_event_add_tracer(d_tracer
, tr
);
2409 #ifdef CONFIG_MODULES
2410 ret
= register_module_notifier(&trace_module_nb
);
2412 pr_warning("Failed to register trace events module notifier\n");
2416 early_initcall(event_trace_memsetup
);
2417 core_initcall(event_trace_enable
);
2418 fs_initcall(event_trace_init
);
2420 #ifdef CONFIG_FTRACE_STARTUP_TEST
2422 static DEFINE_SPINLOCK(test_spinlock
);
2423 static DEFINE_SPINLOCK(test_spinlock_irq
);
2424 static DEFINE_MUTEX(test_mutex
);
2426 static __init
void test_work(struct work_struct
*dummy
)
2428 spin_lock(&test_spinlock
);
2429 spin_lock_irq(&test_spinlock_irq
);
2431 spin_unlock_irq(&test_spinlock_irq
);
2432 spin_unlock(&test_spinlock
);
2434 mutex_lock(&test_mutex
);
2436 mutex_unlock(&test_mutex
);
2439 static __init
int event_test_thread(void *unused
)
2443 test_malloc
= kmalloc(1234, GFP_KERNEL
);
2445 pr_info("failed to kmalloc\n");
2447 schedule_on_each_cpu(test_work
);
2451 set_current_state(TASK_INTERRUPTIBLE
);
2452 while (!kthread_should_stop())
2459 * Do various things that may trigger events.
2461 static __init
void event_test_stuff(void)
2463 struct task_struct
*test_thread
;
2465 test_thread
= kthread_run(event_test_thread
, NULL
, "test-events");
2467 kthread_stop(test_thread
);
2471 * For every trace event defined, we will test each trace point separately,
2472 * and then by groups, and finally all trace points.
2474 static __init
void event_trace_self_tests(void)
2476 struct ftrace_subsystem_dir
*dir
;
2477 struct ftrace_event_file
*file
;
2478 struct ftrace_event_call
*call
;
2479 struct event_subsystem
*system
;
2480 struct trace_array
*tr
;
2483 tr
= top_trace_array();
2485 pr_info("Running tests on trace events:\n");
2487 list_for_each_entry(file
, &tr
->events
, list
) {
2489 call
= file
->event_call
;
2491 /* Only test those that have a probe */
2492 if (!call
->class || !call
->class->probe
)
2496 * Testing syscall events here is pretty useless, but
2497 * we still do it if configured. But this is time consuming.
2498 * What we really need is a user thread to perform the
2499 * syscalls as we test.
2501 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
2502 if (call
->class->system
&&
2503 strcmp(call
->class->system
, "syscalls") == 0)
2507 pr_info("Testing event %s: ", call
->name
);
2510 * If an event is already enabled, someone is using
2511 * it and the self test should not be on.
2513 if (file
->flags
& FTRACE_EVENT_FL_ENABLED
) {
2514 pr_warning("Enabled event during self test!\n");
2519 ftrace_event_enable_disable(file
, 1);
2521 ftrace_event_enable_disable(file
, 0);
2526 /* Now test at the sub system level */
2528 pr_info("Running tests on trace event systems:\n");
2530 list_for_each_entry(dir
, &tr
->systems
, list
) {
2532 system
= dir
->subsystem
;
2534 /* the ftrace system is special, skip it */
2535 if (strcmp(system
->name
, "ftrace") == 0)
2538 pr_info("Testing event system %s: ", system
->name
);
2540 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 1);
2541 if (WARN_ON_ONCE(ret
)) {
2542 pr_warning("error enabling system %s\n",
2549 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 0);
2550 if (WARN_ON_ONCE(ret
)) {
2551 pr_warning("error disabling system %s\n",
2559 /* Test with all events enabled */
2561 pr_info("Running tests on all trace events:\n");
2562 pr_info("Testing all events: ");
2564 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 1);
2565 if (WARN_ON_ONCE(ret
)) {
2566 pr_warning("error enabling all events\n");
2573 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 0);
2574 if (WARN_ON_ONCE(ret
)) {
2575 pr_warning("error disabling all events\n");
2582 #ifdef CONFIG_FUNCTION_TRACER
2584 static DEFINE_PER_CPU(atomic_t
, ftrace_test_event_disable
);
2587 function_test_events_call(unsigned long ip
, unsigned long parent_ip
,
2588 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
2590 struct ring_buffer_event
*event
;
2591 struct ring_buffer
*buffer
;
2592 struct ftrace_entry
*entry
;
2593 unsigned long flags
;
2598 pc
= preempt_count();
2599 preempt_disable_notrace();
2600 cpu
= raw_smp_processor_id();
2601 disabled
= atomic_inc_return(&per_cpu(ftrace_test_event_disable
, cpu
));
2606 local_save_flags(flags
);
2608 event
= trace_current_buffer_lock_reserve(&buffer
,
2609 TRACE_FN
, sizeof(*entry
),
2613 entry
= ring_buffer_event_data(event
);
2615 entry
->parent_ip
= parent_ip
;
2617 trace_buffer_unlock_commit(buffer
, event
, flags
, pc
);
2620 atomic_dec(&per_cpu(ftrace_test_event_disable
, cpu
));
2621 preempt_enable_notrace();
2624 static struct ftrace_ops trace_ops __initdata
=
2626 .func
= function_test_events_call
,
2627 .flags
= FTRACE_OPS_FL_RECURSION_SAFE
,
2630 static __init
void event_trace_self_test_with_function(void)
2633 ret
= register_ftrace_function(&trace_ops
);
2634 if (WARN_ON(ret
< 0)) {
2635 pr_info("Failed to enable function tracer for event tests\n");
2638 pr_info("Running tests again, along with the function tracer\n");
2639 event_trace_self_tests();
2640 unregister_ftrace_function(&trace_ops
);
2643 static __init
void event_trace_self_test_with_function(void)
2648 static __init
int event_trace_self_tests_init(void)
2650 if (!tracing_selftest_disabled
) {
2651 event_trace_self_tests();
2652 event_trace_self_test_with_function();
2658 late_initcall(event_trace_self_tests_init
);