?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.9.243
[linux/fpc-iii.git] / kernel / trace / trace_events.c
blob5bf072e437c413536e0314ce1ac718c113e69eda
1 /*
2 * event tracer
3 *
4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
5 *
6 * - Added format output of fields of the trace point.
7 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
8 *
9 */
10
11 #define pr_fmt(fmt) fmt
12
13 #include <linux/workqueue.h>
14 #include <linux/spinlock.h>
15 #include <linux/kthread.h>
16 #include <linux/tracefs.h>
17 #include <linux/uaccess.h>
18 #include <linux/module.h>
19 #include <linux/ctype.h>
20 #include <linux/sort.h>
21 #include <linux/slab.h>
22 #include <linux/delay.h>
23
24 #include <trace/events/sched.h>
25
26 #include <asm/setup.h>
27
28 #include "trace_output.h"
29
30 #undef TRACE_SYSTEM
31 #define TRACE_SYSTEM "TRACE_SYSTEM"
32
33 DEFINE_MUTEX(event_mutex);
34
35 LIST_HEAD(ftrace_events);
36 static LIST_HEAD(ftrace_generic_fields);
37 static LIST_HEAD(ftrace_common_fields);
38
39 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
40
41 static struct kmem_cache *field_cachep;
42 static struct kmem_cache *file_cachep;
43
44 static inline int system_refcount(struct event_subsystem *system)
45 {
46 return system->ref_count;
47 }
48
49 static int system_refcount_inc(struct event_subsystem *system)
50 {
51 return system->ref_count++;
52 }
53
54 static int system_refcount_dec(struct event_subsystem *system)
55 {
56 return --system->ref_count;
57 }
58
59 /* Double loops, do not use break, only goto's work */
60 #define do_for_each_event_file(tr, file) \
61 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
62 list_for_each_entry(file, &tr->events, list)
63
64 #define do_for_each_event_file_safe(tr, file) \
65 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
66 struct trace_event_file *___n; \
67 list_for_each_entry_safe(file, ___n, &tr->events, list)
68
69 #define while_for_each_event_file() \
70 }
71
72 static struct list_head *
73 trace_get_fields(struct trace_event_call *event_call)
74 {
75 if (!event_call->class->get_fields)
76 return &event_call->class->fields;
77 return event_call->class->get_fields(event_call);
78 }
79
80 static struct ftrace_event_field *
81 __find_event_field(struct list_head *head, char *name)
82 {
83 struct ftrace_event_field *field;
84
85 list_for_each_entry(field, head, link) {
86 if (!strcmp(field->name, name))
87 return field;
88 }
89
90 return NULL;
91 }
92
93 struct ftrace_event_field *
94 trace_find_event_field(struct trace_event_call *call, char *name)
95 {
96 struct ftrace_event_field *field;
97 struct list_head *head;
98
99 head = trace_get_fields(call);
100 field = __find_event_field(head, name);
101 if (field)
102 return field;
103
104 field = __find_event_field(&ftrace_generic_fields, name);
105 if (field)
106 return field;
107
108 return __find_event_field(&ftrace_common_fields, name);
109 }
110
111 static int __trace_define_field(struct list_head *head, const char *type,
112 const char *name, int offset, int size,
113 int is_signed, int filter_type)
114 {
115 struct ftrace_event_field *field;
116
117 field = kmem_cache_alloc(field_cachep, GFP_TRACE);
118 if (!field)
119 return -ENOMEM;
120
121 field->name = name;
122 field->type = type;
123
124 if (filter_type == FILTER_OTHER)
125 field->filter_type = filter_assign_type(type);
126 else
127 field->filter_type = filter_type;
128
129 field->offset = offset;
130 field->size = size;
131 field->is_signed = is_signed;
132
133 list_add(&field->link, head);
134
135 return 0;
136 }
137
138 int trace_define_field(struct trace_event_call *call, const char *type,
139 const char *name, int offset, int size, int is_signed,
140 int filter_type)
141 {
142 struct list_head *head;
143
144 if (WARN_ON(!call->class))
145 return 0;
146
147 head = trace_get_fields(call);
148 return __trace_define_field(head, type, name, offset, size,
149 is_signed, filter_type);
150 }
151 EXPORT_SYMBOL_GPL(trace_define_field);
152
153 #define __generic_field(type, item, filter_type) \
154 ret = __trace_define_field(&ftrace_generic_fields, #type, \
155 #item, 0, 0, is_signed_type(type), \
156 filter_type); \
157 if (ret) \
158 return ret;
159
160 #define __common_field(type, item) \
161 ret = __trace_define_field(&ftrace_common_fields, #type, \
162 "common_" #item, \
163 offsetof(typeof(ent), item), \
164 sizeof(ent.item), \
165 is_signed_type(type), FILTER_OTHER); \
166 if (ret) \
167 return ret;
168
169 static int trace_define_generic_fields(void)
170 {
171 int ret;
172
173 __generic_field(int, CPU, FILTER_CPU);
174 __generic_field(int, cpu, FILTER_CPU);
175 __generic_field(char *, COMM, FILTER_COMM);
176 __generic_field(char *, comm, FILTER_COMM);
177
178 return ret;
179 }
180
181 static int trace_define_common_fields(void)
182 {
183 int ret;
184 struct trace_entry ent;
185
186 __common_field(unsigned short, type);
187 __common_field(unsigned char, flags);
188 __common_field(unsigned char, preempt_count);
189 __common_field(int, pid);
190
191 return ret;
192 }
193
194 static void trace_destroy_fields(struct trace_event_call *call)
195 {
196 struct ftrace_event_field *field, *next;
197 struct list_head *head;
198
199 head = trace_get_fields(call);
200 list_for_each_entry_safe(field, next, head, link) {
201 list_del(&field->link);
202 kmem_cache_free(field_cachep, field);
203 }
204 }
205
206 /*
207 * run-time version of trace_event_get_offsets_<call>() that returns the last
208 * accessible offset of trace fields excluding __dynamic_array bytes
209 */
210 int trace_event_get_offsets(struct trace_event_call *call)
211 {
212 struct ftrace_event_field *tail;
213 struct list_head *head;
214
215 head = trace_get_fields(call);
216 /*
217 * head->next points to the last field with the largest offset,
218 * since it was added last by trace_define_field()
219 */
220 tail = list_first_entry(head, struct ftrace_event_field, link);
221 return tail->offset + tail->size;
222 }
223
224 int trace_event_raw_init(struct trace_event_call *call)
225 {
226 int id;
227
228 id = register_trace_event(&call->event);
229 if (!id)
230 return -ENODEV;
231
232 return 0;
233 }
234 EXPORT_SYMBOL_GPL(trace_event_raw_init);
235
236 bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
237 {
238 struct trace_array *tr = trace_file->tr;
239 struct trace_array_cpu *data;
240 struct trace_pid_list *pid_list;
241
242 pid_list = rcu_dereference_sched(tr->filtered_pids);
243 if (!pid_list)
244 return false;
245
246 data = this_cpu_ptr(tr->trace_buffer.data);
247
248 return data->ignore_pid;
249 }
250 EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid);
251
252 void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
253 struct trace_event_file *trace_file,
254 unsigned long len)
255 {
256 struct trace_event_call *event_call = trace_file->event_call;
257
258 if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) &&
259 trace_event_ignore_this_pid(trace_file))
260 return NULL;
261
262 local_save_flags(fbuffer->flags);
263 fbuffer->pc = preempt_count();
264 /*
265 * If CONFIG_PREEMPT is enabled, then the tracepoint itself disables
266 * preemption (adding one to the preempt_count). Since we are
267 * interested in the preempt_count at the time the tracepoint was
268 * hit, we need to subtract one to offset the increment.
269 */
270 if (IS_ENABLED(CONFIG_PREEMPT))
271 fbuffer->pc--;
272 fbuffer->trace_file = trace_file;
273
274 fbuffer->event =
275 trace_event_buffer_lock_reserve(&fbuffer->buffer, trace_file,
276 event_call->event.type, len,
277 fbuffer->flags, fbuffer->pc);
278 if (!fbuffer->event)
279 return NULL;
280
281 fbuffer->entry = ring_buffer_event_data(fbuffer->event);
282 return fbuffer->entry;
283 }
284 EXPORT_SYMBOL_GPL(trace_event_buffer_reserve);
285
286 static DEFINE_SPINLOCK(tracepoint_iter_lock);
287
288 static void output_printk(struct trace_event_buffer *fbuffer)
289 {
290 struct trace_event_call *event_call;
291 struct trace_event *event;
292 unsigned long flags;
293 struct trace_iterator *iter = tracepoint_print_iter;
294
295 if (!iter)
296 return;
297
298 event_call = fbuffer->trace_file->event_call;
299 if (!event_call || !event_call->event.funcs ||
300 !event_call->event.funcs->trace)
301 return;
302
303 event = &fbuffer->trace_file->event_call->event;
304
305 spin_lock_irqsave(&tracepoint_iter_lock, flags);
306 trace_seq_init(&iter->seq);
307 iter->ent = fbuffer->entry;
308 event_call->event.funcs->trace(iter, 0, event);
309 trace_seq_putc(&iter->seq, 0);
310 printk("%s", iter->seq.buffer);
311
312 spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
313 }
314
315 void trace_event_buffer_commit(struct trace_event_buffer *fbuffer)
316 {
317 if (tracepoint_printk)
318 output_printk(fbuffer);
319
320 event_trigger_unlock_commit(fbuffer->trace_file, fbuffer->buffer,
321 fbuffer->event, fbuffer->entry,
322 fbuffer->flags, fbuffer->pc);
323 }
324 EXPORT_SYMBOL_GPL(trace_event_buffer_commit);
325
326 int trace_event_reg(struct trace_event_call *call,
327 enum trace_reg type, void *data)
328 {
329 struct trace_event_file *file = data;
330
331 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
332 switch (type) {
333 case TRACE_REG_REGISTER:
334 return tracepoint_probe_register(call->tp,
335 call->class->probe,
336 file);
337 case TRACE_REG_UNREGISTER:
338 tracepoint_probe_unregister(call->tp,
339 call->class->probe,
340 file);
341 return 0;
342
343 #ifdef CONFIG_PERF_EVENTS
344 case TRACE_REG_PERF_REGISTER:
345 return tracepoint_probe_register(call->tp,
346 call->class->perf_probe,
347 call);
348 case TRACE_REG_PERF_UNREGISTER:
349 tracepoint_probe_unregister(call->tp,
350 call->class->perf_probe,
351 call);
352 return 0;
353 case TRACE_REG_PERF_OPEN:
354 case TRACE_REG_PERF_CLOSE:
355 case TRACE_REG_PERF_ADD:
356 case TRACE_REG_PERF_DEL:
357 return 0;
358 #endif
359 }
360 return 0;
361 }
362 EXPORT_SYMBOL_GPL(trace_event_reg);
363
364 void trace_event_enable_cmd_record(bool enable)
365 {
366 struct trace_event_file *file;
367 struct trace_array *tr;
368
369 mutex_lock(&event_mutex);
370 do_for_each_event_file(tr, file) {
371
372 if (!(file->flags & EVENT_FILE_FL_ENABLED))
373 continue;
374
375 if (enable) {
376 tracing_start_cmdline_record();
377 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
378 } else {
379 tracing_stop_cmdline_record();
380 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
381 }
382 } while_for_each_event_file();
383 mutex_unlock(&event_mutex);
384 }
385
386 static int __ftrace_event_enable_disable(struct trace_event_file *file,
387 int enable, int soft_disable)
388 {
389 struct trace_event_call *call = file->event_call;
390 struct trace_array *tr = file->tr;
391 unsigned long file_flags = file->flags;
392 int ret = 0;
393 int disable;
394
395 switch (enable) {
396 case 0:
397 /*
398 * When soft_disable is set and enable is cleared, the sm_ref
399 * reference counter is decremented. If it reaches 0, we want
400 * to clear the SOFT_DISABLED flag but leave the event in the
401 * state that it was. That is, if the event was enabled and
402 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
403 * is set we do not want the event to be enabled before we
404 * clear the bit.
405 *
406 * When soft_disable is not set but the SOFT_MODE flag is,
407 * we do nothing. Do not disable the tracepoint, otherwise
408 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
409 */
410 if (soft_disable) {
411 if (atomic_dec_return(&file->sm_ref) > 0)
412 break;
413 disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
414 clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
415 } else
416 disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
417
418 if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
419 clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
420 if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
421 tracing_stop_cmdline_record();
422 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
423 }
424 call->class->reg(call, TRACE_REG_UNREGISTER, file);
425 }
426 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
427 if (file->flags & EVENT_FILE_FL_SOFT_MODE)
428 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
429 else
430 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
431 break;
432 case 1:
433 /*
434 * When soft_disable is set and enable is set, we want to
435 * register the tracepoint for the event, but leave the event
436 * as is. That means, if the event was already enabled, we do
437 * nothing (but set SOFT_MODE). If the event is disabled, we
438 * set SOFT_DISABLED before enabling the event tracepoint, so
439 * it still seems to be disabled.
440 */
441 if (!soft_disable)
442 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
443 else {
444 if (atomic_inc_return(&file->sm_ref) > 1)
445 break;
446 set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
447 }
448
449 if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
450
451 /* Keep the event disabled, when going to SOFT_MODE. */
452 if (soft_disable)
453 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
454
455 if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
456 tracing_start_cmdline_record();
457 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
458 }
459 ret = call->class->reg(call, TRACE_REG_REGISTER, file);
460 if (ret) {
461 tracing_stop_cmdline_record();
462 pr_info("event trace: Could not enable event "
463 "%s\n", trace_event_name(call));
464 break;
465 }
466 set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
467
468 /* WAS_ENABLED gets set but never cleared. */
469 call->flags |= TRACE_EVENT_FL_WAS_ENABLED;
470 }
471 break;
472 }
473
474 /* Enable or disable use of trace_buffered_event */
475 if ((file_flags & EVENT_FILE_FL_SOFT_DISABLED) !=
476 (file->flags & EVENT_FILE_FL_SOFT_DISABLED)) {
477 if (file->flags & EVENT_FILE_FL_SOFT_DISABLED)
478 trace_buffered_event_enable();
479 else
480 trace_buffered_event_disable();
481 }
482
483 return ret;
484 }
485
486 int trace_event_enable_disable(struct trace_event_file *file,
487 int enable, int soft_disable)
488 {
489 return __ftrace_event_enable_disable(file, enable, soft_disable);
490 }
491
492 static int ftrace_event_enable_disable(struct trace_event_file *file,
493 int enable)
494 {
495 return __ftrace_event_enable_disable(file, enable, 0);
496 }
497
498 static void ftrace_clear_events(struct trace_array *tr)
499 {
500 struct trace_event_file *file;
501
502 mutex_lock(&event_mutex);
503 list_for_each_entry(file, &tr->events, list) {
504 ftrace_event_enable_disable(file, 0);
505 }
506 mutex_unlock(&event_mutex);
507 }
508
509 static void
510 event_filter_pid_sched_process_exit(void *data, struct task_struct *task)
511 {
512 struct trace_pid_list *pid_list;
513 struct trace_array *tr = data;
514
515 pid_list = rcu_dereference_sched(tr->filtered_pids);
516 trace_filter_add_remove_task(pid_list, NULL, task);
517 }
518
519 static void
520 event_filter_pid_sched_process_fork(void *data,
521 struct task_struct *self,
522 struct task_struct *task)
523 {
524 struct trace_pid_list *pid_list;
525 struct trace_array *tr = data;
526
527 pid_list = rcu_dereference_sched(tr->filtered_pids);
528 trace_filter_add_remove_task(pid_list, self, task);
529 }
530
531 void trace_event_follow_fork(struct trace_array *tr, bool enable)
532 {
533 if (enable) {
534 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork,
535 tr, INT_MIN);
536 register_trace_prio_sched_process_exit(event_filter_pid_sched_process_exit,
537 tr, INT_MAX);
538 } else {
539 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork,
540 tr);
541 unregister_trace_sched_process_exit(event_filter_pid_sched_process_exit,
542 tr);
543 }
544 }
545
546 static void
547 event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
548 struct task_struct *prev, struct task_struct *next)
549 {
550 struct trace_array *tr = data;
551 struct trace_pid_list *pid_list;
552
553 pid_list = rcu_dereference_sched(tr->filtered_pids);
554
555 this_cpu_write(tr->trace_buffer.data->ignore_pid,
556 trace_ignore_this_task(pid_list, prev) &&
557 trace_ignore_this_task(pid_list, next));
558 }
559
560 static void
561 event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
562 struct task_struct *prev, struct task_struct *next)
563 {
564 struct trace_array *tr = data;
565 struct trace_pid_list *pid_list;
566
567 pid_list = rcu_dereference_sched(tr->filtered_pids);
568
569 this_cpu_write(tr->trace_buffer.data->ignore_pid,
570 trace_ignore_this_task(pid_list, next));
571 }
572
573 static void
574 event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
575 {
576 struct trace_array *tr = data;
577 struct trace_pid_list *pid_list;
578
579 /* Nothing to do if we are already tracing */
580 if (!this_cpu_read(tr->trace_buffer.data->ignore_pid))
581 return;
582
583 pid_list = rcu_dereference_sched(tr->filtered_pids);
584
585 this_cpu_write(tr->trace_buffer.data->ignore_pid,
586 trace_ignore_this_task(pid_list, task));
587 }
588
589 static void
590 event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
591 {
592 struct trace_array *tr = data;
593 struct trace_pid_list *pid_list;
594
595 /* Nothing to do if we are not tracing */
596 if (this_cpu_read(tr->trace_buffer.data->ignore_pid))
597 return;
598
599 pid_list = rcu_dereference_sched(tr->filtered_pids);
600
601 /* Set tracing if current is enabled */
602 this_cpu_write(tr->trace_buffer.data->ignore_pid,
603 trace_ignore_this_task(pid_list, current));
604 }
605
606 static void __ftrace_clear_event_pids(struct trace_array *tr)
607 {
608 struct trace_pid_list *pid_list;
609 struct trace_event_file *file;
610 int cpu;
611
612 pid_list = rcu_dereference_protected(tr->filtered_pids,
613 lockdep_is_held(&event_mutex));
614 if (!pid_list)
615 return;
616
617 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre, tr);
618 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post, tr);
619
620 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, tr);
621 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, tr);
622
623 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, tr);
624 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, tr);
625
626 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre, tr);
627 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post, tr);
628
629 list_for_each_entry(file, &tr->events, list) {
630 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
631 }
632
633 for_each_possible_cpu(cpu)
634 per_cpu_ptr(tr->trace_buffer.data, cpu)->ignore_pid = false;
635
636 rcu_assign_pointer(tr->filtered_pids, NULL);
637
638 /* Wait till all users are no longer using pid filtering */
639 synchronize_sched();
640
641 trace_free_pid_list(pid_list);
642 }
643
644 static void ftrace_clear_event_pids(struct trace_array *tr)
645 {
646 mutex_lock(&event_mutex);
647 __ftrace_clear_event_pids(tr);
648 mutex_unlock(&event_mutex);
649 }
650
651 static void __put_system(struct event_subsystem *system)
652 {
653 struct event_filter *filter = system->filter;
654
655 WARN_ON_ONCE(system_refcount(system) == 0);
656 if (system_refcount_dec(system))
657 return;
658
659 list_del(&system->list);
660
661 if (filter) {
662 kfree(filter->filter_string);
663 kfree(filter);
664 }
665 kfree_const(system->name);
666 kfree(system);
667 }
668
669 static void __get_system(struct event_subsystem *system)
670 {
671 WARN_ON_ONCE(system_refcount(system) == 0);
672 system_refcount_inc(system);
673 }
674
675 static void __get_system_dir(struct trace_subsystem_dir *dir)
676 {
677 WARN_ON_ONCE(dir->ref_count == 0);
678 dir->ref_count++;
679 __get_system(dir->subsystem);
680 }
681
682 static void __put_system_dir(struct trace_subsystem_dir *dir)
683 {
684 WARN_ON_ONCE(dir->ref_count == 0);
685 /* If the subsystem is about to be freed, the dir must be too */
686 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
687
688 __put_system(dir->subsystem);
689 if (!--dir->ref_count)
690 kfree(dir);
691 }
692
693 static void put_system(struct trace_subsystem_dir *dir)
694 {
695 mutex_lock(&event_mutex);
696 __put_system_dir(dir);
697 mutex_unlock(&event_mutex);
698 }
699
700 static void remove_subsystem(struct trace_subsystem_dir *dir)
701 {
702 if (!dir)
703 return;
704
705 if (!--dir->nr_events) {
706 tracefs_remove_recursive(dir->entry);
707 list_del(&dir->list);
708 __put_system_dir(dir);
709 }
710 }
711
712 static void remove_event_file_dir(struct trace_event_file *file)
713 {
714 struct dentry *dir = file->dir;
715 struct dentry *child;
716
717 if (dir) {
718 spin_lock(&dir->d_lock); /* probably unneeded */
719 list_for_each_entry(child, &dir->d_subdirs, d_child) {
720 if (d_really_is_positive(child)) /* probably unneeded */
721 d_inode(child)->i_private = NULL;
722 }
723 spin_unlock(&dir->d_lock);
724
725 tracefs_remove_recursive(dir);
726 }
727
728 list_del(&file->list);
729 remove_subsystem(file->system);
730 free_event_filter(file->filter);
731 kmem_cache_free(file_cachep, file);
732 }
733
734 /*
735 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
736 */
737 static int
738 __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
739 const char *sub, const char *event, int set)
740 {
741 struct trace_event_file *file;
742 struct trace_event_call *call;
743 const char *name;
744 int ret = -EINVAL;
745
746 list_for_each_entry(file, &tr->events, list) {
747
748 call = file->event_call;
749 name = trace_event_name(call);
750
751 if (!name || !call->class || !call->class->reg)
752 continue;
753
754 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
755 continue;
756
757 if (match &&
758 strcmp(match, name) != 0 &&
759 strcmp(match, call->class->system) != 0)
760 continue;
761
762 if (sub && strcmp(sub, call->class->system) != 0)
763 continue;
764
765 if (event && strcmp(event, name) != 0)
766 continue;
767
768 ftrace_event_enable_disable(file, set);
769
770 ret = 0;
771 }
772
773 return ret;
774 }
775
776 static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
777 const char *sub, const char *event, int set)
778 {
779 int ret;
780
781 mutex_lock(&event_mutex);
782 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
783 mutex_unlock(&event_mutex);
784
785 return ret;
786 }
787
788 static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
789 {
790 char *event = NULL, *sub = NULL, *match;
791 int ret;
792
793 if (!tr)
794 return -ENOENT;
795 /*
796 * The buf format can be <subsystem>:<event-name>
797 * *:<event-name> means any event by that name.
798 * :<event-name> is the same.
799 *
800 * <subsystem>:* means all events in that subsystem
801 * <subsystem>: means the same.
802 *
803 * <name> (no ':') means all events in a subsystem with
804 * the name <name> or any event that matches <name>
805 */
806
807 match = strsep(&buf, ":");
808 if (buf) {
809 sub = match;
810 event = buf;
811 match = NULL;
812
813 if (!strlen(sub) || strcmp(sub, "*") == 0)
814 sub = NULL;
815 if (!strlen(event) || strcmp(event, "*") == 0)
816 event = NULL;
817 }
818
819 ret = __ftrace_set_clr_event(tr, match, sub, event, set);
820
821 /* Put back the colon to allow this to be called again */
822 if (buf)
823 *(buf - 1) = ':';
824
825 return ret;
826 }
827
828 /**
829 * trace_set_clr_event - enable or disable an event
830 * @system: system name to match (NULL for any system)
831 * @event: event name to match (NULL for all events, within system)
832 * @set: 1 to enable, 0 to disable
833 *
834 * This is a way for other parts of the kernel to enable or disable
835 * event recording.
836 *
837 * Returns 0 on success, -EINVAL if the parameters do not match any
838 * registered events.
839 */
840 int trace_set_clr_event(const char *system, const char *event, int set)
841 {
842 struct trace_array *tr = top_trace_array();
843
844 if (!tr)
845 return -ENODEV;
846
847 return __ftrace_set_clr_event(tr, NULL, system, event, set);
848 }
849 EXPORT_SYMBOL_GPL(trace_set_clr_event);
850
851 /* 128 should be much more than enough */
852 #define EVENT_BUF_SIZE 127
853
854 static ssize_t
855 ftrace_event_write(struct file *file, const char __user *ubuf,
856 size_t cnt, loff_t *ppos)
857 {
858 struct trace_parser parser;
859 struct seq_file *m = file->private_data;
860 struct trace_array *tr = m->private;
861 ssize_t read, ret;
862
863 if (!cnt)
864 return 0;
865
866 ret = tracing_update_buffers();
867 if (ret < 0)
868 return ret;
869
870 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
871 return -ENOMEM;
872
873 read = trace_get_user(&parser, ubuf, cnt, ppos);
874
875 if (read >= 0 && trace_parser_loaded((&parser))) {
876 int set = 1;
877
878 if (*parser.buffer == '!')
879 set = 0;
880
881 parser.buffer[parser.idx] = 0;
882
883 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);
884 if (ret)
885 goto out_put;
886 }
887
888 ret = read;
889
890 out_put:
891 trace_parser_put(&parser);
892
893 return ret;
894 }
895
896 static void *
897 t_next(struct seq_file *m, void *v, loff_t *pos)
898 {
899 struct trace_event_file *file = v;
900 struct trace_event_call *call;
901 struct trace_array *tr = m->private;
902
903 (*pos)++;
904
905 list_for_each_entry_continue(file, &tr->events, list) {
906 call = file->event_call;
907 /*
908 * The ftrace subsystem is for showing formats only.
909 * They can not be enabled or disabled via the event files.
910 */
911 if (call->class && call->class->reg &&
912 !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
913 return file;
914 }
915
916 return NULL;
917 }
918
919 static void *t_start(struct seq_file *m, loff_t *pos)
920 {
921 struct trace_event_file *file;
922 struct trace_array *tr = m->private;
923 loff_t l;
924
925 mutex_lock(&event_mutex);
926
927 file = list_entry(&tr->events, struct trace_event_file, list);
928 for (l = 0; l <= *pos; ) {
929 file = t_next(m, file, &l);
930 if (!file)
931 break;
932 }
933 return file;
934 }
935
936 static void *
937 s_next(struct seq_file *m, void *v, loff_t *pos)
938 {
939 struct trace_event_file *file = v;
940 struct trace_array *tr = m->private;
941
942 (*pos)++;
943
944 list_for_each_entry_continue(file, &tr->events, list) {
945 if (file->flags & EVENT_FILE_FL_ENABLED)
946 return file;
947 }
948
949 return NULL;
950 }
951
952 static void *s_start(struct seq_file *m, loff_t *pos)
953 {
954 struct trace_event_file *file;
955 struct trace_array *tr = m->private;
956 loff_t l;
957
958 mutex_lock(&event_mutex);
959
960 file = list_entry(&tr->events, struct trace_event_file, list);
961 for (l = 0; l <= *pos; ) {
962 file = s_next(m, file, &l);
963 if (!file)
964 break;
965 }
966 return file;
967 }
968
969 static int t_show(struct seq_file *m, void *v)
970 {
971 struct trace_event_file *file = v;
972 struct trace_event_call *call = file->event_call;
973
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));
977
978 return 0;
979 }
980
981 static void t_stop(struct seq_file *m, void *p)
982 {
983 mutex_unlock(&event_mutex);
984 }
985
986 static void *
987 p_next(struct seq_file *m, void *v, loff_t *pos)
988 {
989 struct trace_array *tr = m->private;
990 struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids);
991
992 return trace_pid_next(pid_list, v, pos);
993 }
994
995 static void *p_start(struct seq_file *m, loff_t *pos)
996 __acquires(RCU)
997 {
998 struct trace_pid_list *pid_list;
999 struct trace_array *tr = m->private;
1000
1001 /*
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.
1006 */
1007 mutex_lock(&event_mutex);
1008 rcu_read_lock_sched();
1009
1010 pid_list = rcu_dereference_sched(tr->filtered_pids);
1011
1012 if (!pid_list)
1013 return NULL;
1014
1015 return trace_pid_start(pid_list, pos);
1016 }
1017
1018 static void p_stop(struct seq_file *m, void *p)
1019 __releases(RCU)
1020 {
1021 rcu_read_unlock_sched();
1022 mutex_unlock(&event_mutex);
1023 }
1024
1025 static ssize_t
1026 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1027 loff_t *ppos)
1028 {
1029 struct trace_event_file *file;
1030 unsigned long flags;
1031 char buf[4] = "0";
1032
1033 mutex_lock(&event_mutex);
1034 file = event_file_data(filp);
1035 if (likely(file))
1036 flags = file->flags;
1037 mutex_unlock(&event_mutex);
1038
1039 if (!file)
1040 return -ENODEV;
1041
1042 if (flags & EVENT_FILE_FL_ENABLED &&
1043 !(flags & EVENT_FILE_FL_SOFT_DISABLED))
1044 strcpy(buf, "1");
1045
1046 if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
1047 flags & EVENT_FILE_FL_SOFT_MODE)
1048 strcat(buf, "*");
1049
1050 strcat(buf, "\n");
1051
1052 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
1053 }
1054
1055 static ssize_t
1056 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1057 loff_t *ppos)
1058 {
1059 struct trace_event_file *file;
1060 unsigned long val;
1061 int ret;
1062
1063 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1064 if (ret)
1065 return ret;
1066
1067 ret = tracing_update_buffers();
1068 if (ret < 0)
1069 return ret;
1070
1071 switch (val) {
1072 case 0:
1073 case 1:
1074 ret = -ENODEV;
1075 mutex_lock(&event_mutex);
1076 file = event_file_data(filp);
1077 if (likely(file))
1078 ret = ftrace_event_enable_disable(file, val);
1079 mutex_unlock(&event_mutex);
1080 break;
1081
1082 default:
1083 return -EINVAL;
1084 }
1085
1086 *ppos += cnt;
1087
1088 return ret ? ret : cnt;
1089 }
1090
1091 static ssize_t
1092 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1093 loff_t *ppos)
1094 {
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;
1101 char buf[2];
1102 int set = 0;
1103 int ret;
1104
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)
1109 continue;
1110
1111 if (system && strcmp(call->class->system, system->name) != 0)
1112 continue;
1113
1114 /*
1115 * We need to find out if all the events are set
1116 * or if all events or cleared, or if we have
1117 * a mixture.
1118 */
1119 set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
1120
1121 /*
1122 * If we have a mixture, no need to look further.
1123 */
1124 if (set == 3)
1125 break;
1126 }
1127 mutex_unlock(&event_mutex);
1128
1129 buf[0] = set_to_char[set];
1130 buf[1] = '\n';
1131
1132 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
1133
1134 return ret;
1135 }
1136
1137 static ssize_t
1138 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1139 loff_t *ppos)
1140 {
1141 struct trace_subsystem_dir *dir = filp->private_data;
1142 struct event_subsystem *system = dir->subsystem;
1143 const char *name = NULL;
1144 unsigned long val;
1145 ssize_t ret;
1146
1147 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1148 if (ret)
1149 return ret;
1150
1151 ret = tracing_update_buffers();
1152 if (ret < 0)
1153 return ret;
1154
1155 if (val != 0 && val != 1)
1156 return -EINVAL;
1157
1158 /*
1159 * Opening of "enable" adds a ref count to system,
1160 * so the name is safe to use.
1161 */
1162 if (system)
1163 name = system->name;
1164
1165 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);
1166 if (ret)
1167 goto out;
1168
1169 ret = cnt;
1170
1171 out:
1172 *ppos += cnt;
1173
1174 return ret;
1175 }
1176
1177 enum {
1178 FORMAT_HEADER = 1,
1179 FORMAT_FIELD_SEPERATOR = 2,
1180 FORMAT_PRINTFMT = 3,
1181 };
1182
1183 static void *f_next(struct seq_file *m, void *v, loff_t *pos)
1184 {
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;
1189
1190 (*pos)++;
1191
1192 switch ((unsigned long)v) {
1193 case FORMAT_HEADER:
1194 node = common_head;
1195 break;
1196
1197 case FORMAT_FIELD_SEPERATOR:
1198 node = head;
1199 break;
1200
1201 case FORMAT_PRINTFMT:
1202 /* all done */
1203 return NULL;
1204 }
1205
1206 node = node->prev;
1207 if (node == common_head)
1208 return (void *)FORMAT_FIELD_SEPERATOR;
1209 else if (node == head)
1210 return (void *)FORMAT_PRINTFMT;
1211 else
1212 return node;
1213 }
1214
1215 static int f_show(struct seq_file *m, void *v)
1216 {
1217 struct trace_event_call *call = event_file_data(m->private);
1218 struct ftrace_event_field *field;
1219 const char *array_descriptor;
1220
1221 switch ((unsigned long)v) {
1222 case FORMAT_HEADER:
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");
1226 return 0;
1227
1228 case FORMAT_FIELD_SEPERATOR:
1229 seq_putc(m, '\n');
1230 return 0;
1231
1232 case FORMAT_PRINTFMT:
1233 seq_printf(m, "\nprint fmt: %s\n",
1234 call->print_fmt);
1235 return 0;
1236 }
1237
1238 field = list_entry(v, struct ftrace_event_field, link);
1239 /*
1240 * Smartly shows the array type(except dynamic array).
1241 * Normal:
1242 * field:TYPE VAR
1243 * If TYPE := TYPE[LEN], it is shown:
1244 * field:TYPE VAR[LEN]
1245 */
1246 array_descriptor = strchr(field->type, '[');
1247
1248 if (!strncmp(field->type, "__data_loc", 10))
1249 array_descriptor = NULL;
1250
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);
1255 else
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);
1261
1262 return 0;
1263 }
1264
1265 static void *f_start(struct seq_file *m, loff_t *pos)
1266 {
1267 void *p = (void *)FORMAT_HEADER;
1268 loff_t l = 0;
1269
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);
1274
1275 while (l < *pos && p)
1276 p = f_next(m, p, &l);
1277
1278 return p;
1279 }
1280
1281 static void f_stop(struct seq_file *m, void *p)
1282 {
1283 mutex_unlock(&event_mutex);
1284 }
1285
1286 static const struct seq_operations trace_format_seq_ops = {
1287 .start = f_start,
1288 .next = f_next,
1289 .stop = f_stop,
1290 .show = f_show,
1291 };
1292
1293 static int trace_format_open(struct inode *inode, struct file *file)
1294 {
1295 struct seq_file *m;
1296 int ret;
1297
1298 ret = seq_open(file, &trace_format_seq_ops);
1299 if (ret < 0)
1300 return ret;
1301
1302 m = file->private_data;
1303 m->private = file;
1304
1305 return 0;
1306 }
1307
1308 static ssize_t
1309 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1310 {
1311 int id = (long)event_file_data(filp);
1312 char buf[32];
1313 int len;
1314
1315 if (unlikely(!id))
1316 return -ENODEV;
1317
1318 len = sprintf(buf, "%d\n", id);
1319
1320 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
1321 }
1322
1323 static ssize_t
1324 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1325 loff_t *ppos)
1326 {
1327 struct trace_event_file *file;
1328 struct trace_seq *s;
1329 int r = -ENODEV;
1330
1331 if (*ppos)
1332 return 0;
1333
1334 s = kmalloc(sizeof(*s), GFP_KERNEL);
1335
1336 if (!s)
1337 return -ENOMEM;
1338
1339 trace_seq_init(s);
1340
1341 mutex_lock(&event_mutex);
1342 file = event_file_data(filp);
1343 if (file)
1344 print_event_filter(file, s);
1345 mutex_unlock(&event_mutex);
1346
1347 if (file)
1348 r = simple_read_from_buffer(ubuf, cnt, ppos,
1349 s->buffer, trace_seq_used(s));
1350
1351 kfree(s);
1352
1353 return r;
1354 }
1355
1356 static ssize_t
1357 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1358 loff_t *ppos)
1359 {
1360 struct trace_event_file *file;
1361 char *buf;
1362 int err = -ENODEV;
1363
1364 if (cnt >= PAGE_SIZE)
1365 return -EINVAL;
1366
1367 buf = memdup_user_nul(ubuf, cnt);
1368 if (IS_ERR(buf))
1369 return PTR_ERR(buf);
1370
1371 mutex_lock(&event_mutex);
1372 file = event_file_data(filp);
1373 if (file)
1374 err = apply_event_filter(file, buf);
1375 mutex_unlock(&event_mutex);
1376
1377 kfree(buf);
1378 if (err < 0)
1379 return err;
1380
1381 *ppos += cnt;
1382
1383 return cnt;
1384 }
1385
1386 static LIST_HEAD(event_subsystems);
1387
1388 static int subsystem_open(struct inode *inode, struct file *filp)
1389 {
1390 struct event_subsystem *system = NULL;
1391 struct trace_subsystem_dir *dir = NULL; /* Initialize for gcc */
1392 struct trace_array *tr;
1393 int ret;
1394
1395 if (tracing_is_disabled())
1396 return -ENODEV;
1397
1398 /* Make sure the system still exists */
1399 mutex_lock(&trace_types_lock);
1400 mutex_lock(&event_mutex);
1401 list_for_each_entry(tr, &ftrace_trace_arrays, list) {
1402 list_for_each_entry(dir, &tr->systems, list) {
1403 if (dir == inode->i_private) {
1404 /* Don't open systems with no events */
1405 if (dir->nr_events) {
1406 __get_system_dir(dir);
1407 system = dir->subsystem;
1408 }
1409 goto exit_loop;
1410 }
1411 }
1412 }
1413 exit_loop:
1414 mutex_unlock(&event_mutex);
1415 mutex_unlock(&trace_types_lock);
1416
1417 if (!system)
1418 return -ENODEV;
1419
1420 /* Some versions of gcc think dir can be uninitialized here */
1421 WARN_ON(!dir);
1422
1423 /* Still need to increment the ref count of the system */
1424 if (trace_array_get(tr) < 0) {
1425 put_system(dir);
1426 return -ENODEV;
1427 }
1428
1429 ret = tracing_open_generic(inode, filp);
1430 if (ret < 0) {
1431 trace_array_put(tr);
1432 put_system(dir);
1433 }
1434
1435 return ret;
1436 }
1437
1438 static int system_tr_open(struct inode *inode, struct file *filp)
1439 {
1440 struct trace_subsystem_dir *dir;
1441 struct trace_array *tr = inode->i_private;
1442 int ret;
1443
1444 if (tracing_is_disabled())
1445 return -ENODEV;
1446
1447 if (trace_array_get(tr) < 0)
1448 return -ENODEV;
1449
1450 /* Make a temporary dir that has no system but points to tr */
1451 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
1452 if (!dir) {
1453 trace_array_put(tr);
1454 return -ENOMEM;
1455 }
1456
1457 dir->tr = tr;
1458
1459 ret = tracing_open_generic(inode, filp);
1460 if (ret < 0) {
1461 trace_array_put(tr);
1462 kfree(dir);
1463 return ret;
1464 }
1465
1466 filp->private_data = dir;
1467
1468 return 0;
1469 }
1470
1471 static int subsystem_release(struct inode *inode, struct file *file)
1472 {
1473 struct trace_subsystem_dir *dir = file->private_data;
1474
1475 trace_array_put(dir->tr);
1476
1477 /*
1478 * If dir->subsystem is NULL, then this is a temporary
1479 * descriptor that was made for a trace_array to enable
1480 * all subsystems.
1481 */
1482 if (dir->subsystem)
1483 put_system(dir);
1484 else
1485 kfree(dir);
1486
1487 return 0;
1488 }
1489
1490 static ssize_t
1491 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1492 loff_t *ppos)
1493 {
1494 struct trace_subsystem_dir *dir = filp->private_data;
1495 struct event_subsystem *system = dir->subsystem;
1496 struct trace_seq *s;
1497 int r;
1498
1499 if (*ppos)
1500 return 0;
1501
1502 s = kmalloc(sizeof(*s), GFP_KERNEL);
1503 if (!s)
1504 return -ENOMEM;
1505
1506 trace_seq_init(s);
1507
1508 print_subsystem_event_filter(system, s);
1509 r = simple_read_from_buffer(ubuf, cnt, ppos,
1510 s->buffer, trace_seq_used(s));
1511
1512 kfree(s);
1513
1514 return r;
1515 }
1516
1517 static ssize_t
1518 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1519 loff_t *ppos)
1520 {
1521 struct trace_subsystem_dir *dir = filp->private_data;
1522 char *buf;
1523 int err;
1524
1525 if (cnt >= PAGE_SIZE)
1526 return -EINVAL;
1527
1528 buf = memdup_user_nul(ubuf, cnt);
1529 if (IS_ERR(buf))
1530 return PTR_ERR(buf);
1531
1532 err = apply_subsystem_event_filter(dir, buf);
1533 kfree(buf);
1534 if (err < 0)
1535 return err;
1536
1537 *ppos += cnt;
1538
1539 return cnt;
1540 }
1541
1542 static ssize_t
1543 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1544 {
1545 int (*func)(struct trace_seq *s) = filp->private_data;
1546 struct trace_seq *s;
1547 int r;
1548
1549 if (*ppos)
1550 return 0;
1551
1552 s = kmalloc(sizeof(*s), GFP_KERNEL);
1553 if (!s)
1554 return -ENOMEM;
1555
1556 trace_seq_init(s);
1557
1558 func(s);
1559 r = simple_read_from_buffer(ubuf, cnt, ppos,
1560 s->buffer, trace_seq_used(s));
1561
1562 kfree(s);
1563
1564 return r;
1565 }
1566
1567 static void ignore_task_cpu(void *data)
1568 {
1569 struct trace_array *tr = data;
1570 struct trace_pid_list *pid_list;
1571
1572 /*
1573 * This function is called by on_each_cpu() while the
1574 * event_mutex is held.
1575 */
1576 pid_list = rcu_dereference_protected(tr->filtered_pids,
1577 mutex_is_locked(&event_mutex));
1578
1579 this_cpu_write(tr->trace_buffer.data->ignore_pid,
1580 trace_ignore_this_task(pid_list, current));
1581 }
1582
1583 static ssize_t
1584 ftrace_event_pid_write(struct file *filp, const char __user *ubuf,
1585 size_t cnt, loff_t *ppos)
1586 {
1587 struct seq_file *m = filp->private_data;
1588 struct trace_array *tr = m->private;
1589 struct trace_pid_list *filtered_pids = NULL;
1590 struct trace_pid_list *pid_list;
1591 struct trace_event_file *file;
1592 ssize_t ret;
1593
1594 if (!cnt)
1595 return 0;
1596
1597 ret = tracing_update_buffers();
1598 if (ret < 0)
1599 return ret;
1600
1601 mutex_lock(&event_mutex);
1602
1603 filtered_pids = rcu_dereference_protected(tr->filtered_pids,
1604 lockdep_is_held(&event_mutex));
1605
1606 ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
1607 if (ret < 0)
1608 goto out;
1609
1610 rcu_assign_pointer(tr->filtered_pids, pid_list);
1611
1612 list_for_each_entry(file, &tr->events, list) {
1613 set_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
1614 }
1615
1616 if (filtered_pids) {
1617 synchronize_sched();
1618 trace_free_pid_list(filtered_pids);
1619 } else if (pid_list) {
1620 /*
1621 * Register a probe that is called before all other probes
1622 * to set ignore_pid if next or prev do not match.
1623 * Register a probe this is called after all other probes
1624 * to only keep ignore_pid set if next pid matches.
1625 */
1626 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre,
1627 tr, INT_MAX);
1628 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post,
1629 tr, 0);
1630
1631 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre,
1632 tr, INT_MAX);
1633 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post,
1634 tr, 0);
1635
1636 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre,
1637 tr, INT_MAX);
1638 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post,
1639 tr, 0);
1640
1641 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre,
1642 tr, INT_MAX);
1643 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post,
1644 tr, 0);
1645 }
1646
1647 /*
1648 * Ignoring of pids is done at task switch. But we have to
1649 * check for those tasks that are currently running.
1650 * Always do this in case a pid was appended or removed.
1651 */
1652 on_each_cpu(ignore_task_cpu, tr, 1);
1653
1654 out:
1655 mutex_unlock(&event_mutex);
1656
1657 if (ret > 0)
1658 *ppos += ret;
1659
1660 return ret;
1661 }
1662
1663 static int ftrace_event_avail_open(struct inode *inode, struct file *file);
1664 static int ftrace_event_set_open(struct inode *inode, struct file *file);
1665 static int ftrace_event_set_pid_open(struct inode *inode, struct file *file);
1666 static int ftrace_event_release(struct inode *inode, struct file *file);
1667
1668 static const struct seq_operations show_event_seq_ops = {
1669 .start = t_start,
1670 .next = t_next,
1671 .show = t_show,
1672 .stop = t_stop,
1673 };
1674
1675 static const struct seq_operations show_set_event_seq_ops = {
1676 .start = s_start,
1677 .next = s_next,
1678 .show = t_show,
1679 .stop = t_stop,
1680 };
1681
1682 static const struct seq_operations show_set_pid_seq_ops = {
1683 .start = p_start,
1684 .next = p_next,
1685 .show = trace_pid_show,
1686 .stop = p_stop,
1687 };
1688
1689 static const struct file_operations ftrace_avail_fops = {
1690 .open = ftrace_event_avail_open,
1691 .read = seq_read,
1692 .llseek = seq_lseek,
1693 .release = seq_release,
1694 };
1695
1696 static const struct file_operations ftrace_set_event_fops = {
1697 .open = ftrace_event_set_open,
1698 .read = seq_read,
1699 .write = ftrace_event_write,
1700 .llseek = seq_lseek,
1701 .release = ftrace_event_release,
1702 };
1703
1704 static const struct file_operations ftrace_set_event_pid_fops = {
1705 .open = ftrace_event_set_pid_open,
1706 .read = seq_read,
1707 .write = ftrace_event_pid_write,
1708 .llseek = seq_lseek,
1709 .release = ftrace_event_release,
1710 };
1711
1712 static const struct file_operations ftrace_enable_fops = {
1713 .open = tracing_open_generic,
1714 .read = event_enable_read,
1715 .write = event_enable_write,
1716 .llseek = default_llseek,
1717 };
1718
1719 static const struct file_operations ftrace_event_format_fops = {
1720 .open = trace_format_open,
1721 .read = seq_read,
1722 .llseek = seq_lseek,
1723 .release = seq_release,
1724 };
1725
1726 static const struct file_operations ftrace_event_id_fops = {
1727 .read = event_id_read,
1728 .llseek = default_llseek,
1729 };
1730
1731 static const struct file_operations ftrace_event_filter_fops = {
1732 .open = tracing_open_generic,
1733 .read = event_filter_read,
1734 .write = event_filter_write,
1735 .llseek = default_llseek,
1736 };
1737
1738 static const struct file_operations ftrace_subsystem_filter_fops = {
1739 .open = subsystem_open,
1740 .read = subsystem_filter_read,
1741 .write = subsystem_filter_write,
1742 .llseek = default_llseek,
1743 .release = subsystem_release,
1744 };
1745
1746 static const struct file_operations ftrace_system_enable_fops = {
1747 .open = subsystem_open,
1748 .read = system_enable_read,
1749 .write = system_enable_write,
1750 .llseek = default_llseek,
1751 .release = subsystem_release,
1752 };
1753
1754 static const struct file_operations ftrace_tr_enable_fops = {
1755 .open = system_tr_open,
1756 .read = system_enable_read,
1757 .write = system_enable_write,
1758 .llseek = default_llseek,
1759 .release = subsystem_release,
1760 };
1761
1762 static const struct file_operations ftrace_show_header_fops = {
1763 .open = tracing_open_generic,
1764 .read = show_header,
1765 .llseek = default_llseek,
1766 };
1767
1768 static int
1769 ftrace_event_open(struct inode *inode, struct file *file,
1770 const struct seq_operations *seq_ops)
1771 {
1772 struct seq_file *m;
1773 int ret;
1774
1775 ret = seq_open(file, seq_ops);
1776 if (ret < 0)
1777 return ret;
1778 m = file->private_data;
1779 /* copy tr over to seq ops */
1780 m->private = inode->i_private;
1781
1782 return ret;
1783 }
1784
1785 static int ftrace_event_release(struct inode *inode, struct file *file)
1786 {
1787 struct trace_array *tr = inode->i_private;
1788
1789 trace_array_put(tr);
1790
1791 return seq_release(inode, file);
1792 }
1793
1794 static int
1795 ftrace_event_avail_open(struct inode *inode, struct file *file)
1796 {
1797 const struct seq_operations *seq_ops = &show_event_seq_ops;
1798
1799 return ftrace_event_open(inode, file, seq_ops);
1800 }
1801
1802 static int
1803 ftrace_event_set_open(struct inode *inode, struct file *file)
1804 {
1805 const struct seq_operations *seq_ops = &show_set_event_seq_ops;
1806 struct trace_array *tr = inode->i_private;
1807 int ret;
1808
1809 if (trace_array_get(tr) < 0)
1810 return -ENODEV;
1811
1812 if ((file->f_mode & FMODE_WRITE) &&
1813 (file->f_flags & O_TRUNC))
1814 ftrace_clear_events(tr);
1815
1816 ret = ftrace_event_open(inode, file, seq_ops);
1817 if (ret < 0)
1818 trace_array_put(tr);
1819 return ret;
1820 }
1821
1822 static int
1823 ftrace_event_set_pid_open(struct inode *inode, struct file *file)
1824 {
1825 const struct seq_operations *seq_ops = &show_set_pid_seq_ops;
1826 struct trace_array *tr = inode->i_private;
1827 int ret;
1828
1829 if (trace_array_get(tr) < 0)
1830 return -ENODEV;
1831
1832 if ((file->f_mode & FMODE_WRITE) &&
1833 (file->f_flags & O_TRUNC))
1834 ftrace_clear_event_pids(tr);
1835
1836 ret = ftrace_event_open(inode, file, seq_ops);
1837 if (ret < 0)
1838 trace_array_put(tr);
1839 return ret;
1840 }
1841
1842 static struct event_subsystem *
1843 create_new_subsystem(const char *name)
1844 {
1845 struct event_subsystem *system;
1846
1847 /* need to create new entry */
1848 system = kmalloc(sizeof(*system), GFP_KERNEL);
1849 if (!system)
1850 return NULL;
1851
1852 system->ref_count = 1;
1853
1854 /* Only allocate if dynamic (kprobes and modules) */
1855 system->name = kstrdup_const(name, GFP_KERNEL);
1856 if (!system->name)
1857 goto out_free;
1858
1859 system->filter = NULL;
1860
1861 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
1862 if (!system->filter)
1863 goto out_free;
1864
1865 list_add(&system->list, &event_subsystems);
1866
1867 return system;
1868
1869 out_free:
1870 kfree_const(system->name);
1871 kfree(system);
1872 return NULL;
1873 }
1874
1875 static struct dentry *
1876 event_subsystem_dir(struct trace_array *tr, const char *name,
1877 struct trace_event_file *file, struct dentry *parent)
1878 {
1879 struct trace_subsystem_dir *dir;
1880 struct event_subsystem *system;
1881 struct dentry *entry;
1882
1883 /* First see if we did not already create this dir */
1884 list_for_each_entry(dir, &tr->systems, list) {
1885 system = dir->subsystem;
1886 if (strcmp(system->name, name) == 0) {
1887 dir->nr_events++;
1888 file->system = dir;
1889 return dir->entry;
1890 }
1891 }
1892
1893 /* Now see if the system itself exists. */
1894 list_for_each_entry(system, &event_subsystems, list) {
1895 if (strcmp(system->name, name) == 0)
1896 break;
1897 }
1898 /* Reset system variable when not found */
1899 if (&system->list == &event_subsystems)
1900 system = NULL;
1901
1902 dir = kmalloc(sizeof(*dir), GFP_KERNEL);
1903 if (!dir)
1904 goto out_fail;
1905
1906 if (!system) {
1907 system = create_new_subsystem(name);
1908 if (!system)
1909 goto out_free;
1910 } else
1911 __get_system(system);
1912
1913 dir->entry = tracefs_create_dir(name, parent);
1914 if (!dir->entry) {
1915 pr_warn("Failed to create system directory %s\n", name);
1916 __put_system(system);
1917 goto out_free;
1918 }
1919
1920 dir->tr = tr;
1921 dir->ref_count = 1;
1922 dir->nr_events = 1;
1923 dir->subsystem = system;
1924 file->system = dir;
1925
1926 entry = tracefs_create_file("filter", 0644, dir->entry, dir,
1927 &ftrace_subsystem_filter_fops);
1928 if (!entry) {
1929 kfree(system->filter);
1930 system->filter = NULL;
1931 pr_warn("Could not create tracefs '%s/filter' entry\n", name);
1932 }
1933
1934 trace_create_file("enable", 0644, dir->entry, dir,
1935 &ftrace_system_enable_fops);
1936
1937 list_add(&dir->list, &tr->systems);
1938
1939 return dir->entry;
1940
1941 out_free:
1942 kfree(dir);
1943 out_fail:
1944 /* Only print this message if failed on memory allocation */
1945 if (!dir || !system)
1946 pr_warn("No memory to create event subsystem %s\n", name);
1947 return NULL;
1948 }
1949
1950 static int
1951 event_create_dir(struct dentry *parent, struct trace_event_file *file)
1952 {
1953 struct trace_event_call *call = file->event_call;
1954 struct trace_array *tr = file->tr;
1955 struct list_head *head;
1956 struct dentry *d_events;
1957 const char *name;
1958 int ret;
1959
1960 /*
1961 * If the trace point header did not define TRACE_SYSTEM
1962 * then the system would be called "TRACE_SYSTEM".
1963 */
1964 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
1965 d_events = event_subsystem_dir(tr, call->class->system, file, parent);
1966 if (!d_events)
1967 return -ENOMEM;
1968 } else
1969 d_events = parent;
1970
1971 name = trace_event_name(call);
1972 file->dir = tracefs_create_dir(name, d_events);
1973 if (!file->dir) {
1974 pr_warn("Could not create tracefs '%s' directory\n", name);
1975 return -1;
1976 }
1977
1978 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
1979 trace_create_file("enable", 0644, file->dir, file,
1980 &ftrace_enable_fops);
1981
1982 #ifdef CONFIG_PERF_EVENTS
1983 if (call->event.type && call->class->reg)
1984 trace_create_file("id", 0444, file->dir,
1985 (void *)(long)call->event.type,
1986 &ftrace_event_id_fops);
1987 #endif
1988
1989 /*
1990 * Other events may have the same class. Only update
1991 * the fields if they are not already defined.
1992 */
1993 head = trace_get_fields(call);
1994 if (list_empty(head)) {
1995 ret = call->class->define_fields(call);
1996 if (ret < 0) {
1997 pr_warn("Could not initialize trace point events/%s\n",
1998 name);
1999 return -1;
2000 }
2001 }
2002 trace_create_file("filter", 0644, file->dir, file,
2003 &ftrace_event_filter_fops);
2004
2005 /*
2006 * Only event directories that can be enabled should have
2007 * triggers.
2008 */
2009 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
2010 trace_create_file("trigger", 0644, file->dir, file,
2011 &event_trigger_fops);
2012
2013 #ifdef CONFIG_HIST_TRIGGERS
2014 trace_create_file("hist", 0444, file->dir, file,
2015 &event_hist_fops);
2016 #endif
2017 trace_create_file("format", 0444, file->dir, call,
2018 &ftrace_event_format_fops);
2019
2020 return 0;
2021 }
2022
2023 static void remove_event_from_tracers(struct trace_event_call *call)
2024 {
2025 struct trace_event_file *file;
2026 struct trace_array *tr;
2027
2028 do_for_each_event_file_safe(tr, file) {
2029 if (file->event_call != call)
2030 continue;
2031
2032 remove_event_file_dir(file);
2033 /*
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
2037 * trace_array.
2038 */
2039 break;
2040 } while_for_each_event_file();
2041 }
2042
2043 static void event_remove(struct trace_event_call *call)
2044 {
2045 struct trace_array *tr;
2046 struct trace_event_file *file;
2047
2048 do_for_each_event_file(tr, file) {
2049 if (file->event_call != call)
2050 continue;
2051 ftrace_event_enable_disable(file, 0);
2052 /*
2053 * The do_for_each_event_file() is
2054 * a double loop. After finding the call for this
2055 * trace_array, we use break to jump to the next
2056 * trace_array.
2057 */
2058 break;
2059 } while_for_each_event_file();
2060
2061 if (call->event.funcs)
2062 __unregister_trace_event(&call->event);
2063 remove_event_from_tracers(call);
2064 list_del(&call->list);
2065 }
2066
2067 static int event_init(struct trace_event_call *call)
2068 {
2069 int ret = 0;
2070 const char *name;
2071
2072 name = trace_event_name(call);
2073 if (WARN_ON(!name))
2074 return -EINVAL;
2075
2076 if (call->class->raw_init) {
2077 ret = call->class->raw_init(call);
2078 if (ret < 0 && ret != -ENOSYS)
2079 pr_warn("Could not initialize trace events/%s\n", name);
2080 }
2081
2082 return ret;
2083 }
2084
2085 static int
2086 __register_event(struct trace_event_call *call, struct module *mod)
2087 {
2088 int ret;
2089
2090 ret = event_init(call);
2091 if (ret < 0)
2092 return ret;
2093
2094 list_add(&call->list, &ftrace_events);
2095 call->mod = mod;
2096
2097 return 0;
2098 }
2099
2100 static char *enum_replace(char *ptr, struct trace_enum_map *map, int len)
2101 {
2102 int rlen;
2103 int elen;
2104
2105 /* Find the length of the enum value as a string */
2106 elen = snprintf(ptr, 0, "%ld", map->enum_value);
2107 /* Make sure there's enough room to replace the string with the value */
2108 if (len < elen)
2109 return NULL;
2110
2111 snprintf(ptr, elen + 1, "%ld", map->enum_value);
2112
2113 /* Get the rest of the string of ptr */
2114 rlen = strlen(ptr + len);
2115 memmove(ptr + elen, ptr + len, rlen);
2116 /* Make sure we end the new string */
2117 ptr[elen + rlen] = 0;
2118
2119 return ptr + elen;
2120 }
2121
2122 static void update_event_printk(struct trace_event_call *call,
2123 struct trace_enum_map *map)
2124 {
2125 char *ptr;
2126 int quote = 0;
2127 int len = strlen(map->enum_string);
2128
2129 for (ptr = call->print_fmt; *ptr; ptr++) {
2130 if (*ptr == '\\') {
2131 ptr++;
2132 /* paranoid */
2133 if (!*ptr)
2134 break;
2135 continue;
2136 }
2137 if (*ptr == '"') {
2138 quote ^= 1;
2139 continue;
2140 }
2141 if (quote)
2142 continue;
2143 if (isdigit(*ptr)) {
2144 /* skip numbers */
2145 do {
2146 ptr++;
2147 /* Check for alpha chars like ULL */
2148 } while (isalnum(*ptr));
2149 if (!*ptr)
2150 break;
2151 /*
2152 * A number must have some kind of delimiter after
2153 * it, and we can ignore that too.
2154 */
2155 continue;
2156 }
2157 if (isalpha(*ptr) || *ptr == '_') {
2158 if (strncmp(map->enum_string, ptr, len) == 0 &&
2159 !isalnum(ptr[len]) && ptr[len] != '_') {
2160 ptr = enum_replace(ptr, map, len);
2161 /* Hmm, enum string smaller than value */
2162 if (WARN_ON_ONCE(!ptr))
2163 return;
2164 /*
2165 * No need to decrement here, as enum_replace()
2166 * returns the pointer to the character passed
2167 * the enum, and two enums can not be placed
2168 * back to back without something in between.
2169 * We can skip that something in between.
2170 */
2171 continue;
2172 }
2173 skip_more:
2174 do {
2175 ptr++;
2176 } while (isalnum(*ptr) || *ptr == '_');
2177 if (!*ptr)
2178 break;
2179 /*
2180 * If what comes after this variable is a '.' or
2181 * '->' then we can continue to ignore that string.
2182 */
2183 if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
2184 ptr += *ptr == '.' ? 1 : 2;
2185 if (!*ptr)
2186 break;
2187 goto skip_more;
2188 }
2189 /*
2190 * Once again, we can skip the delimiter that came
2191 * after the string.
2192 */
2193 continue;
2194 }
2195 }
2196 }
2197
2198 void trace_event_enum_update(struct trace_enum_map **map, int len)
2199 {
2200 struct trace_event_call *call, *p;
2201 const char *last_system = NULL;
2202 bool first = false;
2203 int last_i;
2204 int i;
2205
2206 down_write(&trace_event_sem);
2207 list_for_each_entry_safe(call, p, &ftrace_events, list) {
2208 /* events are usually grouped together with systems */
2209 if (!last_system || call->class->system != last_system) {
2210 first = true;
2211 last_i = 0;
2212 last_system = call->class->system;
2213 }
2214
2215 /*
2216 * Since calls are grouped by systems, the likelyhood that the
2217 * next call in the iteration belongs to the same system as the
2218 * previous call is high. As an optimization, we skip seaching
2219 * for a map[] that matches the call's system if the last call
2220 * was from the same system. That's what last_i is for. If the
2221 * call has the same system as the previous call, then last_i
2222 * will be the index of the first map[] that has a matching
2223 * system.
2224 */
2225 for (i = last_i; i < len; i++) {
2226 if (call->class->system == map[i]->system) {
2227 /* Save the first system if need be */
2228 if (first) {
2229 last_i = i;
2230 first = false;
2231 }
2232 update_event_printk(call, map[i]);
2233 }
2234 }
2235 }
2236 up_write(&trace_event_sem);
2237 }
2238
2239 static struct trace_event_file *
2240 trace_create_new_event(struct trace_event_call *call,
2241 struct trace_array *tr)
2242 {
2243 struct trace_event_file *file;
2244
2245 file = kmem_cache_alloc(file_cachep, GFP_TRACE);
2246 if (!file)
2247 return NULL;
2248
2249 file->event_call = call;
2250 file->tr = tr;
2251 atomic_set(&file->sm_ref, 0);
2252 atomic_set(&file->tm_ref, 0);
2253 INIT_LIST_HEAD(&file->triggers);
2254 list_add(&file->list, &tr->events);
2255
2256 return file;
2257 }
2258
2259 /* Add an event to a trace directory */
2260 static int
2261 __trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)
2262 {
2263 struct trace_event_file *file;
2264
2265 file = trace_create_new_event(call, tr);
2266 if (!file)
2267 return -ENOMEM;
2268
2269 return event_create_dir(tr->event_dir, file);
2270 }
2271
2272 /*
2273 * Just create a decriptor for early init. A descriptor is required
2274 * for enabling events at boot. We want to enable events before
2275 * the filesystem is initialized.
2276 */
2277 static __init int
2278 __trace_early_add_new_event(struct trace_event_call *call,
2279 struct trace_array *tr)
2280 {
2281 struct trace_event_file *file;
2282
2283 file = trace_create_new_event(call, tr);
2284 if (!file)
2285 return -ENOMEM;
2286
2287 return 0;
2288 }
2289
2290 struct ftrace_module_file_ops;
2291 static void __add_event_to_tracers(struct trace_event_call *call);
2292
2293 /* Add an additional event_call dynamically */
2294 int trace_add_event_call(struct trace_event_call *call)
2295 {
2296 int ret;
2297 mutex_lock(&trace_types_lock);
2298 mutex_lock(&event_mutex);
2299
2300 ret = __register_event(call, NULL);
2301 if (ret >= 0)
2302 __add_event_to_tracers(call);
2303
2304 mutex_unlock(&event_mutex);
2305 mutex_unlock(&trace_types_lock);
2306 return ret;
2307 }
2308
2309 /*
2310 * Must be called under locking of trace_types_lock, event_mutex and
2311 * trace_event_sem.
2312 */
2313 static void __trace_remove_event_call(struct trace_event_call *call)
2314 {
2315 event_remove(call);
2316 trace_destroy_fields(call);
2317 free_event_filter(call->filter);
2318 call->filter = NULL;
2319 }
2320
2321 static int probe_remove_event_call(struct trace_event_call *call)
2322 {
2323 struct trace_array *tr;
2324 struct trace_event_file *file;
2325
2326 #ifdef CONFIG_PERF_EVENTS
2327 if (call->perf_refcount)
2328 return -EBUSY;
2329 #endif
2330 do_for_each_event_file(tr, file) {
2331 if (file->event_call != call)
2332 continue;
2333 /*
2334 * We can't rely on ftrace_event_enable_disable(enable => 0)
2335 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
2336 * TRACE_REG_UNREGISTER.
2337 */
2338 if (file->flags & EVENT_FILE_FL_ENABLED)
2339 return -EBUSY;
2340 /*
2341 * The do_for_each_event_file_safe() is
2342 * a double loop. After finding the call for this
2343 * trace_array, we use break to jump to the next
2344 * trace_array.
2345 */
2346 break;
2347 } while_for_each_event_file();
2348
2349 __trace_remove_event_call(call);
2350
2351 return 0;
2352 }
2353
2354 /* Remove an event_call */
2355 int trace_remove_event_call(struct trace_event_call *call)
2356 {
2357 int ret;
2358
2359 mutex_lock(&trace_types_lock);
2360 mutex_lock(&event_mutex);
2361 down_write(&trace_event_sem);
2362 ret = probe_remove_event_call(call);
2363 up_write(&trace_event_sem);
2364 mutex_unlock(&event_mutex);
2365 mutex_unlock(&trace_types_lock);
2366
2367 return ret;
2368 }
2369
2370 #define for_each_event(event, start, end) \
2371 for (event = start; \
2372 (unsigned long)event < (unsigned long)end; \
2373 event++)
2374
2375 #ifdef CONFIG_MODULES
2376
2377 static void trace_module_add_events(struct module *mod)
2378 {
2379 struct trace_event_call **call, **start, **end;
2380
2381 if (!mod->num_trace_events)
2382 return;
2383
2384 /* Don't add infrastructure for mods without tracepoints */
2385 if (trace_module_has_bad_taint(mod)) {
2386 pr_err("%s: module has bad taint, not creating trace events\n",
2387 mod->name);
2388 return;
2389 }
2390
2391 start = mod->trace_events;
2392 end = mod->trace_events + mod->num_trace_events;
2393
2394 for_each_event(call, start, end) {
2395 __register_event(*call, mod);
2396 __add_event_to_tracers(*call);
2397 }
2398 }
2399
2400 static void trace_module_remove_events(struct module *mod)
2401 {
2402 struct trace_event_call *call, *p;
2403 bool clear_trace = false;
2404
2405 down_write(&trace_event_sem);
2406 list_for_each_entry_safe(call, p, &ftrace_events, list) {
2407 if (call->mod == mod) {
2408 if (call->flags & TRACE_EVENT_FL_WAS_ENABLED)
2409 clear_trace = true;
2410 __trace_remove_event_call(call);
2411 }
2412 }
2413 up_write(&trace_event_sem);
2414
2415 /*
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.
2422 */
2423 if (clear_trace)
2424 tracing_reset_all_online_cpus();
2425 }
2426
2427 static int trace_module_notify(struct notifier_block *self,
2428 unsigned long val, void *data)
2429 {
2430 struct module *mod = data;
2431
2432 mutex_lock(&trace_types_lock);
2433 mutex_lock(&event_mutex);
2434 switch (val) {
2435 case MODULE_STATE_COMING:
2436 trace_module_add_events(mod);
2437 break;
2438 case MODULE_STATE_GOING:
2439 trace_module_remove_events(mod);
2440 break;
2441 }
2442 mutex_unlock(&event_mutex);
2443 mutex_unlock(&trace_types_lock);
2444
2445 return 0;
2446 }
2447
2448 static struct notifier_block trace_module_nb = {
2449 .notifier_call = trace_module_notify,
2450 .priority = 1, /* higher than trace.c module notify */
2451 };
2452 #endif /* CONFIG_MODULES */
2453
2454 /* Create a new event directory structure for a trace directory. */
2455 static void
2456 __trace_add_event_dirs(struct trace_array *tr)
2457 {
2458 struct trace_event_call *call;
2459 int ret;
2460
2461 list_for_each_entry(call, &ftrace_events, list) {
2462 ret = __trace_add_new_event(call, tr);
2463 if (ret < 0)
2464 pr_warn("Could not create directory for event %s\n",
2465 trace_event_name(call));
2466 }
2467 }
2468
2469 struct trace_event_file *
2470 find_event_file(struct trace_array *tr, const char *system, const char *event)
2471 {
2472 struct trace_event_file *file;
2473 struct trace_event_call *call;
2474 const char *name;
2475
2476 list_for_each_entry(file, &tr->events, list) {
2477
2478 call = file->event_call;
2479 name = trace_event_name(call);
2480
2481 if (!name || !call->class || !call->class->reg)
2482 continue;
2483
2484 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
2485 continue;
2486
2487 if (strcmp(event, name) == 0 &&
2488 strcmp(system, call->class->system) == 0)
2489 return file;
2490 }
2491 return NULL;
2492 }
2493
2494 #ifdef CONFIG_DYNAMIC_FTRACE
2495
2496 /* Avoid typos */
2497 #define ENABLE_EVENT_STR "enable_event"
2498 #define DISABLE_EVENT_STR "disable_event"
2499
2500 struct event_probe_data {
2501 struct trace_event_file *file;
2502 unsigned long count;
2503 int ref;
2504 bool enable;
2505 };
2506
2507 static void
2508 event_enable_probe(unsigned long ip, unsigned long parent_ip, void **_data)
2509 {
2510 struct event_probe_data **pdata = (struct event_probe_data **)_data;
2511 struct event_probe_data *data = *pdata;
2512
2513 if (!data)
2514 return;
2515
2516 if (data->enable)
2517 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
2518 else
2519 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
2520 }
2521
2522 static void
2523 event_enable_count_probe(unsigned long ip, unsigned long parent_ip, void **_data)
2524 {
2525 struct event_probe_data **pdata = (struct event_probe_data **)_data;
2526 struct event_probe_data *data = *pdata;
2527
2528 if (!data)
2529 return;
2530
2531 if (!data->count)
2532 return;
2533
2534 /* Skip if the event is in a state we want to switch to */
2535 if (data->enable == !(data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
2536 return;
2537
2538 if (data->count != -1)
2539 (data->count)--;
2540
2541 event_enable_probe(ip, parent_ip, _data);
2542 }
2543
2544 static int
2545 event_enable_print(struct seq_file *m, unsigned long ip,
2546 struct ftrace_probe_ops *ops, void *_data)
2547 {
2548 struct event_probe_data *data = _data;
2549
2550 seq_printf(m, "%ps:", (void *)ip);
2551
2552 seq_printf(m, "%s:%s:%s",
2553 data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
2554 data->file->event_call->class->system,
2555 trace_event_name(data->file->event_call));
2556
2557 if (data->count == -1)
2558 seq_puts(m, ":unlimited\n");
2559 else
2560 seq_printf(m, ":count=%ld\n", data->count);
2561
2562 return 0;
2563 }
2564
2565 static int
2566 event_enable_init(struct ftrace_probe_ops *ops, unsigned long ip,
2567 void **_data)
2568 {
2569 struct event_probe_data **pdata = (struct event_probe_data **)_data;
2570 struct event_probe_data *data = *pdata;
2571
2572 data->ref++;
2573 return 0;
2574 }
2575
2576 static void
2577 event_enable_free(struct ftrace_probe_ops *ops, unsigned long ip,
2578 void **_data)
2579 {
2580 struct event_probe_data **pdata = (struct event_probe_data **)_data;
2581 struct event_probe_data *data = *pdata;
2582
2583 if (WARN_ON_ONCE(data->ref <= 0))
2584 return;
2585
2586 data->ref--;
2587 if (!data->ref) {
2588 /* Remove the SOFT_MODE flag */
2589 __ftrace_event_enable_disable(data->file, 0, 1);
2590 module_put(data->file->event_call->mod);
2591 kfree(data);
2592 }
2593 *pdata = NULL;
2594 }
2595
2596 static struct ftrace_probe_ops event_enable_probe_ops = {
2597 .func = event_enable_probe,
2598 .print = event_enable_print,
2599 .init = event_enable_init,
2600 .free = event_enable_free,
2601 };
2602
2603 static struct ftrace_probe_ops event_enable_count_probe_ops = {
2604 .func = event_enable_count_probe,
2605 .print = event_enable_print,
2606 .init = event_enable_init,
2607 .free = event_enable_free,
2608 };
2609
2610 static struct ftrace_probe_ops event_disable_probe_ops = {
2611 .func = event_enable_probe,
2612 .print = event_enable_print,
2613 .init = event_enable_init,
2614 .free = event_enable_free,
2615 };
2616
2617 static struct ftrace_probe_ops event_disable_count_probe_ops = {
2618 .func = event_enable_count_probe,
2619 .print = event_enable_print,
2620 .init = event_enable_init,
2621 .free = event_enable_free,
2622 };
2623
2624 static int
2625 event_enable_func(struct ftrace_hash *hash,
2626 char *glob, char *cmd, char *param, int enabled)
2627 {
2628 struct trace_array *tr = top_trace_array();
2629 struct trace_event_file *file;
2630 struct ftrace_probe_ops *ops;
2631 struct event_probe_data *data;
2632 const char *system;
2633 const char *event;
2634 char *number;
2635 bool enable;
2636 int ret;
2637
2638 if (!tr)
2639 return -ENODEV;
2640
2641 /* hash funcs only work with set_ftrace_filter */
2642 if (!enabled || !param)
2643 return -EINVAL;
2644
2645 system = strsep(&param, ":");
2646 if (!param)
2647 return -EINVAL;
2648
2649 event = strsep(&param, ":");
2650
2651 mutex_lock(&event_mutex);
2652
2653 ret = -EINVAL;
2654 file = find_event_file(tr, system, event);
2655 if (!file)
2656 goto out;
2657
2658 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
2659
2660 if (enable)
2661 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
2662 else
2663 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
2664
2665 if (glob[0] == '!') {
2666 unregister_ftrace_function_probe_func(glob+1, ops);
2667 ret = 0;
2668 goto out;
2669 }
2670
2671 ret = -ENOMEM;
2672 data = kzalloc(sizeof(*data), GFP_KERNEL);
2673 if (!data)
2674 goto out;
2675
2676 data->enable = enable;
2677 data->count = -1;
2678 data->file = file;
2679
2680 if (!param)
2681 goto out_reg;
2682
2683 number = strsep(&param, ":");
2684
2685 ret = -EINVAL;
2686 if (!strlen(number))
2687 goto out_free;
2688
2689 /*
2690 * We use the callback data field (which is a pointer)
2691 * as our counter.
2692 */
2693 ret = kstrtoul(number, 0, &data->count);
2694 if (ret)
2695 goto out_free;
2696
2697 out_reg:
2698 /* Don't let event modules unload while probe registered */
2699 ret = try_module_get(file->event_call->mod);
2700 if (!ret) {
2701 ret = -EBUSY;
2702 goto out_free;
2703 }
2704
2705 ret = __ftrace_event_enable_disable(file, 1, 1);
2706 if (ret < 0)
2707 goto out_put;
2708 ret = register_ftrace_function_probe(glob, ops, data);
2709 /*
2710 * The above returns on success the # of functions enabled,
2711 * but if it didn't find any functions it returns zero.
2712 * Consider no functions a failure too.
2713 */
2714 if (!ret) {
2715 ret = -ENOENT;
2716 goto out_disable;
2717 } else if (ret < 0)
2718 goto out_disable;
2719 /* Just return zero, not the number of enabled functions */
2720 ret = 0;
2721 out:
2722 mutex_unlock(&event_mutex);
2723 return ret;
2724
2725 out_disable:
2726 __ftrace_event_enable_disable(file, 0, 1);
2727 out_put:
2728 module_put(file->event_call->mod);
2729 out_free:
2730 kfree(data);
2731 goto out;
2732 }
2733
2734 static struct ftrace_func_command event_enable_cmd = {
2735 .name = ENABLE_EVENT_STR,
2736 .func = event_enable_func,
2737 };
2738
2739 static struct ftrace_func_command event_disable_cmd = {
2740 .name = DISABLE_EVENT_STR,
2741 .func = event_enable_func,
2742 };
2743
2744 static __init int register_event_cmds(void)
2745 {
2746 int ret;
2747
2748 ret = register_ftrace_command(&event_enable_cmd);
2749 if (WARN_ON(ret < 0))
2750 return ret;
2751 ret = register_ftrace_command(&event_disable_cmd);
2752 if (WARN_ON(ret < 0))
2753 unregister_ftrace_command(&event_enable_cmd);
2754 return ret;
2755 }
2756 #else
2757 static inline int register_event_cmds(void) { return 0; }
2758 #endif /* CONFIG_DYNAMIC_FTRACE */
2759
2760 /*
2761 * The top level array has already had its trace_event_file
2762 * descriptors created in order to allow for early events to
2763 * be recorded. This function is called after the tracefs has been
2764 * initialized, and we now have to create the files associated
2765 * to the events.
2766 */
2767 static __init void
2768 __trace_early_add_event_dirs(struct trace_array *tr)
2769 {
2770 struct trace_event_file *file;
2771 int ret;
2772
2773
2774 list_for_each_entry(file, &tr->events, list) {
2775 ret = event_create_dir(tr->event_dir, file);
2776 if (ret < 0)
2777 pr_warn("Could not create directory for event %s\n",
2778 trace_event_name(file->event_call));
2779 }
2780 }
2781
2782 /*
2783 * For early boot up, the top trace array requires to have
2784 * a list of events that can be enabled. This must be done before
2785 * the filesystem is set up in order to allow events to be traced
2786 * early.
2787 */
2788 static __init void
2789 __trace_early_add_events(struct trace_array *tr)
2790 {
2791 struct trace_event_call *call;
2792 int ret;
2793
2794 list_for_each_entry(call, &ftrace_events, list) {
2795 /* Early boot up should not have any modules loaded */
2796 if (WARN_ON_ONCE(call->mod))
2797 continue;
2798
2799 ret = __trace_early_add_new_event(call, tr);
2800 if (ret < 0)
2801 pr_warn("Could not create early event %s\n",
2802 trace_event_name(call));
2803 }
2804 }
2805
2806 /* Remove the event directory structure for a trace directory. */
2807 static void
2808 __trace_remove_event_dirs(struct trace_array *tr)
2809 {
2810 struct trace_event_file *file, *next;
2811
2812 list_for_each_entry_safe(file, next, &tr->events, list)
2813 remove_event_file_dir(file);
2814 }
2815
2816 static void __add_event_to_tracers(struct trace_event_call *call)
2817 {
2818 struct trace_array *tr;
2819
2820 list_for_each_entry(tr, &ftrace_trace_arrays, list)
2821 __trace_add_new_event(call, tr);
2822 }
2823
2824 extern struct trace_event_call *__start_ftrace_events[];
2825 extern struct trace_event_call *__stop_ftrace_events[];
2826
2827 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
2828
2829 static __init int setup_trace_event(char *str)
2830 {
2831 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
2832 ring_buffer_expanded = true;
2833 tracing_selftest_disabled = true;
2834
2835 return 1;
2836 }
2837 __setup("trace_event=", setup_trace_event);
2838
2839 /* Expects to have event_mutex held when called */
2840 static int
2841 create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
2842 {
2843 struct dentry *d_events;
2844 struct dentry *entry;
2845
2846 entry = tracefs_create_file("set_event", 0644, parent,
2847 tr, &ftrace_set_event_fops);
2848 if (!entry) {
2849 pr_warn("Could not create tracefs 'set_event' entry\n");
2850 return -ENOMEM;
2851 }
2852
2853 d_events = tracefs_create_dir("events", parent);
2854 if (!d_events) {
2855 pr_warn("Could not create tracefs 'events' directory\n");
2856 return -ENOMEM;
2857 }
2858
2859 entry = tracefs_create_file("set_event_pid", 0644, parent,
2860 tr, &ftrace_set_event_pid_fops);
2861
2862 /* ring buffer internal formats */
2863 trace_create_file("header_page", 0444, d_events,
2864 ring_buffer_print_page_header,
2865 &ftrace_show_header_fops);
2866
2867 trace_create_file("header_event", 0444, d_events,
2868 ring_buffer_print_entry_header,
2869 &ftrace_show_header_fops);
2870
2871 trace_create_file("enable", 0644, d_events,
2872 tr, &ftrace_tr_enable_fops);
2873
2874 tr->event_dir = d_events;
2875
2876 return 0;
2877 }
2878
2879 /**
2880 * event_trace_add_tracer - add a instance of a trace_array to events
2881 * @parent: The parent dentry to place the files/directories for events in
2882 * @tr: The trace array associated with these events
2883 *
2884 * When a new instance is created, it needs to set up its events
2885 * directory, as well as other files associated with events. It also
2886 * creates the event hierachry in the @parent/events directory.
2887 *
2888 * Returns 0 on success.
2889 */
2890 int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
2891 {
2892 int ret;
2893
2894 mutex_lock(&event_mutex);
2895
2896 ret = create_event_toplevel_files(parent, tr);
2897 if (ret)
2898 goto out_unlock;
2899
2900 down_write(&trace_event_sem);
2901 __trace_add_event_dirs(tr);
2902 up_write(&trace_event_sem);
2903
2904 out_unlock:
2905 mutex_unlock(&event_mutex);
2906
2907 return ret;
2908 }
2909
2910 /*
2911 * The top trace array already had its file descriptors created.
2912 * Now the files themselves need to be created.
2913 */
2914 static __init int
2915 early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
2916 {
2917 int ret;
2918
2919 mutex_lock(&event_mutex);
2920
2921 ret = create_event_toplevel_files(parent, tr);
2922 if (ret)
2923 goto out_unlock;
2924
2925 down_write(&trace_event_sem);
2926 __trace_early_add_event_dirs(tr);
2927 up_write(&trace_event_sem);
2928
2929 out_unlock:
2930 mutex_unlock(&event_mutex);
2931
2932 return ret;
2933 }
2934
2935 int event_trace_del_tracer(struct trace_array *tr)
2936 {
2937 mutex_lock(&event_mutex);
2938
2939 /* Disable any event triggers and associated soft-disabled events */
2940 clear_event_triggers(tr);
2941
2942 /* Clear the pid list */
2943 __ftrace_clear_event_pids(tr);
2944
2945 /* Disable any running events */
2946 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
2947
2948 /* Access to events are within rcu_read_lock_sched() */
2949 synchronize_sched();
2950
2951 down_write(&trace_event_sem);
2952 __trace_remove_event_dirs(tr);
2953 tracefs_remove_recursive(tr->event_dir);
2954 up_write(&trace_event_sem);
2955
2956 tr->event_dir = NULL;
2957
2958 mutex_unlock(&event_mutex);
2959
2960 return 0;
2961 }
2962
2963 static __init int event_trace_memsetup(void)
2964 {
2965 field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
2966 file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC);
2967 return 0;
2968 }
2969
2970 static __init void
2971 early_enable_events(struct trace_array *tr, bool disable_first)
2972 {
2973 char *buf = bootup_event_buf;
2974 char *token;
2975 int ret;
2976
2977 while (true) {
2978 token = strsep(&buf, ",");
2979
2980 if (!token)
2981 break;
2982
2983 if (*token) {
2984 /* Restarting syscalls requires that we stop them first */
2985 if (disable_first)
2986 ftrace_set_clr_event(tr, token, 0);
2987
2988 ret = ftrace_set_clr_event(tr, token, 1);
2989 if (ret)
2990 pr_warn("Failed to enable trace event: %s\n", token);
2991 }
2992
2993 /* Put back the comma to allow this to be called again */
2994 if (buf)
2995 *(buf - 1) = ',';
2996 }
2997 }
2998
2999 static __init int event_trace_enable(void)
3000 {
3001 struct trace_array *tr = top_trace_array();
3002 struct trace_event_call **iter, *call;
3003 int ret;
3004
3005 if (!tr)
3006 return -ENODEV;
3007
3008 for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
3009
3010 call = *iter;
3011 ret = event_init(call);
3012 if (!ret)
3013 list_add(&call->list, &ftrace_events);
3014 }
3015
3016 /*
3017 * We need the top trace array to have a working set of trace
3018 * points at early init, before the debug files and directories
3019 * are created. Create the file entries now, and attach them
3020 * to the actual file dentries later.
3021 */
3022 __trace_early_add_events(tr);
3023
3024 early_enable_events(tr, false);
3025
3026 trace_printk_start_comm();
3027
3028 register_event_cmds();
3029
3030 register_trigger_cmds();
3031
3032 return 0;
3033 }
3034
3035 /*
3036 * event_trace_enable() is called from trace_event_init() first to
3037 * initialize events and perhaps start any events that are on the
3038 * command line. Unfortunately, there are some events that will not
3039 * start this early, like the system call tracepoints that need
3040 * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable()
3041 * is called before pid 1 starts, and this flag is never set, making
3042 * the syscall tracepoint never get reached, but the event is enabled
3043 * regardless (and not doing anything).
3044 */
3045 static __init int event_trace_enable_again(void)
3046 {
3047 struct trace_array *tr;
3048
3049 tr = top_trace_array();
3050 if (!tr)
3051 return -ENODEV;
3052
3053 early_enable_events(tr, true);
3054
3055 return 0;
3056 }
3057
3058 early_initcall(event_trace_enable_again);
3059
3060 static __init int event_trace_init(void)
3061 {
3062 struct trace_array *tr;
3063 struct dentry *d_tracer;
3064 struct dentry *entry;
3065 int ret;
3066
3067 tr = top_trace_array();
3068 if (!tr)
3069 return -ENODEV;
3070
3071 d_tracer = tracing_init_dentry();
3072 if (IS_ERR(d_tracer))
3073 return 0;
3074
3075 entry = tracefs_create_file("available_events", 0444, d_tracer,
3076 tr, &ftrace_avail_fops);
3077 if (!entry)
3078 pr_warn("Could not create tracefs 'available_events' entry\n");
3079
3080 if (trace_define_generic_fields())
3081 pr_warn("tracing: Failed to allocated generic fields");
3082
3083 if (trace_define_common_fields())
3084 pr_warn("tracing: Failed to allocate common fields");
3085
3086 ret = early_event_add_tracer(d_tracer, tr);
3087 if (ret)
3088 return ret;
3089
3090 #ifdef CONFIG_MODULES
3091 ret = register_module_notifier(&trace_module_nb);
3092 if (ret)
3093 pr_warn("Failed to register trace events module notifier\n");
3094 #endif
3095 return 0;
3096 }
3097
3098 void __init trace_event_init(void)
3099 {
3100 event_trace_memsetup();
3101 init_ftrace_syscalls();
3102 event_trace_enable();
3103 }
3104
3105 fs_initcall(event_trace_init);
3106
3107 #ifdef CONFIG_FTRACE_STARTUP_TEST
3108
3109 static DEFINE_SPINLOCK(test_spinlock);
3110 static DEFINE_SPINLOCK(test_spinlock_irq);
3111 static DEFINE_MUTEX(test_mutex);
3112
3113 static __init void test_work(struct work_struct *dummy)
3114 {
3115 spin_lock(&test_spinlock);
3116 spin_lock_irq(&test_spinlock_irq);
3117 udelay(1);
3118 spin_unlock_irq(&test_spinlock_irq);
3119 spin_unlock(&test_spinlock);
3120
3121 mutex_lock(&test_mutex);
3122 msleep(1);
3123 mutex_unlock(&test_mutex);
3124 }
3125
3126 static __init int event_test_thread(void *unused)
3127 {
3128 void *test_malloc;
3129
3130 test_malloc = kmalloc(1234, GFP_KERNEL);
3131 if (!test_malloc)
3132 pr_info("failed to kmalloc\n");
3133
3134 schedule_on_each_cpu(test_work);
3135
3136 kfree(test_malloc);
3137
3138 set_current_state(TASK_INTERRUPTIBLE);
3139 while (!kthread_should_stop()) {
3140 schedule();
3141 set_current_state(TASK_INTERRUPTIBLE);
3142 }
3143 __set_current_state(TASK_RUNNING);
3144
3145 return 0;
3146 }
3147
3148 /*
3149 * Do various things that may trigger events.
3150 */
3151 static __init void event_test_stuff(void)
3152 {
3153 struct task_struct *test_thread;
3154
3155 test_thread = kthread_run(event_test_thread, NULL, "test-events");
3156 msleep(1);
3157 kthread_stop(test_thread);
3158 }
3159
3160 /*
3161 * For every trace event defined, we will test each trace point separately,
3162 * and then by groups, and finally all trace points.
3163 */
3164 static __init void event_trace_self_tests(void)
3165 {
3166 struct trace_subsystem_dir *dir;
3167 struct trace_event_file *file;
3168 struct trace_event_call *call;
3169 struct event_subsystem *system;
3170 struct trace_array *tr;
3171 int ret;
3172
3173 tr = top_trace_array();
3174 if (!tr)
3175 return;
3176
3177 pr_info("Running tests on trace events:\n");
3178
3179 list_for_each_entry(file, &tr->events, list) {
3180
3181 call = file->event_call;
3182
3183 /* Only test those that have a probe */
3184 if (!call->class || !call->class->probe)
3185 continue;
3186
3187 /*
3188 * Testing syscall events here is pretty useless, but
3189 * we still do it if configured. But this is time consuming.
3190 * What we really need is a user thread to perform the
3191 * syscalls as we test.
3192 */
3193 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
3194 if (call->class->system &&
3195 strcmp(call->class->system, "syscalls") == 0)
3196 continue;
3197 #endif
3198
3199 pr_info("Testing event %s: ", trace_event_name(call));
3200
3201 /*
3202 * If an event is already enabled, someone is using
3203 * it and the self test should not be on.
3204 */
3205 if (file->flags & EVENT_FILE_FL_ENABLED) {
3206 pr_warn("Enabled event during self test!\n");
3207 WARN_ON_ONCE(1);
3208 continue;
3209 }
3210
3211 ftrace_event_enable_disable(file, 1);
3212 event_test_stuff();
3213 ftrace_event_enable_disable(file, 0);
3214
3215 pr_cont("OK\n");
3216 }
3217
3218 /* Now test at the sub system level */
3219
3220 pr_info("Running tests on trace event systems:\n");
3221
3222 list_for_each_entry(dir, &tr->systems, list) {
3223
3224 system = dir->subsystem;
3225
3226 /* the ftrace system is special, skip it */
3227 if (strcmp(system->name, "ftrace") == 0)
3228 continue;
3229
3230 pr_info("Testing event system %s: ", system->name);
3231
3232 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1);
3233 if (WARN_ON_ONCE(ret)) {
3234 pr_warn("error enabling system %s\n",
3235 system->name);
3236 continue;
3237 }
3238
3239 event_test_stuff();
3240
3241 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0);
3242 if (WARN_ON_ONCE(ret)) {
3243 pr_warn("error disabling system %s\n",
3244 system->name);
3245 continue;
3246 }
3247
3248 pr_cont("OK\n");
3249 }
3250
3251 /* Test with all events enabled */
3252
3253 pr_info("Running tests on all trace events:\n");
3254 pr_info("Testing all events: ");
3255
3256 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1);
3257 if (WARN_ON_ONCE(ret)) {
3258 pr_warn("error enabling all events\n");
3259 return;
3260 }
3261
3262 event_test_stuff();
3263
3264 /* reset sysname */
3265 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
3266 if (WARN_ON_ONCE(ret)) {
3267 pr_warn("error disabling all events\n");
3268 return;
3269 }
3270
3271 pr_cont("OK\n");
3272 }
3273
3274 #ifdef CONFIG_FUNCTION_TRACER
3275
3276 static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
3277
3278 static struct trace_event_file event_trace_file __initdata;
3279
3280 static void __init
3281 function_test_events_call(unsigned long ip, unsigned long parent_ip,
3282 struct ftrace_ops *op, struct pt_regs *pt_regs)
3283 {
3284 struct ring_buffer_event *event;
3285 struct ring_buffer *buffer;
3286 struct ftrace_entry *entry;
3287 unsigned long flags;
3288 long disabled;
3289 int cpu;
3290 int pc;
3291
3292 pc = preempt_count();
3293 preempt_disable_notrace();
3294 cpu = raw_smp_processor_id();
3295 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
3296
3297 if (disabled != 1)
3298 goto out;
3299
3300 local_save_flags(flags);
3301
3302 event = trace_event_buffer_lock_reserve(&buffer, &event_trace_file,
3303 TRACE_FN, sizeof(*entry),
3304 flags, pc);
3305 if (!event)
3306 goto out;
3307 entry = ring_buffer_event_data(event);
3308 entry->ip = ip;
3309 entry->parent_ip = parent_ip;
3310
3311 event_trigger_unlock_commit(&event_trace_file, buffer, event,
3312 entry, flags, pc);
3313 out:
3314 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
3315 preempt_enable_notrace();
3316 }
3317
3318 static struct ftrace_ops trace_ops __initdata =
3319 {
3320 .func = function_test_events_call,
3321 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
3322 };
3323
3324 static __init void event_trace_self_test_with_function(void)
3325 {
3326 int ret;
3327
3328 event_trace_file.tr = top_trace_array();
3329 if (WARN_ON(!event_trace_file.tr))
3330 return;
3331
3332 ret = register_ftrace_function(&trace_ops);
3333 if (WARN_ON(ret < 0)) {
3334 pr_info("Failed to enable function tracer for event tests\n");
3335 return;
3336 }
3337 pr_info("Running tests again, along with the function tracer\n");
3338 event_trace_self_tests();
3339 unregister_ftrace_function(&trace_ops);
3340 }
3341 #else
3342 static __init void event_trace_self_test_with_function(void)
3343 {
3344 }
3345 #endif
3346
3347 static __init int event_trace_self_tests_init(void)
3348 {
3349 if (!tracing_selftest_disabled) {
3350 event_trace_self_tests();
3351 event_trace_self_test_with_function();
3352 }
3353
3354 return 0;
3355 }
3356
3357 late_initcall(event_trace_self_tests_init);
3358
3359 #endif
Linux with added FPC-III support