1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) fmt
13
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>
25
26#include <trace/events/sched.h>
27#include <trace/syscall.h>
28
29#include <asm/setup.h>
30
31#include "trace_output.h"
32
33#undef TRACE_SYSTEM
34#define TRACE_SYSTEM "TRACE_SYSTEM"
35
36DEFINE_MUTEX(event_mutex);
37
38LIST_HEAD(ftrace_events);
39static LIST_HEAD(ftrace_generic_fields);
40static LIST_HEAD(ftrace_common_fields);
41static bool eventdir_initialized;
42
43#define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
44
45static struct kmem_cache *field_cachep;
46static struct kmem_cache *file_cachep;
47
48static inline int system_refcount(struct event_subsystem *system)
49{
50 return system->ref_count;
51}
52
53static int system_refcount_inc(struct event_subsystem *system)
54{
55 return system->ref_count++;
56}
57
58static int system_refcount_dec(struct event_subsystem *system)
59{
60 return --system->ref_count;
61}
62
63
64#define do_for_each_event_file(tr, file) \
65 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
66 list_for_each_entry(file, &tr->events, list)
67
68#define do_for_each_event_file_safe(tr, file) \
69 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
70 struct trace_event_file *___n; \
71 list_for_each_entry_safe(file, ___n, &tr->events, list)
72
73#define while_for_each_event_file() \
74 }
75
76static struct ftrace_event_field *
77__find_event_field(struct list_head *head, char *name)
78{
79 struct ftrace_event_field *field;
80
81 list_for_each_entry(field, head, link) {
82 if (!strcmp(field->name, name))
83 return field;
84 }
85
86 return NULL;
87}
88
89struct ftrace_event_field *
90trace_find_event_field(struct trace_event_call *call, char *name)
91{
92 struct ftrace_event_field *field;
93 struct list_head *head;
94
95 head = trace_get_fields(call);
96 field = __find_event_field(head, name);
97 if (field)
98 return field;
99
100 field = __find_event_field(&ftrace_generic_fields, name);
101 if (field)
102 return field;
103
104 return __find_event_field(&ftrace_common_fields, name);
105}
106
107static int __trace_define_field(struct list_head *head, const char *type,
108 const char *name, int offset, int size,
109 int is_signed, int filter_type)
110{
111 struct ftrace_event_field *field;
112
113 field = kmem_cache_alloc(field_cachep, GFP_TRACE);
114 if (!field)
115 return -ENOMEM;
116
117 field->name = name;
118 field->type = type;
119
120 if (filter_type == FILTER_OTHER)
121 field->filter_type = filter_assign_type(type);
122 else
123 field->filter_type = filter_type;
124
125 field->offset = offset;
126 field->size = size;
127 field->is_signed = is_signed;
128
129 list_add(&field->link, head);
130
131 return 0;
132}
133
134int trace_define_field(struct trace_event_call *call, const char *type,
135 const char *name, int offset, int size, int is_signed,
136 int filter_type)
137{
138 struct list_head *head;
139
140 if (WARN_ON(!call->class))
141 return 0;
142
143 head = trace_get_fields(call);
144 return __trace_define_field(head, type, name, offset, size,
145 is_signed, filter_type);
146}
147EXPORT_SYMBOL_GPL(trace_define_field);
148
149#define __generic_field(type, item, filter_type) \
150 ret = __trace_define_field(&ftrace_generic_fields, #type, \
151 #item, 0, 0, is_signed_type(type), \
152 filter_type); \
153 if (ret) \
154 return ret;
155
156#define __common_field(type, item) \
157 ret = __trace_define_field(&ftrace_common_fields, #type, \
158 "common_" #item, \
159 offsetof(typeof(ent), item), \
160 sizeof(ent.item), \
161 is_signed_type(type), FILTER_OTHER); \
162 if (ret) \
163 return ret;
164
165static int trace_define_generic_fields(void)
166{
167 int ret;
168
169 __generic_field(int, CPU, FILTER_CPU);
170 __generic_field(int, cpu, FILTER_CPU);
171 __generic_field(char *, COMM, FILTER_COMM);
172 __generic_field(char *, comm, FILTER_COMM);
173
174 return ret;
175}
176
177static int trace_define_common_fields(void)
178{
179 int ret;
180 struct trace_entry ent;
181
182 __common_field(unsigned short, type);
183 __common_field(unsigned char, flags);
184
185 __common_field(unsigned char, preempt_count);
186 __common_field(int, pid);
187
188 return ret;
189}
190
191static void trace_destroy_fields(struct trace_event_call *call)
192{
193 struct ftrace_event_field *field, *next;
194 struct list_head *head;
195
196 head = trace_get_fields(call);
197 list_for_each_entry_safe(field, next, head, link) {
198 list_del(&field->link);
199 kmem_cache_free(field_cachep, field);
200 }
201}
202
203
204
205
206
207int trace_event_get_offsets(struct trace_event_call *call)
208{
209 struct ftrace_event_field *tail;
210 struct list_head *head;
211
212 head = trace_get_fields(call);
213
214
215
216
217 tail = list_first_entry(head, struct ftrace_event_field, link);
218 return tail->offset + tail->size;
219}
220
221
222
223
224
225static bool test_field(const char *fmt, struct trace_event_call *call)
226{
227 struct trace_event_fields *field = call->class->fields_array;
228 const char *array_descriptor;
229 const char *p = fmt;
230 int len;
231
232 if (!(len = str_has_prefix(fmt, "REC->")))
233 return false;
234 fmt += len;
235 for (p = fmt; *p; p++) {
236 if (!isalnum(*p) && *p != '_')
237 break;
238 }
239 len = p - fmt;
240
241 for (; field->type; field++) {
242 if (strncmp(field->name, fmt, len) ||
243 field->name[len])
244 continue;
245 array_descriptor = strchr(field->type, '[');
246
247 return array_descriptor != NULL;
248 }
249 return false;
250}
251
252
253
254
255
256
257
258static void test_event_printk(struct trace_event_call *call)
259{
260 u64 dereference_flags = 0;
261 bool first = true;
262 const char *fmt, *c, *r, *a;
263 int parens = 0;
264 char in_quote = 0;
265 int start_arg = 0;
266 int arg = 0;
267 int i;
268
269 fmt = call->print_fmt;
270
271 if (!fmt)
272 return;
273
274 for (i = 0; fmt[i]; i++) {
275 switch (fmt[i]) {
276 case '\\':
277 i++;
278 if (!fmt[i])
279 return;
280 continue;
281 case '"':
282 case '\'':
283
284
285
286
287
288
289
290 if (first) {
291 if (fmt[i] == '\'')
292 continue;
293 if (in_quote) {
294 arg = 0;
295 first = false;
296
297
298
299
300 if (!dereference_flags)
301 return;
302 }
303 }
304 if (in_quote) {
305 if (in_quote == fmt[i])
306 in_quote = 0;
307 } else {
308 in_quote = fmt[i];
309 }
310 continue;
311 case '%':
312 if (!first || !in_quote)
313 continue;
314 i++;
315 if (!fmt[i])
316 return;
317 switch (fmt[i]) {
318 case '%':
319 continue;
320 case 'p':
321
322 switch (fmt[i + 1]) {
323 case 'B': case 'R': case 'r':
324 case 'b': case 'M': case 'm':
325 case 'I': case 'i': case 'E':
326 case 'U': case 'V': case 'N':
327 case 'a': case 'd': case 'D':
328 case 'g': case 't': case 'C':
329 case 'O': case 'f':
330 if (WARN_ONCE(arg == 63,
331 "Too many args for event: %s",
332 trace_event_name(call)))
333 return;
334 dereference_flags |= 1ULL << arg;
335 }
336 break;
337 default:
338 {
339 bool star = false;
340 int j;
341
342
343 for (j = 0; fmt[i + j]; j++) {
344 if (isdigit(fmt[i + j]) ||
345 fmt[i + j] == '.')
346 continue;
347 if (fmt[i + j] == '*') {
348 star = true;
349 continue;
350 }
351 if ((fmt[i + j] == 's') && star)
352 arg++;
353 break;
354 }
355 break;
356 }
357
358 }
359 arg++;
360 continue;
361 case '(':
362 if (in_quote)
363 continue;
364 parens++;
365 continue;
366 case ')':
367 if (in_quote)
368 continue;
369 parens--;
370 if (WARN_ONCE(parens < 0,
371 "Paren mismatch for event: %s\narg='%s'\n%*s",
372 trace_event_name(call),
373 fmt + start_arg,
374 (i - start_arg) + 5, "^"))
375 return;
376 continue;
377 case ',':
378 if (in_quote || parens)
379 continue;
380 i++;
381 while (isspace(fmt[i]))
382 i++;
383 start_arg = i;
384 if (!(dereference_flags & (1ULL << arg)))
385 goto next_arg;
386
387
388 c = strchr(fmt + i, ',');
389 r = strstr(fmt + i, "REC->");
390 if (r && (!c || r < c)) {
391
392
393
394
395
396
397
398
399 a = strchr(fmt + i, '&');
400 if ((a && (a < r)) || test_field(r, call))
401 dereference_flags &= ~(1ULL << arg);
402 }
403 next_arg:
404 i--;
405 arg++;
406 }
407 }
408
409
410
411
412
413
414
415
416
417 if (WARN_ON_ONCE(dereference_flags)) {
418 arg = 1;
419 while (!(dereference_flags & 1)) {
420 dereference_flags >>= 1;
421 arg++;
422 }
423 pr_warn("event %s has unsafe dereference of argument %d\n",
424 trace_event_name(call), arg);
425 pr_warn("print_fmt: %s\n", fmt);
426 }
427}
428
429int trace_event_raw_init(struct trace_event_call *call)
430{
431 int id;
432
433 id = register_trace_event(&call->event);
434 if (!id)
435 return -ENODEV;
436
437 test_event_printk(call);
438
439 return 0;
440}
441EXPORT_SYMBOL_GPL(trace_event_raw_init);
442
443bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
444{
445 struct trace_array *tr = trace_file->tr;
446 struct trace_array_cpu *data;
447 struct trace_pid_list *no_pid_list;
448 struct trace_pid_list *pid_list;
449
450 pid_list = rcu_dereference_raw(tr->filtered_pids);
451 no_pid_list = rcu_dereference_raw(tr->filtered_no_pids);
452
453 if (!pid_list && !no_pid_list)
454 return false;
455
456 data = this_cpu_ptr(tr->array_buffer.data);
457
458 return data->ignore_pid;
459}
460EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid);
461
462void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
463 struct trace_event_file *trace_file,
464 unsigned long len)
465{
466 struct trace_event_call *event_call = trace_file->event_call;
467
468 if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) &&
469 trace_event_ignore_this_pid(trace_file))
470 return NULL;
471
472
473
474
475
476
477
478 fbuffer->trace_ctx = tracing_gen_ctx_dec();
479 fbuffer->trace_file = trace_file;
480
481 fbuffer->event =
482 trace_event_buffer_lock_reserve(&fbuffer->buffer, trace_file,
483 event_call->event.type, len,
484 fbuffer->trace_ctx);
485 if (!fbuffer->event)
486 return NULL;
487
488 fbuffer->regs = NULL;
489 fbuffer->entry = ring_buffer_event_data(fbuffer->event);
490 return fbuffer->entry;
491}
492EXPORT_SYMBOL_GPL(trace_event_buffer_reserve);
493
494int trace_event_reg(struct trace_event_call *call,
495 enum trace_reg type, void *data)
496{
497 struct trace_event_file *file = data;
498
499 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
500 switch (type) {
501 case TRACE_REG_REGISTER:
502 return tracepoint_probe_register(call->tp,
503 call->class->probe,
504 file);
505 case TRACE_REG_UNREGISTER:
506 tracepoint_probe_unregister(call->tp,
507 call->class->probe,
508 file);
509 return 0;
510
511#ifdef CONFIG_PERF_EVENTS
512 case TRACE_REG_PERF_REGISTER:
513 return tracepoint_probe_register(call->tp,
514 call->class->perf_probe,
515 call);
516 case TRACE_REG_PERF_UNREGISTER:
517 tracepoint_probe_unregister(call->tp,
518 call->class->perf_probe,
519 call);
520 return 0;
521 case TRACE_REG_PERF_OPEN:
522 case TRACE_REG_PERF_CLOSE:
523 case TRACE_REG_PERF_ADD:
524 case TRACE_REG_PERF_DEL:
525 return 0;
526#endif
527 }
528 return 0;
529}
530EXPORT_SYMBOL_GPL(trace_event_reg);
531
532void trace_event_enable_cmd_record(bool enable)
533{
534 struct trace_event_file *file;
535 struct trace_array *tr;
536
537 lockdep_assert_held(&event_mutex);
538
539 do_for_each_event_file(tr, file) {
540
541 if (!(file->flags & EVENT_FILE_FL_ENABLED))
542 continue;
543
544 if (enable) {
545 tracing_start_cmdline_record();
546 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
547 } else {
548 tracing_stop_cmdline_record();
549 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
550 }
551 } while_for_each_event_file();
552}
553
554void trace_event_enable_tgid_record(bool enable)
555{
556 struct trace_event_file *file;
557 struct trace_array *tr;
558
559 lockdep_assert_held(&event_mutex);
560
561 do_for_each_event_file(tr, file) {
562 if (!(file->flags & EVENT_FILE_FL_ENABLED))
563 continue;
564
565 if (enable) {
566 tracing_start_tgid_record();
567 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
568 } else {
569 tracing_stop_tgid_record();
570 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT,
571 &file->flags);
572 }
573 } while_for_each_event_file();
574}
575
576static int __ftrace_event_enable_disable(struct trace_event_file *file,
577 int enable, int soft_disable)
578{
579 struct trace_event_call *call = file->event_call;
580 struct trace_array *tr = file->tr;
581 unsigned long file_flags = file->flags;
582 int ret = 0;
583 int disable;
584
585 switch (enable) {
586 case 0:
587
588
589
590
591
592
593
594
595
596
597
598
599
600 if (soft_disable) {
601 if (atomic_dec_return(&file->sm_ref) > 0)
602 break;
603 disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
604 clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
605 } else
606 disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
607
608 if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
609 clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
610 if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
611 tracing_stop_cmdline_record();
612 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
613 }
614
615 if (file->flags & EVENT_FILE_FL_RECORDED_TGID) {
616 tracing_stop_tgid_record();
617 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
618 }
619
620 call->class->reg(call, TRACE_REG_UNREGISTER, file);
621 }
622
623 if (file->flags & EVENT_FILE_FL_SOFT_MODE)
624 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
625 else
626 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
627 break;
628 case 1:
629
630
631
632
633
634
635
636
637 if (!soft_disable)
638 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
639 else {
640 if (atomic_inc_return(&file->sm_ref) > 1)
641 break;
642 set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
643 }
644
645 if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
646 bool cmd = false, tgid = false;
647
648
649 if (soft_disable)
650 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
651
652 if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
653 cmd = true;
654 tracing_start_cmdline_record();
655 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
656 }
657
658 if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
659 tgid = true;
660 tracing_start_tgid_record();
661 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
662 }
663
664 ret = call->class->reg(call, TRACE_REG_REGISTER, file);
665 if (ret) {
666 if (cmd)
667 tracing_stop_cmdline_record();
668 if (tgid)
669 tracing_stop_tgid_record();
670 pr_info("event trace: Could not enable event "
671 "%s\n", trace_event_name(call));
672 break;
673 }
674 set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
675
676
677 set_bit(EVENT_FILE_FL_WAS_ENABLED_BIT, &file->flags);
678 }
679 break;
680 }
681
682
683 if ((file_flags & EVENT_FILE_FL_SOFT_DISABLED) !=
684 (file->flags & EVENT_FILE_FL_SOFT_DISABLED)) {
685 if (file->flags & EVENT_FILE_FL_SOFT_DISABLED)
686 trace_buffered_event_enable();
687 else
688 trace_buffered_event_disable();
689 }
690
691 return ret;
692}
693
694int trace_event_enable_disable(struct trace_event_file *file,
695 int enable, int soft_disable)
696{
697 return __ftrace_event_enable_disable(file, enable, soft_disable);
698}
699
700static int ftrace_event_enable_disable(struct trace_event_file *file,
701 int enable)
702{
703 return __ftrace_event_enable_disable(file, enable, 0);
704}
705
706static void ftrace_clear_events(struct trace_array *tr)
707{
708 struct trace_event_file *file;
709
710 mutex_lock(&event_mutex);
711 list_for_each_entry(file, &tr->events, list) {
712 ftrace_event_enable_disable(file, 0);
713 }
714 mutex_unlock(&event_mutex);
715}
716
717static void
718event_filter_pid_sched_process_exit(void *data, struct task_struct *task)
719{
720 struct trace_pid_list *pid_list;
721 struct trace_array *tr = data;
722
723 pid_list = rcu_dereference_raw(tr->filtered_pids);
724 trace_filter_add_remove_task(pid_list, NULL, task);
725
726 pid_list = rcu_dereference_raw(tr->filtered_no_pids);
727 trace_filter_add_remove_task(pid_list, NULL, task);
728}
729
730static void
731event_filter_pid_sched_process_fork(void *data,
732 struct task_struct *self,
733 struct task_struct *task)
734{
735 struct trace_pid_list *pid_list;
736 struct trace_array *tr = data;
737
738 pid_list = rcu_dereference_sched(tr->filtered_pids);
739 trace_filter_add_remove_task(pid_list, self, task);
740
741 pid_list = rcu_dereference_sched(tr->filtered_no_pids);
742 trace_filter_add_remove_task(pid_list, self, task);
743}
744
745void trace_event_follow_fork(struct trace_array *tr, bool enable)
746{
747 if (enable) {
748 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork,
749 tr, INT_MIN);
750 register_trace_prio_sched_process_free(event_filter_pid_sched_process_exit,
751 tr, INT_MAX);
752 } else {
753 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork,
754 tr);
755 unregister_trace_sched_process_free(event_filter_pid_sched_process_exit,
756 tr);
757 }
758}
759
760static void
761event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
762 struct task_struct *prev, struct task_struct *next)
763{
764 struct trace_array *tr = data;
765 struct trace_pid_list *no_pid_list;
766 struct trace_pid_list *pid_list;
767 bool ret;
768
769 pid_list = rcu_dereference_sched(tr->filtered_pids);
770 no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
771
772
773
774
775
776 ret = trace_ignore_this_task(NULL, no_pid_list, prev) &&
777 trace_ignore_this_task(NULL, no_pid_list, next);
778
779 this_cpu_write(tr->array_buffer.data->ignore_pid, ret ||
780 (trace_ignore_this_task(pid_list, NULL, prev) &&
781 trace_ignore_this_task(pid_list, NULL, next)));
782}
783
784static void
785event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
786 struct task_struct *prev, struct task_struct *next)
787{
788 struct trace_array *tr = data;
789 struct trace_pid_list *no_pid_list;
790 struct trace_pid_list *pid_list;
791
792 pid_list = rcu_dereference_sched(tr->filtered_pids);
793 no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
794
795 this_cpu_write(tr->array_buffer.data->ignore_pid,
796 trace_ignore_this_task(pid_list, no_pid_list, next));
797}
798
799static void
800event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
801{
802 struct trace_array *tr = data;
803 struct trace_pid_list *no_pid_list;
804 struct trace_pid_list *pid_list;
805
806
807 if (!this_cpu_read(tr->array_buffer.data->ignore_pid))
808 return;
809
810 pid_list = rcu_dereference_sched(tr->filtered_pids);
811 no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
812
813 this_cpu_write(tr->array_buffer.data->ignore_pid,
814 trace_ignore_this_task(pid_list, no_pid_list, task));
815}
816
817static void
818event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
819{
820 struct trace_array *tr = data;
821 struct trace_pid_list *no_pid_list;
822 struct trace_pid_list *pid_list;
823
824
825 if (this_cpu_read(tr->array_buffer.data->ignore_pid))
826 return;
827
828 pid_list = rcu_dereference_sched(tr->filtered_pids);
829 no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
830
831
832 this_cpu_write(tr->array_buffer.data->ignore_pid,
833 trace_ignore_this_task(pid_list, no_pid_list, current));
834}
835
836static void unregister_pid_events(struct trace_array *tr)
837{
838 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre, tr);
839 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post, tr);
840
841 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, tr);
842 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, tr);
843
844 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, tr);
845 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, tr);
846
847 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre, tr);
848 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post, tr);
849}
850
851static void __ftrace_clear_event_pids(struct trace_array *tr, int type)
852{
853 struct trace_pid_list *pid_list;
854 struct trace_pid_list *no_pid_list;
855 struct trace_event_file *file;
856 int cpu;
857
858 pid_list = rcu_dereference_protected(tr->filtered_pids,
859 lockdep_is_held(&event_mutex));
860 no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
861 lockdep_is_held(&event_mutex));
862
863
864 if (!pid_type_enabled(type, pid_list, no_pid_list))
865 return;
866
867 if (!still_need_pid_events(type, pid_list, no_pid_list)) {
868 unregister_pid_events(tr);
869
870 list_for_each_entry(file, &tr->events, list) {
871 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
872 }
873
874 for_each_possible_cpu(cpu)
875 per_cpu_ptr(tr->array_buffer.data, cpu)->ignore_pid = false;
876 }
877
878 if (type & TRACE_PIDS)
879 rcu_assign_pointer(tr->filtered_pids, NULL);
880
881 if (type & TRACE_NO_PIDS)
882 rcu_assign_pointer(tr->filtered_no_pids, NULL);
883
884
885 tracepoint_synchronize_unregister();
886
887 if ((type & TRACE_PIDS) && pid_list)
888 trace_pid_list_free(pid_list);
889
890 if ((type & TRACE_NO_PIDS) && no_pid_list)
891 trace_pid_list_free(no_pid_list);
892}
893
894static void ftrace_clear_event_pids(struct trace_array *tr, int type)
895{
896 mutex_lock(&event_mutex);
897 __ftrace_clear_event_pids(tr, type);
898 mutex_unlock(&event_mutex);
899}
900
901static void __put_system(struct event_subsystem *system)
902{
903 struct event_filter *filter = system->filter;
904
905 WARN_ON_ONCE(system_refcount(system) == 0);
906 if (system_refcount_dec(system))
907 return;
908
909 list_del(&system->list);
910
911 if (filter) {
912 kfree(filter->filter_string);
913 kfree(filter);
914 }
915 kfree_const(system->name);
916 kfree(system);
917}
918
919static void __get_system(struct event_subsystem *system)
920{
921 WARN_ON_ONCE(system_refcount(system) == 0);
922 system_refcount_inc(system);
923}
924
925static void __get_system_dir(struct trace_subsystem_dir *dir)
926{
927 WARN_ON_ONCE(dir->ref_count == 0);
928 dir->ref_count++;
929 __get_system(dir->subsystem);
930}
931
932static void __put_system_dir(struct trace_subsystem_dir *dir)
933{
934 WARN_ON_ONCE(dir->ref_count == 0);
935
936 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
937
938 __put_system(dir->subsystem);
939 if (!--dir->ref_count)
940 kfree(dir);
941}
942
943static void put_system(struct trace_subsystem_dir *dir)
944{
945 mutex_lock(&event_mutex);
946 __put_system_dir(dir);
947 mutex_unlock(&event_mutex);
948}
949
950static void remove_subsystem(struct trace_subsystem_dir *dir)
951{
952 if (!dir)
953 return;
954
955 if (!--dir->nr_events) {
956 tracefs_remove(dir->entry);
957 list_del(&dir->list);
958 __put_system_dir(dir);
959 }
960}
961
962static void remove_event_file_dir(struct trace_event_file *file)
963{
964 struct dentry *dir = file->dir;
965 struct dentry *child;
966
967 if (dir) {
968 spin_lock(&dir->d_lock);
969 list_for_each_entry(child, &dir->d_subdirs, d_child) {
970 if (d_really_is_positive(child))
971 d_inode(child)->i_private = NULL;
972 }
973 spin_unlock(&dir->d_lock);
974
975 tracefs_remove(dir);
976 }
977
978 list_del(&file->list);
979 remove_subsystem(file->system);
980 free_event_filter(file->filter);
981 kmem_cache_free(file_cachep, file);
982}
983
984
985
986
987static int
988__ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
989 const char *sub, const char *event, int set)
990{
991 struct trace_event_file *file;
992 struct trace_event_call *call;
993 const char *name;
994 int ret = -EINVAL;
995 int eret = 0;
996
997 list_for_each_entry(file, &tr->events, list) {
998
999 call = file->event_call;
1000 name = trace_event_name(call);
1001
1002 if (!name || !call->class || !call->class->reg)
1003 continue;
1004
1005 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
1006 continue;
1007
1008 if (match &&
1009 strcmp(match, name) != 0 &&
1010 strcmp(match, call->class->system) != 0)
1011 continue;
1012
1013 if (sub && strcmp(sub, call->class->system) != 0)
1014 continue;
1015
1016 if (event && strcmp(event, name) != 0)
1017 continue;
1018
1019 ret = ftrace_event_enable_disable(file, set);
1020
1021
1022
1023
1024
1025
1026 if (ret && !eret)
1027 eret = ret;
1028
1029 ret = eret;
1030 }
1031
1032 return ret;
1033}
1034
1035static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
1036 const char *sub, const char *event, int set)
1037{
1038 int ret;
1039
1040 mutex_lock(&event_mutex);
1041 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
1042 mutex_unlock(&event_mutex);
1043
1044 return ret;
1045}
1046
1047int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
1048{
1049 char *event = NULL, *sub = NULL, *match;
1050 int ret;
1051
1052 if (!tr)
1053 return -ENOENT;
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066 match = strsep(&buf, ":");
1067 if (buf) {
1068 sub = match;
1069 event = buf;
1070 match = NULL;
1071
1072 if (!strlen(sub) || strcmp(sub, "*") == 0)
1073 sub = NULL;
1074 if (!strlen(event) || strcmp(event, "*") == 0)
1075 event = NULL;
1076 }
1077
1078 ret = __ftrace_set_clr_event(tr, match, sub, event, set);
1079
1080
1081 if (buf)
1082 *(buf - 1) = ':';
1083
1084 return ret;
1085}
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099int trace_set_clr_event(const char *system, const char *event, int set)
1100{
1101 struct trace_array *tr = top_trace_array();
1102
1103 if (!tr)
1104 return -ENODEV;
1105
1106 return __ftrace_set_clr_event(tr, NULL, system, event, set);
1107}
1108EXPORT_SYMBOL_GPL(trace_set_clr_event);
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123int trace_array_set_clr_event(struct trace_array *tr, const char *system,
1124 const char *event, bool enable)
1125{
1126 int set;
1127
1128 if (!tr)
1129 return -ENOENT;
1130
1131 set = (enable == true) ? 1 : 0;
1132 return __ftrace_set_clr_event(tr, NULL, system, event, set);
1133}
1134EXPORT_SYMBOL_GPL(trace_array_set_clr_event);
1135
1136
1137#define EVENT_BUF_SIZE 127
1138
1139static ssize_t
1140ftrace_event_write(struct file *file, const char __user *ubuf,
1141 size_t cnt, loff_t *ppos)
1142{
1143 struct trace_parser parser;
1144 struct seq_file *m = file->private_data;
1145 struct trace_array *tr = m->private;
1146 ssize_t read, ret;
1147
1148 if (!cnt)
1149 return 0;
1150
1151 ret = tracing_update_buffers();
1152 if (ret < 0)
1153 return ret;
1154
1155 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
1156 return -ENOMEM;
1157
1158 read = trace_get_user(&parser, ubuf, cnt, ppos);
1159
1160 if (read >= 0 && trace_parser_loaded((&parser))) {
1161 int set = 1;
1162
1163 if (*parser.buffer == '!')
1164 set = 0;
1165
1166 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);
1167 if (ret)
1168 goto out_put;
1169 }
1170
1171 ret = read;
1172
1173 out_put:
1174 trace_parser_put(&parser);
1175
1176 return ret;
1177}
1178
1179static void *
1180t_next(struct seq_file *m, void *v, loff_t *pos)
1181{
1182 struct trace_event_file *file = v;
1183 struct trace_event_call *call;
1184 struct trace_array *tr = m->private;
1185
1186 (*pos)++;
1187
1188 list_for_each_entry_continue(file, &tr->events, list) {
1189 call = file->event_call;
1190
1191
1192
1193
1194 if (call->class && call->class->reg &&
1195 !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
1196 return file;
1197 }
1198
1199 return NULL;
1200}
1201
1202static void *t_start(struct seq_file *m, loff_t *pos)
1203{
1204 struct trace_event_file *file;
1205 struct trace_array *tr = m->private;
1206 loff_t l;
1207
1208 mutex_lock(&event_mutex);
1209
1210 file = list_entry(&tr->events, struct trace_event_file, list);
1211 for (l = 0; l <= *pos; ) {
1212 file = t_next(m, file, &l);
1213 if (!file)
1214 break;
1215 }
1216 return file;
1217}
1218
1219static void *
1220s_next(struct seq_file *m, void *v, loff_t *pos)
1221{
1222 struct trace_event_file *file = v;
1223 struct trace_array *tr = m->private;
1224
1225 (*pos)++;
1226
1227 list_for_each_entry_continue(file, &tr->events, list) {
1228 if (file->flags & EVENT_FILE_FL_ENABLED)
1229 return file;
1230 }
1231
1232 return NULL;
1233}
1234
1235static void *s_start(struct seq_file *m, loff_t *pos)
1236{
1237 struct trace_event_file *file;
1238 struct trace_array *tr = m->private;
1239 loff_t l;
1240
1241 mutex_lock(&event_mutex);
1242
1243 file = list_entry(&tr->events, struct trace_event_file, list);
1244 for (l = 0; l <= *pos; ) {
1245 file = s_next(m, file, &l);
1246 if (!file)
1247 break;
1248 }
1249 return file;
1250}
1251
1252static int t_show(struct seq_file *m, void *v)
1253{
1254 struct trace_event_file *file = v;
1255 struct trace_event_call *call = file->event_call;
1256
1257 if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
1258 seq_printf(m, "%s:", call->class->system);
1259 seq_printf(m, "%s\n", trace_event_name(call));
1260
1261 return 0;
1262}
1263
1264static void t_stop(struct seq_file *m, void *p)
1265{
1266 mutex_unlock(&event_mutex);
1267}
1268
1269static void *
1270__next(struct seq_file *m, void *v, loff_t *pos, int type)
1271{
1272 struct trace_array *tr = m->private;
1273 struct trace_pid_list *pid_list;
1274
1275 if (type == TRACE_PIDS)
1276 pid_list = rcu_dereference_sched(tr->filtered_pids);
1277 else
1278 pid_list = rcu_dereference_sched(tr->filtered_no_pids);
1279
1280 return trace_pid_next(pid_list, v, pos);
1281}
1282
1283static void *
1284p_next(struct seq_file *m, void *v, loff_t *pos)
1285{
1286 return __next(m, v, pos, TRACE_PIDS);
1287}
1288
1289static void *
1290np_next(struct seq_file *m, void *v, loff_t *pos)
1291{
1292 return __next(m, v, pos, TRACE_NO_PIDS);
1293}
1294
1295static void *__start(struct seq_file *m, loff_t *pos, int type)
1296 __acquires(RCU)
1297{
1298 struct trace_pid_list *pid_list;
1299 struct trace_array *tr = m->private;
1300
1301
1302
1303
1304
1305
1306
1307 mutex_lock(&event_mutex);
1308 rcu_read_lock_sched();
1309
1310 if (type == TRACE_PIDS)
1311 pid_list = rcu_dereference_sched(tr->filtered_pids);
1312 else
1313 pid_list = rcu_dereference_sched(tr->filtered_no_pids);
1314
1315 if (!pid_list)
1316 return NULL;
1317
1318 return trace_pid_start(pid_list, pos);
1319}
1320
1321static void *p_start(struct seq_file *m, loff_t *pos)
1322 __acquires(RCU)
1323{
1324 return __start(m, pos, TRACE_PIDS);
1325}
1326
1327static void *np_start(struct seq_file *m, loff_t *pos)
1328 __acquires(RCU)
1329{
1330 return __start(m, pos, TRACE_NO_PIDS);
1331}
1332
1333static void p_stop(struct seq_file *m, void *p)
1334 __releases(RCU)
1335{
1336 rcu_read_unlock_sched();
1337 mutex_unlock(&event_mutex);
1338}
1339
1340static ssize_t
1341event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1342 loff_t *ppos)
1343{
1344 struct trace_event_file *file;
1345 unsigned long flags;
1346 char buf[4] = "0";
1347
1348 mutex_lock(&event_mutex);
1349 file = event_file_data(filp);
1350 if (likely(file))
1351 flags = file->flags;
1352 mutex_unlock(&event_mutex);
1353
1354 if (!file)
1355 return -ENODEV;
1356
1357 if (flags & EVENT_FILE_FL_ENABLED &&
1358 !(flags & EVENT_FILE_FL_SOFT_DISABLED))
1359 strcpy(buf, "1");
1360
1361 if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
1362 flags & EVENT_FILE_FL_SOFT_MODE)
1363 strcat(buf, "*");
1364
1365 strcat(buf, "\n");
1366
1367 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
1368}
1369
1370static ssize_t
1371event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1372 loff_t *ppos)
1373{
1374 struct trace_event_file *file;
1375 unsigned long val;
1376 int ret;
1377
1378 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1379 if (ret)
1380 return ret;
1381
1382 ret = tracing_update_buffers();
1383 if (ret < 0)
1384 return ret;
1385
1386 switch (val) {
1387 case 0:
1388 case 1:
1389 ret = -ENODEV;
1390 mutex_lock(&event_mutex);
1391 file = event_file_data(filp);
1392 if (likely(file))
1393 ret = ftrace_event_enable_disable(file, val);
1394 mutex_unlock(&event_mutex);
1395 break;
1396
1397 default:
1398 return -EINVAL;
1399 }
1400
1401 *ppos += cnt;
1402
1403 return ret ? ret : cnt;
1404}
1405
1406static ssize_t
1407system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1408 loff_t *ppos)
1409{
1410 const char set_to_char[4] = { '?', '0', '1', 'X' };
1411 struct trace_subsystem_dir *dir = filp->private_data;
1412 struct event_subsystem *system = dir->subsystem;
1413 struct trace_event_call *call;
1414 struct trace_event_file *file;
1415 struct trace_array *tr = dir->tr;
1416 char buf[2];
1417 int set = 0;
1418 int ret;
1419
1420 mutex_lock(&event_mutex);
1421 list_for_each_entry(file, &tr->events, list) {
1422 call = file->event_call;
1423 if ((call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) ||
1424 !trace_event_name(call) || !call->class || !call->class->reg)
1425 continue;
1426
1427 if (system && strcmp(call->class->system, system->name) != 0)
1428 continue;
1429
1430
1431
1432
1433
1434
1435 set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
1436
1437
1438
1439
1440 if (set == 3)
1441 break;
1442 }
1443 mutex_unlock(&event_mutex);
1444
1445 buf[0] = set_to_char[set];
1446 buf[1] = '\n';
1447
1448 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
1449
1450 return ret;
1451}
1452
1453static ssize_t
1454system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1455 loff_t *ppos)
1456{
1457 struct trace_subsystem_dir *dir = filp->private_data;
1458 struct event_subsystem *system = dir->subsystem;
1459 const char *name = NULL;
1460 unsigned long val;
1461 ssize_t ret;
1462
1463 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1464 if (ret)
1465 return ret;
1466
1467 ret = tracing_update_buffers();
1468 if (ret < 0)
1469 return ret;
1470
1471 if (val != 0 && val != 1)
1472 return -EINVAL;
1473
1474
1475
1476
1477
1478 if (system)
1479 name = system->name;
1480
1481 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);
1482 if (ret)
1483 goto out;
1484
1485 ret = cnt;
1486
1487out:
1488 *ppos += cnt;
1489
1490 return ret;
1491}
1492
1493enum {
1494 FORMAT_HEADER = 1,
1495 FORMAT_FIELD_SEPERATOR = 2,
1496 FORMAT_PRINTFMT = 3,
1497};
1498
1499static void *f_next(struct seq_file *m, void *v, loff_t *pos)
1500{
1501 struct trace_event_call *call = event_file_data(m->private);
1502 struct list_head *common_head = &ftrace_common_fields;
1503 struct list_head *head = trace_get_fields(call);
1504 struct list_head *node = v;
1505
1506 (*pos)++;
1507
1508 switch ((unsigned long)v) {
1509 case FORMAT_HEADER:
1510 node = common_head;
1511 break;
1512
1513 case FORMAT_FIELD_SEPERATOR:
1514 node = head;
1515 break;
1516
1517 case FORMAT_PRINTFMT:
1518
1519 return NULL;
1520 }
1521
1522 node = node->prev;
1523 if (node == common_head)
1524 return (void *)FORMAT_FIELD_SEPERATOR;
1525 else if (node == head)
1526 return (void *)FORMAT_PRINTFMT;
1527 else
1528 return node;
1529}
1530
1531static int f_show(struct seq_file *m, void *v)
1532{
1533 struct trace_event_call *call = event_file_data(m->private);
1534 struct ftrace_event_field *field;
1535 const char *array_descriptor;
1536
1537 switch ((unsigned long)v) {
1538 case FORMAT_HEADER:
1539 seq_printf(m, "name: %s\n", trace_event_name(call));
1540 seq_printf(m, "ID: %d\n", call->event.type);
1541 seq_puts(m, "format:\n");
1542 return 0;
1543
1544 case FORMAT_FIELD_SEPERATOR:
1545 seq_putc(m, '\n');
1546 return 0;
1547
1548 case FORMAT_PRINTFMT:
1549 seq_printf(m, "\nprint fmt: %s\n",
1550 call->print_fmt);
1551 return 0;
1552 }
1553
1554 field = list_entry(v, struct ftrace_event_field, link);
1555
1556
1557
1558
1559
1560
1561
1562 array_descriptor = strchr(field->type, '[');
1563
1564 if (str_has_prefix(field->type, "__data_loc"))
1565 array_descriptor = NULL;
1566
1567 if (!array_descriptor)
1568 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1569 field->type, field->name, field->offset,
1570 field->size, !!field->is_signed);
1571 else
1572 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1573 (int)(array_descriptor - field->type),
1574 field->type, field->name,
1575 array_descriptor, field->offset,
1576 field->size, !!field->is_signed);
1577
1578 return 0;
1579}
1580
1581static void *f_start(struct seq_file *m, loff_t *pos)
1582{
1583 void *p = (void *)FORMAT_HEADER;
1584 loff_t l = 0;
1585
1586
1587 mutex_lock(&event_mutex);
1588 if (!event_file_data(m->private))
1589 return ERR_PTR(-ENODEV);
1590
1591 while (l < *pos && p)
1592 p = f_next(m, p, &l);
1593
1594 return p;
1595}
1596
1597static void f_stop(struct seq_file *m, void *p)
1598{
1599 mutex_unlock(&event_mutex);
1600}
1601
1602static const struct seq_operations trace_format_seq_ops = {
1603 .start = f_start,
1604 .next = f_next,
1605 .stop = f_stop,
1606 .show = f_show,
1607};
1608
1609static int trace_format_open(struct inode *inode, struct file *file)
1610{
1611 struct seq_file *m;
1612 int ret;
1613
1614
1615
1616 ret = seq_open(file, &trace_format_seq_ops);
1617 if (ret < 0)
1618 return ret;
1619
1620 m = file->private_data;
1621 m->private = file;
1622
1623 return 0;
1624}
1625
1626static ssize_t
1627event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1628{
1629 int id = (long)event_file_data(filp);
1630 char buf[32];
1631 int len;
1632
1633 if (unlikely(!id))
1634 return -ENODEV;
1635
1636 len = sprintf(buf, "%d\n", id);
1637
1638 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
1639}
1640
1641static ssize_t
1642event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1643 loff_t *ppos)
1644{
1645 struct trace_event_file *file;
1646 struct trace_seq *s;
1647 int r = -ENODEV;
1648
1649 if (*ppos)
1650 return 0;
1651
1652 s = kmalloc(sizeof(*s), GFP_KERNEL);
1653
1654 if (!s)
1655 return -ENOMEM;
1656
1657 trace_seq_init(s);
1658
1659 mutex_lock(&event_mutex);
1660 file = event_file_data(filp);
1661 if (file)
1662 print_event_filter(file, s);
1663 mutex_unlock(&event_mutex);
1664
1665 if (file)
1666 r = simple_read_from_buffer(ubuf, cnt, ppos,
1667 s->buffer, trace_seq_used(s));
1668
1669 kfree(s);
1670
1671 return r;
1672}
1673
1674static ssize_t
1675event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1676 loff_t *ppos)
1677{
1678 struct trace_event_file *file;
1679 char *buf;
1680 int err = -ENODEV;
1681
1682 if (cnt >= PAGE_SIZE)
1683 return -EINVAL;
1684
1685 buf = memdup_user_nul(ubuf, cnt);
1686 if (IS_ERR(buf))
1687 return PTR_ERR(buf);
1688
1689 mutex_lock(&event_mutex);
1690 file = event_file_data(filp);
1691 if (file)
1692 err = apply_event_filter(file, buf);
1693 mutex_unlock(&event_mutex);
1694
1695 kfree(buf);
1696 if (err < 0)
1697 return err;
1698
1699 *ppos += cnt;
1700
1701 return cnt;
1702}
1703
1704static LIST_HEAD(event_subsystems);
1705
1706static int subsystem_open(struct inode *inode, struct file *filp)
1707{
1708 struct event_subsystem *system = NULL;
1709 struct trace_subsystem_dir *dir = NULL;
1710 struct trace_array *tr;
1711 int ret;
1712
1713 if (tracing_is_disabled())
1714 return -ENODEV;
1715
1716
1717 mutex_lock(&event_mutex);
1718 mutex_lock(&trace_types_lock);
1719 list_for_each_entry(tr, &ftrace_trace_arrays, list) {
1720 list_for_each_entry(dir, &tr->systems, list) {
1721 if (dir == inode->i_private) {
1722
1723 if (dir->nr_events) {
1724 __get_system_dir(dir);
1725 system = dir->subsystem;
1726 }
1727 goto exit_loop;
1728 }
1729 }
1730 }
1731 exit_loop:
1732 mutex_unlock(&trace_types_lock);
1733 mutex_unlock(&event_mutex);
1734
1735 if (!system)
1736 return -ENODEV;
1737
1738
1739 WARN_ON(!dir);
1740
1741
1742 if (trace_array_get(tr) < 0) {
1743 put_system(dir);
1744 return -ENODEV;
1745 }
1746
1747 ret = tracing_open_generic(inode, filp);
1748 if (ret < 0) {
1749 trace_array_put(tr);
1750 put_system(dir);
1751 }
1752
1753 return ret;
1754}
1755
1756static int system_tr_open(struct inode *inode, struct file *filp)
1757{
1758 struct trace_subsystem_dir *dir;
1759 struct trace_array *tr = inode->i_private;
1760 int ret;
1761
1762
1763 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
1764 if (!dir)
1765 return -ENOMEM;
1766
1767 ret = tracing_open_generic_tr(inode, filp);
1768 if (ret < 0) {
1769 kfree(dir);
1770 return ret;
1771 }
1772 dir->tr = tr;
1773 filp->private_data = dir;
1774
1775 return 0;
1776}
1777
1778static int subsystem_release(struct inode *inode, struct file *file)
1779{
1780 struct trace_subsystem_dir *dir = file->private_data;
1781
1782 trace_array_put(dir->tr);
1783
1784
1785
1786
1787
1788
1789 if (dir->subsystem)
1790 put_system(dir);
1791 else
1792 kfree(dir);
1793
1794 return 0;
1795}
1796
1797static ssize_t
1798subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1799 loff_t *ppos)
1800{
1801 struct trace_subsystem_dir *dir = filp->private_data;
1802 struct event_subsystem *system = dir->subsystem;
1803 struct trace_seq *s;
1804 int r;
1805
1806 if (*ppos)
1807 return 0;
1808
1809 s = kmalloc(sizeof(*s), GFP_KERNEL);
1810 if (!s)
1811 return -ENOMEM;
1812
1813 trace_seq_init(s);
1814
1815 print_subsystem_event_filter(system, s);
1816 r = simple_read_from_buffer(ubuf, cnt, ppos,
1817 s->buffer, trace_seq_used(s));
1818
1819 kfree(s);
1820
1821 return r;
1822}
1823
1824static ssize_t
1825subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1826 loff_t *ppos)
1827{
1828 struct trace_subsystem_dir *dir = filp->private_data;
1829 char *buf;
1830 int err;
1831
1832 if (cnt >= PAGE_SIZE)
1833 return -EINVAL;
1834
1835 buf = memdup_user_nul(ubuf, cnt);
1836 if (IS_ERR(buf))
1837 return PTR_ERR(buf);
1838
1839 err = apply_subsystem_event_filter(dir, buf);
1840 kfree(buf);
1841 if (err < 0)
1842 return err;
1843
1844 *ppos += cnt;
1845
1846 return cnt;
1847}
1848
1849static ssize_t
1850show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1851{
1852 int (*func)(struct trace_seq *s) = filp->private_data;
1853 struct trace_seq *s;
1854 int r;
1855
1856 if (*ppos)
1857 return 0;
1858
1859 s = kmalloc(sizeof(*s), GFP_KERNEL);
1860 if (!s)
1861 return -ENOMEM;
1862
1863 trace_seq_init(s);
1864
1865 func(s);
1866 r = simple_read_from_buffer(ubuf, cnt, ppos,
1867 s->buffer, trace_seq_used(s));
1868
1869 kfree(s);
1870
1871 return r;
1872}
1873
1874static void ignore_task_cpu(void *data)
1875{
1876 struct trace_array *tr = data;
1877 struct trace_pid_list *pid_list;
1878 struct trace_pid_list *no_pid_list;
1879
1880
1881
1882
1883
1884 pid_list = rcu_dereference_protected(tr->filtered_pids,
1885 mutex_is_locked(&event_mutex));
1886 no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
1887 mutex_is_locked(&event_mutex));
1888
1889 this_cpu_write(tr->array_buffer.data->ignore_pid,
1890 trace_ignore_this_task(pid_list, no_pid_list, current));
1891}
1892
1893static void register_pid_events(struct trace_array *tr)
1894{
1895
1896
1897
1898
1899
1900
1901 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre,
1902 tr, INT_MAX);
1903 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post,
1904 tr, 0);
1905
1906 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre,
1907 tr, INT_MAX);
1908 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post,
1909 tr, 0);
1910
1911 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre,
1912 tr, INT_MAX);
1913 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post,
1914 tr, 0);
1915
1916 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre,
1917 tr, INT_MAX);
1918 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post,
1919 tr, 0);
1920}
1921
1922static ssize_t
1923event_pid_write(struct file *filp, const char __user *ubuf,
1924 size_t cnt, loff_t *ppos, int type)
1925{
1926 struct seq_file *m = filp->private_data;
1927 struct trace_array *tr = m->private;
1928 struct trace_pid_list *filtered_pids = NULL;
1929 struct trace_pid_list *other_pids = NULL;
1930 struct trace_pid_list *pid_list;
1931 struct trace_event_file *file;
1932 ssize_t ret;
1933
1934 if (!cnt)
1935 return 0;
1936
1937 ret = tracing_update_buffers();
1938 if (ret < 0)
1939 return ret;
1940
1941 mutex_lock(&event_mutex);
1942
1943 if (type == TRACE_PIDS) {
1944 filtered_pids = rcu_dereference_protected(tr->filtered_pids,
1945 lockdep_is_held(&event_mutex));
1946 other_pids = rcu_dereference_protected(tr->filtered_no_pids,
1947 lockdep_is_held(&event_mutex));
1948 } else {
1949 filtered_pids = rcu_dereference_protected(tr->filtered_no_pids,
1950 lockdep_is_held(&event_mutex));
1951 other_pids = rcu_dereference_protected(tr->filtered_pids,
1952 lockdep_is_held(&event_mutex));
1953 }
1954
1955 ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
1956 if (ret < 0)
1957 goto out;
1958
1959 if (type == TRACE_PIDS)
1960 rcu_assign_pointer(tr->filtered_pids, pid_list);
1961 else
1962 rcu_assign_pointer(tr->filtered_no_pids, pid_list);
1963
1964 list_for_each_entry(file, &tr->events, list) {
1965 set_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
1966 }
1967
1968 if (filtered_pids) {
1969 tracepoint_synchronize_unregister();
1970 trace_pid_list_free(filtered_pids);
1971 } else if (pid_list && !other_pids) {
1972 register_pid_events(tr);
1973 }
1974
1975
1976
1977
1978
1979
1980 on_each_cpu(ignore_task_cpu, tr, 1);
1981
1982 out:
1983 mutex_unlock(&event_mutex);
1984
1985 if (ret > 0)
1986 *ppos += ret;
1987
1988 return ret;
1989}
1990
1991static ssize_t
1992ftrace_event_pid_write(struct file *filp, const char __user *ubuf,
1993 size_t cnt, loff_t *ppos)
1994{
1995 return event_pid_write(filp, ubuf, cnt, ppos, TRACE_PIDS);
1996}
1997
1998static ssize_t
1999ftrace_event_npid_write(struct file *filp, const char __user *ubuf,
2000 size_t cnt, loff_t *ppos)
2001{
2002 return event_pid_write(filp, ubuf, cnt, ppos, TRACE_NO_PIDS);
2003}
2004
2005static int ftrace_event_avail_open(struct inode *inode, struct file *file);
2006static int ftrace_event_set_open(struct inode *inode, struct file *file);
2007static int ftrace_event_set_pid_open(struct inode *inode, struct file *file);
2008static int ftrace_event_set_npid_open(struct inode *inode, struct file *file);
2009static int ftrace_event_release(struct inode *inode, struct file *file);
2010
2011static const struct seq_operations show_event_seq_ops = {
2012 .start = t_start,
2013 .next = t_next,
2014 .show = t_show,
2015 .stop = t_stop,
2016};
2017
2018static const struct seq_operations show_set_event_seq_ops = {
2019 .start = s_start,
2020 .next = s_next,
2021 .show = t_show,
2022 .stop = t_stop,
2023};
2024
2025static const struct seq_operations show_set_pid_seq_ops = {
2026 .start = p_start,
2027 .next = p_next,
2028 .show = trace_pid_show,
2029 .stop = p_stop,
2030};
2031
2032static const struct seq_operations show_set_no_pid_seq_ops = {
2033 .start = np_start,
2034 .next = np_next,
2035 .show = trace_pid_show,
2036 .stop = p_stop,
2037};
2038
2039static const struct file_operations ftrace_avail_fops = {
2040 .open = ftrace_event_avail_open,
2041 .read = seq_read,
2042 .llseek = seq_lseek,
2043 .release = seq_release,
2044};
2045
2046static const struct file_operations ftrace_set_event_fops = {
2047 .open = ftrace_event_set_open,
2048 .read = seq_read,
2049 .write = ftrace_event_write,
2050 .llseek = seq_lseek,
2051 .release = ftrace_event_release,
2052};
2053
2054static const struct file_operations ftrace_set_event_pid_fops = {
2055 .open = ftrace_event_set_pid_open,
2056 .read = seq_read,
2057 .write = ftrace_event_pid_write,
2058 .llseek = seq_lseek,
2059 .release = ftrace_event_release,
2060};
2061
2062static const struct file_operations ftrace_set_event_notrace_pid_fops = {
2063 .open = ftrace_event_set_npid_open,
2064 .read = seq_read,
2065 .write = ftrace_event_npid_write,
2066 .llseek = seq_lseek,
2067 .release = ftrace_event_release,
2068};
2069
2070static const struct file_operations ftrace_enable_fops = {
2071 .open = tracing_open_generic,
2072 .read = event_enable_read,
2073 .write = event_enable_write,
2074 .llseek = default_llseek,
2075};
2076
2077static const struct file_operations ftrace_event_format_fops = {
2078 .open = trace_format_open,
2079 .read = seq_read,
2080 .llseek = seq_lseek,
2081 .release = seq_release,
2082};
2083
2084static const struct file_operations ftrace_event_id_fops = {
2085 .read = event_id_read,
2086 .llseek = default_llseek,
2087};
2088
2089static const struct file_operations ftrace_event_filter_fops = {
2090 .open = tracing_open_generic,
2091 .read = event_filter_read,
2092 .write = event_filter_write,
2093 .llseek = default_llseek,
2094};
2095
2096static const struct file_operations ftrace_subsystem_filter_fops = {
2097 .open = subsystem_open,
2098 .read = subsystem_filter_read,
2099 .write = subsystem_filter_write,
2100 .llseek = default_llseek,
2101 .release = subsystem_release,
2102};
2103
2104static const struct file_operations ftrace_system_enable_fops = {
2105 .open = subsystem_open,
2106 .read = system_enable_read,
2107 .write = system_enable_write,
2108 .llseek = default_llseek,
2109 .release = subsystem_release,
2110};
2111
2112static const struct file_operations ftrace_tr_enable_fops = {
2113 .open = system_tr_open,
2114 .read = system_enable_read,
2115 .write = system_enable_write,
2116 .llseek = default_llseek,
2117 .release = subsystem_release,
2118};
2119
2120static const struct file_operations ftrace_show_header_fops = {
2121 .open = tracing_open_generic,
2122 .read = show_header,
2123 .llseek = default_llseek,
2124};
2125
2126static int
2127ftrace_event_open(struct inode *inode, struct file *file,
2128 const struct seq_operations *seq_ops)
2129{
2130 struct seq_file *m;
2131 int ret;
2132
2133 ret = security_locked_down(LOCKDOWN_TRACEFS);
2134 if (ret)
2135 return ret;
2136
2137 ret = seq_open(file, seq_ops);
2138 if (ret < 0)
2139 return ret;
2140 m = file->private_data;
2141
2142 m->private = inode->i_private;
2143
2144 return ret;
2145}
2146
2147static int ftrace_event_release(struct inode *inode, struct file *file)
2148{
2149 struct trace_array *tr = inode->i_private;
2150
2151 trace_array_put(tr);
2152
2153 return seq_release(inode, file);
2154}
2155
2156static int
2157ftrace_event_avail_open(struct inode *inode, struct file *file)
2158{
2159 const struct seq_operations *seq_ops = &show_event_seq_ops;
2160
2161
2162 return ftrace_event_open(inode, file, seq_ops);
2163}
2164
2165static int
2166ftrace_event_set_open(struct inode *inode, struct file *file)
2167{
2168 const struct seq_operations *seq_ops = &show_set_event_seq_ops;
2169 struct trace_array *tr = inode->i_private;
2170 int ret;
2171
2172 ret = tracing_check_open_get_tr(tr);
2173 if (ret)
2174 return ret;
2175
2176 if ((file->f_mode & FMODE_WRITE) &&
2177 (file->f_flags & O_TRUNC))
2178 ftrace_clear_events(tr);
2179
2180 ret = ftrace_event_open(inode, file, seq_ops);
2181 if (ret < 0)
2182 trace_array_put(tr);
2183 return ret;
2184}
2185
2186static int
2187ftrace_event_set_pid_open(struct inode *inode, struct file *file)
2188{
2189 const struct seq_operations *seq_ops = &show_set_pid_seq_ops;
2190 struct trace_array *tr = inode->i_private;
2191 int ret;
2192
2193 ret = tracing_check_open_get_tr(tr);
2194 if (ret)
2195 return ret;
2196
2197 if ((file->f_mode & FMODE_WRITE) &&
2198 (file->f_flags & O_TRUNC))
2199 ftrace_clear_event_pids(tr, TRACE_PIDS);
2200
2201 ret = ftrace_event_open(inode, file, seq_ops);
2202 if (ret < 0)
2203 trace_array_put(tr);
2204 return ret;
2205}
2206
2207static int
2208ftrace_event_set_npid_open(struct inode *inode, struct file *file)
2209{
2210 const struct seq_operations *seq_ops = &show_set_no_pid_seq_ops;
2211 struct trace_array *tr = inode->i_private;
2212 int ret;
2213
2214 ret = tracing_check_open_get_tr(tr);
2215 if (ret)
2216 return ret;
2217
2218 if ((file->f_mode & FMODE_WRITE) &&
2219 (file->f_flags & O_TRUNC))
2220 ftrace_clear_event_pids(tr, TRACE_NO_PIDS);
2221
2222 ret = ftrace_event_open(inode, file, seq_ops);
2223 if (ret < 0)
2224 trace_array_put(tr);
2225 return ret;
2226}
2227
2228static struct event_subsystem *
2229create_new_subsystem(const char *name)
2230{
2231 struct event_subsystem *system;
2232
2233
2234 system = kmalloc(sizeof(*system), GFP_KERNEL);
2235 if (!system)
2236 return NULL;
2237
2238 system->ref_count = 1;
2239
2240
2241 system->name = kstrdup_const(name, GFP_KERNEL);
2242 if (!system->name)
2243 goto out_free;
2244
2245 system->filter = NULL;
2246
2247 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
2248 if (!system->filter)
2249 goto out_free;
2250
2251 list_add(&system->list, &event_subsystems);
2252
2253 return system;
2254
2255 out_free:
2256 kfree_const(system->name);
2257 kfree(system);
2258 return NULL;
2259}
2260
2261static struct dentry *
2262event_subsystem_dir(struct trace_array *tr, const char *name,
2263 struct trace_event_file *file, struct dentry *parent)
2264{
2265 struct trace_subsystem_dir *dir;
2266 struct event_subsystem *system;
2267 struct dentry *entry;
2268
2269
2270 list_for_each_entry(dir, &tr->systems, list) {
2271 system = dir->subsystem;
2272 if (strcmp(system->name, name) == 0) {
2273 dir->nr_events++;
2274 file->system = dir;
2275 return dir->entry;
2276 }
2277 }
2278
2279
2280 list_for_each_entry(system, &event_subsystems, list) {
2281 if (strcmp(system->name, name) == 0)
2282 break;
2283 }
2284
2285 if (&system->list == &event_subsystems)
2286 system = NULL;
2287
2288 dir = kmalloc(sizeof(*dir), GFP_KERNEL);
2289 if (!dir)
2290 goto out_fail;
2291
2292 if (!system) {
2293 system = create_new_subsystem(name);
2294 if (!system)
2295 goto out_free;
2296 } else
2297 __get_system(system);
2298
2299 dir->entry = tracefs_create_dir(name, parent);
2300 if (!dir->entry) {
2301 pr_warn("Failed to create system directory %s\n", name);
2302 __put_system(system);
2303 goto out_free;
2304 }
2305
2306 dir->tr = tr;
2307 dir->ref_count = 1;
2308 dir->nr_events = 1;
2309 dir->subsystem = system;
2310 file->system = dir;
2311
2312
2313 if (strcmp(name, "ftrace") != 0) {
2314
2315 entry = tracefs_create_file("filter", TRACE_MODE_WRITE,
2316 dir->entry, dir,
2317 &ftrace_subsystem_filter_fops);
2318 if (!entry) {
2319 kfree(system->filter);
2320 system->filter = NULL;
2321 pr_warn("Could not create tracefs '%s/filter' entry\n", name);
2322 }
2323
2324 trace_create_file("enable", TRACE_MODE_WRITE, dir->entry, dir,
2325 &ftrace_system_enable_fops);
2326 }
2327
2328 list_add(&dir->list, &tr->systems);
2329
2330 return dir->entry;
2331
2332 out_free:
2333 kfree(dir);
2334 out_fail:
2335
2336 if (!dir || !system)
2337 pr_warn("No memory to create event subsystem %s\n", name);
2338 return NULL;
2339}
2340
2341static int
2342event_define_fields(struct trace_event_call *call)
2343{
2344 struct list_head *head;
2345 int ret = 0;
2346
2347
2348
2349
2350
2351 head = trace_get_fields(call);
2352 if (list_empty(head)) {
2353 struct trace_event_fields *field = call->class->fields_array;
2354 unsigned int offset = sizeof(struct trace_entry);
2355
2356 for (; field->type; field++) {
2357 if (field->type == TRACE_FUNCTION_TYPE) {
2358 field->define_fields(call);
2359 break;
2360 }
2361
2362 offset = ALIGN(offset, field->align);
2363 ret = trace_define_field(call, field->type, field->name,
2364 offset, field->size,
2365 field->is_signed, field->filter_type);
2366 if (WARN_ON_ONCE(ret)) {
2367 pr_err("error code is %d\n", ret);
2368 break;
2369 }
2370
2371 offset += field->size;
2372 }
2373 }
2374
2375 return ret;
2376}
2377
2378static int
2379event_create_dir(struct dentry *parent, struct trace_event_file *file)
2380{
2381 struct trace_event_call *call = file->event_call;
2382 struct trace_array *tr = file->tr;
2383 struct dentry *d_events;
2384 const char *name;
2385 int ret;
2386
2387
2388
2389
2390
2391 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
2392 d_events = event_subsystem_dir(tr, call->class->system, file, parent);
2393 if (!d_events)
2394 return -ENOMEM;
2395 } else
2396 d_events = parent;
2397
2398 name = trace_event_name(call);
2399 file->dir = tracefs_create_dir(name, d_events);
2400 if (!file->dir) {
2401 pr_warn("Could not create tracefs '%s' directory\n", name);
2402 return -1;
2403 }
2404
2405 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
2406 trace_create_file("enable", TRACE_MODE_WRITE, file->dir, file,
2407 &ftrace_enable_fops);
2408
2409#ifdef CONFIG_PERF_EVENTS
2410 if (call->event.type && call->class->reg)
2411 trace_create_file("id", TRACE_MODE_READ, file->dir,
2412 (void *)(long)call->event.type,
2413 &ftrace_event_id_fops);
2414#endif
2415
2416 ret = event_define_fields(call);
2417 if (ret < 0) {
2418 pr_warn("Could not initialize trace point events/%s\n", name);
2419 return ret;
2420 }
2421
2422
2423
2424
2425
2426 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
2427 trace_create_file("filter", TRACE_MODE_WRITE, file->dir,
2428 file, &ftrace_event_filter_fops);
2429
2430 trace_create_file("trigger", TRACE_MODE_WRITE, file->dir,
2431 file, &event_trigger_fops);
2432 }
2433
2434#ifdef CONFIG_HIST_TRIGGERS
2435 trace_create_file("hist", TRACE_MODE_READ, file->dir, file,
2436 &event_hist_fops);
2437#endif
2438#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2439 trace_create_file("hist_debug", TRACE_MODE_READ, file->dir, file,
2440 &event_hist_debug_fops);
2441#endif
2442 trace_create_file("format", TRACE_MODE_READ, file->dir, call,
2443 &ftrace_event_format_fops);
2444
2445#ifdef CONFIG_TRACE_EVENT_INJECT
2446 if (call->event.type && call->class->reg)
2447 trace_create_file("inject", 0200, file->dir, file,
2448 &event_inject_fops);
2449#endif
2450
2451 return 0;
2452}
2453
2454static void remove_event_from_tracers(struct trace_event_call *call)
2455{
2456 struct trace_event_file *file;
2457 struct trace_array *tr;
2458
2459 do_for_each_event_file_safe(tr, file) {
2460 if (file->event_call != call)
2461 continue;
2462
2463 remove_event_file_dir(file);
2464
2465
2466
2467
2468
2469
2470 break;
2471 } while_for_each_event_file();
2472}
2473
2474static void event_remove(struct trace_event_call *call)
2475{
2476 struct trace_array *tr;
2477 struct trace_event_file *file;
2478
2479 do_for_each_event_file(tr, file) {
2480 if (file->event_call != call)
2481 continue;
2482
2483 if (file->flags & EVENT_FILE_FL_WAS_ENABLED)
2484 tr->clear_trace = true;
2485
2486 ftrace_event_enable_disable(file, 0);
2487
2488
2489
2490
2491
2492
2493 break;
2494 } while_for_each_event_file();
2495
2496 if (call->event.funcs)
2497 __unregister_trace_event(&call->event);
2498 remove_event_from_tracers(call);
2499 list_del(&call->list);
2500}
2501
2502static int event_init(struct trace_event_call *call)
2503{
2504 int ret = 0;
2505 const char *name;
2506
2507 name = trace_event_name(call);
2508 if (WARN_ON(!name))
2509 return -EINVAL;
2510
2511 if (call->class->raw_init) {
2512 ret = call->class->raw_init(call);
2513 if (ret < 0 && ret != -ENOSYS)
2514 pr_warn("Could not initialize trace events/%s\n", name);
2515 }
2516
2517 return ret;
2518}
2519
2520static int
2521__register_event(struct trace_event_call *call, struct module *mod)
2522{
2523 int ret;
2524
2525 ret = event_init(call);
2526 if (ret < 0)
2527 return ret;
2528
2529 list_add(&call->list, &ftrace_events);
2530 if (call->flags & TRACE_EVENT_FL_DYNAMIC)
2531 atomic_set(&call->refcnt, 0);
2532 else
2533 call->module = mod;
2534
2535 return 0;
2536}
2537
2538static char *eval_replace(char *ptr, struct trace_eval_map *map, int len)
2539{
2540 int rlen;
2541 int elen;
2542
2543
2544 elen = snprintf(ptr, 0, "%ld", map->eval_value);
2545
2546 if (len < elen)
2547 return NULL;
2548
2549 snprintf(ptr, elen + 1, "%ld", map->eval_value);
2550
2551
2552 rlen = strlen(ptr + len);
2553 memmove(ptr + elen, ptr + len, rlen);
2554
2555 ptr[elen + rlen] = 0;
2556
2557 return ptr + elen;
2558}
2559
2560static void update_event_printk(struct trace_event_call *call,
2561 struct trace_eval_map *map)
2562{
2563 char *ptr;
2564 int quote = 0;
2565 int len = strlen(map->eval_string);
2566
2567 for (ptr = call->print_fmt; *ptr; ptr++) {
2568 if (*ptr == '\\') {
2569 ptr++;
2570
2571 if (!*ptr)
2572 break;
2573 continue;
2574 }
2575 if (*ptr == '"') {
2576 quote ^= 1;
2577 continue;
2578 }
2579 if (quote)
2580 continue;
2581 if (isdigit(*ptr)) {
2582
2583 do {
2584 ptr++;
2585
2586 } while (isalnum(*ptr));
2587 if (!*ptr)
2588 break;
2589
2590
2591
2592
2593 continue;
2594 }
2595 if (isalpha(*ptr) || *ptr == '_') {
2596 if (strncmp(map->eval_string, ptr, len) == 0 &&
2597 !isalnum(ptr[len]) && ptr[len] != '_') {
2598 ptr = eval_replace(ptr, map, len);
2599
2600 if (WARN_ON_ONCE(!ptr))
2601 return;
2602
2603
2604
2605
2606
2607
2608
2609 continue;
2610 }
2611 skip_more:
2612 do {
2613 ptr++;
2614 } while (isalnum(*ptr) || *ptr == '_');
2615 if (!*ptr)
2616 break;
2617
2618
2619
2620
2621 if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
2622 ptr += *ptr == '.' ? 1 : 2;
2623 if (!*ptr)
2624 break;
2625 goto skip_more;
2626 }
2627
2628
2629
2630
2631 continue;
2632 }
2633 }
2634}
2635
2636void trace_event_eval_update(struct trace_eval_map **map, int len)
2637{
2638 struct trace_event_call *call, *p;
2639 const char *last_system = NULL;
2640 bool first = false;
2641 int last_i;
2642 int i;
2643
2644 down_write(&trace_event_sem);
2645 list_for_each_entry_safe(call, p, &ftrace_events, list) {
2646
2647 if (!last_system || call->class->system != last_system) {
2648 first = true;
2649 last_i = 0;
2650 last_system = call->class->system;
2651 }
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663 for (i = last_i; i < len; i++) {
2664 if (call->class->system == map[i]->system) {
2665
2666 if (first) {
2667 last_i = i;
2668 first = false;
2669 }
2670 update_event_printk(call, map[i]);
2671 }
2672 }
2673 }
2674 up_write(&trace_event_sem);
2675}
2676
2677static struct trace_event_file *
2678trace_create_new_event(struct trace_event_call *call,
2679 struct trace_array *tr)
2680{
2681 struct trace_pid_list *no_pid_list;
2682 struct trace_pid_list *pid_list;
2683 struct trace_event_file *file;
2684 unsigned int first;
2685
2686 file = kmem_cache_alloc(file_cachep, GFP_TRACE);
2687 if (!file)
2688 return NULL;
2689
2690 pid_list = rcu_dereference_protected(tr->filtered_pids,
2691 lockdep_is_held(&event_mutex));
2692 no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
2693 lockdep_is_held(&event_mutex));
2694
2695 if (!trace_pid_list_first(pid_list, &first) ||
2696 !trace_pid_list_first(no_pid_list, &first))
2697 file->flags |= EVENT_FILE_FL_PID_FILTER;
2698
2699 file->event_call = call;
2700 file->tr = tr;
2701 atomic_set(&file->sm_ref, 0);
2702 atomic_set(&file->tm_ref, 0);
2703 INIT_LIST_HEAD(&file->triggers);
2704 list_add(&file->list, &tr->events);
2705
2706 return file;
2707}
2708
2709
2710static int
2711__trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)
2712{
2713 struct trace_event_file *file;
2714
2715 file = trace_create_new_event(call, tr);
2716 if (!file)
2717 return -ENOMEM;
2718
2719 if (eventdir_initialized)
2720 return event_create_dir(tr->event_dir, file);
2721 else
2722 return event_define_fields(call);
2723}
2724
2725
2726
2727
2728
2729
2730static int
2731__trace_early_add_new_event(struct trace_event_call *call,
2732 struct trace_array *tr)
2733{
2734 struct trace_event_file *file;
2735
2736 file = trace_create_new_event(call, tr);
2737 if (!file)
2738 return -ENOMEM;
2739
2740 return event_define_fields(call);
2741}
2742
2743struct ftrace_module_file_ops;
2744static void __add_event_to_tracers(struct trace_event_call *call);
2745
2746
2747int trace_add_event_call(struct trace_event_call *call)
2748{
2749 int ret;
2750 lockdep_assert_held(&event_mutex);
2751
2752 mutex_lock(&trace_types_lock);
2753
2754 ret = __register_event(call, NULL);
2755 if (ret >= 0)
2756 __add_event_to_tracers(call);
2757
2758 mutex_unlock(&trace_types_lock);
2759 return ret;
2760}
2761
2762
2763
2764
2765
2766static void __trace_remove_event_call(struct trace_event_call *call)
2767{
2768 event_remove(call);
2769 trace_destroy_fields(call);
2770 free_event_filter(call->filter);
2771 call->filter = NULL;
2772}
2773
2774static int probe_remove_event_call(struct trace_event_call *call)
2775{
2776 struct trace_array *tr;
2777 struct trace_event_file *file;
2778
2779#ifdef CONFIG_PERF_EVENTS
2780 if (call->perf_refcount)
2781 return -EBUSY;
2782#endif
2783 do_for_each_event_file(tr, file) {
2784 if (file->event_call != call)
2785 continue;
2786
2787
2788
2789
2790
2791 if (file->flags & EVENT_FILE_FL_ENABLED)
2792 return -EBUSY;
2793
2794
2795
2796
2797
2798
2799 break;
2800 } while_for_each_event_file();
2801
2802 __trace_remove_event_call(call);
2803
2804 return 0;
2805}
2806
2807
2808int trace_remove_event_call(struct trace_event_call *call)
2809{
2810 int ret;
2811
2812 lockdep_assert_held(&event_mutex);
2813
2814 mutex_lock(&trace_types_lock);
2815 down_write(&trace_event_sem);
2816 ret = probe_remove_event_call(call);
2817 up_write(&trace_event_sem);
2818 mutex_unlock(&trace_types_lock);
2819
2820 return ret;
2821}
2822
2823#define for_each_event(event, start, end) \
2824 for (event = start; \
2825 (unsigned long)event < (unsigned long)end; \
2826 event++)
2827
2828#ifdef CONFIG_MODULES
2829
2830static void trace_module_add_events(struct module *mod)
2831{
2832 struct trace_event_call **call, **start, **end;
2833
2834 if (!mod->num_trace_events)
2835 return;
2836
2837
2838 if (trace_module_has_bad_taint(mod)) {
2839 pr_err("%s: module has bad taint, not creating trace events\n",
2840 mod->name);
2841 return;
2842 }
2843
2844 start = mod->trace_events;
2845 end = mod->trace_events + mod->num_trace_events;
2846
2847 for_each_event(call, start, end) {
2848 __register_event(*call, mod);
2849 __add_event_to_tracers(*call);
2850 }
2851}
2852
2853static void trace_module_remove_events(struct module *mod)
2854{
2855 struct trace_event_call *call, *p;
2856
2857 down_write(&trace_event_sem);
2858 list_for_each_entry_safe(call, p, &ftrace_events, list) {
2859 if ((call->flags & TRACE_EVENT_FL_DYNAMIC) || !call->module)
2860 continue;
2861 if (call->module == mod)
2862 __trace_remove_event_call(call);
2863 }
2864 up_write(&trace_event_sem);
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874 tracing_reset_all_online_cpus();
2875}
2876
2877static int trace_module_notify(struct notifier_block *self,
2878 unsigned long val, void *data)
2879{
2880 struct module *mod = data;
2881
2882 mutex_lock(&event_mutex);
2883 mutex_lock(&trace_types_lock);
2884 switch (val) {
2885 case MODULE_STATE_COMING:
2886 trace_module_add_events(mod);
2887 break;
2888 case MODULE_STATE_GOING:
2889 trace_module_remove_events(mod);
2890 break;
2891 }
2892 mutex_unlock(&trace_types_lock);
2893 mutex_unlock(&event_mutex);
2894
2895 return NOTIFY_OK;
2896}
2897
2898static struct notifier_block trace_module_nb = {
2899 .notifier_call = trace_module_notify,
2900 .priority = 1,
2901};
2902#endif
2903
2904
2905static void
2906__trace_add_event_dirs(struct trace_array *tr)
2907{
2908 struct trace_event_call *call;
2909 int ret;
2910
2911 list_for_each_entry(call, &ftrace_events, list) {
2912 ret = __trace_add_new_event(call, tr);
2913 if (ret < 0)
2914 pr_warn("Could not create directory for event %s\n",
2915 trace_event_name(call));
2916 }
2917}
2918
2919
2920struct trace_event_file *
2921__find_event_file(struct trace_array *tr, const char *system, const char *event)
2922{
2923 struct trace_event_file *file;
2924 struct trace_event_call *call;
2925 const char *name;
2926
2927 list_for_each_entry(file, &tr->events, list) {
2928
2929 call = file->event_call;
2930 name = trace_event_name(call);
2931
2932 if (!name || !call->class)
2933 continue;
2934
2935 if (strcmp(event, name) == 0 &&
2936 strcmp(system, call->class->system) == 0)
2937 return file;
2938 }
2939 return NULL;
2940}
2941
2942
2943struct trace_event_file *
2944find_event_file(struct trace_array *tr, const char *system, const char *event)
2945{
2946 struct trace_event_file *file;
2947
2948 file = __find_event_file(tr, system, event);
2949 if (!file || !file->event_call->class->reg ||
2950 file->event_call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
2951 return NULL;
2952
2953 return file;
2954}
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976struct trace_event_file *trace_get_event_file(const char *instance,
2977 const char *system,
2978 const char *event)
2979{
2980 struct trace_array *tr = top_trace_array();
2981 struct trace_event_file *file = NULL;
2982 int ret = -EINVAL;
2983
2984 if (instance) {
2985 tr = trace_array_find_get(instance);
2986 if (!tr)
2987 return ERR_PTR(-ENOENT);
2988 } else {
2989 ret = trace_array_get(tr);
2990 if (ret)
2991 return ERR_PTR(ret);
2992 }
2993
2994 mutex_lock(&event_mutex);
2995
2996 file = find_event_file(tr, system, event);
2997 if (!file) {
2998 trace_array_put(tr);
2999 ret = -EINVAL;
3000 goto out;
3001 }
3002
3003
3004 ret = trace_event_try_get_ref(file->event_call);
3005 if (!ret) {
3006 trace_array_put(tr);
3007 ret = -EBUSY;
3008 goto out;
3009 }
3010
3011 ret = 0;
3012 out:
3013 mutex_unlock(&event_mutex);
3014
3015 if (ret)
3016 file = ERR_PTR(ret);
3017
3018 return file;
3019}
3020EXPORT_SYMBOL_GPL(trace_get_event_file);
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031void trace_put_event_file(struct trace_event_file *file)
3032{
3033 mutex_lock(&event_mutex);
3034 trace_event_put_ref(file->event_call);
3035 mutex_unlock(&event_mutex);
3036
3037 trace_array_put(file->tr);
3038}
3039EXPORT_SYMBOL_GPL(trace_put_event_file);
3040
3041#ifdef CONFIG_DYNAMIC_FTRACE
3042
3043
3044#define ENABLE_EVENT_STR "enable_event"
3045#define DISABLE_EVENT_STR "disable_event"
3046
3047struct event_probe_data {
3048 struct trace_event_file *file;
3049 unsigned long count;
3050 int ref;
3051 bool enable;
3052};
3053
3054static void update_event_probe(struct event_probe_data *data)
3055{
3056 if (data->enable)
3057 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
3058 else
3059 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
3060}
3061
3062static void
3063event_enable_probe(unsigned long ip, unsigned long parent_ip,
3064 struct trace_array *tr, struct ftrace_probe_ops *ops,
3065 void *data)
3066{
3067 struct ftrace_func_mapper *mapper = data;
3068 struct event_probe_data *edata;
3069 void **pdata;
3070
3071 pdata = ftrace_func_mapper_find_ip(mapper, ip);
3072 if (!pdata || !*pdata)
3073 return;
3074
3075 edata = *pdata;
3076 update_event_probe(edata);
3077}
3078
3079static void
3080event_enable_count_probe(unsigned long ip, unsigned long parent_ip,
3081 struct trace_array *tr, struct ftrace_probe_ops *ops,
3082 void *data)
3083{
3084 struct ftrace_func_mapper *mapper = data;
3085 struct event_probe_data *edata;
3086 void **pdata;
3087
3088 pdata = ftrace_func_mapper_find_ip(mapper, ip);
3089 if (!pdata || !*pdata)
3090 return;
3091
3092 edata = *pdata;
3093
3094 if (!edata->count)
3095 return;
3096
3097
3098 if (edata->enable == !(edata->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
3099 return;
3100
3101 if (edata->count != -1)
3102 (edata->count)--;
3103
3104 update_event_probe(edata);
3105}
3106
3107static int
3108event_enable_print(struct seq_file *m, unsigned long ip,
3109 struct ftrace_probe_ops *ops, void *data)
3110{
3111 struct ftrace_func_mapper *mapper = data;
3112 struct event_probe_data *edata;
3113 void **pdata;
3114
3115 pdata = ftrace_func_mapper_find_ip(mapper, ip);
3116
3117 if (WARN_ON_ONCE(!pdata || !*pdata))
3118 return 0;
3119
3120 edata = *pdata;
3121
3122 seq_printf(m, "%ps:", (void *)ip);
3123
3124 seq_printf(m, "%s:%s:%s",
3125 edata->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
3126 edata->file->event_call->class->system,
3127 trace_event_name(edata->file->event_call));
3128
3129 if (edata->count == -1)
3130 seq_puts(m, ":unlimited\n");
3131 else
3132 seq_printf(m, ":count=%ld\n", edata->count);
3133
3134 return 0;
3135}
3136
3137static int
3138event_enable_init(struct ftrace_probe_ops *ops, struct trace_array *tr,
3139 unsigned long ip, void *init_data, void **data)
3140{
3141 struct ftrace_func_mapper *mapper = *data;
3142 struct event_probe_data *edata = init_data;
3143 int ret;
3144
3145 if (!mapper) {
3146 mapper = allocate_ftrace_func_mapper();
3147 if (!mapper)
3148 return -ENODEV;
3149 *data = mapper;
3150 }
3151
3152 ret = ftrace_func_mapper_add_ip(mapper, ip, edata);
3153 if (ret < 0)
3154 return ret;
3155
3156 edata->ref++;
3157
3158 return 0;
3159}
3160
3161static int free_probe_data(void *data)
3162{
3163 struct event_probe_data *edata = data;
3164
3165 edata->ref--;
3166 if (!edata->ref) {
3167
3168 __ftrace_event_enable_disable(edata->file, 0, 1);
3169 trace_event_put_ref(edata->file->event_call);
3170 kfree(edata);
3171 }
3172 return 0;
3173}
3174
3175static void
3176event_enable_free(struct ftrace_probe_ops *ops, struct trace_array *tr,
3177 unsigned long ip, void *data)
3178{
3179 struct ftrace_func_mapper *mapper = data;
3180 struct event_probe_data *edata;
3181
3182 if (!ip) {
3183 if (!mapper)
3184 return;
3185 free_ftrace_func_mapper(mapper, free_probe_data);
3186 return;
3187 }
3188
3189 edata = ftrace_func_mapper_remove_ip(mapper, ip);
3190
3191 if (WARN_ON_ONCE(!edata))
3192 return;
3193
3194 if (WARN_ON_ONCE(edata->ref <= 0))
3195 return;
3196
3197 free_probe_data(edata);
3198}
3199
3200static struct ftrace_probe_ops event_enable_probe_ops = {
3201 .func = event_enable_probe,
3202 .print = event_enable_print,
3203 .init = event_enable_init,
3204 .free = event_enable_free,
3205};
3206
3207static struct ftrace_probe_ops event_enable_count_probe_ops = {
3208 .func = event_enable_count_probe,
3209 .print = event_enable_print,
3210 .init = event_enable_init,
3211 .free = event_enable_free,
3212};
3213
3214static struct ftrace_probe_ops event_disable_probe_ops = {
3215 .func = event_enable_probe,
3216 .print = event_enable_print,
3217 .init = event_enable_init,
3218 .free = event_enable_free,
3219};
3220
3221static struct ftrace_probe_ops event_disable_count_probe_ops = {
3222 .func = event_enable_count_probe,
3223 .print = event_enable_print,
3224 .init = event_enable_init,
3225 .free = event_enable_free,
3226};
3227
3228static int
3229event_enable_func(struct trace_array *tr, struct ftrace_hash *hash,
3230 char *glob, char *cmd, char *param, int enabled)
3231{
3232 struct trace_event_file *file;
3233 struct ftrace_probe_ops *ops;
3234 struct event_probe_data *data;
3235 const char *system;
3236 const char *event;
3237 char *number;
3238 bool enable;
3239 int ret;
3240
3241 if (!tr)
3242 return -ENODEV;
3243
3244
3245 if (!enabled || !param)
3246 return -EINVAL;
3247
3248 system = strsep(¶m, ":");
3249 if (!param)
3250 return -EINVAL;
3251
3252 event = strsep(¶m, ":");
3253
3254 mutex_lock(&event_mutex);
3255
3256 ret = -EINVAL;
3257 file = find_event_file(tr, system, event);
3258 if (!file)
3259 goto out;
3260
3261 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
3262
3263 if (enable)
3264 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
3265 else
3266 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
3267
3268 if (glob[0] == '!') {
3269 ret = unregister_ftrace_function_probe_func(glob+1, tr, ops);
3270 goto out;
3271 }
3272
3273 ret = -ENOMEM;
3274
3275 data = kzalloc(sizeof(*data), GFP_KERNEL);
3276 if (!data)
3277 goto out;
3278
3279 data->enable = enable;
3280 data->count = -1;
3281 data->file = file;
3282
3283 if (!param)
3284 goto out_reg;
3285
3286 number = strsep(¶m, ":");
3287
3288 ret = -EINVAL;
3289 if (!strlen(number))
3290 goto out_free;
3291
3292
3293
3294
3295
3296 ret = kstrtoul(number, 0, &data->count);
3297 if (ret)
3298 goto out_free;
3299
3300 out_reg:
3301
3302 ret = trace_event_try_get_ref(file->event_call);
3303 if (!ret) {
3304 ret = -EBUSY;
3305 goto out_free;
3306 }
3307
3308 ret = __ftrace_event_enable_disable(file, 1, 1);
3309 if (ret < 0)
3310 goto out_put;
3311
3312 ret = register_ftrace_function_probe(glob, tr, ops, data);
3313
3314
3315
3316
3317
3318 if (!ret) {
3319 ret = -ENOENT;
3320 goto out_disable;
3321 } else if (ret < 0)
3322 goto out_disable;
3323
3324 ret = 0;
3325 out:
3326 mutex_unlock(&event_mutex);
3327 return ret;
3328
3329 out_disable:
3330 __ftrace_event_enable_disable(file, 0, 1);
3331 out_put:
3332 trace_event_put_ref(file->event_call);
3333 out_free:
3334 kfree(data);
3335 goto out;
3336}
3337
3338static struct ftrace_func_command event_enable_cmd = {
3339 .name = ENABLE_EVENT_STR,
3340 .func = event_enable_func,
3341};
3342
3343static struct ftrace_func_command event_disable_cmd = {
3344 .name = DISABLE_EVENT_STR,
3345 .func = event_enable_func,
3346};
3347
3348static __init int register_event_cmds(void)
3349{
3350 int ret;
3351
3352 ret = register_ftrace_command(&event_enable_cmd);
3353 if (WARN_ON(ret < 0))
3354 return ret;
3355 ret = register_ftrace_command(&event_disable_cmd);
3356 if (WARN_ON(ret < 0))
3357 unregister_ftrace_command(&event_enable_cmd);
3358 return ret;
3359}
3360#else
3361static inline int register_event_cmds(void) { return 0; }
3362#endif
3363
3364
3365
3366
3367
3368
3369
3370
3371static void __trace_early_add_event_dirs(struct trace_array *tr)
3372{
3373 struct trace_event_file *file;
3374 int ret;
3375
3376
3377 list_for_each_entry(file, &tr->events, list) {
3378 ret = event_create_dir(tr->event_dir, file);
3379 if (ret < 0)
3380 pr_warn("Could not create directory for event %s\n",
3381 trace_event_name(file->event_call));
3382 }
3383}
3384
3385
3386
3387
3388
3389
3390
3391void __trace_early_add_events(struct trace_array *tr)
3392{
3393 struct trace_event_call *call;
3394 int ret;
3395
3396 list_for_each_entry(call, &ftrace_events, list) {
3397
3398 if (!(call->flags & TRACE_EVENT_FL_DYNAMIC) &&
3399 WARN_ON_ONCE(call->module))
3400 continue;
3401
3402 ret = __trace_early_add_new_event(call, tr);
3403 if (ret < 0)
3404 pr_warn("Could not create early event %s\n",
3405 trace_event_name(call));
3406 }
3407}
3408
3409
3410static void
3411__trace_remove_event_dirs(struct trace_array *tr)
3412{
3413 struct trace_event_file *file, *next;
3414
3415 list_for_each_entry_safe(file, next, &tr->events, list)
3416 remove_event_file_dir(file);
3417}
3418
3419static void __add_event_to_tracers(struct trace_event_call *call)
3420{
3421 struct trace_array *tr;
3422
3423 list_for_each_entry(tr, &ftrace_trace_arrays, list)
3424 __trace_add_new_event(call, tr);
3425}
3426
3427extern struct trace_event_call *__start_ftrace_events[];
3428extern struct trace_event_call *__stop_ftrace_events[];
3429
3430static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
3431
3432static __init int setup_trace_event(char *str)
3433{
3434 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
3435 ring_buffer_expanded = true;
3436 disable_tracing_selftest("running event tracing");
3437
3438 return 1;
3439}
3440__setup("trace_event=", setup_trace_event);
3441
3442
3443static int
3444create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
3445{
3446 struct dentry *d_events;
3447 struct dentry *entry;
3448
3449 entry = tracefs_create_file("set_event", TRACE_MODE_WRITE, parent,
3450 tr, &ftrace_set_event_fops);
3451 if (!entry) {
3452 pr_warn("Could not create tracefs 'set_event' entry\n");
3453 return -ENOMEM;
3454 }
3455
3456 d_events = tracefs_create_dir("events", parent);
3457 if (!d_events) {
3458 pr_warn("Could not create tracefs 'events' directory\n");
3459 return -ENOMEM;
3460 }
3461
3462 entry = trace_create_file("enable", TRACE_MODE_WRITE, d_events,
3463 tr, &ftrace_tr_enable_fops);
3464 if (!entry) {
3465 pr_warn("Could not create tracefs 'enable' entry\n");
3466 return -ENOMEM;
3467 }
3468
3469
3470
3471 entry = tracefs_create_file("set_event_pid", TRACE_MODE_WRITE, parent,
3472 tr, &ftrace_set_event_pid_fops);
3473 if (!entry)
3474 pr_warn("Could not create tracefs 'set_event_pid' entry\n");
3475
3476 entry = tracefs_create_file("set_event_notrace_pid",
3477 TRACE_MODE_WRITE, parent, tr,
3478 &ftrace_set_event_notrace_pid_fops);
3479 if (!entry)
3480 pr_warn("Could not create tracefs 'set_event_notrace_pid' entry\n");
3481
3482
3483 entry = trace_create_file("header_page", TRACE_MODE_READ, d_events,
3484 ring_buffer_print_page_header,
3485 &ftrace_show_header_fops);
3486 if (!entry)
3487 pr_warn("Could not create tracefs 'header_page' entry\n");
3488
3489 entry = trace_create_file("header_event", TRACE_MODE_READ, d_events,
3490 ring_buffer_print_entry_header,
3491 &ftrace_show_header_fops);
3492 if (!entry)
3493 pr_warn("Could not create tracefs 'header_event' entry\n");
3494
3495 tr->event_dir = d_events;
3496
3497 return 0;
3498}
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
3514{
3515 int ret;
3516
3517 lockdep_assert_held(&event_mutex);
3518
3519 ret = create_event_toplevel_files(parent, tr);
3520 if (ret)
3521 goto out;
3522
3523 down_write(&trace_event_sem);
3524
3525 if (unlikely(!list_empty(&tr->events)))
3526 __trace_early_add_event_dirs(tr);
3527 else
3528 __trace_add_event_dirs(tr);
3529 up_write(&trace_event_sem);
3530
3531 out:
3532 return ret;
3533}
3534
3535
3536
3537
3538
3539static __init int
3540early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
3541{
3542 int ret;
3543
3544 mutex_lock(&event_mutex);
3545
3546 ret = create_event_toplevel_files(parent, tr);
3547 if (ret)
3548 goto out_unlock;
3549
3550 down_write(&trace_event_sem);
3551 __trace_early_add_event_dirs(tr);
3552 up_write(&trace_event_sem);
3553
3554 out_unlock:
3555 mutex_unlock(&event_mutex);
3556
3557 return ret;
3558}
3559
3560
3561int event_trace_del_tracer(struct trace_array *tr)
3562{
3563 lockdep_assert_held(&event_mutex);
3564
3565
3566 clear_event_triggers(tr);
3567
3568
3569 __ftrace_clear_event_pids(tr, TRACE_PIDS | TRACE_NO_PIDS);
3570
3571
3572 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
3573
3574
3575 tracepoint_synchronize_unregister();
3576
3577 down_write(&trace_event_sem);
3578 __trace_remove_event_dirs(tr);
3579 tracefs_remove(tr->event_dir);
3580 up_write(&trace_event_sem);
3581
3582 tr->event_dir = NULL;
3583
3584 return 0;
3585}
3586
3587static __init int event_trace_memsetup(void)
3588{
3589 field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
3590 file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC);
3591 return 0;
3592}
3593
3594static __init void
3595early_enable_events(struct trace_array *tr, bool disable_first)
3596{
3597 char *buf = bootup_event_buf;
3598 char *token;
3599 int ret;
3600
3601 while (true) {
3602 token = strsep(&buf, ",");
3603
3604 if (!token)
3605 break;
3606
3607 if (*token) {
3608
3609 if (disable_first)
3610 ftrace_set_clr_event(tr, token, 0);
3611
3612 ret = ftrace_set_clr_event(tr, token, 1);
3613 if (ret)
3614 pr_warn("Failed to enable trace event: %s\n", token);
3615 }
3616
3617
3618 if (buf)
3619 *(buf - 1) = ',';
3620 }
3621}
3622
3623static __init int event_trace_enable(void)
3624{
3625 struct trace_array *tr = top_trace_array();
3626 struct trace_event_call **iter, *call;
3627 int ret;
3628
3629 if (!tr)
3630 return -ENODEV;
3631
3632 for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
3633
3634 call = *iter;
3635 ret = event_init(call);
3636 if (!ret)
3637 list_add(&call->list, &ftrace_events);
3638 }
3639
3640
3641
3642
3643
3644
3645
3646 __trace_early_add_events(tr);
3647
3648 early_enable_events(tr, false);
3649
3650 trace_printk_start_comm();
3651
3652 register_event_cmds();
3653
3654 register_trigger_cmds();
3655
3656 return 0;
3657}
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669static __init int event_trace_enable_again(void)
3670{
3671 struct trace_array *tr;
3672
3673 tr = top_trace_array();
3674 if (!tr)
3675 return -ENODEV;
3676
3677 early_enable_events(tr, true);
3678
3679 return 0;
3680}
3681
3682early_initcall(event_trace_enable_again);
3683
3684
3685static __init int event_trace_init_fields(void)
3686{
3687 if (trace_define_generic_fields())
3688 pr_warn("tracing: Failed to allocated generic fields");
3689
3690 if (trace_define_common_fields())
3691 pr_warn("tracing: Failed to allocate common fields");
3692
3693 return 0;
3694}
3695
3696__init int event_trace_init(void)
3697{
3698 struct trace_array *tr;
3699 struct dentry *entry;
3700 int ret;
3701
3702 tr = top_trace_array();
3703 if (!tr)
3704 return -ENODEV;
3705
3706 entry = tracefs_create_file("available_events", TRACE_MODE_READ,
3707 NULL, tr, &ftrace_avail_fops);
3708 if (!entry)
3709 pr_warn("Could not create tracefs 'available_events' entry\n");
3710
3711 ret = early_event_add_tracer(NULL, tr);
3712 if (ret)
3713 return ret;
3714
3715#ifdef CONFIG_MODULES
3716 ret = register_module_notifier(&trace_module_nb);
3717 if (ret)
3718 pr_warn("Failed to register trace events module notifier\n");
3719#endif
3720
3721 eventdir_initialized = true;
3722
3723 return 0;
3724}
3725
3726void __init trace_event_init(void)
3727{
3728 event_trace_memsetup();
3729 init_ftrace_syscalls();
3730 event_trace_enable();
3731 event_trace_init_fields();
3732}
3733
3734#ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
3735
3736static DEFINE_SPINLOCK(test_spinlock);
3737static DEFINE_SPINLOCK(test_spinlock_irq);
3738static DEFINE_MUTEX(test_mutex);
3739
3740static __init void test_work(struct work_struct *dummy)
3741{
3742 spin_lock(&test_spinlock);
3743 spin_lock_irq(&test_spinlock_irq);
3744 udelay(1);
3745 spin_unlock_irq(&test_spinlock_irq);
3746 spin_unlock(&test_spinlock);
3747
3748 mutex_lock(&test_mutex);
3749 msleep(1);
3750 mutex_unlock(&test_mutex);
3751}
3752
3753static __init int event_test_thread(void *unused)
3754{
3755 void *test_malloc;
3756
3757 test_malloc = kmalloc(1234, GFP_KERNEL);
3758 if (!test_malloc)
3759 pr_info("failed to kmalloc\n");
3760
3761 schedule_on_each_cpu(test_work);
3762
3763 kfree(test_malloc);
3764
3765 set_current_state(TASK_INTERRUPTIBLE);
3766 while (!kthread_should_stop()) {
3767 schedule();
3768 set_current_state(TASK_INTERRUPTIBLE);
3769 }
3770 __set_current_state(TASK_RUNNING);
3771
3772 return 0;
3773}
3774
3775
3776
3777
3778static __init void event_test_stuff(void)
3779{
3780 struct task_struct *test_thread;
3781
3782 test_thread = kthread_run(event_test_thread, NULL, "test-events");
3783 msleep(1);
3784 kthread_stop(test_thread);
3785}
3786
3787
3788
3789
3790
3791static __init void event_trace_self_tests(void)
3792{
3793 struct trace_subsystem_dir *dir;
3794 struct trace_event_file *file;
3795 struct trace_event_call *call;
3796 struct event_subsystem *system;
3797 struct trace_array *tr;
3798 int ret;
3799
3800 tr = top_trace_array();
3801 if (!tr)
3802 return;
3803
3804 pr_info("Running tests on trace events:\n");
3805
3806 list_for_each_entry(file, &tr->events, list) {
3807
3808 call = file->event_call;
3809
3810
3811 if (!call->class || !call->class->probe)
3812 continue;
3813
3814
3815
3816
3817
3818
3819
3820#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
3821 if (call->class->system &&
3822 strcmp(call->class->system, "syscalls") == 0)
3823 continue;
3824#endif
3825
3826 pr_info("Testing event %s: ", trace_event_name(call));
3827
3828
3829
3830
3831
3832 if (file->flags & EVENT_FILE_FL_ENABLED) {
3833 pr_warn("Enabled event during self test!\n");
3834 WARN_ON_ONCE(1);
3835 continue;
3836 }
3837
3838 ftrace_event_enable_disable(file, 1);
3839 event_test_stuff();
3840 ftrace_event_enable_disable(file, 0);
3841
3842 pr_cont("OK\n");
3843 }
3844
3845
3846
3847 pr_info("Running tests on trace event systems:\n");
3848
3849 list_for_each_entry(dir, &tr->systems, list) {
3850
3851 system = dir->subsystem;
3852
3853
3854 if (strcmp(system->name, "ftrace") == 0)
3855 continue;
3856
3857 pr_info("Testing event system %s: ", system->name);
3858
3859 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1);
3860 if (WARN_ON_ONCE(ret)) {
3861 pr_warn("error enabling system %s\n",
3862 system->name);
3863 continue;
3864 }
3865
3866 event_test_stuff();
3867
3868 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0);
3869 if (WARN_ON_ONCE(ret)) {
3870 pr_warn("error disabling system %s\n",
3871 system->name);
3872 continue;
3873 }
3874
3875 pr_cont("OK\n");
3876 }
3877
3878
3879
3880 pr_info("Running tests on all trace events:\n");
3881 pr_info("Testing all events: ");
3882
3883 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1);
3884 if (WARN_ON_ONCE(ret)) {
3885 pr_warn("error enabling all events\n");
3886 return;
3887 }
3888
3889 event_test_stuff();
3890
3891
3892 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
3893 if (WARN_ON_ONCE(ret)) {
3894 pr_warn("error disabling all events\n");
3895 return;
3896 }
3897
3898 pr_cont("OK\n");
3899}
3900
3901#ifdef CONFIG_FUNCTION_TRACER
3902
3903static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
3904
3905static struct trace_event_file event_trace_file __initdata;
3906
3907static void __init
3908function_test_events_call(unsigned long ip, unsigned long parent_ip,
3909 struct ftrace_ops *op, struct ftrace_regs *regs)
3910{
3911 struct trace_buffer *buffer;
3912 struct ring_buffer_event *event;
3913 struct ftrace_entry *entry;
3914 unsigned int trace_ctx;
3915 long disabled;
3916 int cpu;
3917
3918 trace_ctx = tracing_gen_ctx();
3919 preempt_disable_notrace();
3920 cpu = raw_smp_processor_id();
3921 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
3922
3923 if (disabled != 1)
3924 goto out;
3925
3926 event = trace_event_buffer_lock_reserve(&buffer, &event_trace_file,
3927 TRACE_FN, sizeof(*entry),
3928 trace_ctx);
3929 if (!event)
3930 goto out;
3931 entry = ring_buffer_event_data(event);
3932 entry->ip = ip;
3933 entry->parent_ip = parent_ip;
3934
3935 event_trigger_unlock_commit(&event_trace_file, buffer, event,
3936 entry, trace_ctx);
3937 out:
3938 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
3939 preempt_enable_notrace();
3940}
3941
3942static struct ftrace_ops trace_ops __initdata =
3943{
3944 .func = function_test_events_call,
3945};
3946
3947static __init void event_trace_self_test_with_function(void)
3948{
3949 int ret;
3950
3951 event_trace_file.tr = top_trace_array();
3952 if (WARN_ON(!event_trace_file.tr))
3953 return;
3954
3955 ret = register_ftrace_function(&trace_ops);
3956 if (WARN_ON(ret < 0)) {
3957 pr_info("Failed to enable function tracer for event tests\n");
3958 return;
3959 }
3960 pr_info("Running tests again, along with the function tracer\n");
3961 event_trace_self_tests();
3962 unregister_ftrace_function(&trace_ops);
3963}
3964#else
3965static __init void event_trace_self_test_with_function(void)
3966{
3967}
3968#endif
3969
3970static __init int event_trace_self_tests_init(void)
3971{
3972 if (!tracing_selftest_disabled) {
3973 event_trace_self_tests();
3974 event_trace_self_test_with_function();
3975 }
3976
3977 return 0;
3978}
3979
3980late_initcall(event_trace_self_tests_init);
3981
3982#endif
3983