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
;
799 * The buf format can be <subsystem>:<event-name>
800 * *:<event-name> means any event by that name.
801 * :<event-name> is the same.
803 * <subsystem>:* means all events in that subsystem
804 * <subsystem>: means the same.
806 * <name> (no ':') means all events in a subsystem with
807 * the name <name> or any event that matches <name>
810 match
= strsep(&buf
, ":");
816 if (!strlen(sub
) || strcmp(sub
, "*") == 0)
818 if (!strlen(event
) || strcmp(event
, "*") == 0)
822 ret
= __ftrace_set_clr_event(tr
, match
, sub
, event
, set
);
824 /* Put back the colon to allow this to be called again */
832 * trace_set_clr_event - enable or disable an event
833 * @system: system name to match (NULL for any system)
834 * @event: event name to match (NULL for all events, within system)
835 * @set: 1 to enable, 0 to disable
837 * This is a way for other parts of the kernel to enable or disable
840 * Returns 0 on success, -EINVAL if the parameters do not match any
843 int trace_set_clr_event(const char *system
, const char *event
, int set
)
845 struct trace_array
*tr
= top_trace_array();
850 return __ftrace_set_clr_event(tr
, NULL
, system
, event
, set
);
852 EXPORT_SYMBOL_GPL(trace_set_clr_event
);
855 * trace_array_set_clr_event - enable or disable an event for a trace array.
856 * @tr: concerned trace array.
857 * @system: system name to match (NULL for any system)
858 * @event: event name to match (NULL for all events, within system)
859 * @enable: true to enable, false to disable
861 * This is a way for other parts of the kernel to enable or disable
864 * Returns 0 on success, -EINVAL if the parameters do not match any
867 int trace_array_set_clr_event(struct trace_array
*tr
, const char *system
,
868 const char *event
, bool enable
)
875 set
= (enable
== true) ? 1 : 0;
876 return __ftrace_set_clr_event(tr
, NULL
, system
, event
, set
);
878 EXPORT_SYMBOL_GPL(trace_array_set_clr_event
);
880 /* 128 should be much more than enough */
881 #define EVENT_BUF_SIZE 127
884 ftrace_event_write(struct file
*file
, const char __user
*ubuf
,
885 size_t cnt
, loff_t
*ppos
)
887 struct trace_parser parser
;
888 struct seq_file
*m
= file
->private_data
;
889 struct trace_array
*tr
= m
->private;
895 ret
= tracing_update_buffers();
899 if (trace_parser_get_init(&parser
, EVENT_BUF_SIZE
+ 1))
902 read
= trace_get_user(&parser
, ubuf
, cnt
, ppos
);
904 if (read
>= 0 && trace_parser_loaded((&parser
))) {
907 if (*parser
.buffer
== '!')
910 ret
= ftrace_set_clr_event(tr
, parser
.buffer
+ !set
, set
);
918 trace_parser_put(&parser
);
924 t_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
926 struct trace_event_file
*file
= v
;
927 struct trace_event_call
*call
;
928 struct trace_array
*tr
= m
->private;
932 list_for_each_entry_continue(file
, &tr
->events
, list
) {
933 call
= file
->event_call
;
935 * The ftrace subsystem is for showing formats only.
936 * They can not be enabled or disabled via the event files.
938 if (call
->class && call
->class->reg
&&
939 !(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
))
946 static void *t_start(struct seq_file
*m
, loff_t
*pos
)
948 struct trace_event_file
*file
;
949 struct trace_array
*tr
= m
->private;
952 mutex_lock(&event_mutex
);
954 file
= list_entry(&tr
->events
, struct trace_event_file
, list
);
955 for (l
= 0; l
<= *pos
; ) {
956 file
= t_next(m
, file
, &l
);
964 s_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
966 struct trace_event_file
*file
= v
;
967 struct trace_array
*tr
= m
->private;
971 list_for_each_entry_continue(file
, &tr
->events
, list
) {
972 if (file
->flags
& EVENT_FILE_FL_ENABLED
)
979 static void *s_start(struct seq_file
*m
, loff_t
*pos
)
981 struct trace_event_file
*file
;
982 struct trace_array
*tr
= m
->private;
985 mutex_lock(&event_mutex
);
987 file
= list_entry(&tr
->events
, struct trace_event_file
, list
);
988 for (l
= 0; l
<= *pos
; ) {
989 file
= s_next(m
, file
, &l
);
996 static int t_show(struct seq_file
*m
, void *v
)
998 struct trace_event_file
*file
= v
;
999 struct trace_event_call
*call
= file
->event_call
;
1001 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0)
1002 seq_printf(m
, "%s:", call
->class->system
);
1003 seq_printf(m
, "%s\n", trace_event_name(call
));
1008 static void t_stop(struct seq_file
*m
, void *p
)
1010 mutex_unlock(&event_mutex
);
1014 p_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1016 struct trace_array
*tr
= m
->private;
1017 struct trace_pid_list
*pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
1019 return trace_pid_next(pid_list
, v
, pos
);
1022 static void *p_start(struct seq_file
*m
, loff_t
*pos
)
1025 struct trace_pid_list
*pid_list
;
1026 struct trace_array
*tr
= m
->private;
1029 * Grab the mutex, to keep calls to p_next() having the same
1030 * tr->filtered_pids as p_start() has.
1031 * If we just passed the tr->filtered_pids around, then RCU would
1032 * have been enough, but doing that makes things more complex.
1034 mutex_lock(&event_mutex
);
1035 rcu_read_lock_sched();
1037 pid_list
= rcu_dereference_sched(tr
->filtered_pids
);
1042 return trace_pid_start(pid_list
, pos
);
1045 static void p_stop(struct seq_file
*m
, void *p
)
1048 rcu_read_unlock_sched();
1049 mutex_unlock(&event_mutex
);
1053 event_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1056 struct trace_event_file
*file
;
1057 unsigned long flags
;
1060 mutex_lock(&event_mutex
);
1061 file
= event_file_data(filp
);
1063 flags
= file
->flags
;
1064 mutex_unlock(&event_mutex
);
1069 if (flags
& EVENT_FILE_FL_ENABLED
&&
1070 !(flags
& EVENT_FILE_FL_SOFT_DISABLED
))
1073 if (flags
& EVENT_FILE_FL_SOFT_DISABLED
||
1074 flags
& EVENT_FILE_FL_SOFT_MODE
)
1079 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, strlen(buf
));
1083 event_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1086 struct trace_event_file
*file
;
1090 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
1094 ret
= tracing_update_buffers();
1102 mutex_lock(&event_mutex
);
1103 file
= event_file_data(filp
);
1105 ret
= ftrace_event_enable_disable(file
, val
);
1106 mutex_unlock(&event_mutex
);
1115 return ret
? ret
: cnt
;
1119 system_enable_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1122 const char set_to_char
[4] = { '?', '0', '1', 'X' };
1123 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1124 struct event_subsystem
*system
= dir
->subsystem
;
1125 struct trace_event_call
*call
;
1126 struct trace_event_file
*file
;
1127 struct trace_array
*tr
= dir
->tr
;
1132 mutex_lock(&event_mutex
);
1133 list_for_each_entry(file
, &tr
->events
, list
) {
1134 call
= file
->event_call
;
1135 if (!trace_event_name(call
) || !call
->class || !call
->class->reg
)
1138 if (system
&& strcmp(call
->class->system
, system
->name
) != 0)
1142 * We need to find out if all the events are set
1143 * or if all events or cleared, or if we have
1146 set
|= (1 << !!(file
->flags
& EVENT_FILE_FL_ENABLED
));
1149 * If we have a mixture, no need to look further.
1154 mutex_unlock(&event_mutex
);
1156 buf
[0] = set_to_char
[set
];
1159 ret
= simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, 2);
1165 system_enable_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1168 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1169 struct event_subsystem
*system
= dir
->subsystem
;
1170 const char *name
= NULL
;
1174 ret
= kstrtoul_from_user(ubuf
, cnt
, 10, &val
);
1178 ret
= tracing_update_buffers();
1182 if (val
!= 0 && val
!= 1)
1186 * Opening of "enable" adds a ref count to system,
1187 * so the name is safe to use.
1190 name
= system
->name
;
1192 ret
= __ftrace_set_clr_event(dir
->tr
, NULL
, name
, NULL
, val
);
1206 FORMAT_FIELD_SEPERATOR
= 2,
1207 FORMAT_PRINTFMT
= 3,
1210 static void *f_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1212 struct trace_event_call
*call
= event_file_data(m
->private);
1213 struct list_head
*common_head
= &ftrace_common_fields
;
1214 struct list_head
*head
= trace_get_fields(call
);
1215 struct list_head
*node
= v
;
1219 switch ((unsigned long)v
) {
1224 case FORMAT_FIELD_SEPERATOR
:
1228 case FORMAT_PRINTFMT
:
1234 if (node
== common_head
)
1235 return (void *)FORMAT_FIELD_SEPERATOR
;
1236 else if (node
== head
)
1237 return (void *)FORMAT_PRINTFMT
;
1242 static int f_show(struct seq_file
*m
, void *v
)
1244 struct trace_event_call
*call
= event_file_data(m
->private);
1245 struct ftrace_event_field
*field
;
1246 const char *array_descriptor
;
1248 switch ((unsigned long)v
) {
1250 seq_printf(m
, "name: %s\n", trace_event_name(call
));
1251 seq_printf(m
, "ID: %d\n", call
->event
.type
);
1252 seq_puts(m
, "format:\n");
1255 case FORMAT_FIELD_SEPERATOR
:
1259 case FORMAT_PRINTFMT
:
1260 seq_printf(m
, "\nprint fmt: %s\n",
1265 field
= list_entry(v
, struct ftrace_event_field
, link
);
1267 * Smartly shows the array type(except dynamic array).
1270 * If TYPE := TYPE[LEN], it is shown:
1271 * field:TYPE VAR[LEN]
1273 array_descriptor
= strchr(field
->type
, '[');
1275 if (str_has_prefix(field
->type
, "__data_loc"))
1276 array_descriptor
= NULL
;
1278 if (!array_descriptor
)
1279 seq_printf(m
, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1280 field
->type
, field
->name
, field
->offset
,
1281 field
->size
, !!field
->is_signed
);
1283 seq_printf(m
, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1284 (int)(array_descriptor
- field
->type
),
1285 field
->type
, field
->name
,
1286 array_descriptor
, field
->offset
,
1287 field
->size
, !!field
->is_signed
);
1292 static void *f_start(struct seq_file
*m
, loff_t
*pos
)
1294 void *p
= (void *)FORMAT_HEADER
;
1297 /* ->stop() is called even if ->start() fails */
1298 mutex_lock(&event_mutex
);
1299 if (!event_file_data(m
->private))
1300 return ERR_PTR(-ENODEV
);
1302 while (l
< *pos
&& p
)
1303 p
= f_next(m
, p
, &l
);
1308 static void f_stop(struct seq_file
*m
, void *p
)
1310 mutex_unlock(&event_mutex
);
1313 static const struct seq_operations trace_format_seq_ops
= {
1320 static int trace_format_open(struct inode
*inode
, struct file
*file
)
1325 /* Do we want to hide event format files on tracefs lockdown? */
1327 ret
= seq_open(file
, &trace_format_seq_ops
);
1331 m
= file
->private_data
;
1338 event_id_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
1340 int id
= (long)event_file_data(filp
);
1347 len
= sprintf(buf
, "%d\n", id
);
1349 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, len
);
1353 event_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1356 struct trace_event_file
*file
;
1357 struct trace_seq
*s
;
1363 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1370 mutex_lock(&event_mutex
);
1371 file
= event_file_data(filp
);
1373 print_event_filter(file
, s
);
1374 mutex_unlock(&event_mutex
);
1377 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1378 s
->buffer
, trace_seq_used(s
));
1386 event_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1389 struct trace_event_file
*file
;
1393 if (cnt
>= PAGE_SIZE
)
1396 buf
= memdup_user_nul(ubuf
, cnt
);
1398 return PTR_ERR(buf
);
1400 mutex_lock(&event_mutex
);
1401 file
= event_file_data(filp
);
1403 err
= apply_event_filter(file
, buf
);
1404 mutex_unlock(&event_mutex
);
1415 static LIST_HEAD(event_subsystems
);
1417 static int subsystem_open(struct inode
*inode
, struct file
*filp
)
1419 struct event_subsystem
*system
= NULL
;
1420 struct trace_subsystem_dir
*dir
= NULL
; /* Initialize for gcc */
1421 struct trace_array
*tr
;
1424 if (tracing_is_disabled())
1427 /* Make sure the system still exists */
1428 mutex_lock(&event_mutex
);
1429 mutex_lock(&trace_types_lock
);
1430 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
) {
1431 list_for_each_entry(dir
, &tr
->systems
, list
) {
1432 if (dir
== inode
->i_private
) {
1433 /* Don't open systems with no events */
1434 if (dir
->nr_events
) {
1435 __get_system_dir(dir
);
1436 system
= dir
->subsystem
;
1443 mutex_unlock(&trace_types_lock
);
1444 mutex_unlock(&event_mutex
);
1449 /* Some versions of gcc think dir can be uninitialized here */
1452 /* Still need to increment the ref count of the system */
1453 if (trace_array_get(tr
) < 0) {
1458 ret
= tracing_open_generic(inode
, filp
);
1460 trace_array_put(tr
);
1467 static int system_tr_open(struct inode
*inode
, struct file
*filp
)
1469 struct trace_subsystem_dir
*dir
;
1470 struct trace_array
*tr
= inode
->i_private
;
1473 /* Make a temporary dir that has no system but points to tr */
1474 dir
= kzalloc(sizeof(*dir
), GFP_KERNEL
);
1478 ret
= tracing_open_generic_tr(inode
, filp
);
1484 filp
->private_data
= dir
;
1489 static int subsystem_release(struct inode
*inode
, struct file
*file
)
1491 struct trace_subsystem_dir
*dir
= file
->private_data
;
1493 trace_array_put(dir
->tr
);
1496 * If dir->subsystem is NULL, then this is a temporary
1497 * descriptor that was made for a trace_array to enable
1509 subsystem_filter_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
,
1512 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1513 struct event_subsystem
*system
= dir
->subsystem
;
1514 struct trace_seq
*s
;
1520 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1526 print_subsystem_event_filter(system
, s
);
1527 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1528 s
->buffer
, trace_seq_used(s
));
1536 subsystem_filter_write(struct file
*filp
, const char __user
*ubuf
, size_t cnt
,
1539 struct trace_subsystem_dir
*dir
= filp
->private_data
;
1543 if (cnt
>= PAGE_SIZE
)
1546 buf
= memdup_user_nul(ubuf
, cnt
);
1548 return PTR_ERR(buf
);
1550 err
= apply_subsystem_event_filter(dir
, buf
);
1561 show_header(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
1563 int (*func
)(struct trace_seq
*s
) = filp
->private_data
;
1564 struct trace_seq
*s
;
1570 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1577 r
= simple_read_from_buffer(ubuf
, cnt
, ppos
,
1578 s
->buffer
, trace_seq_used(s
));
1585 static void ignore_task_cpu(void *data
)
1587 struct trace_array
*tr
= data
;
1588 struct trace_pid_list
*pid_list
;
1591 * This function is called by on_each_cpu() while the
1592 * event_mutex is held.
1594 pid_list
= rcu_dereference_protected(tr
->filtered_pids
,
1595 mutex_is_locked(&event_mutex
));
1597 this_cpu_write(tr
->trace_buffer
.data
->ignore_pid
,
1598 trace_ignore_this_task(pid_list
, current
));
1602 ftrace_event_pid_write(struct file
*filp
, const char __user
*ubuf
,
1603 size_t cnt
, loff_t
*ppos
)
1605 struct seq_file
*m
= filp
->private_data
;
1606 struct trace_array
*tr
= m
->private;
1607 struct trace_pid_list
*filtered_pids
= NULL
;
1608 struct trace_pid_list
*pid_list
;
1609 struct trace_event_file
*file
;
1615 ret
= tracing_update_buffers();
1619 mutex_lock(&event_mutex
);
1621 filtered_pids
= rcu_dereference_protected(tr
->filtered_pids
,
1622 lockdep_is_held(&event_mutex
));
1624 ret
= trace_pid_write(filtered_pids
, &pid_list
, ubuf
, cnt
);
1628 rcu_assign_pointer(tr
->filtered_pids
, pid_list
);
1630 list_for_each_entry(file
, &tr
->events
, list
) {
1631 set_bit(EVENT_FILE_FL_PID_FILTER_BIT
, &file
->flags
);
1634 if (filtered_pids
) {
1635 tracepoint_synchronize_unregister();
1636 trace_free_pid_list(filtered_pids
);
1637 } else if (pid_list
) {
1639 * Register a probe that is called before all other probes
1640 * to set ignore_pid if next or prev do not match.
1641 * Register a probe this is called after all other probes
1642 * to only keep ignore_pid set if next pid matches.
1644 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre
,
1646 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post
,
1649 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre
,
1651 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post
,
1654 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre
,
1656 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post
,
1659 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre
,
1661 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post
,
1666 * Ignoring of pids is done at task switch. But we have to
1667 * check for those tasks that are currently running.
1668 * Always do this in case a pid was appended or removed.
1670 on_each_cpu(ignore_task_cpu
, tr
, 1);
1673 mutex_unlock(&event_mutex
);
1681 static int ftrace_event_avail_open(struct inode
*inode
, struct file
*file
);
1682 static int ftrace_event_set_open(struct inode
*inode
, struct file
*file
);
1683 static int ftrace_event_set_pid_open(struct inode
*inode
, struct file
*file
);
1684 static int ftrace_event_release(struct inode
*inode
, struct file
*file
);
1686 static const struct seq_operations show_event_seq_ops
= {
1693 static const struct seq_operations show_set_event_seq_ops
= {
1700 static const struct seq_operations show_set_pid_seq_ops
= {
1703 .show
= trace_pid_show
,
1707 static const struct file_operations ftrace_avail_fops
= {
1708 .open
= ftrace_event_avail_open
,
1710 .llseek
= seq_lseek
,
1711 .release
= seq_release
,
1714 static const struct file_operations ftrace_set_event_fops
= {
1715 .open
= ftrace_event_set_open
,
1717 .write
= ftrace_event_write
,
1718 .llseek
= seq_lseek
,
1719 .release
= ftrace_event_release
,
1722 static const struct file_operations ftrace_set_event_pid_fops
= {
1723 .open
= ftrace_event_set_pid_open
,
1725 .write
= ftrace_event_pid_write
,
1726 .llseek
= seq_lseek
,
1727 .release
= ftrace_event_release
,
1730 static const struct file_operations ftrace_enable_fops
= {
1731 .open
= tracing_open_generic
,
1732 .read
= event_enable_read
,
1733 .write
= event_enable_write
,
1734 .llseek
= default_llseek
,
1737 static const struct file_operations ftrace_event_format_fops
= {
1738 .open
= trace_format_open
,
1740 .llseek
= seq_lseek
,
1741 .release
= seq_release
,
1744 static const struct file_operations ftrace_event_id_fops
= {
1745 .read
= event_id_read
,
1746 .llseek
= default_llseek
,
1749 static const struct file_operations ftrace_event_filter_fops
= {
1750 .open
= tracing_open_generic
,
1751 .read
= event_filter_read
,
1752 .write
= event_filter_write
,
1753 .llseek
= default_llseek
,
1756 static const struct file_operations ftrace_subsystem_filter_fops
= {
1757 .open
= subsystem_open
,
1758 .read
= subsystem_filter_read
,
1759 .write
= subsystem_filter_write
,
1760 .llseek
= default_llseek
,
1761 .release
= subsystem_release
,
1764 static const struct file_operations ftrace_system_enable_fops
= {
1765 .open
= subsystem_open
,
1766 .read
= system_enable_read
,
1767 .write
= system_enable_write
,
1768 .llseek
= default_llseek
,
1769 .release
= subsystem_release
,
1772 static const struct file_operations ftrace_tr_enable_fops
= {
1773 .open
= system_tr_open
,
1774 .read
= system_enable_read
,
1775 .write
= system_enable_write
,
1776 .llseek
= default_llseek
,
1777 .release
= subsystem_release
,
1780 static const struct file_operations ftrace_show_header_fops
= {
1781 .open
= tracing_open_generic
,
1782 .read
= show_header
,
1783 .llseek
= default_llseek
,
1787 ftrace_event_open(struct inode
*inode
, struct file
*file
,
1788 const struct seq_operations
*seq_ops
)
1793 ret
= security_locked_down(LOCKDOWN_TRACEFS
);
1797 ret
= seq_open(file
, seq_ops
);
1800 m
= file
->private_data
;
1801 /* copy tr over to seq ops */
1802 m
->private = inode
->i_private
;
1807 static int ftrace_event_release(struct inode
*inode
, struct file
*file
)
1809 struct trace_array
*tr
= inode
->i_private
;
1811 trace_array_put(tr
);
1813 return seq_release(inode
, file
);
1817 ftrace_event_avail_open(struct inode
*inode
, struct file
*file
)
1819 const struct seq_operations
*seq_ops
= &show_event_seq_ops
;
1821 /* Checks for tracefs lockdown */
1822 return ftrace_event_open(inode
, file
, seq_ops
);
1826 ftrace_event_set_open(struct inode
*inode
, struct file
*file
)
1828 const struct seq_operations
*seq_ops
= &show_set_event_seq_ops
;
1829 struct trace_array
*tr
= inode
->i_private
;
1832 ret
= tracing_check_open_get_tr(tr
);
1836 if ((file
->f_mode
& FMODE_WRITE
) &&
1837 (file
->f_flags
& O_TRUNC
))
1838 ftrace_clear_events(tr
);
1840 ret
= ftrace_event_open(inode
, file
, seq_ops
);
1842 trace_array_put(tr
);
1847 ftrace_event_set_pid_open(struct inode
*inode
, struct file
*file
)
1849 const struct seq_operations
*seq_ops
= &show_set_pid_seq_ops
;
1850 struct trace_array
*tr
= inode
->i_private
;
1853 ret
= tracing_check_open_get_tr(tr
);
1857 if ((file
->f_mode
& FMODE_WRITE
) &&
1858 (file
->f_flags
& O_TRUNC
))
1859 ftrace_clear_event_pids(tr
);
1861 ret
= ftrace_event_open(inode
, file
, seq_ops
);
1863 trace_array_put(tr
);
1867 static struct event_subsystem
*
1868 create_new_subsystem(const char *name
)
1870 struct event_subsystem
*system
;
1872 /* need to create new entry */
1873 system
= kmalloc(sizeof(*system
), GFP_KERNEL
);
1877 system
->ref_count
= 1;
1879 /* Only allocate if dynamic (kprobes and modules) */
1880 system
->name
= kstrdup_const(name
, GFP_KERNEL
);
1884 system
->filter
= NULL
;
1886 system
->filter
= kzalloc(sizeof(struct event_filter
), GFP_KERNEL
);
1887 if (!system
->filter
)
1890 list_add(&system
->list
, &event_subsystems
);
1895 kfree_const(system
->name
);
1900 static struct dentry
*
1901 event_subsystem_dir(struct trace_array
*tr
, const char *name
,
1902 struct trace_event_file
*file
, struct dentry
*parent
)
1904 struct trace_subsystem_dir
*dir
;
1905 struct event_subsystem
*system
;
1906 struct dentry
*entry
;
1908 /* First see if we did not already create this dir */
1909 list_for_each_entry(dir
, &tr
->systems
, list
) {
1910 system
= dir
->subsystem
;
1911 if (strcmp(system
->name
, name
) == 0) {
1918 /* Now see if the system itself exists. */
1919 list_for_each_entry(system
, &event_subsystems
, list
) {
1920 if (strcmp(system
->name
, name
) == 0)
1923 /* Reset system variable when not found */
1924 if (&system
->list
== &event_subsystems
)
1927 dir
= kmalloc(sizeof(*dir
), GFP_KERNEL
);
1932 system
= create_new_subsystem(name
);
1936 __get_system(system
);
1938 dir
->entry
= tracefs_create_dir(name
, parent
);
1940 pr_warn("Failed to create system directory %s\n", name
);
1941 __put_system(system
);
1948 dir
->subsystem
= system
;
1951 entry
= tracefs_create_file("filter", 0644, dir
->entry
, dir
,
1952 &ftrace_subsystem_filter_fops
);
1954 kfree(system
->filter
);
1955 system
->filter
= NULL
;
1956 pr_warn("Could not create tracefs '%s/filter' entry\n", name
);
1959 trace_create_file("enable", 0644, dir
->entry
, dir
,
1960 &ftrace_system_enable_fops
);
1962 list_add(&dir
->list
, &tr
->systems
);
1969 /* Only print this message if failed on memory allocation */
1970 if (!dir
|| !system
)
1971 pr_warn("No memory to create event subsystem %s\n", name
);
1976 event_create_dir(struct dentry
*parent
, struct trace_event_file
*file
)
1978 struct trace_event_call
*call
= file
->event_call
;
1979 struct trace_array
*tr
= file
->tr
;
1980 struct list_head
*head
;
1981 struct dentry
*d_events
;
1986 * If the trace point header did not define TRACE_SYSTEM
1987 * then the system would be called "TRACE_SYSTEM".
1989 if (strcmp(call
->class->system
, TRACE_SYSTEM
) != 0) {
1990 d_events
= event_subsystem_dir(tr
, call
->class->system
, file
, parent
);
1996 name
= trace_event_name(call
);
1997 file
->dir
= tracefs_create_dir(name
, d_events
);
1999 pr_warn("Could not create tracefs '%s' directory\n", name
);
2003 if (call
->class->reg
&& !(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
))
2004 trace_create_file("enable", 0644, file
->dir
, file
,
2005 &ftrace_enable_fops
);
2007 #ifdef CONFIG_PERF_EVENTS
2008 if (call
->event
.type
&& call
->class->reg
)
2009 trace_create_file("id", 0444, file
->dir
,
2010 (void *)(long)call
->event
.type
,
2011 &ftrace_event_id_fops
);
2015 * Other events may have the same class. Only update
2016 * the fields if they are not already defined.
2018 head
= trace_get_fields(call
);
2019 if (list_empty(head
)) {
2020 ret
= call
->class->define_fields(call
);
2022 pr_warn("Could not initialize trace point events/%s\n",
2029 * Only event directories that can be enabled should have
2030 * triggers or filters.
2032 if (!(call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)) {
2033 trace_create_file("filter", 0644, file
->dir
, file
,
2034 &ftrace_event_filter_fops
);
2036 trace_create_file("trigger", 0644, file
->dir
, file
,
2037 &event_trigger_fops
);
2040 #ifdef CONFIG_HIST_TRIGGERS
2041 trace_create_file("hist", 0444, file
->dir
, file
,
2044 trace_create_file("format", 0444, file
->dir
, call
,
2045 &ftrace_event_format_fops
);
2047 #ifdef CONFIG_TRACE_EVENT_INJECT
2048 if (call
->event
.type
&& call
->class->reg
)
2049 trace_create_file("inject", 0200, file
->dir
, file
,
2050 &event_inject_fops
);
2056 static void remove_event_from_tracers(struct trace_event_call
*call
)
2058 struct trace_event_file
*file
;
2059 struct trace_array
*tr
;
2061 do_for_each_event_file_safe(tr
, file
) {
2062 if (file
->event_call
!= call
)
2065 remove_event_file_dir(file
);
2067 * The do_for_each_event_file_safe() is
2068 * a double loop. After finding the call for this
2069 * trace_array, we use break to jump to the next
2073 } while_for_each_event_file();
2076 static void event_remove(struct trace_event_call
*call
)
2078 struct trace_array
*tr
;
2079 struct trace_event_file
*file
;
2081 do_for_each_event_file(tr
, file
) {
2082 if (file
->event_call
!= call
)
2085 if (file
->flags
& EVENT_FILE_FL_WAS_ENABLED
)
2086 tr
->clear_trace
= true;
2088 ftrace_event_enable_disable(file
, 0);
2090 * The do_for_each_event_file() is
2091 * a double loop. After finding the call for this
2092 * trace_array, we use break to jump to the next
2096 } while_for_each_event_file();
2098 if (call
->event
.funcs
)
2099 __unregister_trace_event(&call
->event
);
2100 remove_event_from_tracers(call
);
2101 list_del(&call
->list
);
2104 static int event_init(struct trace_event_call
*call
)
2109 name
= trace_event_name(call
);
2113 if (call
->class->raw_init
) {
2114 ret
= call
->class->raw_init(call
);
2115 if (ret
< 0 && ret
!= -ENOSYS
)
2116 pr_warn("Could not initialize trace events/%s\n", name
);
2123 __register_event(struct trace_event_call
*call
, struct module
*mod
)
2127 ret
= event_init(call
);
2131 list_add(&call
->list
, &ftrace_events
);
2137 static char *eval_replace(char *ptr
, struct trace_eval_map
*map
, int len
)
2142 /* Find the length of the eval value as a string */
2143 elen
= snprintf(ptr
, 0, "%ld", map
->eval_value
);
2144 /* Make sure there's enough room to replace the string with the value */
2148 snprintf(ptr
, elen
+ 1, "%ld", map
->eval_value
);
2150 /* Get the rest of the string of ptr */
2151 rlen
= strlen(ptr
+ len
);
2152 memmove(ptr
+ elen
, ptr
+ len
, rlen
);
2153 /* Make sure we end the new string */
2154 ptr
[elen
+ rlen
] = 0;
2159 static void update_event_printk(struct trace_event_call
*call
,
2160 struct trace_eval_map
*map
)
2164 int len
= strlen(map
->eval_string
);
2166 for (ptr
= call
->print_fmt
; *ptr
; ptr
++) {
2180 if (isdigit(*ptr
)) {
2184 /* Check for alpha chars like ULL */
2185 } while (isalnum(*ptr
));
2189 * A number must have some kind of delimiter after
2190 * it, and we can ignore that too.
2194 if (isalpha(*ptr
) || *ptr
== '_') {
2195 if (strncmp(map
->eval_string
, ptr
, len
) == 0 &&
2196 !isalnum(ptr
[len
]) && ptr
[len
] != '_') {
2197 ptr
= eval_replace(ptr
, map
, len
);
2198 /* enum/sizeof string smaller than value */
2199 if (WARN_ON_ONCE(!ptr
))
2202 * No need to decrement here, as eval_replace()
2203 * returns the pointer to the character passed
2204 * the eval, and two evals can not be placed
2205 * back to back without something in between.
2206 * We can skip that something in between.
2213 } while (isalnum(*ptr
) || *ptr
== '_');
2217 * If what comes after this variable is a '.' or
2218 * '->' then we can continue to ignore that string.
2220 if (*ptr
== '.' || (ptr
[0] == '-' && ptr
[1] == '>')) {
2221 ptr
+= *ptr
== '.' ? 1 : 2;
2227 * Once again, we can skip the delimiter that came
2235 void trace_event_eval_update(struct trace_eval_map
**map
, int len
)
2237 struct trace_event_call
*call
, *p
;
2238 const char *last_system
= NULL
;
2243 down_write(&trace_event_sem
);
2244 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
2245 /* events are usually grouped together with systems */
2246 if (!last_system
|| call
->class->system
!= last_system
) {
2249 last_system
= call
->class->system
;
2253 * Since calls are grouped by systems, the likelyhood that the
2254 * next call in the iteration belongs to the same system as the
2255 * previous call is high. As an optimization, we skip seaching
2256 * for a map[] that matches the call's system if the last call
2257 * was from the same system. That's what last_i is for. If the
2258 * call has the same system as the previous call, then last_i
2259 * will be the index of the first map[] that has a matching
2262 for (i
= last_i
; i
< len
; i
++) {
2263 if (call
->class->system
== map
[i
]->system
) {
2264 /* Save the first system if need be */
2269 update_event_printk(call
, map
[i
]);
2273 up_write(&trace_event_sem
);
2276 static struct trace_event_file
*
2277 trace_create_new_event(struct trace_event_call
*call
,
2278 struct trace_array
*tr
)
2280 struct trace_event_file
*file
;
2282 file
= kmem_cache_alloc(file_cachep
, GFP_TRACE
);
2286 file
->event_call
= call
;
2288 atomic_set(&file
->sm_ref
, 0);
2289 atomic_set(&file
->tm_ref
, 0);
2290 INIT_LIST_HEAD(&file
->triggers
);
2291 list_add(&file
->list
, &tr
->events
);
2296 /* Add an event to a trace directory */
2298 __trace_add_new_event(struct trace_event_call
*call
, struct trace_array
*tr
)
2300 struct trace_event_file
*file
;
2302 file
= trace_create_new_event(call
, tr
);
2306 return event_create_dir(tr
->event_dir
, file
);
2310 * Just create a decriptor for early init. A descriptor is required
2311 * for enabling events at boot. We want to enable events before
2312 * the filesystem is initialized.
2315 __trace_early_add_new_event(struct trace_event_call
*call
,
2316 struct trace_array
*tr
)
2318 struct trace_event_file
*file
;
2320 file
= trace_create_new_event(call
, tr
);
2327 struct ftrace_module_file_ops
;
2328 static void __add_event_to_tracers(struct trace_event_call
*call
);
2330 /* Add an additional event_call dynamically */
2331 int trace_add_event_call(struct trace_event_call
*call
)
2334 lockdep_assert_held(&event_mutex
);
2336 mutex_lock(&trace_types_lock
);
2338 ret
= __register_event(call
, NULL
);
2340 __add_event_to_tracers(call
);
2342 mutex_unlock(&trace_types_lock
);
2347 * Must be called under locking of trace_types_lock, event_mutex and
2350 static void __trace_remove_event_call(struct trace_event_call
*call
)
2353 trace_destroy_fields(call
);
2354 free_event_filter(call
->filter
);
2355 call
->filter
= NULL
;
2358 static int probe_remove_event_call(struct trace_event_call
*call
)
2360 struct trace_array
*tr
;
2361 struct trace_event_file
*file
;
2363 #ifdef CONFIG_PERF_EVENTS
2364 if (call
->perf_refcount
)
2367 do_for_each_event_file(tr
, file
) {
2368 if (file
->event_call
!= call
)
2371 * We can't rely on ftrace_event_enable_disable(enable => 0)
2372 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
2373 * TRACE_REG_UNREGISTER.
2375 if (file
->flags
& EVENT_FILE_FL_ENABLED
)
2378 * The do_for_each_event_file_safe() is
2379 * a double loop. After finding the call for this
2380 * trace_array, we use break to jump to the next
2384 } while_for_each_event_file();
2386 __trace_remove_event_call(call
);
2391 /* Remove an event_call */
2392 int trace_remove_event_call(struct trace_event_call
*call
)
2396 lockdep_assert_held(&event_mutex
);
2398 mutex_lock(&trace_types_lock
);
2399 down_write(&trace_event_sem
);
2400 ret
= probe_remove_event_call(call
);
2401 up_write(&trace_event_sem
);
2402 mutex_unlock(&trace_types_lock
);
2407 #define for_each_event(event, start, end) \
2408 for (event = start; \
2409 (unsigned long)event < (unsigned long)end; \
2412 #ifdef CONFIG_MODULES
2414 static void trace_module_add_events(struct module
*mod
)
2416 struct trace_event_call
**call
, **start
, **end
;
2418 if (!mod
->num_trace_events
)
2421 /* Don't add infrastructure for mods without tracepoints */
2422 if (trace_module_has_bad_taint(mod
)) {
2423 pr_err("%s: module has bad taint, not creating trace events\n",
2428 start
= mod
->trace_events
;
2429 end
= mod
->trace_events
+ mod
->num_trace_events
;
2431 for_each_event(call
, start
, end
) {
2432 __register_event(*call
, mod
);
2433 __add_event_to_tracers(*call
);
2437 static void trace_module_remove_events(struct module
*mod
)
2439 struct trace_event_call
*call
, *p
;
2441 down_write(&trace_event_sem
);
2442 list_for_each_entry_safe(call
, p
, &ftrace_events
, list
) {
2443 if (call
->mod
== mod
)
2444 __trace_remove_event_call(call
);
2446 up_write(&trace_event_sem
);
2449 * It is safest to reset the ring buffer if the module being unloaded
2450 * registered any events that were used. The only worry is if
2451 * a new module gets loaded, and takes on the same id as the events
2452 * of this module. When printing out the buffer, traced events left
2453 * over from this module may be passed to the new module events and
2454 * unexpected results may occur.
2456 tracing_reset_all_online_cpus();
2459 static int trace_module_notify(struct notifier_block
*self
,
2460 unsigned long val
, void *data
)
2462 struct module
*mod
= data
;
2464 mutex_lock(&event_mutex
);
2465 mutex_lock(&trace_types_lock
);
2467 case MODULE_STATE_COMING
:
2468 trace_module_add_events(mod
);
2470 case MODULE_STATE_GOING
:
2471 trace_module_remove_events(mod
);
2474 mutex_unlock(&trace_types_lock
);
2475 mutex_unlock(&event_mutex
);
2480 static struct notifier_block trace_module_nb
= {
2481 .notifier_call
= trace_module_notify
,
2482 .priority
= 1, /* higher than trace.c module notify */
2484 #endif /* CONFIG_MODULES */
2486 /* Create a new event directory structure for a trace directory. */
2488 __trace_add_event_dirs(struct trace_array
*tr
)
2490 struct trace_event_call
*call
;
2493 list_for_each_entry(call
, &ftrace_events
, list
) {
2494 ret
= __trace_add_new_event(call
, tr
);
2496 pr_warn("Could not create directory for event %s\n",
2497 trace_event_name(call
));
2501 /* Returns any file that matches the system and event */
2502 struct trace_event_file
*
2503 __find_event_file(struct trace_array
*tr
, const char *system
, const char *event
)
2505 struct trace_event_file
*file
;
2506 struct trace_event_call
*call
;
2509 list_for_each_entry(file
, &tr
->events
, list
) {
2511 call
= file
->event_call
;
2512 name
= trace_event_name(call
);
2514 if (!name
|| !call
->class)
2517 if (strcmp(event
, name
) == 0 &&
2518 strcmp(system
, call
->class->system
) == 0)
2524 /* Returns valid trace event files that match system and event */
2525 struct trace_event_file
*
2526 find_event_file(struct trace_array
*tr
, const char *system
, const char *event
)
2528 struct trace_event_file
*file
;
2530 file
= __find_event_file(tr
, system
, event
);
2531 if (!file
|| !file
->event_call
->class->reg
||
2532 file
->event_call
->flags
& TRACE_EVENT_FL_IGNORE_ENABLE
)
2538 #ifdef CONFIG_DYNAMIC_FTRACE
2541 #define ENABLE_EVENT_STR "enable_event"
2542 #define DISABLE_EVENT_STR "disable_event"
2544 struct event_probe_data
{
2545 struct trace_event_file
*file
;
2546 unsigned long count
;
2551 static void update_event_probe(struct event_probe_data
*data
)
2554 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
2556 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT
, &data
->file
->flags
);
2560 event_enable_probe(unsigned long ip
, unsigned long parent_ip
,
2561 struct trace_array
*tr
, struct ftrace_probe_ops
*ops
,
2564 struct ftrace_func_mapper
*mapper
= data
;
2565 struct event_probe_data
*edata
;
2568 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2569 if (!pdata
|| !*pdata
)
2573 update_event_probe(edata
);
2577 event_enable_count_probe(unsigned long ip
, unsigned long parent_ip
,
2578 struct trace_array
*tr
, struct ftrace_probe_ops
*ops
,
2581 struct ftrace_func_mapper
*mapper
= data
;
2582 struct event_probe_data
*edata
;
2585 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2586 if (!pdata
|| !*pdata
)
2594 /* Skip if the event is in a state we want to switch to */
2595 if (edata
->enable
== !(edata
->file
->flags
& EVENT_FILE_FL_SOFT_DISABLED
))
2598 if (edata
->count
!= -1)
2601 update_event_probe(edata
);
2605 event_enable_print(struct seq_file
*m
, unsigned long ip
,
2606 struct ftrace_probe_ops
*ops
, void *data
)
2608 struct ftrace_func_mapper
*mapper
= data
;
2609 struct event_probe_data
*edata
;
2612 pdata
= ftrace_func_mapper_find_ip(mapper
, ip
);
2614 if (WARN_ON_ONCE(!pdata
|| !*pdata
))
2619 seq_printf(m
, "%ps:", (void *)ip
);
2621 seq_printf(m
, "%s:%s:%s",
2622 edata
->enable
? ENABLE_EVENT_STR
: DISABLE_EVENT_STR
,
2623 edata
->file
->event_call
->class->system
,
2624 trace_event_name(edata
->file
->event_call
));
2626 if (edata
->count
== -1)
2627 seq_puts(m
, ":unlimited\n");
2629 seq_printf(m
, ":count=%ld\n", edata
->count
);
2635 event_enable_init(struct ftrace_probe_ops
*ops
, struct trace_array
*tr
,
2636 unsigned long ip
, void *init_data
, void **data
)
2638 struct ftrace_func_mapper
*mapper
= *data
;
2639 struct event_probe_data
*edata
= init_data
;
2643 mapper
= allocate_ftrace_func_mapper();
2649 ret
= ftrace_func_mapper_add_ip(mapper
, ip
, edata
);
2658 static int free_probe_data(void *data
)
2660 struct event_probe_data
*edata
= data
;
2664 /* Remove the SOFT_MODE flag */
2665 __ftrace_event_enable_disable(edata
->file
, 0, 1);
2666 module_put(edata
->file
->event_call
->mod
);
2673 event_enable_free(struct ftrace_probe_ops
*ops
, struct trace_array
*tr
,
2674 unsigned long ip
, void *data
)
2676 struct ftrace_func_mapper
*mapper
= data
;
2677 struct event_probe_data
*edata
;
2682 free_ftrace_func_mapper(mapper
, free_probe_data
);
2686 edata
= ftrace_func_mapper_remove_ip(mapper
, ip
);
2688 if (WARN_ON_ONCE(!edata
))
2691 if (WARN_ON_ONCE(edata
->ref
<= 0))
2694 free_probe_data(edata
);
2697 static struct ftrace_probe_ops event_enable_probe_ops
= {
2698 .func
= event_enable_probe
,
2699 .print
= event_enable_print
,
2700 .init
= event_enable_init
,
2701 .free
= event_enable_free
,
2704 static struct ftrace_probe_ops event_enable_count_probe_ops
= {
2705 .func
= event_enable_count_probe
,
2706 .print
= event_enable_print
,
2707 .init
= event_enable_init
,
2708 .free
= event_enable_free
,
2711 static struct ftrace_probe_ops event_disable_probe_ops
= {
2712 .func
= event_enable_probe
,
2713 .print
= event_enable_print
,
2714 .init
= event_enable_init
,
2715 .free
= event_enable_free
,
2718 static struct ftrace_probe_ops event_disable_count_probe_ops
= {
2719 .func
= event_enable_count_probe
,
2720 .print
= event_enable_print
,
2721 .init
= event_enable_init
,
2722 .free
= event_enable_free
,
2726 event_enable_func(struct trace_array
*tr
, struct ftrace_hash
*hash
,
2727 char *glob
, char *cmd
, char *param
, int enabled
)
2729 struct trace_event_file
*file
;
2730 struct ftrace_probe_ops
*ops
;
2731 struct event_probe_data
*data
;
2741 /* hash funcs only work with set_ftrace_filter */
2742 if (!enabled
|| !param
)
2745 system
= strsep(¶m
, ":");
2749 event
= strsep(¶m
, ":");
2751 mutex_lock(&event_mutex
);
2754 file
= find_event_file(tr
, system
, event
);
2758 enable
= strcmp(cmd
, ENABLE_EVENT_STR
) == 0;
2761 ops
= param
? &event_enable_count_probe_ops
: &event_enable_probe_ops
;
2763 ops
= param
? &event_disable_count_probe_ops
: &event_disable_probe_ops
;
2765 if (glob
[0] == '!') {
2766 ret
= unregister_ftrace_function_probe_func(glob
+1, tr
, ops
);
2772 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
2776 data
->enable
= enable
;
2783 number
= strsep(¶m
, ":");
2786 if (!strlen(number
))
2790 * We use the callback data field (which is a pointer)
2793 ret
= kstrtoul(number
, 0, &data
->count
);
2798 /* Don't let event modules unload while probe registered */
2799 ret
= try_module_get(file
->event_call
->mod
);
2805 ret
= __ftrace_event_enable_disable(file
, 1, 1);
2809 ret
= register_ftrace_function_probe(glob
, tr
, ops
, data
);
2811 * The above returns on success the # of functions enabled,
2812 * but if it didn't find any functions it returns zero.
2813 * Consider no functions a failure too.
2820 /* Just return zero, not the number of enabled functions */
2823 mutex_unlock(&event_mutex
);
2827 __ftrace_event_enable_disable(file
, 0, 1);
2829 module_put(file
->event_call
->mod
);
2835 static struct ftrace_func_command event_enable_cmd
= {
2836 .name
= ENABLE_EVENT_STR
,
2837 .func
= event_enable_func
,
2840 static struct ftrace_func_command event_disable_cmd
= {
2841 .name
= DISABLE_EVENT_STR
,
2842 .func
= event_enable_func
,
2845 static __init
int register_event_cmds(void)
2849 ret
= register_ftrace_command(&event_enable_cmd
);
2850 if (WARN_ON(ret
< 0))
2852 ret
= register_ftrace_command(&event_disable_cmd
);
2853 if (WARN_ON(ret
< 0))
2854 unregister_ftrace_command(&event_enable_cmd
);
2858 static inline int register_event_cmds(void) { return 0; }
2859 #endif /* CONFIG_DYNAMIC_FTRACE */
2862 * The top level array has already had its trace_event_file
2863 * descriptors created in order to allow for early events to
2864 * be recorded. This function is called after the tracefs has been
2865 * initialized, and we now have to create the files associated
2869 __trace_early_add_event_dirs(struct trace_array
*tr
)
2871 struct trace_event_file
*file
;
2875 list_for_each_entry(file
, &tr
->events
, list
) {
2876 ret
= event_create_dir(tr
->event_dir
, file
);
2878 pr_warn("Could not create directory for event %s\n",
2879 trace_event_name(file
->event_call
));
2884 * For early boot up, the top trace array requires to have
2885 * a list of events that can be enabled. This must be done before
2886 * the filesystem is set up in order to allow events to be traced
2890 __trace_early_add_events(struct trace_array
*tr
)
2892 struct trace_event_call
*call
;
2895 list_for_each_entry(call
, &ftrace_events
, list
) {
2896 /* Early boot up should not have any modules loaded */
2897 if (WARN_ON_ONCE(call
->mod
))
2900 ret
= __trace_early_add_new_event(call
, tr
);
2902 pr_warn("Could not create early event %s\n",
2903 trace_event_name(call
));
2907 /* Remove the event directory structure for a trace directory. */
2909 __trace_remove_event_dirs(struct trace_array
*tr
)
2911 struct trace_event_file
*file
, *next
;
2913 list_for_each_entry_safe(file
, next
, &tr
->events
, list
)
2914 remove_event_file_dir(file
);
2917 static void __add_event_to_tracers(struct trace_event_call
*call
)
2919 struct trace_array
*tr
;
2921 list_for_each_entry(tr
, &ftrace_trace_arrays
, list
)
2922 __trace_add_new_event(call
, tr
);
2925 extern struct trace_event_call
*__start_ftrace_events
[];
2926 extern struct trace_event_call
*__stop_ftrace_events
[];
2928 static char bootup_event_buf
[COMMAND_LINE_SIZE
] __initdata
;
2930 static __init
int setup_trace_event(char *str
)
2932 strlcpy(bootup_event_buf
, str
, COMMAND_LINE_SIZE
);
2933 ring_buffer_expanded
= true;
2934 tracing_selftest_disabled
= true;
2938 __setup("trace_event=", setup_trace_event
);
2940 /* Expects to have event_mutex held when called */
2942 create_event_toplevel_files(struct dentry
*parent
, struct trace_array
*tr
)
2944 struct dentry
*d_events
;
2945 struct dentry
*entry
;
2947 entry
= tracefs_create_file("set_event", 0644, parent
,
2948 tr
, &ftrace_set_event_fops
);
2950 pr_warn("Could not create tracefs 'set_event' entry\n");
2954 d_events
= tracefs_create_dir("events", parent
);
2956 pr_warn("Could not create tracefs 'events' directory\n");
2960 entry
= trace_create_file("enable", 0644, d_events
,
2961 tr
, &ftrace_tr_enable_fops
);
2963 pr_warn("Could not create tracefs 'enable' entry\n");
2967 /* There are not as crucial, just warn if they are not created */
2969 entry
= tracefs_create_file("set_event_pid", 0644, parent
,
2970 tr
, &ftrace_set_event_pid_fops
);
2972 pr_warn("Could not create tracefs 'set_event_pid' entry\n");
2974 /* ring buffer internal formats */
2975 entry
= trace_create_file("header_page", 0444, d_events
,
2976 ring_buffer_print_page_header
,
2977 &ftrace_show_header_fops
);
2979 pr_warn("Could not create tracefs 'header_page' entry\n");
2981 entry
= trace_create_file("header_event", 0444, d_events
,
2982 ring_buffer_print_entry_header
,
2983 &ftrace_show_header_fops
);
2985 pr_warn("Could not create tracefs 'header_event' entry\n");
2987 tr
->event_dir
= d_events
;
2993 * event_trace_add_tracer - add a instance of a trace_array to events
2994 * @parent: The parent dentry to place the files/directories for events in
2995 * @tr: The trace array associated with these events
2997 * When a new instance is created, it needs to set up its events
2998 * directory, as well as other files associated with events. It also
2999 * creates the event hierachry in the @parent/events directory.
3001 * Returns 0 on success.
3003 * Must be called with event_mutex held.
3005 int event_trace_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
3009 lockdep_assert_held(&event_mutex
);
3011 ret
= create_event_toplevel_files(parent
, tr
);
3015 down_write(&trace_event_sem
);
3016 __trace_add_event_dirs(tr
);
3017 up_write(&trace_event_sem
);
3024 * The top trace array already had its file descriptors created.
3025 * Now the files themselves need to be created.
3028 early_event_add_tracer(struct dentry
*parent
, struct trace_array
*tr
)
3032 mutex_lock(&event_mutex
);
3034 ret
= create_event_toplevel_files(parent
, tr
);
3038 down_write(&trace_event_sem
);
3039 __trace_early_add_event_dirs(tr
);
3040 up_write(&trace_event_sem
);
3043 mutex_unlock(&event_mutex
);
3048 /* Must be called with event_mutex held */
3049 int event_trace_del_tracer(struct trace_array
*tr
)
3051 lockdep_assert_held(&event_mutex
);
3053 /* Disable any event triggers and associated soft-disabled events */
3054 clear_event_triggers(tr
);
3056 /* Clear the pid list */
3057 __ftrace_clear_event_pids(tr
);
3059 /* Disable any running events */
3060 __ftrace_set_clr_event_nolock(tr
, NULL
, NULL
, NULL
, 0);
3062 /* Make sure no more events are being executed */
3063 tracepoint_synchronize_unregister();
3065 down_write(&trace_event_sem
);
3066 __trace_remove_event_dirs(tr
);
3067 tracefs_remove_recursive(tr
->event_dir
);
3068 up_write(&trace_event_sem
);
3070 tr
->event_dir
= NULL
;
3075 static __init
int event_trace_memsetup(void)
3077 field_cachep
= KMEM_CACHE(ftrace_event_field
, SLAB_PANIC
);
3078 file_cachep
= KMEM_CACHE(trace_event_file
, SLAB_PANIC
);
3083 early_enable_events(struct trace_array
*tr
, bool disable_first
)
3085 char *buf
= bootup_event_buf
;
3090 token
= strsep(&buf
, ",");
3096 /* Restarting syscalls requires that we stop them first */
3098 ftrace_set_clr_event(tr
, token
, 0);
3100 ret
= ftrace_set_clr_event(tr
, token
, 1);
3102 pr_warn("Failed to enable trace event: %s\n", token
);
3105 /* Put back the comma to allow this to be called again */
3111 static __init
int event_trace_enable(void)
3113 struct trace_array
*tr
= top_trace_array();
3114 struct trace_event_call
**iter
, *call
;
3120 for_each_event(iter
, __start_ftrace_events
, __stop_ftrace_events
) {
3123 ret
= event_init(call
);
3125 list_add(&call
->list
, &ftrace_events
);
3129 * We need the top trace array to have a working set of trace
3130 * points at early init, before the debug files and directories
3131 * are created. Create the file entries now, and attach them
3132 * to the actual file dentries later.
3134 __trace_early_add_events(tr
);
3136 early_enable_events(tr
, false);
3138 trace_printk_start_comm();
3140 register_event_cmds();
3142 register_trigger_cmds();
3148 * event_trace_enable() is called from trace_event_init() first to
3149 * initialize events and perhaps start any events that are on the
3150 * command line. Unfortunately, there are some events that will not
3151 * start this early, like the system call tracepoints that need
3152 * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable()
3153 * is called before pid 1 starts, and this flag is never set, making
3154 * the syscall tracepoint never get reached, but the event is enabled
3155 * regardless (and not doing anything).
3157 static __init
int event_trace_enable_again(void)
3159 struct trace_array
*tr
;
3161 tr
= top_trace_array();
3165 early_enable_events(tr
, true);
3170 early_initcall(event_trace_enable_again
);
3172 __init
int event_trace_init(void)
3174 struct trace_array
*tr
;
3175 struct dentry
*d_tracer
;
3176 struct dentry
*entry
;
3179 tr
= top_trace_array();
3183 d_tracer
= tracing_init_dentry();
3184 if (IS_ERR(d_tracer
))
3187 entry
= tracefs_create_file("available_events", 0444, d_tracer
,
3188 tr
, &ftrace_avail_fops
);
3190 pr_warn("Could not create tracefs 'available_events' entry\n");
3192 if (trace_define_generic_fields())
3193 pr_warn("tracing: Failed to allocated generic fields");
3195 if (trace_define_common_fields())
3196 pr_warn("tracing: Failed to allocate common fields");
3198 ret
= early_event_add_tracer(d_tracer
, tr
);
3202 #ifdef CONFIG_MODULES
3203 ret
= register_module_notifier(&trace_module_nb
);
3205 pr_warn("Failed to register trace events module notifier\n");
3210 void __init
trace_event_init(void)
3212 event_trace_memsetup();
3213 init_ftrace_syscalls();
3214 event_trace_enable();
3217 #ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
3219 static DEFINE_SPINLOCK(test_spinlock
);
3220 static DEFINE_SPINLOCK(test_spinlock_irq
);
3221 static DEFINE_MUTEX(test_mutex
);
3223 static __init
void test_work(struct work_struct
*dummy
)
3225 spin_lock(&test_spinlock
);
3226 spin_lock_irq(&test_spinlock_irq
);
3228 spin_unlock_irq(&test_spinlock_irq
);
3229 spin_unlock(&test_spinlock
);
3231 mutex_lock(&test_mutex
);
3233 mutex_unlock(&test_mutex
);
3236 static __init
int event_test_thread(void *unused
)
3240 test_malloc
= kmalloc(1234, GFP_KERNEL
);
3242 pr_info("failed to kmalloc\n");
3244 schedule_on_each_cpu(test_work
);
3248 set_current_state(TASK_INTERRUPTIBLE
);
3249 while (!kthread_should_stop()) {
3251 set_current_state(TASK_INTERRUPTIBLE
);
3253 __set_current_state(TASK_RUNNING
);
3259 * Do various things that may trigger events.
3261 static __init
void event_test_stuff(void)
3263 struct task_struct
*test_thread
;
3265 test_thread
= kthread_run(event_test_thread
, NULL
, "test-events");
3267 kthread_stop(test_thread
);
3271 * For every trace event defined, we will test each trace point separately,
3272 * and then by groups, and finally all trace points.
3274 static __init
void event_trace_self_tests(void)
3276 struct trace_subsystem_dir
*dir
;
3277 struct trace_event_file
*file
;
3278 struct trace_event_call
*call
;
3279 struct event_subsystem
*system
;
3280 struct trace_array
*tr
;
3283 tr
= top_trace_array();
3287 pr_info("Running tests on trace events:\n");
3289 list_for_each_entry(file
, &tr
->events
, list
) {
3291 call
= file
->event_call
;
3293 /* Only test those that have a probe */
3294 if (!call
->class || !call
->class->probe
)
3298 * Testing syscall events here is pretty useless, but
3299 * we still do it if configured. But this is time consuming.
3300 * What we really need is a user thread to perform the
3301 * syscalls as we test.
3303 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
3304 if (call
->class->system
&&
3305 strcmp(call
->class->system
, "syscalls") == 0)
3309 pr_info("Testing event %s: ", trace_event_name(call
));
3312 * If an event is already enabled, someone is using
3313 * it and the self test should not be on.
3315 if (file
->flags
& EVENT_FILE_FL_ENABLED
) {
3316 pr_warn("Enabled event during self test!\n");
3321 ftrace_event_enable_disable(file
, 1);
3323 ftrace_event_enable_disable(file
, 0);
3328 /* Now test at the sub system level */
3330 pr_info("Running tests on trace event systems:\n");
3332 list_for_each_entry(dir
, &tr
->systems
, list
) {
3334 system
= dir
->subsystem
;
3336 /* the ftrace system is special, skip it */
3337 if (strcmp(system
->name
, "ftrace") == 0)
3340 pr_info("Testing event system %s: ", system
->name
);
3342 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 1);
3343 if (WARN_ON_ONCE(ret
)) {
3344 pr_warn("error enabling system %s\n",
3351 ret
= __ftrace_set_clr_event(tr
, NULL
, system
->name
, NULL
, 0);
3352 if (WARN_ON_ONCE(ret
)) {
3353 pr_warn("error disabling system %s\n",
3361 /* Test with all events enabled */
3363 pr_info("Running tests on all trace events:\n");
3364 pr_info("Testing all events: ");
3366 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 1);
3367 if (WARN_ON_ONCE(ret
)) {
3368 pr_warn("error enabling all events\n");
3375 ret
= __ftrace_set_clr_event(tr
, NULL
, NULL
, NULL
, 0);
3376 if (WARN_ON_ONCE(ret
)) {
3377 pr_warn("error disabling all events\n");
3384 #ifdef CONFIG_FUNCTION_TRACER
3386 static DEFINE_PER_CPU(atomic_t
, ftrace_test_event_disable
);
3388 static struct trace_event_file event_trace_file __initdata
;
3391 function_test_events_call(unsigned long ip
, unsigned long parent_ip
,
3392 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
3394 struct ring_buffer_event
*event
;
3395 struct ring_buffer
*buffer
;
3396 struct ftrace_entry
*entry
;
3397 unsigned long flags
;
3402 pc
= preempt_count();
3403 preempt_disable_notrace();
3404 cpu
= raw_smp_processor_id();
3405 disabled
= atomic_inc_return(&per_cpu(ftrace_test_event_disable
, cpu
));
3410 local_save_flags(flags
);
3412 event
= trace_event_buffer_lock_reserve(&buffer
, &event_trace_file
,
3413 TRACE_FN
, sizeof(*entry
),
3417 entry
= ring_buffer_event_data(event
);
3419 entry
->parent_ip
= parent_ip
;
3421 event_trigger_unlock_commit(&event_trace_file
, buffer
, event
,
3424 atomic_dec(&per_cpu(ftrace_test_event_disable
, cpu
));
3425 preempt_enable_notrace();
3428 static struct ftrace_ops trace_ops __initdata
=
3430 .func
= function_test_events_call
,
3431 .flags
= FTRACE_OPS_FL_RECURSION_SAFE
,
3434 static __init
void event_trace_self_test_with_function(void)
3438 event_trace_file
.tr
= top_trace_array();
3439 if (WARN_ON(!event_trace_file
.tr
))
3442 ret
= register_ftrace_function(&trace_ops
);
3443 if (WARN_ON(ret
< 0)) {
3444 pr_info("Failed to enable function tracer for event tests\n");
3447 pr_info("Running tests again, along with the function tracer\n");
3448 event_trace_self_tests();
3449 unregister_ftrace_function(&trace_ops
);
3452 static __init
void event_trace_self_test_with_function(void)
3457 static __init
int event_trace_self_tests_init(void)
3459 if (!tracing_selftest_disabled
) {
3460 event_trace_self_tests();
3461 event_trace_self_test_with_function();
3467 late_initcall(event_trace_self_tests_init
);