1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
7 * - Added format output of fields of the trace point.
8 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
12 #define pr_fmt(fmt) fmt
14 #include <linux/workqueue.h>
15 #include <linux/security.h>
16 #include <linux/spinlock.h>
17 #include <linux/kthread.h>
18 #include <linux/tracefs.h>
19 #include <linux/uaccess.h>
20 #include <linux/module.h>
21 #include <linux/ctype.h>
22 #include <linux/sort.h>
23 #include <linux/slab.h>
24 #include <linux/delay.h>
26 #include <trace/events/sched.h>
28 #include <asm/setup.h>
30 #include "trace_output.h"
33 #define TRACE_SYSTEM "TRACE_SYSTEM"
35 DEFINE_MUTEX(event_mutex
);
37 LIST_HEAD(ftrace_events
);
38 static LIST_HEAD(ftrace_generic_fields
);
39 static LIST_HEAD(ftrace_common_fields
);
41 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
43 static struct kmem_cache
*field_cachep
;
44 static struct kmem_cache
*file_cachep
;
46 static inline int system_refcount(struct event_subsystem
*system
)
48 return system
->ref_count
;
51 static int system_refcount_inc(struct event_subsystem
*system
)
53 return system
->ref_count
++;
56 static int system_refcount_dec(struct event_subsystem
*system
)
58 return --system
->ref_count
;
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 trace_event_file *___n; \
69 list_for_each_entry_safe(file, ___n, &tr->events, list)
71 #define while_for_each_event_file() \
74 static struct ftrace_event_field
*
75 __find_event_field(struct list_head
*head
, char *name
)
77 struct ftrace_event_field
*field
;
79 list_for_each_entry(field
, head
, link
) {
80 if (!strcmp(field
->name
, name
))
87 struct ftrace_event_field
*
88 trace_find_event_field(struct trace_event_call
*call
, char *name
)
90 struct ftrace_event_field
*field
;
91 struct list_head
*head
;
93 head
= trace_get_fields(call
);
94 field
= __find_event_field(head
, name
);
98 field
= __find_event_field(&ftrace_generic_fields
, name
);
102 return __find_event_field(&ftrace_common_fields
, name
);
105 static int __trace_define_field(struct list_head
*head
, const char *type
,
106 const char *name
, int offset
, int size
,
107 int is_signed
, int filter_type
)
109 struct ftrace_event_field
*field
;
111 field
= kmem_cache_alloc(field_cachep
, GFP_TRACE
);
118 if (filter_type
== FILTER_OTHER
)
119 field
->filter_type
= filter_assign_type(type
);
121 field
->filter_type
= filter_type
;
123 field
->offset
= offset
;
125 field
->is_signed
= is_signed
;
127 list_add(&field
->link
, head
);
132 int trace_define_field(struct trace_event_call
*call
, const char *type
,
133 const char *name
, int offset
, int size
, int is_signed
,
136 struct list_head
*head
;
138 if (WARN_ON(!call
->class))
141 head
= trace_get_fields(call
);
142 return __trace_define_field(head
, type
, name
, offset
, size
,
143 is_signed
, filter_type
);
145 EXPORT_SYMBOL_GPL(trace_define_field
);
147 #define __generic_field(type, item, filter_type) \
148 ret = __trace_define_field(&ftrace_generic_fields, #type, \
149 #item, 0, 0, is_signed_type(type), \
154 #define __common_field(type, item) \
155 ret = __trace_define_field(&ftrace_common_fields, #type, \
157 offsetof(typeof(ent), item), \
159 is_signed_type(type), FILTER_OTHER); \
163 static int trace_define_generic_fields(void)
167 __generic_field(int, CPU
, FILTER_CPU
);
168 __generic_field(int, cpu
, FILTER_CPU
);
169 __generic_field(char *, COMM
, FILTER_COMM
);
170 __generic_field(char *, comm
, FILTER_COMM
);
175 static int trace_define_common_fields(void)
178 struct trace_entry ent
;
180 __common_field(unsigned short, type
);
181 __common_field(unsigned char, flags
);
182 __common_field(unsigned char, preempt_count
);
183 __common_field(int, pid
);
188 static void trace_destroy_fields(struct trace_event_call
*call
)
190 struct ftrace_event_field
*field
, *next
;
191 struct list_head
*head
;
193 head
= trace_get_fields(call
);
194 list_for_each_entry_safe(field
, next
, head
, link
) {
195 list_del(&field
->link
);
196 kmem_cache_free(field_cachep
, field
);
201 * run-time version of trace_event_get_offsets_<call>() that returns the last
202 * accessible offset of trace fields excluding __dynamic_array bytes
204 int trace_event_get_offsets(struct trace_event_call
*call
)
206 struct ftrace_event_field
*tail
;
207 struct list_head
*head
;
209 head
= trace_get_fields(call
);
211 * head->next points to the last field with the largest offset,
212 * since it was added last by trace_define_field()
214 tail
= list_first_entry(head
, struct ftrace_event_field
, link
);
215 return tail
->offset
+ tail
->size
;
218 int trace_event_raw_init(struct trace_event_call
*call
)
222 id
= register_trace_event(&call
->event
);
228 EXPORT_SYMBOL_GPL(trace_event_raw_init
);
230 bool trace_event_ignore_this_pid(struct trace_event_file
*trace_file
)
232 struct trace_array
*tr
= trace_file
->tr
;
233 struct trace_array_cpu
*data
;
234 struct trace_pid_list
*pid_list
;
236 pid_list
= rcu_dereference_raw(tr
->filtered_pids
);
240 data
= this_cpu_ptr(tr
->trace_buffer
.data
);
242 return data
->ignore_pid
;
244 EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid
);
246 void *trace_event_buffer_reserve(struct trace_event_buffer
*fbuffer
,
247 struct trace_event_file
*trace_file
,
250 struct trace_event_call
*event_call
= trace_file
->event_call
;
252 if ((trace_file
->flags
& EVENT_FILE_FL_PID_FILTER
) &&
253 trace_event_ignore_this_pid(trace_file
))
256 local_save_flags(fbuffer
->flags
);
257 fbuffer
->pc
= preempt_count();
259 * If CONFIG_PREEMPTION is enabled, then the tracepoint itself disables
260 * preemption (adding one to the preempt_count). Since we are
261 * interested in the preempt_count at the time the tracepoint was
262 * hit, we need to subtract one to offset the increment.
264 if (IS_ENABLED(CONFIG_PREEMPTION
))
266 fbuffer
->trace_file
= trace_file
;
269 trace_event_buffer_lock_reserve(&fbuffer
->buffer
, trace_file
,
270 event_call
->event
.type
, len
,
271 fbuffer
->flags
, fbuffer
->pc
);
275 fbuffer
->entry
= ring_buffer_event_data(fbuffer
->event
);
276 return fbuffer
->entry
;
278 EXPORT_SYMBOL_GPL(trace_event_buffer_reserve
);
280 int trace_event_reg(struct trace_event_call
*call
,
281 enum trace_reg type
, void *data
)
283 struct trace_event_file
*file
= data
;
285 WARN_ON(!(call
->flags
& TRACE_EVENT_FL_TRACEPOINT
));
287 case TRACE_REG_REGISTER
:
288 return tracepoint_probe_register(call
->tp
,
291 case TRACE_REG_UNREGISTER
:
292 tracepoint_probe_unregister(call
->tp
,
297 #ifdef CONFIG_PERF_EVENTS
298 case TRACE_REG_PERF_REGISTER
:
299 return tracepoint_probe_register(call
->tp
,
300 call
->class->perf_probe
,
302 case TRACE_REG_PERF_UNREGISTER
:
303 tracepoint_probe_unregister(call
->tp
,
304 call
->class->perf_probe
,
307 case TRACE_REG_PERF_OPEN
:
308 case TRACE_REG_PERF_CLOSE
:
309 case TRACE_REG_PERF_ADD
:
310 case TRACE_REG_PERF_DEL
:
316 EXPORT_SYMBOL_GPL(trace_event_reg
);
318 void trace_event_enable_cmd_record(bool enable
)
320 struct trace_event_file
*file
;
321 struct trace_array
*tr
;
323 mutex_lock(&event_mutex
);
324 do_for_each_event_file(tr
, file
) {
326 if (!(file
->flags
& EVENT_FILE_FL_ENABLED
))
330 tracing_start_cmdline_record();
331 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT
, &file
->flags
);
333 tracing_stop_cmdline_record();
334 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT
, &file
->flags
);
336 } while_for_each_event_file();
337 mutex_unlock(&event_mutex
);
340 void trace_event_enable_tgid_record(bool enable
)
342 struct trace_event_file
*file
;
343 struct trace_array
*tr
;
345 mutex_lock(&event_mutex
);
346 do_for_each_event_file(tr
, file
) {
347 if (!(file
->flags
& EVENT_FILE_FL_ENABLED
))
351 tracing_start_tgid_record();
352 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT
, &file
->flags
);
354 tracing_stop_tgid_record();
355 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT
,
358 } while_for_each_event_file();
359 mutex_unlock(&event_mutex
);
362 static int __ftrace_event_enable_disable(struct trace_event_file
*file
,
363 int enable
, int soft_disable
)
365 struct trace_event_call
*call
= file
->event_call
;
366 struct trace_array
*tr
= file
->tr
;
367 unsigned long file_flags
= file
->flags
;
374 * When soft_disable is set and enable is cleared, the sm_ref
375 * reference counter is decremented. If it reaches 0, we want
376 * to clear the SOFT_DISABLED flag but leave the event in the
377 * state that it was. That is, if the event was enabled and
378 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
379 * is set we do not want the event to be enabled before we
382 * When soft_disable is not set but the SOFT_MODE flag is,
383 * we do nothing. Do not disable the tracepoint, otherwise
384 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
387 if (atomic_dec_return(&file
->sm_ref
) > 0)
389 disable
= file
->flags
& EVENT_FILE_FL_SOFT_DISABLED
;
390 clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT
, &file
->flags
);
392 disable
= !(file
->flags
& EVENT_FILE_FL_SOFT_MODE
);
394 if (disable
&& (file
->flags
& EVENT_FILE_FL_ENABLED
)) {
395 clear_bit(EVENT_FILE_FL_ENABLED_BIT
, &file
->flags
);
396 if (file
->flags
& EVENT_FILE_FL_RECORDED_CMD
) {
397 tracing_stop_cmdline_record();
398 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT
, &file
->flags
);
401 if (file
->flags
& EVENT_FILE_FL_RECORDED_TGID
) {
402 tracing_stop_tgid_record();
403 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT
, &file
->flags
);
406 call
->class->reg(call
, TRACE_REG_UNREGISTER
, file
);
408 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
409 if (file
->flags
& EVENT_FILE_FL_SOFT_MODE
)
410 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &file
->flags
);
412 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &file
->flags
);
416 * When soft_disable is set and enable is set, we want to
417 * register the tracepoint for the event, but leave the event
418 * as is. That means, if the event was already enabled, we do
419 * nothing (but set SOFT_MODE). If the event is disabled, we
420 * set SOFT_DISABLED before enabling the event tracepoint, so
421 * it still seems to be disabled.
424 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &file
->flags
);
426 if (atomic_inc_return(&file
->sm_ref
) > 1)
428 set_bit(EVENT_FILE_FL_SOFT_MODE_BIT
, &file
->flags
);
431 if (!(file
->flags
& EVENT_FILE_FL_ENABLED
)) {
432 bool cmd
= false, tgid
= false;
434 /* Keep the event disabled, when going to SOFT_MODE. */
436 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &file
->flags
);
438 if (tr
->trace_flags
& TRACE_ITER_RECORD_CMD
) {
440 tracing_start_cmdline_record();
441 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT
, &file
->flags
);
444 if (tr
->trace_flags
& TRACE_ITER_RECORD_TGID
) {
446 tracing_start_tgid_record();
447 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT
, &file
->flags
);
450 ret
= call
->class->reg(call
, TRACE_REG_REGISTER
, file
);
453 tracing_stop_cmdline_record();
455 tracing_stop_tgid_record();
456 pr_info("event trace: Could not enable event "
457 "%s\n", trace_event_name(call
));
460 set_bit(EVENT_FILE_FL_ENABLED_BIT
, &file
->flags
);
462 /* WAS_ENABLED gets set but never cleared. */
463 set_bit(EVENT_FILE_FL_WAS_ENABLED_BIT
, &file
->flags
);
468 /* Enable or disable use of trace_buffered_event */
469 if ((file_flags
& EVENT_FILE_FL_SOFT_DISABLED
) !=
470 (file
->flags
& EVENT_FILE_FL_SOFT_DISABLED
)) {
471 if (file
->flags
& EVENT_FILE_FL_SOFT_DISABLED
)
472 trace_buffered_event_enable();
474 trace_buffered_event_disable();
480 int trace_event_enable_disable(struct trace_event_file
*file
,
481 int enable
, int soft_disable
)
483 return __ftrace_event_enable_disable(file
, enable
, soft_disable
);
486 static int ftrace_event_enable_disable(struct trace_event_file
*file
,
489 return __ftrace_event_enable_disable(file
, enable
, 0);
492 static void ftrace_clear_events(struct trace_array
*tr
)
494 struct trace_event_file
*file
;
496 mutex_lock(&event_mutex
);
497 list_for_each_entry(file
, &tr
->events
, list
) {
498 ftrace_event_enable_disable(file
, 0);
500 mutex_unlock(&event_mutex
);
504 event_filter_pid_sched_process_exit(void *data
, struct task_struct
*task
)
506 struct trace_pid_list
*pid_list
;
507 struct trace_array
*tr
= data
;
509 pid_list
= rcu_dereference_raw(tr
->filtered_pids
);
510 trace_filter_add_remove_task(pid_list
, NULL
, task
);
514 event_filter_pid_sched_process_fork(void *data
,
515 struct task_struct
*self
,
516 struct task_struct
*task
)
518 struct trace_pid_list
*pid_list
;
519 struct trace_array
*tr
= data
;
521 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
522 trace_filter_add_remove_task(pid_list
, self
, task
);
525 void trace_event_follow_fork(struct trace_array
*tr
, bool enable
)
528 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork
,
530 register_trace_prio_sched_process_exit(event_filter_pid_sched_process_exit
,
533 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork
,
535 unregister_trace_sched_process_exit(event_filter_pid_sched_process_exit
,
541 event_filter_pid_sched_switch_probe_pre(void *data
, bool preempt
,
542 struct task_struct
*prev
, struct task_struct
*next
)
544 struct trace_array
*tr
= data
;
545 struct trace_pid_list
*pid_list
;
547 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
549 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
550 trace_ignore_this_task(pid_list
, prev
) &&
551 trace_ignore_this_task(pid_list
, next
));
555 event_filter_pid_sched_switch_probe_post(void *data
, bool preempt
,
556 struct task_struct
*prev
, struct task_struct
*next
)
558 struct trace_array
*tr
= data
;
559 struct trace_pid_list
*pid_list
;
561 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
563 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
564 trace_ignore_this_task(pid_list
, next
));
568 event_filter_pid_sched_wakeup_probe_pre(void *data
, struct task_struct
*task
)
570 struct trace_array
*tr
= data
;
571 struct trace_pid_list
*pid_list
;
573 /* Nothing to do if we are already tracing */
574 if (!this_cpu_read(tr
->trace_buffer
.data
->ignore_pid
))
577 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
579 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
580 trace_ignore_this_task(pid_list
, task
));
584 event_filter_pid_sched_wakeup_probe_post(void *data
, struct task_struct
*task
)
586 struct trace_array
*tr
= data
;
587 struct trace_pid_list
*pid_list
;
589 /* Nothing to do if we are not tracing */
590 if (this_cpu_read(tr
->trace_buffer
.data
->ignore_pid
))
593 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
595 /* Set tracing if current is enabled */
596 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
597 trace_ignore_this_task(pid_list
, current
));
600 static void __ftrace_clear_event_pids(struct trace_array
*tr
)
602 struct trace_pid_list
*pid_list
;
603 struct trace_event_file
*file
;
606 pid_list
= rcu_dereference_protected(tr
->filtered_pids
,
607 lockdep_is_held(&event_mutex
));
611 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre
, tr
);
612 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post
, tr
);
614 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre
, tr
);
615 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post
, tr
);
617 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre
, tr
);
618 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post
, tr
);
620 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre
, tr
);
621 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post
, tr
);
623 list_for_each_entry(file
, &tr
->events
, list
) {
624 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT
, &file
->flags
);
627 for_each_possible_cpu(cpu
)
628 per_cpu_ptr(tr
->trace_buffer
.data
, cpu
)->ignore_pid
= false;
630 rcu_assign_pointer(tr
->filtered_pids
, NULL
);
632 /* Wait till all users are no longer using pid filtering */
633 tracepoint_synchronize_unregister();
635 trace_free_pid_list(pid_list
);
638 static void ftrace_clear_event_pids(struct trace_array
*tr
)
640 mutex_lock(&event_mutex
);
641 __ftrace_clear_event_pids(tr
);
642 mutex_unlock(&event_mutex
);
645 static void __put_system(struct event_subsystem
*system
)
647 struct event_filter
*filter
= system
->filter
;
649 WARN_ON_ONCE(system_refcount(system
) == 0);
650 if (system_refcount_dec(system
))
653 list_del(&system
->list
);
656 kfree(filter
->filter_string
);
659 kfree_const(system
->name
);
663 static void __get_system(struct event_subsystem
*system
)
665 WARN_ON_ONCE(system_refcount(system
) == 0);
666 system_refcount_inc(system
);
669 static void __get_system_dir(struct trace_subsystem_dir
*dir
)
671 WARN_ON_ONCE(dir
->ref_count
== 0);
673 __get_system(dir
->subsystem
);
676 static void __put_system_dir(struct trace_subsystem_dir
*dir
)
678 WARN_ON_ONCE(dir
->ref_count
== 0);
679 /* If the subsystem is about to be freed, the dir must be too */
680 WARN_ON_ONCE(system_refcount(dir
->subsystem
) == 1 && dir
->ref_count
!= 1);
682 __put_system(dir
->subsystem
);
683 if (!--dir
->ref_count
)
687 static void put_system(struct trace_subsystem_dir
*dir
)
689 mutex_lock(&event_mutex
);
690 __put_system_dir(dir
);
691 mutex_unlock(&event_mutex
);
694 static void remove_subsystem(struct trace_subsystem_dir
*dir
)
699 if (!--dir
->nr_events
) {
700 tracefs_remove_recursive(dir
->entry
);
701 list_del(&dir
->list
);
702 __put_system_dir(dir
);
706 static void remove_event_file_dir(struct trace_event_file
*file
)
708 struct dentry
*dir
= file
->dir
;
709 struct dentry
*child
;
712 spin_lock(&dir
->d_lock
); /* probably unneeded */
713 list_for_each_entry(child
, &dir
->d_subdirs
, d_child
) {
714 if (d_really_is_positive(child
)) /* probably unneeded */
715 d_inode(child
)->i_private
= NULL
;
717 spin_unlock(&dir
->d_lock
);
719 tracefs_remove_recursive(dir
);
722 list_del(&file
->list
);
723 remove_subsystem(file
->system
);
724 free_event_filter(file
->filter
);
725 kmem_cache_free(file_cachep
, file
);
729 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
732 __ftrace_set_clr_event_nolock(struct trace_array
*tr
, const char *match
,
733 const char *sub
, const char *event
, int set
)
735 struct trace_event_file
*file
;
736 struct trace_event_call
*call
;
741 list_for_each_entry(file
, &tr
->events
, list
) {
743 call
= file
->event_call
;
744 name
= trace_event_name(call
);
746 if (!name
|| !call
->class || !call
->class->reg
)
749 if (call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)
753 strcmp(match
, name
) != 0 &&
754 strcmp(match
, call
->class->system
) != 0)
757 if (sub
&& strcmp(sub
, call
->class->system
) != 0)
760 if (event
&& strcmp(event
, name
) != 0)
763 ret
= ftrace_event_enable_disable(file
, set
);
766 * Save the first error and return that. Some events
767 * may still have been enabled, but let the user
768 * know that something went wrong.
779 static int __ftrace_set_clr_event(struct trace_array
*tr
, const char *match
,
780 const char *sub
, const char *event
, int set
)
784 mutex_lock(&event_mutex
);
785 ret
= __ftrace_set_clr_event_nolock(tr
, match
, sub
, event
, set
);
786 mutex_unlock(&event_mutex
);
791 int ftrace_set_clr_event(struct trace_array
*tr
, char *buf
, int set
)
793 char *event
= NULL
, *sub
= NULL
, *match
;
797 * The buf format can be <subsystem>:<event-name>
798 * *:<event-name> means any event by that name.
799 * :<event-name> is the same.
801 * <subsystem>:* means all events in that subsystem
802 * <subsystem>: means the same.
804 * <name> (no ':') means all events in a subsystem with
805 * the name <name> or any event that matches <name>
808 match
= strsep(&buf
, ":");
814 if (!strlen(sub
) || strcmp(sub
, "*") == 0)
816 if (!strlen(event
) || strcmp(event
, "*") == 0)
820 ret
= __ftrace_set_clr_event(tr
, match
, sub
, event
, set
);
822 /* Put back the colon to allow this to be called again */
828 EXPORT_SYMBOL_GPL(ftrace_set_clr_event
);
831 * trace_set_clr_event - enable or disable an event
832 * @system: system name to match (NULL for any system)
833 * @event: event name to match (NULL for all events, within system)
834 * @set: 1 to enable, 0 to disable
836 * This is a way for other parts of the kernel to enable or disable
839 * Returns 0 on success, -EINVAL if the parameters do not match any
842 int trace_set_clr_event(const char *system
, const char *event
, int set
)
844 struct trace_array
*tr
= top_trace_array();
849 return __ftrace_set_clr_event(tr
, NULL
, system
, event
, set
);
851 EXPORT_SYMBOL_GPL(trace_set_clr_event
);
853 /* 128 should be much more than enough */
854 #define EVENT_BUF_SIZE 127
857 ftrace_event_write(struct file
*file
, const char __user
*ubuf
,
858 size_t cnt
, loff_t
*ppos
)
860 struct trace_parser parser
;
861 struct seq_file
*m
= file
->private_data
;
862 struct trace_array
*tr
= m
->private;
868 ret
= tracing_update_buffers();
872 if (trace_parser_get_init(&parser
, EVENT_BUF_SIZE
+ 1))
875 read
= trace_get_user(&parser
, ubuf
, cnt
, ppos
);
877 if (read
>= 0 && trace_parser_loaded((&parser
))) {
880 if (*parser
.buffer
== '!')
883 ret
= ftrace_set_clr_event(tr
, parser
.buffer
+ !set
, set
);
891 trace_parser_put(&parser
);
897 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
899 struct trace_event_file
*file
= v
;
900 struct trace_event_call
*call
;
901 struct trace_array
*tr
= m
->private;
905 list_for_each_entry_continue(file
, &tr
->events
, list
) {
906 call
= file
->event_call
;
908 * The ftrace subsystem is for showing formats only.
909 * They can not be enabled or disabled via the event files.
911 if (call
->class && call
->class->reg
&&
912 !(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
))
919 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
921 struct trace_event_file
*file
;
922 struct trace_array
*tr
= m
->private;
925 mutex_lock(&event_mutex
);
927 file
= list_entry(&tr
->events
, struct trace_event_file
, list
);
928 for (l
= 0; l
<= *pos
; ) {
929 file
= t_next(m
, file
, &l
);
937 s_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
939 struct trace_event_file
*file
= v
;
940 struct trace_array
*tr
= m
->private;
944 list_for_each_entry_continue(file
, &tr
->events
, list
) {
945 if (file
->flags
& EVENT_FILE_FL_ENABLED
)
952 static void *s_start(struct seq_file
*m
, loff_t
*pos
)
954 struct trace_event_file
*file
;
955 struct trace_array
*tr
= m
->private;
958 mutex_lock(&event_mutex
);
960 file
= list_entry(&tr
->events
, struct trace_event_file
, list
);
961 for (l
= 0; l
<= *pos
; ) {
962 file
= s_next(m
, file
, &l
);
969 static int t_show(struct seq_file
*m
, void *v
)
971 struct trace_event_file
*file
= v
;
972 struct trace_event_call
*call
= file
->event_call
;
974 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0)
975 seq_printf(m
, "%s:", call
->class->system
);
976 seq_printf(m
, "%s\n", trace_event_name(call
));
981 static void t_stop(struct seq_file
*m
, void *p
)
983 mutex_unlock(&event_mutex
);
987 p_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
989 struct trace_array
*tr
= m
->private;
990 struct trace_pid_list
*pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
992 return trace_pid_next(pid_list
, v
, pos
);
995 static void *p_start(struct seq_file
*m
, loff_t
*pos
)
998 struct trace_pid_list
*pid_list
;
999 struct trace_array
*tr
= m
->private;
1002 * Grab the mutex, to keep calls to p_next() having the same
1003 * tr->filtered_pids as p_start() has.
1004 * If we just passed the tr->filtered_pids around, then RCU would
1005 * have been enough, but doing that makes things more complex.
1007 mutex_lock(&event_mutex
);
1008 rcu_read_lock_sched();
1010 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
1015 return trace_pid_start(pid_list
, pos
);
1018 static void p_stop(struct seq_file
*m
, void *p
)
1021 rcu_read_unlock_sched();
1022 mutex_unlock(&event_mutex
);
1026 event_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1029 struct trace_event_file
*file
;
1030 unsigned long flags
;
1033 mutex_lock(&event_mutex
);
1034 file
= event_file_data(filp
);
1036 flags
= file
->flags
;
1037 mutex_unlock(&event_mutex
);
1042 if (flags
& EVENT_FILE_FL_ENABLED
&&
1043 !(flags
& EVENT_FILE_FL_SOFT_DISABLED
))
1046 if (flags
& EVENT_FILE_FL_SOFT_DISABLED
||
1047 flags
& EVENT_FILE_FL_SOFT_MODE
)
1052 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, strlen(buf
));
1056 event_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1059 struct trace_event_file
*file
;
1063 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
1067 ret
= tracing_update_buffers();
1075 mutex_lock(&event_mutex
);
1076 file
= event_file_data(filp
);
1078 ret
= ftrace_event_enable_disable(file
, val
);
1079 mutex_unlock(&event_mutex
);
1088 return ret
? ret
: cnt
;
1092 system_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1095 const char set_to_char
[4] = { '?', '0', '1', 'X' };
1096 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1097 struct event_subsystem
*system
= dir
->subsystem
;
1098 struct trace_event_call
*call
;
1099 struct trace_event_file
*file
;
1100 struct trace_array
*tr
= dir
->tr
;
1105 mutex_lock(&event_mutex
);
1106 list_for_each_entry(file
, &tr
->events
, list
) {
1107 call
= file
->event_call
;
1108 if (!trace_event_name(call
) || !call
->class || !call
->class->reg
)
1111 if (system
&& strcmp(call
->class->system
, system
->name
) != 0)
1115 * We need to find out if all the events are set
1116 * or if all events or cleared, or if we have
1119 set
|= (1 << !!(file
->flags
& EVENT_FILE_FL_ENABLED
));
1122 * If we have a mixture, no need to look further.
1127 mutex_unlock(&event_mutex
);
1129 buf
[0] = set_to_char
[set
];
1132 ret
= simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, 2);
1138 system_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1141 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1142 struct event_subsystem
*system
= dir
->subsystem
;
1143 const char *name
= NULL
;
1147 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
1151 ret
= tracing_update_buffers();
1155 if (val
!= 0 && val
!= 1)
1159 * Opening of "enable" adds a ref count to system,
1160 * so the name is safe to use.
1163 name
= system
->name
;
1165 ret
= __ftrace_set_clr_event(dir
->tr
, NULL
, name
, NULL
, val
);
1179 FORMAT_FIELD_SEPERATOR
= 2,
1180 FORMAT_PRINTFMT
= 3,
1183 static void *f_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1185 struct trace_event_call
*call
= event_file_data(m
->private);
1186 struct list_head
*common_head
= &ftrace_common_fields
;
1187 struct list_head
*head
= trace_get_fields(call
);
1188 struct list_head
*node
= v
;
1192 switch ((unsigned long)v
) {
1197 case FORMAT_FIELD_SEPERATOR
:
1201 case FORMAT_PRINTFMT
:
1207 if (node
== common_head
)
1208 return (void *)FORMAT_FIELD_SEPERATOR
;
1209 else if (node
== head
)
1210 return (void *)FORMAT_PRINTFMT
;
1215 static int f_show(struct seq_file
*m
, void *v
)
1217 struct trace_event_call
*call
= event_file_data(m
->private);
1218 struct ftrace_event_field
*field
;
1219 const char *array_descriptor
;
1221 switch ((unsigned long)v
) {
1223 seq_printf(m
, "name: %s\n", trace_event_name(call
));
1224 seq_printf(m
, "ID: %d\n", call
->event
.type
);
1225 seq_puts(m
, "format:\n");
1228 case FORMAT_FIELD_SEPERATOR
:
1232 case FORMAT_PRINTFMT
:
1233 seq_printf(m
, "\nprint fmt: %s\n",
1238 field
= list_entry(v
, struct ftrace_event_field
, link
);
1240 * Smartly shows the array type(except dynamic array).
1243 * If TYPE := TYPE[LEN], it is shown:
1244 * field:TYPE VAR[LEN]
1246 array_descriptor
= strchr(field
->type
, '[');
1248 if (str_has_prefix(field
->type
, "__data_loc"))
1249 array_descriptor
= NULL
;
1251 if (!array_descriptor
)
1252 seq_printf(m
, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1253 field
->type
, field
->name
, field
->offset
,
1254 field
->size
, !!field
->is_signed
);
1256 seq_printf(m
, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1257 (int)(array_descriptor
- field
->type
),
1258 field
->type
, field
->name
,
1259 array_descriptor
, field
->offset
,
1260 field
->size
, !!field
->is_signed
);
1265 static void *f_start(struct seq_file
*m
, loff_t
*pos
)
1267 void *p
= (void *)FORMAT_HEADER
;
1270 /* ->stop() is called even if ->start() fails */
1271 mutex_lock(&event_mutex
);
1272 if (!event_file_data(m
->private))
1273 return ERR_PTR(-ENODEV
);
1275 while (l
< *pos
&& p
)
1276 p
= f_next(m
, p
, &l
);
1281 static void f_stop(struct seq_file
*m
, void *p
)
1283 mutex_unlock(&event_mutex
);
1286 static const struct seq_operations trace_format_seq_ops
= {
1293 static int trace_format_open(struct inode
*inode
, struct file
*file
)
1298 /* Do we want to hide event format files on tracefs lockdown? */
1300 ret
= seq_open(file
, &trace_format_seq_ops
);
1304 m
= file
->private_data
;
1311 event_id_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
1313 int id
= (long)event_file_data(filp
);
1320 len
= sprintf(buf
, "%d\n", id
);
1322 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, len
);
1326 event_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1329 struct trace_event_file
*file
;
1330 struct trace_seq
*s
;
1336 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1343 mutex_lock(&event_mutex
);
1344 file
= event_file_data(filp
);
1346 print_event_filter(file
, s
);
1347 mutex_unlock(&event_mutex
);
1350 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1351 s
->buffer
, trace_seq_used(s
));
1359 event_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1362 struct trace_event_file
*file
;
1366 if (cnt
>= PAGE_SIZE
)
1369 buf
= memdup_user_nul(ubuf
, cnt
);
1371 return PTR_ERR(buf
);
1373 mutex_lock(&event_mutex
);
1374 file
= event_file_data(filp
);
1376 err
= apply_event_filter(file
, buf
);
1377 mutex_unlock(&event_mutex
);
1388 static LIST_HEAD(event_subsystems
);
1390 static int subsystem_open(struct inode
*inode
, struct file
*filp
)
1392 struct event_subsystem
*system
= NULL
;
1393 struct trace_subsystem_dir
*dir
= NULL
; /* Initialize for gcc */
1394 struct trace_array
*tr
;
1397 if (tracing_is_disabled())
1400 /* Make sure the system still exists */
1401 mutex_lock(&event_mutex
);
1402 mutex_lock(&trace_types_lock
);
1403 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
) {
1404 list_for_each_entry(dir
, &tr
->systems
, list
) {
1405 if (dir
== inode
->i_private
) {
1406 /* Don't open systems with no events */
1407 if (dir
->nr_events
) {
1408 __get_system_dir(dir
);
1409 system
= dir
->subsystem
;
1416 mutex_unlock(&trace_types_lock
);
1417 mutex_unlock(&event_mutex
);
1422 /* Some versions of gcc think dir can be uninitialized here */
1425 /* Still need to increment the ref count of the system */
1426 if (trace_array_get(tr
) < 0) {
1431 ret
= tracing_open_generic(inode
, filp
);
1433 trace_array_put(tr
);
1440 static int system_tr_open(struct inode
*inode
, struct file
*filp
)
1442 struct trace_subsystem_dir
*dir
;
1443 struct trace_array
*tr
= inode
->i_private
;
1446 /* Make a temporary dir that has no system but points to tr */
1447 dir
= kzalloc(sizeof(*dir
), GFP_KERNEL
);
1451 ret
= tracing_open_generic_tr(inode
, filp
);
1457 filp
->private_data
= dir
;
1462 static int subsystem_release(struct inode
*inode
, struct file
*file
)
1464 struct trace_subsystem_dir
*dir
= file
->private_data
;
1466 trace_array_put(dir
->tr
);
1469 * If dir->subsystem is NULL, then this is a temporary
1470 * descriptor that was made for a trace_array to enable
1482 subsystem_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1485 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1486 struct event_subsystem
*system
= dir
->subsystem
;
1487 struct trace_seq
*s
;
1493 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1499 print_subsystem_event_filter(system
, s
);
1500 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1501 s
->buffer
, trace_seq_used(s
));
1509 subsystem_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1512 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1516 if (cnt
>= PAGE_SIZE
)
1519 buf
= memdup_user_nul(ubuf
, cnt
);
1521 return PTR_ERR(buf
);
1523 err
= apply_subsystem_event_filter(dir
, buf
);
1534 show_header(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
1536 int (*func
)(struct trace_seq
*s
) = filp
->private_data
;
1537 struct trace_seq
*s
;
1543 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1550 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1551 s
->buffer
, trace_seq_used(s
));
1558 static void ignore_task_cpu(void *data
)
1560 struct trace_array
*tr
= data
;
1561 struct trace_pid_list
*pid_list
;
1564 * This function is called by on_each_cpu() while the
1565 * event_mutex is held.
1567 pid_list
= rcu_dereference_protected(tr
->filtered_pids
,
1568 mutex_is_locked(&event_mutex
));
1570 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
1571 trace_ignore_this_task(pid_list
, current
));
1575 ftrace_event_pid_write(struct file
*filp
, const char __user
*ubuf
,
1576 size_t cnt
, loff_t
*ppos
)
1578 struct seq_file
*m
= filp
->private_data
;
1579 struct trace_array
*tr
= m
->private;
1580 struct trace_pid_list
*filtered_pids
= NULL
;
1581 struct trace_pid_list
*pid_list
;
1582 struct trace_event_file
*file
;
1588 ret
= tracing_update_buffers();
1592 mutex_lock(&event_mutex
);
1594 filtered_pids
= rcu_dereference_protected(tr
->filtered_pids
,
1595 lockdep_is_held(&event_mutex
));
1597 ret
= trace_pid_write(filtered_pids
, &pid_list
, ubuf
, cnt
);
1601 rcu_assign_pointer(tr
->filtered_pids
, pid_list
);
1603 list_for_each_entry(file
, &tr
->events
, list
) {
1604 set_bit(EVENT_FILE_FL_PID_FILTER_BIT
, &file
->flags
);
1607 if (filtered_pids
) {
1608 tracepoint_synchronize_unregister();
1609 trace_free_pid_list(filtered_pids
);
1610 } else if (pid_list
) {
1612 * Register a probe that is called before all other probes
1613 * to set ignore_pid if next or prev do not match.
1614 * Register a probe this is called after all other probes
1615 * to only keep ignore_pid set if next pid matches.
1617 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre
,
1619 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post
,
1622 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre
,
1624 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post
,
1627 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre
,
1629 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post
,
1632 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre
,
1634 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post
,
1639 * Ignoring of pids is done at task switch. But we have to
1640 * check for those tasks that are currently running.
1641 * Always do this in case a pid was appended or removed.
1643 on_each_cpu(ignore_task_cpu
, tr
, 1);
1646 mutex_unlock(&event_mutex
);
1654 static int ftrace_event_avail_open(struct inode
*inode
, struct file
*file
);
1655 static int ftrace_event_set_open(struct inode
*inode
, struct file
*file
);
1656 static int ftrace_event_set_pid_open(struct inode
*inode
, struct file
*file
);
1657 static int ftrace_event_release(struct inode
*inode
, struct file
*file
);
1659 static const struct seq_operations show_event_seq_ops
= {
1666 static const struct seq_operations show_set_event_seq_ops
= {
1673 static const struct seq_operations show_set_pid_seq_ops
= {
1676 .show
= trace_pid_show
,
1680 static const struct file_operations ftrace_avail_fops
= {
1681 .open
= ftrace_event_avail_open
,
1683 .llseek
= seq_lseek
,
1684 .release
= seq_release
,
1687 static const struct file_operations ftrace_set_event_fops
= {
1688 .open
= ftrace_event_set_open
,
1690 .write
= ftrace_event_write
,
1691 .llseek
= seq_lseek
,
1692 .release
= ftrace_event_release
,
1695 static const struct file_operations ftrace_set_event_pid_fops
= {
1696 .open
= ftrace_event_set_pid_open
,
1698 .write
= ftrace_event_pid_write
,
1699 .llseek
= seq_lseek
,
1700 .release
= ftrace_event_release
,
1703 static const struct file_operations ftrace_enable_fops
= {
1704 .open
= tracing_open_generic
,
1705 .read
= event_enable_read
,
1706 .write
= event_enable_write
,
1707 .llseek
= default_llseek
,
1710 static const struct file_operations ftrace_event_format_fops
= {
1711 .open
= trace_format_open
,
1713 .llseek
= seq_lseek
,
1714 .release
= seq_release
,
1717 static const struct file_operations ftrace_event_id_fops
= {
1718 .read
= event_id_read
,
1719 .llseek
= default_llseek
,
1722 static const struct file_operations ftrace_event_filter_fops
= {
1723 .open
= tracing_open_generic
,
1724 .read
= event_filter_read
,
1725 .write
= event_filter_write
,
1726 .llseek
= default_llseek
,
1729 static const struct file_operations ftrace_subsystem_filter_fops
= {
1730 .open
= subsystem_open
,
1731 .read
= subsystem_filter_read
,
1732 .write
= subsystem_filter_write
,
1733 .llseek
= default_llseek
,
1734 .release
= subsystem_release
,
1737 static const struct file_operations ftrace_system_enable_fops
= {
1738 .open
= subsystem_open
,
1739 .read
= system_enable_read
,
1740 .write
= system_enable_write
,
1741 .llseek
= default_llseek
,
1742 .release
= subsystem_release
,
1745 static const struct file_operations ftrace_tr_enable_fops
= {
1746 .open
= system_tr_open
,
1747 .read
= system_enable_read
,
1748 .write
= system_enable_write
,
1749 .llseek
= default_llseek
,
1750 .release
= subsystem_release
,
1753 static const struct file_operations ftrace_show_header_fops
= {
1754 .open
= tracing_open_generic
,
1755 .read
= show_header
,
1756 .llseek
= default_llseek
,
1760 ftrace_event_open(struct inode
*inode
, struct file
*file
,
1761 const struct seq_operations
*seq_ops
)
1766 ret
= security_locked_down(LOCKDOWN_TRACEFS
);
1770 ret
= seq_open(file
, seq_ops
);
1773 m
= file
->private_data
;
1774 /* copy tr over to seq ops */
1775 m
->private = inode
->i_private
;
1780 static int ftrace_event_release(struct inode
*inode
, struct file
*file
)
1782 struct trace_array
*tr
= inode
->i_private
;
1784 trace_array_put(tr
);
1786 return seq_release(inode
, file
);
1790 ftrace_event_avail_open(struct inode
*inode
, struct file
*file
)
1792 const struct seq_operations
*seq_ops
= &show_event_seq_ops
;
1794 /* Checks for tracefs lockdown */
1795 return ftrace_event_open(inode
, file
, seq_ops
);
1799 ftrace_event_set_open(struct inode
*inode
, struct file
*file
)
1801 const struct seq_operations
*seq_ops
= &show_set_event_seq_ops
;
1802 struct trace_array
*tr
= inode
->i_private
;
1805 ret
= tracing_check_open_get_tr(tr
);
1809 if ((file
->f_mode
& FMODE_WRITE
) &&
1810 (file
->f_flags
& O_TRUNC
))
1811 ftrace_clear_events(tr
);
1813 ret
= ftrace_event_open(inode
, file
, seq_ops
);
1815 trace_array_put(tr
);
1820 ftrace_event_set_pid_open(struct inode
*inode
, struct file
*file
)
1822 const struct seq_operations
*seq_ops
= &show_set_pid_seq_ops
;
1823 struct trace_array
*tr
= inode
->i_private
;
1826 ret
= tracing_check_open_get_tr(tr
);
1830 if ((file
->f_mode
& FMODE_WRITE
) &&
1831 (file
->f_flags
& O_TRUNC
))
1832 ftrace_clear_event_pids(tr
);
1834 ret
= ftrace_event_open(inode
, file
, seq_ops
);
1836 trace_array_put(tr
);
1840 static struct event_subsystem
*
1841 create_new_subsystem(const char *name
)
1843 struct event_subsystem
*system
;
1845 /* need to create new entry */
1846 system
= kmalloc(sizeof(*system
), GFP_KERNEL
);
1850 system
->ref_count
= 1;
1852 /* Only allocate if dynamic (kprobes and modules) */
1853 system
->name
= kstrdup_const(name
, GFP_KERNEL
);
1857 system
->filter
= NULL
;
1859 system
->filter
= kzalloc(sizeof(struct event_filter
), GFP_KERNEL
);
1860 if (!system
->filter
)
1863 list_add(&system
->list
, &event_subsystems
);
1868 kfree_const(system
->name
);
1873 static struct dentry
*
1874 event_subsystem_dir(struct trace_array
*tr
, const char *name
,
1875 struct trace_event_file
*file
, struct dentry
*parent
)
1877 struct trace_subsystem_dir
*dir
;
1878 struct event_subsystem
*system
;
1879 struct dentry
*entry
;
1881 /* First see if we did not already create this dir */
1882 list_for_each_entry(dir
, &tr
->systems
, list
) {
1883 system
= dir
->subsystem
;
1884 if (strcmp(system
->name
, name
) == 0) {
1891 /* Now see if the system itself exists. */
1892 list_for_each_entry(system
, &event_subsystems
, list
) {
1893 if (strcmp(system
->name
, name
) == 0)
1896 /* Reset system variable when not found */
1897 if (&system
->list
== &event_subsystems
)
1900 dir
= kmalloc(sizeof(*dir
), GFP_KERNEL
);
1905 system
= create_new_subsystem(name
);
1909 __get_system(system
);
1911 dir
->entry
= tracefs_create_dir(name
, parent
);
1913 pr_warn("Failed to create system directory %s\n", name
);
1914 __put_system(system
);
1921 dir
->subsystem
= system
;
1924 entry
= tracefs_create_file("filter", 0644, dir
->entry
, dir
,
1925 &ftrace_subsystem_filter_fops
);
1927 kfree(system
->filter
);
1928 system
->filter
= NULL
;
1929 pr_warn("Could not create tracefs '%s/filter' entry\n", name
);
1932 trace_create_file("enable", 0644, dir
->entry
, dir
,
1933 &ftrace_system_enable_fops
);
1935 list_add(&dir
->list
, &tr
->systems
);
1942 /* Only print this message if failed on memory allocation */
1943 if (!dir
|| !system
)
1944 pr_warn("No memory to create event subsystem %s\n", name
);
1949 event_create_dir(struct dentry
*parent
, struct trace_event_file
*file
)
1951 struct trace_event_call
*call
= file
->event_call
;
1952 struct trace_array
*tr
= file
->tr
;
1953 struct list_head
*head
;
1954 struct dentry
*d_events
;
1959 * If the trace point header did not define TRACE_SYSTEM
1960 * then the system would be called "TRACE_SYSTEM".
1962 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0) {
1963 d_events
= event_subsystem_dir(tr
, call
->class->system
, file
, parent
);
1969 name
= trace_event_name(call
);
1970 file
->dir
= tracefs_create_dir(name
, d_events
);
1972 pr_warn("Could not create tracefs '%s' directory\n", name
);
1976 if (call
->class->reg
&& !(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
))
1977 trace_create_file("enable", 0644, file
->dir
, file
,
1978 &ftrace_enable_fops
);
1980 #ifdef CONFIG_PERF_EVENTS
1981 if (call
->event
.type
&& call
->class->reg
)
1982 trace_create_file("id", 0444, file
->dir
,
1983 (void *)(long)call
->event
.type
,
1984 &ftrace_event_id_fops
);
1988 * Other events may have the same class. Only update
1989 * the fields if they are not already defined.
1991 head
= trace_get_fields(call
);
1992 if (list_empty(head
)) {
1993 ret
= call
->class->define_fields(call
);
1995 pr_warn("Could not initialize trace point events/%s\n",
2002 * Only event directories that can be enabled should have
2003 * triggers or filters.
2005 if (!(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)) {
2006 trace_create_file("filter", 0644, file
->dir
, file
,
2007 &ftrace_event_filter_fops
);
2009 trace_create_file("trigger", 0644, file
->dir
, file
,
2010 &event_trigger_fops
);
2013 #ifdef CONFIG_HIST_TRIGGERS
2014 trace_create_file("hist", 0444, file
->dir
, file
,
2017 trace_create_file("format", 0444, file
->dir
, call
,
2018 &ftrace_event_format_fops
);
2023 static void remove_event_from_tracers(struct trace_event_call
*call
)
2025 struct trace_event_file
*file
;
2026 struct trace_array
*tr
;
2028 do_for_each_event_file_safe(tr
, file
) {
2029 if (file
->event_call
!= call
)
2032 remove_event_file_dir(file
);
2034 * The do_for_each_event_file_safe() is
2035 * a double loop. After finding the call for this
2036 * trace_array, we use break to jump to the next
2040 } while_for_each_event_file();
2043 static void event_remove(struct trace_event_call
*call
)
2045 struct trace_array
*tr
;
2046 struct trace_event_file
*file
;
2048 do_for_each_event_file(tr
, file
) {
2049 if (file
->event_call
!= call
)
2052 if (file
->flags
& EVENT_FILE_FL_WAS_ENABLED
)
2053 tr
->clear_trace
= true;
2055 ftrace_event_enable_disable(file
, 0);
2057 * The do_for_each_event_file() is
2058 * a double loop. After finding the call for this
2059 * trace_array, we use break to jump to the next
2063 } while_for_each_event_file();
2065 if (call
->event
.funcs
)
2066 __unregister_trace_event(&call
->event
);
2067 remove_event_from_tracers(call
);
2068 list_del(&call
->list
);
2071 static int event_init(struct trace_event_call
*call
)
2076 name
= trace_event_name(call
);
2080 if (call
->class->raw_init
) {
2081 ret
= call
->class->raw_init(call
);
2082 if (ret
< 0 && ret
!= -ENOSYS
)
2083 pr_warn("Could not initialize trace events/%s\n", name
);
2090 __register_event(struct trace_event_call
*call
, struct module
*mod
)
2094 ret
= event_init(call
);
2098 list_add(&call
->list
, &ftrace_events
);
2104 static char *eval_replace(char *ptr
, struct trace_eval_map
*map
, int len
)
2109 /* Find the length of the eval value as a string */
2110 elen
= snprintf(ptr
, 0, "%ld", map
->eval_value
);
2111 /* Make sure there's enough room to replace the string with the value */
2115 snprintf(ptr
, elen
+ 1, "%ld", map
->eval_value
);
2117 /* Get the rest of the string of ptr */
2118 rlen
= strlen(ptr
+ len
);
2119 memmove(ptr
+ elen
, ptr
+ len
, rlen
);
2120 /* Make sure we end the new string */
2121 ptr
[elen
+ rlen
] = 0;
2126 static void update_event_printk(struct trace_event_call
*call
,
2127 struct trace_eval_map
*map
)
2131 int len
= strlen(map
->eval_string
);
2133 for (ptr
= call
->print_fmt
; *ptr
; ptr
++) {
2147 if (isdigit(*ptr
)) {
2151 /* Check for alpha chars like ULL */
2152 } while (isalnum(*ptr
));
2156 * A number must have some kind of delimiter after
2157 * it, and we can ignore that too.
2161 if (isalpha(*ptr
) || *ptr
== '_') {
2162 if (strncmp(map
->eval_string
, ptr
, len
) == 0 &&
2163 !isalnum(ptr
[len
]) && ptr
[len
] != '_') {
2164 ptr
= eval_replace(ptr
, map
, len
);
2165 /* enum/sizeof string smaller than value */
2166 if (WARN_ON_ONCE(!ptr
))
2169 * No need to decrement here, as eval_replace()
2170 * returns the pointer to the character passed
2171 * the eval, and two evals can not be placed
2172 * back to back without something in between.
2173 * We can skip that something in between.
2180 } while (isalnum(*ptr
) || *ptr
== '_');
2184 * If what comes after this variable is a '.' or
2185 * '->' then we can continue to ignore that string.
2187 if (*ptr
== '.' || (ptr
[0] == '-' && ptr
[1] == '>')) {
2188 ptr
+= *ptr
== '.' ? 1 : 2;
2194 * Once again, we can skip the delimiter that came
2202 void trace_event_eval_update(struct trace_eval_map
**map
, int len
)
2204 struct trace_event_call
*call
, *p
;
2205 const char *last_system
= NULL
;
2210 down_write(&trace_event_sem
);
2211 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
2212 /* events are usually grouped together with systems */
2213 if (!last_system
|| call
->class->system
!= last_system
) {
2216 last_system
= call
->class->system
;
2220 * Since calls are grouped by systems, the likelyhood that the
2221 * next call in the iteration belongs to the same system as the
2222 * previous call is high. As an optimization, we skip seaching
2223 * for a map[] that matches the call's system if the last call
2224 * was from the same system. That's what last_i is for. If the
2225 * call has the same system as the previous call, then last_i
2226 * will be the index of the first map[] that has a matching
2229 for (i
= last_i
; i
< len
; i
++) {
2230 if (call
->class->system
== map
[i
]->system
) {
2231 /* Save the first system if need be */
2236 update_event_printk(call
, map
[i
]);
2240 up_write(&trace_event_sem
);
2243 static struct trace_event_file
*
2244 trace_create_new_event(struct trace_event_call
*call
,
2245 struct trace_array
*tr
)
2247 struct trace_event_file
*file
;
2249 file
= kmem_cache_alloc(file_cachep
, GFP_TRACE
);
2253 file
->event_call
= call
;
2255 atomic_set(&file
->sm_ref
, 0);
2256 atomic_set(&file
->tm_ref
, 0);
2257 INIT_LIST_HEAD(&file
->triggers
);
2258 list_add(&file
->list
, &tr
->events
);
2263 /* Add an event to a trace directory */
2265 __trace_add_new_event(struct trace_event_call
*call
, struct trace_array
*tr
)
2267 struct trace_event_file
*file
;
2269 file
= trace_create_new_event(call
, tr
);
2273 return event_create_dir(tr
->event_dir
, file
);
2277 * Just create a decriptor for early init. A descriptor is required
2278 * for enabling events at boot. We want to enable events before
2279 * the filesystem is initialized.
2282 __trace_early_add_new_event(struct trace_event_call
*call
,
2283 struct trace_array
*tr
)
2285 struct trace_event_file
*file
;
2287 file
= trace_create_new_event(call
, tr
);
2294 struct ftrace_module_file_ops
;
2295 static void __add_event_to_tracers(struct trace_event_call
*call
);
2297 /* Add an additional event_call dynamically */
2298 int trace_add_event_call(struct trace_event_call
*call
)
2301 lockdep_assert_held(&event_mutex
);
2303 mutex_lock(&trace_types_lock
);
2305 ret
= __register_event(call
, NULL
);
2307 __add_event_to_tracers(call
);
2309 mutex_unlock(&trace_types_lock
);
2314 * Must be called under locking of trace_types_lock, event_mutex and
2317 static void __trace_remove_event_call(struct trace_event_call
*call
)
2320 trace_destroy_fields(call
);
2321 free_event_filter(call
->filter
);
2322 call
->filter
= NULL
;
2325 static int probe_remove_event_call(struct trace_event_call
*call
)
2327 struct trace_array
*tr
;
2328 struct trace_event_file
*file
;
2330 #ifdef CONFIG_PERF_EVENTS
2331 if (call
->perf_refcount
)
2334 do_for_each_event_file(tr
, file
) {
2335 if (file
->event_call
!= call
)
2338 * We can't rely on ftrace_event_enable_disable(enable => 0)
2339 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
2340 * TRACE_REG_UNREGISTER.
2342 if (file
->flags
& EVENT_FILE_FL_ENABLED
)
2345 * The do_for_each_event_file_safe() is
2346 * a double loop. After finding the call for this
2347 * trace_array, we use break to jump to the next
2351 } while_for_each_event_file();
2353 __trace_remove_event_call(call
);
2358 /* Remove an event_call */
2359 int trace_remove_event_call(struct trace_event_call
*call
)
2363 lockdep_assert_held(&event_mutex
);
2365 mutex_lock(&trace_types_lock
);
2366 down_write(&trace_event_sem
);
2367 ret
= probe_remove_event_call(call
);
2368 up_write(&trace_event_sem
);
2369 mutex_unlock(&trace_types_lock
);
2374 #define for_each_event(event, start, end) \
2375 for (event = start; \
2376 (unsigned long)event < (unsigned long)end; \
2379 #ifdef CONFIG_MODULES
2381 static void trace_module_add_events(struct module
*mod
)
2383 struct trace_event_call
**call
, **start
, **end
;
2385 if (!mod
->num_trace_events
)
2388 /* Don't add infrastructure for mods without tracepoints */
2389 if (trace_module_has_bad_taint(mod
)) {
2390 pr_err("%s: module has bad taint, not creating trace events\n",
2395 start
= mod
->trace_events
;
2396 end
= mod
->trace_events
+ mod
->num_trace_events
;
2398 for_each_event(call
, start
, end
) {
2399 __register_event(*call
, mod
);
2400 __add_event_to_tracers(*call
);
2404 static void trace_module_remove_events(struct module
*mod
)
2406 struct trace_event_call
*call
, *p
;
2408 down_write(&trace_event_sem
);
2409 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
2410 if (call
->mod
== mod
)
2411 __trace_remove_event_call(call
);
2413 up_write(&trace_event_sem
);
2416 * It is safest to reset the ring buffer if the module being unloaded
2417 * registered any events that were used. The only worry is if
2418 * a new module gets loaded, and takes on the same id as the events
2419 * of this module. When printing out the buffer, traced events left
2420 * over from this module may be passed to the new module events and
2421 * unexpected results may occur.
2423 tracing_reset_all_online_cpus();
2426 static int trace_module_notify(struct notifier_block
*self
,
2427 unsigned long val
, void *data
)
2429 struct module
*mod
= data
;
2431 mutex_lock(&event_mutex
);
2432 mutex_lock(&trace_types_lock
);
2434 case MODULE_STATE_COMING
:
2435 trace_module_add_events(mod
);
2437 case MODULE_STATE_GOING
:
2438 trace_module_remove_events(mod
);
2441 mutex_unlock(&trace_types_lock
);
2442 mutex_unlock(&event_mutex
);
2447 static struct notifier_block trace_module_nb
= {
2448 .notifier_call
= trace_module_notify
,
2449 .priority
= 1, /* higher than trace.c module notify */
2451 #endif /* CONFIG_MODULES */
2453 /* Create a new event directory structure for a trace directory. */
2455 __trace_add_event_dirs(struct trace_array
*tr
)
2457 struct trace_event_call
*call
;
2460 list_for_each_entry(call
, &ftrace_events
, list
) {
2461 ret
= __trace_add_new_event(call
, tr
);
2463 pr_warn("Could not create directory for event %s\n",
2464 trace_event_name(call
));
2468 /* Returns any file that matches the system and event */
2469 struct trace_event_file
*
2470 __find_event_file(struct trace_array
*tr
, const char *system
, const char *event
)
2472 struct trace_event_file
*file
;
2473 struct trace_event_call
*call
;
2476 list_for_each_entry(file
, &tr
->events
, list
) {
2478 call
= file
->event_call
;
2479 name
= trace_event_name(call
);
2481 if (!name
|| !call
->class)
2484 if (strcmp(event
, name
) == 0 &&
2485 strcmp(system
, call
->class->system
) == 0)
2491 /* Returns valid trace event files that match system and event */
2492 struct trace_event_file
*
2493 find_event_file(struct trace_array
*tr
, const char *system
, const char *event
)
2495 struct trace_event_file
*file
;
2497 file
= __find_event_file(tr
, system
, event
);
2498 if (!file
|| !file
->event_call
->class->reg
||
2499 file
->event_call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)
2505 #ifdef CONFIG_DYNAMIC_FTRACE
2508 #define ENABLE_EVENT_STR "enable_event"
2509 #define DISABLE_EVENT_STR "disable_event"
2511 struct event_probe_data
{
2512 struct trace_event_file
*file
;
2513 unsigned long count
;
2518 static void update_event_probe(struct event_probe_data
*data
)
2521 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
2523 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
2527 event_enable_probe(unsigned long ip
, unsigned long parent_ip
,
2528 struct trace_array
*tr
, struct ftrace_probe_ops
*ops
,
2531 struct ftrace_func_mapper
*mapper
= data
;
2532 struct event_probe_data
*edata
;
2535 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2536 if (!pdata
|| !*pdata
)
2540 update_event_probe(edata
);
2544 event_enable_count_probe(unsigned long ip
, unsigned long parent_ip
,
2545 struct trace_array
*tr
, struct ftrace_probe_ops
*ops
,
2548 struct ftrace_func_mapper
*mapper
= data
;
2549 struct event_probe_data
*edata
;
2552 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2553 if (!pdata
|| !*pdata
)
2561 /* Skip if the event is in a state we want to switch to */
2562 if (edata
->enable
== !(edata
->file
->flags
& EVENT_FILE_FL_SOFT_DISABLED
))
2565 if (edata
->count
!= -1)
2568 update_event_probe(edata
);
2572 event_enable_print(struct seq_file
*m
, unsigned long ip
,
2573 struct ftrace_probe_ops
*ops
, void *data
)
2575 struct ftrace_func_mapper
*mapper
= data
;
2576 struct event_probe_data
*edata
;
2579 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2581 if (WARN_ON_ONCE(!pdata
|| !*pdata
))
2586 seq_printf(m
, "%ps:", (void *)ip
);
2588 seq_printf(m
, "%s:%s:%s",
2589 edata
->enable
? ENABLE_EVENT_STR
: DISABLE_EVENT_STR
,
2590 edata
->file
->event_call
->class->system
,
2591 trace_event_name(edata
->file
->event_call
));
2593 if (edata
->count
== -1)
2594 seq_puts(m
, ":unlimited\n");
2596 seq_printf(m
, ":count=%ld\n", edata
->count
);
2602 event_enable_init(struct ftrace_probe_ops
*ops
, struct trace_array
*tr
,
2603 unsigned long ip
, void *init_data
, void **data
)
2605 struct ftrace_func_mapper
*mapper
= *data
;
2606 struct event_probe_data
*edata
= init_data
;
2610 mapper
= allocate_ftrace_func_mapper();
2616 ret
= ftrace_func_mapper_add_ip(mapper
, ip
, edata
);
2625 static int free_probe_data(void *data
)
2627 struct event_probe_data
*edata
= data
;
2631 /* Remove the SOFT_MODE flag */
2632 __ftrace_event_enable_disable(edata
->file
, 0, 1);
2633 module_put(edata
->file
->event_call
->mod
);
2640 event_enable_free(struct ftrace_probe_ops
*ops
, struct trace_array
*tr
,
2641 unsigned long ip
, void *data
)
2643 struct ftrace_func_mapper
*mapper
= data
;
2644 struct event_probe_data
*edata
;
2649 free_ftrace_func_mapper(mapper
, free_probe_data
);
2653 edata
= ftrace_func_mapper_remove_ip(mapper
, ip
);
2655 if (WARN_ON_ONCE(!edata
))
2658 if (WARN_ON_ONCE(edata
->ref
<= 0))
2661 free_probe_data(edata
);
2664 static struct ftrace_probe_ops event_enable_probe_ops
= {
2665 .func
= event_enable_probe
,
2666 .print
= event_enable_print
,
2667 .init
= event_enable_init
,
2668 .free
= event_enable_free
,
2671 static struct ftrace_probe_ops event_enable_count_probe_ops
= {
2672 .func
= event_enable_count_probe
,
2673 .print
= event_enable_print
,
2674 .init
= event_enable_init
,
2675 .free
= event_enable_free
,
2678 static struct ftrace_probe_ops event_disable_probe_ops
= {
2679 .func
= event_enable_probe
,
2680 .print
= event_enable_print
,
2681 .init
= event_enable_init
,
2682 .free
= event_enable_free
,
2685 static struct ftrace_probe_ops event_disable_count_probe_ops
= {
2686 .func
= event_enable_count_probe
,
2687 .print
= event_enable_print
,
2688 .init
= event_enable_init
,
2689 .free
= event_enable_free
,
2693 event_enable_func(struct trace_array
*tr
, struct ftrace_hash
*hash
,
2694 char *glob
, char *cmd
, char *param
, int enabled
)
2696 struct trace_event_file
*file
;
2697 struct ftrace_probe_ops
*ops
;
2698 struct event_probe_data
*data
;
2708 /* hash funcs only work with set_ftrace_filter */
2709 if (!enabled
|| !param
)
2712 system
= strsep(¶m
, ":");
2716 event
= strsep(¶m
, ":");
2718 mutex_lock(&event_mutex
);
2721 file
= find_event_file(tr
, system
, event
);
2725 enable
= strcmp(cmd
, ENABLE_EVENT_STR
) == 0;
2728 ops
= param
? &event_enable_count_probe_ops
: &event_enable_probe_ops
;
2730 ops
= param
? &event_disable_count_probe_ops
: &event_disable_probe_ops
;
2732 if (glob
[0] == '!') {
2733 ret
= unregister_ftrace_function_probe_func(glob
+1, tr
, ops
);
2739 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
2743 data
->enable
= enable
;
2750 number
= strsep(¶m
, ":");
2753 if (!strlen(number
))
2757 * We use the callback data field (which is a pointer)
2760 ret
= kstrtoul(number
, 0, &data
->count
);
2765 /* Don't let event modules unload while probe registered */
2766 ret
= try_module_get(file
->event_call
->mod
);
2772 ret
= __ftrace_event_enable_disable(file
, 1, 1);
2776 ret
= register_ftrace_function_probe(glob
, tr
, ops
, data
);
2778 * The above returns on success the # of functions enabled,
2779 * but if it didn't find any functions it returns zero.
2780 * Consider no functions a failure too.
2787 /* Just return zero, not the number of enabled functions */
2790 mutex_unlock(&event_mutex
);
2794 __ftrace_event_enable_disable(file
, 0, 1);
2796 module_put(file
->event_call
->mod
);
2802 static struct ftrace_func_command event_enable_cmd
= {
2803 .name
= ENABLE_EVENT_STR
,
2804 .func
= event_enable_func
,
2807 static struct ftrace_func_command event_disable_cmd
= {
2808 .name
= DISABLE_EVENT_STR
,
2809 .func
= event_enable_func
,
2812 static __init
int register_event_cmds(void)
2816 ret
= register_ftrace_command(&event_enable_cmd
);
2817 if (WARN_ON(ret
< 0))
2819 ret
= register_ftrace_command(&event_disable_cmd
);
2820 if (WARN_ON(ret
< 0))
2821 unregister_ftrace_command(&event_enable_cmd
);
2825 static inline int register_event_cmds(void) { return 0; }
2826 #endif /* CONFIG_DYNAMIC_FTRACE */
2829 * The top level array has already had its trace_event_file
2830 * descriptors created in order to allow for early events to
2831 * be recorded. This function is called after the tracefs has been
2832 * initialized, and we now have to create the files associated
2836 __trace_early_add_event_dirs(struct trace_array
*tr
)
2838 struct trace_event_file
*file
;
2842 list_for_each_entry(file
, &tr
->events
, list
) {
2843 ret
= event_create_dir(tr
->event_dir
, file
);
2845 pr_warn("Could not create directory for event %s\n",
2846 trace_event_name(file
->event_call
));
2851 * For early boot up, the top trace array requires to have
2852 * a list of events that can be enabled. This must be done before
2853 * the filesystem is set up in order to allow events to be traced
2857 __trace_early_add_events(struct trace_array
*tr
)
2859 struct trace_event_call
*call
;
2862 list_for_each_entry(call
, &ftrace_events
, list
) {
2863 /* Early boot up should not have any modules loaded */
2864 if (WARN_ON_ONCE(call
->mod
))
2867 ret
= __trace_early_add_new_event(call
, tr
);
2869 pr_warn("Could not create early event %s\n",
2870 trace_event_name(call
));
2874 /* Remove the event directory structure for a trace directory. */
2876 __trace_remove_event_dirs(struct trace_array
*tr
)
2878 struct trace_event_file
*file
, *next
;
2880 list_for_each_entry_safe(file
, next
, &tr
->events
, list
)
2881 remove_event_file_dir(file
);
2884 static void __add_event_to_tracers(struct trace_event_call
*call
)
2886 struct trace_array
*tr
;
2888 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
)
2889 __trace_add_new_event(call
, tr
);
2892 extern struct trace_event_call
*__start_ftrace_events
[];
2893 extern struct trace_event_call
*__stop_ftrace_events
[];
2895 static char bootup_event_buf
[COMMAND_LINE_SIZE
] __initdata
;
2897 static __init
int setup_trace_event(char *str
)
2899 strlcpy(bootup_event_buf
, str
, COMMAND_LINE_SIZE
);
2900 ring_buffer_expanded
= true;
2901 tracing_selftest_disabled
= true;
2905 __setup("trace_event=", setup_trace_event
);
2907 /* Expects to have event_mutex held when called */
2909 create_event_toplevel_files(struct dentry
*parent
, struct trace_array
*tr
)
2911 struct dentry
*d_events
;
2912 struct dentry
*entry
;
2914 entry
= tracefs_create_file("set_event", 0644, parent
,
2915 tr
, &ftrace_set_event_fops
);
2917 pr_warn("Could not create tracefs 'set_event' entry\n");
2921 d_events
= tracefs_create_dir("events", parent
);
2923 pr_warn("Could not create tracefs 'events' directory\n");
2927 entry
= trace_create_file("enable", 0644, d_events
,
2928 tr
, &ftrace_tr_enable_fops
);
2930 pr_warn("Could not create tracefs 'enable' entry\n");
2934 /* There are not as crucial, just warn if they are not created */
2936 entry
= tracefs_create_file("set_event_pid", 0644, parent
,
2937 tr
, &ftrace_set_event_pid_fops
);
2939 pr_warn("Could not create tracefs 'set_event_pid' entry\n");
2941 /* ring buffer internal formats */
2942 entry
= trace_create_file("header_page", 0444, d_events
,
2943 ring_buffer_print_page_header
,
2944 &ftrace_show_header_fops
);
2946 pr_warn("Could not create tracefs 'header_page' entry\n");
2948 entry
= trace_create_file("header_event", 0444, d_events
,
2949 ring_buffer_print_entry_header
,
2950 &ftrace_show_header_fops
);
2952 pr_warn("Could not create tracefs 'header_event' entry\n");
2954 tr
->event_dir
= d_events
;
2960 * event_trace_add_tracer - add a instance of a trace_array to events
2961 * @parent: The parent dentry to place the files/directories for events in
2962 * @tr: The trace array associated with these events
2964 * When a new instance is created, it needs to set up its events
2965 * directory, as well as other files associated with events. It also
2966 * creates the event hierachry in the @parent/events directory.
2968 * Returns 0 on success.
2970 * Must be called with event_mutex held.
2972 int event_trace_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
2976 lockdep_assert_held(&event_mutex
);
2978 ret
= create_event_toplevel_files(parent
, tr
);
2982 down_write(&trace_event_sem
);
2983 __trace_add_event_dirs(tr
);
2984 up_write(&trace_event_sem
);
2991 * The top trace array already had its file descriptors created.
2992 * Now the files themselves need to be created.
2995 early_event_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
2999 mutex_lock(&event_mutex
);
3001 ret
= create_event_toplevel_files(parent
, tr
);
3005 down_write(&trace_event_sem
);
3006 __trace_early_add_event_dirs(tr
);
3007 up_write(&trace_event_sem
);
3010 mutex_unlock(&event_mutex
);
3015 /* Must be called with event_mutex held */
3016 int event_trace_del_tracer(struct trace_array
*tr
)
3018 lockdep_assert_held(&event_mutex
);
3020 /* Disable any event triggers and associated soft-disabled events */
3021 clear_event_triggers(tr
);
3023 /* Clear the pid list */
3024 __ftrace_clear_event_pids(tr
);
3026 /* Disable any running events */
3027 __ftrace_set_clr_event_nolock(tr
, NULL
, NULL
, NULL
, 0);
3029 /* Make sure no more events are being executed */
3030 tracepoint_synchronize_unregister();
3032 down_write(&trace_event_sem
);
3033 __trace_remove_event_dirs(tr
);
3034 tracefs_remove_recursive(tr
->event_dir
);
3035 up_write(&trace_event_sem
);
3037 tr
->event_dir
= NULL
;
3042 static __init
int event_trace_memsetup(void)
3044 field_cachep
= KMEM_CACHE(ftrace_event_field
, SLAB_PANIC
);
3045 file_cachep
= KMEM_CACHE(trace_event_file
, SLAB_PANIC
);
3050 early_enable_events(struct trace_array
*tr
, bool disable_first
)
3052 char *buf
= bootup_event_buf
;
3057 token
= strsep(&buf
, ",");
3063 /* Restarting syscalls requires that we stop them first */
3065 ftrace_set_clr_event(tr
, token
, 0);
3067 ret
= ftrace_set_clr_event(tr
, token
, 1);
3069 pr_warn("Failed to enable trace event: %s\n", token
);
3072 /* Put back the comma to allow this to be called again */
3078 static __init
int event_trace_enable(void)
3080 struct trace_array
*tr
= top_trace_array();
3081 struct trace_event_call
**iter
, *call
;
3087 for_each_event(iter
, __start_ftrace_events
, __stop_ftrace_events
) {
3090 ret
= event_init(call
);
3092 list_add(&call
->list
, &ftrace_events
);
3096 * We need the top trace array to have a working set of trace
3097 * points at early init, before the debug files and directories
3098 * are created. Create the file entries now, and attach them
3099 * to the actual file dentries later.
3101 __trace_early_add_events(tr
);
3103 early_enable_events(tr
, false);
3105 trace_printk_start_comm();
3107 register_event_cmds();
3109 register_trigger_cmds();
3115 * event_trace_enable() is called from trace_event_init() first to
3116 * initialize events and perhaps start any events that are on the
3117 * command line. Unfortunately, there are some events that will not
3118 * start this early, like the system call tracepoints that need
3119 * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable()
3120 * is called before pid 1 starts, and this flag is never set, making
3121 * the syscall tracepoint never get reached, but the event is enabled
3122 * regardless (and not doing anything).
3124 static __init
int event_trace_enable_again(void)
3126 struct trace_array
*tr
;
3128 tr
= top_trace_array();
3132 early_enable_events(tr
, true);
3137 early_initcall(event_trace_enable_again
);
3139 __init
int event_trace_init(void)
3141 struct trace_array
*tr
;
3142 struct dentry
*d_tracer
;
3143 struct dentry
*entry
;
3146 tr
= top_trace_array();
3150 d_tracer
= tracing_init_dentry();
3151 if (IS_ERR(d_tracer
))
3154 entry
= tracefs_create_file("available_events", 0444, d_tracer
,
3155 tr
, &ftrace_avail_fops
);
3157 pr_warn("Could not create tracefs 'available_events' entry\n");
3159 if (trace_define_generic_fields())
3160 pr_warn("tracing: Failed to allocated generic fields");
3162 if (trace_define_common_fields())
3163 pr_warn("tracing: Failed to allocate common fields");
3165 ret
= early_event_add_tracer(d_tracer
, tr
);
3169 #ifdef CONFIG_MODULES
3170 ret
= register_module_notifier(&trace_module_nb
);
3172 pr_warn("Failed to register trace events module notifier\n");
3177 void __init
trace_event_init(void)
3179 event_trace_memsetup();
3180 init_ftrace_syscalls();
3181 event_trace_enable();
3184 #ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
3186 static DEFINE_SPINLOCK(test_spinlock
);
3187 static DEFINE_SPINLOCK(test_spinlock_irq
);
3188 static DEFINE_MUTEX(test_mutex
);
3190 static __init
void test_work(struct work_struct
*dummy
)
3192 spin_lock(&test_spinlock
);
3193 spin_lock_irq(&test_spinlock_irq
);
3195 spin_unlock_irq(&test_spinlock_irq
);
3196 spin_unlock(&test_spinlock
);
3198 mutex_lock(&test_mutex
);
3200 mutex_unlock(&test_mutex
);
3203 static __init
int event_test_thread(void *unused
)
3207 test_malloc
= kmalloc(1234, GFP_KERNEL
);
3209 pr_info("failed to kmalloc\n");
3211 schedule_on_each_cpu(test_work
);
3215 set_current_state(TASK_INTERRUPTIBLE
);
3216 while (!kthread_should_stop()) {
3218 set_current_state(TASK_INTERRUPTIBLE
);
3220 __set_current_state(TASK_RUNNING
);
3226 * Do various things that may trigger events.
3228 static __init
void event_test_stuff(void)
3230 struct task_struct
*test_thread
;
3232 test_thread
= kthread_run(event_test_thread
, NULL
, "test-events");
3234 kthread_stop(test_thread
);
3238 * For every trace event defined, we will test each trace point separately,
3239 * and then by groups, and finally all trace points.
3241 static __init
void event_trace_self_tests(void)
3243 struct trace_subsystem_dir
*dir
;
3244 struct trace_event_file
*file
;
3245 struct trace_event_call
*call
;
3246 struct event_subsystem
*system
;
3247 struct trace_array
*tr
;
3250 tr
= top_trace_array();
3254 pr_info("Running tests on trace events:\n");
3256 list_for_each_entry(file
, &tr
->events
, list
) {
3258 call
= file
->event_call
;
3260 /* Only test those that have a probe */
3261 if (!call
->class || !call
->class->probe
)
3265 * Testing syscall events here is pretty useless, but
3266 * we still do it if configured. But this is time consuming.
3267 * What we really need is a user thread to perform the
3268 * syscalls as we test.
3270 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
3271 if (call
->class->system
&&
3272 strcmp(call
->class->system
, "syscalls") == 0)
3276 pr_info("Testing event %s: ", trace_event_name(call
));
3279 * If an event is already enabled, someone is using
3280 * it and the self test should not be on.
3282 if (file
->flags
& EVENT_FILE_FL_ENABLED
) {
3283 pr_warn("Enabled event during self test!\n");
3288 ftrace_event_enable_disable(file
, 1);
3290 ftrace_event_enable_disable(file
, 0);
3295 /* Now test at the sub system level */
3297 pr_info("Running tests on trace event systems:\n");
3299 list_for_each_entry(dir
, &tr
->systems
, list
) {
3301 system
= dir
->subsystem
;
3303 /* the ftrace system is special, skip it */
3304 if (strcmp(system
->name
, "ftrace") == 0)
3307 pr_info("Testing event system %s: ", system
->name
);
3309 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 1);
3310 if (WARN_ON_ONCE(ret
)) {
3311 pr_warn("error enabling system %s\n",
3318 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 0);
3319 if (WARN_ON_ONCE(ret
)) {
3320 pr_warn("error disabling system %s\n",
3328 /* Test with all events enabled */
3330 pr_info("Running tests on all trace events:\n");
3331 pr_info("Testing all events: ");
3333 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 1);
3334 if (WARN_ON_ONCE(ret
)) {
3335 pr_warn("error enabling all events\n");
3342 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 0);
3343 if (WARN_ON_ONCE(ret
)) {
3344 pr_warn("error disabling all events\n");
3351 #ifdef CONFIG_FUNCTION_TRACER
3353 static DEFINE_PER_CPU(atomic_t
, ftrace_test_event_disable
);
3355 static struct trace_event_file event_trace_file __initdata
;
3358 function_test_events_call(unsigned long ip
, unsigned long parent_ip
,
3359 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
3361 struct ring_buffer_event
*event
;
3362 struct ring_buffer
*buffer
;
3363 struct ftrace_entry
*entry
;
3364 unsigned long flags
;
3369 pc
= preempt_count();
3370 preempt_disable_notrace();
3371 cpu
= raw_smp_processor_id();
3372 disabled
= atomic_inc_return(&per_cpu(ftrace_test_event_disable
, cpu
));
3377 local_save_flags(flags
);
3379 event
= trace_event_buffer_lock_reserve(&buffer
, &event_trace_file
,
3380 TRACE_FN
, sizeof(*entry
),
3384 entry
= ring_buffer_event_data(event
);
3386 entry
->parent_ip
= parent_ip
;
3388 event_trigger_unlock_commit(&event_trace_file
, buffer
, event
,
3391 atomic_dec(&per_cpu(ftrace_test_event_disable
, cpu
));
3392 preempt_enable_notrace();
3395 static struct ftrace_ops trace_ops __initdata
=
3397 .func
= function_test_events_call
,
3398 .flags
= FTRACE_OPS_FL_RECURSION_SAFE
,
3401 static __init
void event_trace_self_test_with_function(void)
3405 event_trace_file
.tr
= top_trace_array();
3406 if (WARN_ON(!event_trace_file
.tr
))
3409 ret
= register_ftrace_function(&trace_ops
);
3410 if (WARN_ON(ret
< 0)) {
3411 pr_info("Failed to enable function tracer for event tests\n");
3414 pr_info("Running tests again, along with the function tracer\n");
3415 event_trace_self_tests();
3416 unregister_ftrace_function(&trace_ops
);
3419 static __init
void event_trace_self_test_with_function(void)
3424 static __init
int event_trace_self_tests_init(void)
3426 if (!tracing_selftest_disabled
) {
3427 event_trace_self_tests();
3428 event_trace_self_test_with_function();
3434 late_initcall(event_trace_self_tests_init
);