Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
trace_events.c
Go to the documentation of this file.
1 /*
2  * event tracer
3  *
4  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <[email protected]>
5  *
6  * - Added format output of fields of the trace point.
7  * This was based off of work by Tom Zanussi <[email protected]>.
8  *
9  */
10 
11 #include <linux/workqueue.h>
12 #include <linux/spinlock.h>
13 #include <linux/kthread.h>
14 #include <linux/debugfs.h>
15 #include <linux/uaccess.h>
16 #include <linux/module.h>
17 #include <linux/ctype.h>
18 #include <linux/slab.h>
19 #include <linux/delay.h>
20 
21 #include <asm/setup.h>
22 
23 #include "trace_output.h"
24 
25 #undef TRACE_SYSTEM
26 #define TRACE_SYSTEM "TRACE_SYSTEM"
27 
28 DEFINE_MUTEX(event_mutex);
29 
30 DEFINE_MUTEX(event_storage_mutex);
31 EXPORT_SYMBOL_GPL(event_storage_mutex);
32 
35 
36 LIST_HEAD(ftrace_events);
37 LIST_HEAD(ftrace_common_fields);
38 
39 struct list_head *
41 {
42  if (!event_call->class->get_fields)
43  return &event_call->class->fields;
44  return event_call->class->get_fields(event_call);
45 }
46 
47 static int __trace_define_field(struct list_head *head, const char *type,
48  const char *name, int offset, int size,
49  int is_signed, int filter_type)
50 {
51  struct ftrace_event_field *field;
52 
53  field = kzalloc(sizeof(*field), GFP_KERNEL);
54  if (!field)
55  goto err;
56 
57  field->name = kstrdup(name, GFP_KERNEL);
58  if (!field->name)
59  goto err;
60 
61  field->type = kstrdup(type, GFP_KERNEL);
62  if (!field->type)
63  goto err;
64 
65  if (filter_type == FILTER_OTHER)
66  field->filter_type = filter_assign_type(type);
67  else
68  field->filter_type = filter_type;
69 
70  field->offset = offset;
71  field->size = size;
72  field->is_signed = is_signed;
73 
74  list_add(&field->link, head);
75 
76  return 0;
77 
78 err:
79  if (field)
80  kfree(field->name);
81  kfree(field);
82 
83  return -ENOMEM;
84 }
85 
86 int trace_define_field(struct ftrace_event_call *call, const char *type,
87  const char *name, int offset, int size, int is_signed,
88  int filter_type)
89 {
90  struct list_head *head;
91 
92  if (WARN_ON(!call->class))
93  return 0;
94 
95  head = trace_get_fields(call);
96  return __trace_define_field(head, type, name, offset, size,
97  is_signed, filter_type);
98 }
100 
101 #define __common_field(type, item) \
102  ret = __trace_define_field(&ftrace_common_fields, #type, \
103  "common_" #item, \
104  offsetof(typeof(ent), item), \
105  sizeof(ent.item), \
106  is_signed_type(type), FILTER_OTHER); \
107  if (ret) \
108  return ret;
109 
110 static int trace_define_common_fields(void)
111 {
112  int ret;
113  struct trace_entry ent;
114 
115  __common_field(unsigned short, type);
116  __common_field(unsigned char, flags);
117  __common_field(unsigned char, preempt_count);
118  __common_field(int, pid);
119  __common_field(int, padding);
120 
121  return ret;
122 }
123 
125 {
126  struct ftrace_event_field *field, *next;
127  struct list_head *head;
128 
129  head = trace_get_fields(call);
130  list_for_each_entry_safe(field, next, head, link) {
131  list_del(&field->link);
132  kfree(field->type);
133  kfree(field->name);
134  kfree(field);
135  }
136 }
137 
139 {
140  int id;
141 
142  id = register_ftrace_event(&call->event);
143  if (!id)
144  return -ENODEV;
145 
146  return 0;
147 }
149 
151  enum trace_reg type, void *data)
152 {
153  switch (type) {
154  case TRACE_REG_REGISTER:
155  return tracepoint_probe_register(call->name,
156  call->class->probe,
157  call);
160  call->class->probe,
161  call);
162  return 0;
163 
164 #ifdef CONFIG_PERF_EVENTS
165  case TRACE_REG_PERF_REGISTER:
166  return tracepoint_probe_register(call->name,
167  call->class->perf_probe,
168  call);
169  case TRACE_REG_PERF_UNREGISTER:
171  call->class->perf_probe,
172  call);
173  return 0;
174  case TRACE_REG_PERF_OPEN:
175  case TRACE_REG_PERF_CLOSE:
176  case TRACE_REG_PERF_ADD:
177  case TRACE_REG_PERF_DEL:
178  return 0;
179 #endif
180  }
181  return 0;
182 }
184 
186 {
187  struct ftrace_event_call *call;
188 
191  if (!(call->flags & TRACE_EVENT_FL_ENABLED))
192  continue;
193 
194  if (enable) {
197  } else {
200  }
201  }
203 }
204 
205 static int ftrace_event_enable_disable(struct ftrace_event_call *call,
206  int enable)
207 {
208  int ret = 0;
209 
210  switch (enable) {
211  case 0:
212  if (call->flags & TRACE_EVENT_FL_ENABLED) {
213  call->flags &= ~TRACE_EVENT_FL_ENABLED;
214  if (call->flags & TRACE_EVENT_FL_RECORDED_CMD) {
217  }
218  call->class->reg(call, TRACE_REG_UNREGISTER, NULL);
219  }
220  break;
221  case 1:
222  if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {
226  }
227  ret = call->class->reg(call, TRACE_REG_REGISTER, NULL);
228  if (ret) {
230  pr_info("event trace: Could not enable event "
231  "%s\n", call->name);
232  break;
233  }
234  call->flags |= TRACE_EVENT_FL_ENABLED;
235  }
236  break;
237  }
238 
239  return ret;
240 }
241 
242 static void ftrace_clear_events(void)
243 {
244  struct ftrace_event_call *call;
245 
246  mutex_lock(&event_mutex);
247  list_for_each_entry(call, &ftrace_events, list) {
248  ftrace_event_enable_disable(call, 0);
249  }
250  mutex_unlock(&event_mutex);
251 }
252 
253 static void __put_system(struct event_subsystem *system)
254 {
255  struct event_filter *filter = system->filter;
256 
257  WARN_ON_ONCE(system->ref_count == 0);
258  if (--system->ref_count)
259  return;
260 
261  if (filter) {
262  kfree(filter->filter_string);
263  kfree(filter);
264  }
265  kfree(system->name);
266  kfree(system);
267 }
268 
269 static void __get_system(struct event_subsystem *system)
270 {
271  WARN_ON_ONCE(system->ref_count == 0);
272  system->ref_count++;
273 }
274 
275 static void put_system(struct event_subsystem *system)
276 {
277  mutex_lock(&event_mutex);
278  __put_system(system);
279  mutex_unlock(&event_mutex);
280 }
281 
282 /*
283  * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
284  */
285 static int __ftrace_set_clr_event(const char *match, const char *sub,
286  const char *event, int set)
287 {
288  struct ftrace_event_call *call;
289  int ret = -EINVAL;
290 
291  mutex_lock(&event_mutex);
292  list_for_each_entry(call, &ftrace_events, list) {
293 
294  if (!call->name || !call->class || !call->class->reg)
295  continue;
296 
298  continue;
299 
300  if (match &&
301  strcmp(match, call->name) != 0 &&
302  strcmp(match, call->class->system) != 0)
303  continue;
304 
305  if (sub && strcmp(sub, call->class->system) != 0)
306  continue;
307 
308  if (event && strcmp(event, call->name) != 0)
309  continue;
310 
311  ftrace_event_enable_disable(call, set);
312 
313  ret = 0;
314  }
315  mutex_unlock(&event_mutex);
316 
317  return ret;
318 }
319 
320 static int ftrace_set_clr_event(char *buf, int set)
321 {
322  char *event = NULL, *sub = NULL, *match;
323 
324  /*
325  * The buf format can be <subsystem>:<event-name>
326  * *:<event-name> means any event by that name.
327  * :<event-name> is the same.
328  *
329  * <subsystem>:* means all events in that subsystem
330  * <subsystem>: means the same.
331  *
332  * <name> (no ':') means all events in a subsystem with
333  * the name <name> or any event that matches <name>
334  */
335 
336  match = strsep(&buf, ":");
337  if (buf) {
338  sub = match;
339  event = buf;
340  match = NULL;
341 
342  if (!strlen(sub) || strcmp(sub, "*") == 0)
343  sub = NULL;
344  if (!strlen(event) || strcmp(event, "*") == 0)
345  event = NULL;
346  }
347 
348  return __ftrace_set_clr_event(match, sub, event, set);
349 }
350 
363 int trace_set_clr_event(const char *system, const char *event, int set)
364 {
365  return __ftrace_set_clr_event(NULL, system, event, set);
366 }
368 
369 /* 128 should be much more than enough */
370 #define EVENT_BUF_SIZE 127
371 
372 static ssize_t
373 ftrace_event_write(struct file *file, const char __user *ubuf,
374  size_t cnt, loff_t *ppos)
375 {
376  struct trace_parser parser;
377  ssize_t read, ret;
378 
379  if (!cnt)
380  return 0;
381 
382  ret = tracing_update_buffers();
383  if (ret < 0)
384  return ret;
385 
386  if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
387  return -ENOMEM;
388 
389  read = trace_get_user(&parser, ubuf, cnt, ppos);
390 
391  if (read >= 0 && trace_parser_loaded((&parser))) {
392  int set = 1;
393 
394  if (*parser.buffer == '!')
395  set = 0;
396 
397  parser.buffer[parser.idx] = 0;
398 
399  ret = ftrace_set_clr_event(parser.buffer + !set, set);
400  if (ret)
401  goto out_put;
402  }
403 
404  ret = read;
405 
406  out_put:
407  trace_parser_put(&parser);
408 
409  return ret;
410 }
411 
412 static void *
413 t_next(struct seq_file *m, void *v, loff_t *pos)
414 {
415  struct ftrace_event_call *call = v;
416 
417  (*pos)++;
418 
419  list_for_each_entry_continue(call, &ftrace_events, list) {
420  /*
421  * The ftrace subsystem is for showing formats only.
422  * They can not be enabled or disabled via the event files.
423  */
424  if (call->class && call->class->reg)
425  return call;
426  }
427 
428  return NULL;
429 }
430 
431 static void *t_start(struct seq_file *m, loff_t *pos)
432 {
433  struct ftrace_event_call *call;
434  loff_t l;
435 
436  mutex_lock(&event_mutex);
437 
438  call = list_entry(&ftrace_events, struct ftrace_event_call, list);
439  for (l = 0; l <= *pos; ) {
440  call = t_next(m, call, &l);
441  if (!call)
442  break;
443  }
444  return call;
445 }
446 
447 static void *
448 s_next(struct seq_file *m, void *v, loff_t *pos)
449 {
450  struct ftrace_event_call *call = v;
451 
452  (*pos)++;
453 
454  list_for_each_entry_continue(call, &ftrace_events, list) {
455  if (call->flags & TRACE_EVENT_FL_ENABLED)
456  return call;
457  }
458 
459  return NULL;
460 }
461 
462 static void *s_start(struct seq_file *m, loff_t *pos)
463 {
464  struct ftrace_event_call *call;
465  loff_t l;
466 
467  mutex_lock(&event_mutex);
468 
469  call = list_entry(&ftrace_events, struct ftrace_event_call, list);
470  for (l = 0; l <= *pos; ) {
471  call = s_next(m, call, &l);
472  if (!call)
473  break;
474  }
475  return call;
476 }
477 
478 static int t_show(struct seq_file *m, void *v)
479 {
480  struct ftrace_event_call *call = v;
481 
482  if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
483  seq_printf(m, "%s:", call->class->system);
484  seq_printf(m, "%s\n", call->name);
485 
486  return 0;
487 }
488 
489 static void t_stop(struct seq_file *m, void *p)
490 {
491  mutex_unlock(&event_mutex);
492 }
493 
494 static int
495 ftrace_event_seq_open(struct inode *inode, struct file *file)
496 {
497  const struct seq_operations *seq_ops;
498 
499  if ((file->f_mode & FMODE_WRITE) &&
500  (file->f_flags & O_TRUNC))
501  ftrace_clear_events();
502 
503  seq_ops = inode->i_private;
504  return seq_open(file, seq_ops);
505 }
506 
507 static ssize_t
508 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
509  loff_t *ppos)
510 {
511  struct ftrace_event_call *call = filp->private_data;
512  char *buf;
513 
514  if (call->flags & TRACE_EVENT_FL_ENABLED)
515  buf = "1\n";
516  else
517  buf = "0\n";
518 
519  return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
520 }
521 
522 static ssize_t
523 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
524  loff_t *ppos)
525 {
526  struct ftrace_event_call *call = filp->private_data;
527  unsigned long val;
528  int ret;
529 
530  ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
531  if (ret)
532  return ret;
533 
534  ret = tracing_update_buffers();
535  if (ret < 0)
536  return ret;
537 
538  switch (val) {
539  case 0:
540  case 1:
541  mutex_lock(&event_mutex);
542  ret = ftrace_event_enable_disable(call, val);
543  mutex_unlock(&event_mutex);
544  break;
545 
546  default:
547  return -EINVAL;
548  }
549 
550  *ppos += cnt;
551 
552  return ret ? ret : cnt;
553 }
554 
555 static ssize_t
556 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
557  loff_t *ppos)
558 {
559  const char set_to_char[4] = { '?', '0', '1', 'X' };
560  struct event_subsystem *system = filp->private_data;
561  struct ftrace_event_call *call;
562  char buf[2];
563  int set = 0;
564  int ret;
565 
566  mutex_lock(&event_mutex);
567  list_for_each_entry(call, &ftrace_events, list) {
568  if (!call->name || !call->class || !call->class->reg)
569  continue;
570 
571  if (system && strcmp(call->class->system, system->name) != 0)
572  continue;
573 
574  /*
575  * We need to find out if all the events are set
576  * or if all events or cleared, or if we have
577  * a mixture.
578  */
579  set |= (1 << !!(call->flags & TRACE_EVENT_FL_ENABLED));
580 
581  /*
582  * If we have a mixture, no need to look further.
583  */
584  if (set == 3)
585  break;
586  }
587  mutex_unlock(&event_mutex);
588 
589  buf[0] = set_to_char[set];
590  buf[1] = '\n';
591 
592  ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
593 
594  return ret;
595 }
596 
597 static ssize_t
598 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
599  loff_t *ppos)
600 {
601  struct event_subsystem *system = filp->private_data;
602  const char *name = NULL;
603  unsigned long val;
604  ssize_t ret;
605 
606  ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
607  if (ret)
608  return ret;
609 
610  ret = tracing_update_buffers();
611  if (ret < 0)
612  return ret;
613 
614  if (val != 0 && val != 1)
615  return -EINVAL;
616 
617  /*
618  * Opening of "enable" adds a ref count to system,
619  * so the name is safe to use.
620  */
621  if (system)
622  name = system->name;
623 
624  ret = __ftrace_set_clr_event(NULL, name, NULL, val);
625  if (ret)
626  goto out;
627 
628  ret = cnt;
629 
630 out:
631  *ppos += cnt;
632 
633  return ret;
634 }
635 
636 enum {
640 };
641 
642 static void *f_next(struct seq_file *m, void *v, loff_t *pos)
643 {
644  struct ftrace_event_call *call = m->private;
645  struct ftrace_event_field *field;
646  struct list_head *common_head = &ftrace_common_fields;
647  struct list_head *head = trace_get_fields(call);
648 
649  (*pos)++;
650 
651  switch ((unsigned long)v) {
652  case FORMAT_HEADER:
653  if (unlikely(list_empty(common_head)))
654  return NULL;
655 
656  field = list_entry(common_head->prev,
657  struct ftrace_event_field, link);
658  return field;
659 
661  if (unlikely(list_empty(head)))
662  return NULL;
663 
664  field = list_entry(head->prev, struct ftrace_event_field, link);
665  return field;
666 
667  case FORMAT_PRINTFMT:
668  /* all done */
669  return NULL;
670  }
671 
672  field = v;
673  if (field->link.prev == common_head)
674  return (void *)FORMAT_FIELD_SEPERATOR;
675  else if (field->link.prev == head)
676  return (void *)FORMAT_PRINTFMT;
677 
678  field = list_entry(field->link.prev, struct ftrace_event_field, link);
679 
680  return field;
681 }
682 
683 static void *f_start(struct seq_file *m, loff_t *pos)
684 {
685  loff_t l = 0;
686  void *p;
687 
688  /* Start by showing the header */
689  if (!*pos)
690  return (void *)FORMAT_HEADER;
691 
692  p = (void *)FORMAT_HEADER;
693  do {
694  p = f_next(m, p, &l);
695  } while (p && l < *pos);
696 
697  return p;
698 }
699 
700 static int f_show(struct seq_file *m, void *v)
701 {
702  struct ftrace_event_call *call = m->private;
703  struct ftrace_event_field *field;
704  const char *array_descriptor;
705 
706  switch ((unsigned long)v) {
707  case FORMAT_HEADER:
708  seq_printf(m, "name: %s\n", call->name);
709  seq_printf(m, "ID: %d\n", call->event.type);
710  seq_printf(m, "format:\n");
711  return 0;
712 
714  seq_putc(m, '\n');
715  return 0;
716 
717  case FORMAT_PRINTFMT:
718  seq_printf(m, "\nprint fmt: %s\n",
719  call->print_fmt);
720  return 0;
721  }
722 
723  field = v;
724 
725  /*
726  * Smartly shows the array type(except dynamic array).
727  * Normal:
728  * field:TYPE VAR
729  * If TYPE := TYPE[LEN], it is shown:
730  * field:TYPE VAR[LEN]
731  */
732  array_descriptor = strchr(field->type, '[');
733 
734  if (!strncmp(field->type, "__data_loc", 10))
735  array_descriptor = NULL;
736 
737  if (!array_descriptor)
738  seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
739  field->type, field->name, field->offset,
740  field->size, !!field->is_signed);
741  else
742  seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
743  (int)(array_descriptor - field->type),
744  field->type, field->name,
745  array_descriptor, field->offset,
746  field->size, !!field->is_signed);
747 
748  return 0;
749 }
750 
751 static void f_stop(struct seq_file *m, void *p)
752 {
753 }
754 
755 static const struct seq_operations trace_format_seq_ops = {
756  .start = f_start,
757  .next = f_next,
758  .stop = f_stop,
759  .show = f_show,
760 };
761 
762 static int trace_format_open(struct inode *inode, struct file *file)
763 {
764  struct ftrace_event_call *call = inode->i_private;
765  struct seq_file *m;
766  int ret;
767 
768  ret = seq_open(file, &trace_format_seq_ops);
769  if (ret < 0)
770  return ret;
771 
772  m = file->private_data;
773  m->private = call;
774 
775  return 0;
776 }
777 
778 static ssize_t
779 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
780 {
781  struct ftrace_event_call *call = filp->private_data;
782  struct trace_seq *s;
783  int r;
784 
785  if (*ppos)
786  return 0;
787 
788  s = kmalloc(sizeof(*s), GFP_KERNEL);
789  if (!s)
790  return -ENOMEM;
791 
792  trace_seq_init(s);
793  trace_seq_printf(s, "%d\n", call->event.type);
794 
795  r = simple_read_from_buffer(ubuf, cnt, ppos,
796  s->buffer, s->len);
797  kfree(s);
798  return r;
799 }
800 
801 static ssize_t
802 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
803  loff_t *ppos)
804 {
805  struct ftrace_event_call *call = filp->private_data;
806  struct trace_seq *s;
807  int r;
808 
809  if (*ppos)
810  return 0;
811 
812  s = kmalloc(sizeof(*s), GFP_KERNEL);
813  if (!s)
814  return -ENOMEM;
815 
816  trace_seq_init(s);
817 
818  print_event_filter(call, s);
819  r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
820 
821  kfree(s);
822 
823  return r;
824 }
825 
826 static ssize_t
827 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
828  loff_t *ppos)
829 {
830  struct ftrace_event_call *call = filp->private_data;
831  char *buf;
832  int err;
833 
834  if (cnt >= PAGE_SIZE)
835  return -EINVAL;
836 
837  buf = (char *)__get_free_page(GFP_TEMPORARY);
838  if (!buf)
839  return -ENOMEM;
840 
841  if (copy_from_user(buf, ubuf, cnt)) {
842  free_page((unsigned long) buf);
843  return -EFAULT;
844  }
845  buf[cnt] = '\0';
846 
847  err = apply_event_filter(call, buf);
848  free_page((unsigned long) buf);
849  if (err < 0)
850  return err;
851 
852  *ppos += cnt;
853 
854  return cnt;
855 }
856 
857 static LIST_HEAD(event_subsystems);
858 
859 static int subsystem_open(struct inode *inode, struct file *filp)
860 {
861  struct event_subsystem *system = NULL;
862  int ret;
863 
864  if (!inode->i_private)
865  goto skip_search;
866 
867  /* Make sure the system still exists */
868  mutex_lock(&event_mutex);
869  list_for_each_entry(system, &event_subsystems, list) {
870  if (system == inode->i_private) {
871  /* Don't open systems with no events */
872  if (!system->nr_events) {
873  system = NULL;
874  break;
875  }
876  __get_system(system);
877  break;
878  }
879  }
880  mutex_unlock(&event_mutex);
881 
882  if (system != inode->i_private)
883  return -ENODEV;
884 
885  skip_search:
886  ret = tracing_open_generic(inode, filp);
887  if (ret < 0 && system)
888  put_system(system);
889 
890  return ret;
891 }
892 
893 static int subsystem_release(struct inode *inode, struct file *file)
894 {
895  struct event_subsystem *system = inode->i_private;
896 
897  if (system)
898  put_system(system);
899 
900  return 0;
901 }
902 
903 static ssize_t
904 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
905  loff_t *ppos)
906 {
907  struct event_subsystem *system = filp->private_data;
908  struct trace_seq *s;
909  int r;
910 
911  if (*ppos)
912  return 0;
913 
914  s = kmalloc(sizeof(*s), GFP_KERNEL);
915  if (!s)
916  return -ENOMEM;
917 
918  trace_seq_init(s);
919 
920  print_subsystem_event_filter(system, s);
921  r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
922 
923  kfree(s);
924 
925  return r;
926 }
927 
928 static ssize_t
929 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
930  loff_t *ppos)
931 {
932  struct event_subsystem *system = filp->private_data;
933  char *buf;
934  int err;
935 
936  if (cnt >= PAGE_SIZE)
937  return -EINVAL;
938 
939  buf = (char *)__get_free_page(GFP_TEMPORARY);
940  if (!buf)
941  return -ENOMEM;
942 
943  if (copy_from_user(buf, ubuf, cnt)) {
944  free_page((unsigned long) buf);
945  return -EFAULT;
946  }
947  buf[cnt] = '\0';
948 
949  err = apply_subsystem_event_filter(system, buf);
950  free_page((unsigned long) buf);
951  if (err < 0)
952  return err;
953 
954  *ppos += cnt;
955 
956  return cnt;
957 }
958 
959 static ssize_t
960 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
961 {
962  int (*func)(struct trace_seq *s) = filp->private_data;
963  struct trace_seq *s;
964  int r;
965 
966  if (*ppos)
967  return 0;
968 
969  s = kmalloc(sizeof(*s), GFP_KERNEL);
970  if (!s)
971  return -ENOMEM;
972 
973  trace_seq_init(s);
974 
975  func(s);
976  r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
977 
978  kfree(s);
979 
980  return r;
981 }
982 
983 static const struct seq_operations show_event_seq_ops = {
984  .start = t_start,
985  .next = t_next,
986  .show = t_show,
987  .stop = t_stop,
988 };
989 
990 static const struct seq_operations show_set_event_seq_ops = {
991  .start = s_start,
992  .next = s_next,
993  .show = t_show,
994  .stop = t_stop,
995 };
996 
997 static const struct file_operations ftrace_avail_fops = {
998  .open = ftrace_event_seq_open,
999  .read = seq_read,
1000  .llseek = seq_lseek,
1001  .release = seq_release,
1002 };
1003 
1004 static const struct file_operations ftrace_set_event_fops = {
1005  .open = ftrace_event_seq_open,
1006  .read = seq_read,
1007  .write = ftrace_event_write,
1008  .llseek = seq_lseek,
1009  .release = seq_release,
1010 };
1011 
1012 static const struct file_operations ftrace_enable_fops = {
1013  .open = tracing_open_generic,
1014  .read = event_enable_read,
1015  .write = event_enable_write,
1016  .llseek = default_llseek,
1017 };
1018 
1019 static const struct file_operations ftrace_event_format_fops = {
1020  .open = trace_format_open,
1021  .read = seq_read,
1022  .llseek = seq_lseek,
1023  .release = seq_release,
1024 };
1025 
1026 static const struct file_operations ftrace_event_id_fops = {
1027  .open = tracing_open_generic,
1028  .read = event_id_read,
1029  .llseek = default_llseek,
1030 };
1031 
1032 static const struct file_operations ftrace_event_filter_fops = {
1033  .open = tracing_open_generic,
1034  .read = event_filter_read,
1035  .write = event_filter_write,
1036  .llseek = default_llseek,
1037 };
1038 
1039 static const struct file_operations ftrace_subsystem_filter_fops = {
1040  .open = subsystem_open,
1041  .read = subsystem_filter_read,
1042  .write = subsystem_filter_write,
1043  .llseek = default_llseek,
1044  .release = subsystem_release,
1045 };
1046 
1047 static const struct file_operations ftrace_system_enable_fops = {
1048  .open = subsystem_open,
1049  .read = system_enable_read,
1050  .write = system_enable_write,
1051  .llseek = default_llseek,
1052  .release = subsystem_release,
1053 };
1054 
1055 static const struct file_operations ftrace_show_header_fops = {
1056  .open = tracing_open_generic,
1057  .read = show_header,
1058  .llseek = default_llseek,
1059 };
1060 
1061 static struct dentry *event_trace_events_dir(void)
1062 {
1063  static struct dentry *d_tracer;
1064  static struct dentry *d_events;
1065 
1066  if (d_events)
1067  return d_events;
1068 
1069  d_tracer = tracing_init_dentry();
1070  if (!d_tracer)
1071  return NULL;
1072 
1073  d_events = debugfs_create_dir("events", d_tracer);
1074  if (!d_events)
1075  pr_warning("Could not create debugfs "
1076  "'events' directory\n");
1077 
1078  return d_events;
1079 }
1080 
1081 static struct dentry *
1082 event_subsystem_dir(const char *name, struct dentry *d_events)
1083 {
1084  struct event_subsystem *system;
1085  struct dentry *entry;
1086 
1087  /* First see if we did not already create this dir */
1088  list_for_each_entry(system, &event_subsystems, list) {
1089  if (strcmp(system->name, name) == 0) {
1090  system->nr_events++;
1091  return system->entry;
1092  }
1093  }
1094 
1095  /* need to create new entry */
1096  system = kmalloc(sizeof(*system), GFP_KERNEL);
1097  if (!system) {
1098  pr_warning("No memory to create event subsystem %s\n",
1099  name);
1100  return d_events;
1101  }
1102 
1103  system->entry = debugfs_create_dir(name, d_events);
1104  if (!system->entry) {
1105  pr_warning("Could not create event subsystem %s\n",
1106  name);
1107  kfree(system);
1108  return d_events;
1109  }
1110 
1111  system->nr_events = 1;
1112  system->ref_count = 1;
1113  system->name = kstrdup(name, GFP_KERNEL);
1114  if (!system->name) {
1115  debugfs_remove(system->entry);
1116  kfree(system);
1117  return d_events;
1118  }
1119 
1120  list_add(&system->list, &event_subsystems);
1121 
1122  system->filter = NULL;
1123 
1124  system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
1125  if (!system->filter) {
1126  pr_warning("Could not allocate filter for subsystem "
1127  "'%s'\n", name);
1128  return system->entry;
1129  }
1130 
1131  entry = debugfs_create_file("filter", 0644, system->entry, system,
1132  &ftrace_subsystem_filter_fops);
1133  if (!entry) {
1134  kfree(system->filter);
1135  system->filter = NULL;
1136  pr_warning("Could not create debugfs "
1137  "'%s/filter' entry\n", name);
1138  }
1139 
1140  trace_create_file("enable", 0644, system->entry, system,
1141  &ftrace_system_enable_fops);
1142 
1143  return system->entry;
1144 }
1145 
1146 static int
1147 event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
1148  const struct file_operations *id,
1149  const struct file_operations *enable,
1150  const struct file_operations *filter,
1151  const struct file_operations *format)
1152 {
1153  struct list_head *head;
1154  int ret;
1155 
1156  /*
1157  * If the trace point header did not define TRACE_SYSTEM
1158  * then the system would be called "TRACE_SYSTEM".
1159  */
1160  if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
1161  d_events = event_subsystem_dir(call->class->system, d_events);
1162 
1163  call->dir = debugfs_create_dir(call->name, d_events);
1164  if (!call->dir) {
1165  pr_warning("Could not create debugfs "
1166  "'%s' directory\n", call->name);
1167  return -1;
1168  }
1169 
1170  if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
1171  trace_create_file("enable", 0644, call->dir, call,
1172  enable);
1173 
1174 #ifdef CONFIG_PERF_EVENTS
1175  if (call->event.type && call->class->reg)
1176  trace_create_file("id", 0444, call->dir, call,
1177  id);
1178 #endif
1179 
1180  /*
1181  * Other events may have the same class. Only update
1182  * the fields if they are not already defined.
1183  */
1184  head = trace_get_fields(call);
1185  if (list_empty(head)) {
1186  ret = call->class->define_fields(call);
1187  if (ret < 0) {
1188  pr_warning("Could not initialize trace point"
1189  " events/%s\n", call->name);
1190  return ret;
1191  }
1192  }
1193  trace_create_file("filter", 0644, call->dir, call,
1194  filter);
1195 
1196  trace_create_file("format", 0444, call->dir, call,
1197  format);
1198 
1199  return 0;
1200 }
1201 
1202 static void event_remove(struct ftrace_event_call *call)
1203 {
1204  ftrace_event_enable_disable(call, 0);
1205  if (call->event.funcs)
1207  list_del(&call->list);
1208 }
1209 
1210 static int event_init(struct ftrace_event_call *call)
1211 {
1212  int ret = 0;
1213 
1214  if (WARN_ON(!call->name))
1215  return -EINVAL;
1216 
1217  if (call->class->raw_init) {
1218  ret = call->class->raw_init(call);
1219  if (ret < 0 && ret != -ENOSYS)
1220  pr_warn("Could not initialize trace events/%s\n",
1221  call->name);
1222  }
1223 
1224  return ret;
1225 }
1226 
1227 static int
1228 __trace_add_event_call(struct ftrace_event_call *call, struct module *mod,
1229  const struct file_operations *id,
1230  const struct file_operations *enable,
1231  const struct file_operations *filter,
1232  const struct file_operations *format)
1233 {
1234  struct dentry *d_events;
1235  int ret;
1236 
1237  ret = event_init(call);
1238  if (ret < 0)
1239  return ret;
1240 
1241  d_events = event_trace_events_dir();
1242  if (!d_events)
1243  return -ENOENT;
1244 
1245  ret = event_create_dir(call, d_events, id, enable, filter, format);
1246  if (!ret)
1247  list_add(&call->list, &ftrace_events);
1248  call->mod = mod;
1249 
1250  return ret;
1251 }
1252 
1253 /* Add an additional event_call dynamically */
1255 {
1256  int ret;
1258  ret = __trace_add_event_call(call, NULL, &ftrace_event_id_fops,
1259  &ftrace_enable_fops,
1260  &ftrace_event_filter_fops,
1261  &ftrace_event_format_fops);
1263  return ret;
1264 }
1265 
1266 static void remove_subsystem_dir(const char *name)
1267 {
1268  struct event_subsystem *system;
1269 
1270  if (strcmp(name, TRACE_SYSTEM) == 0)
1271  return;
1272 
1273  list_for_each_entry(system, &event_subsystems, list) {
1274  if (strcmp(system->name, name) == 0) {
1275  if (!--system->nr_events) {
1277  list_del(&system->list);
1278  __put_system(system);
1279  }
1280  break;
1281  }
1282  }
1283 }
1284 
1285 /*
1286  * Must be called under locking both of event_mutex and trace_event_mutex.
1287  */
1288 static void __trace_remove_event_call(struct ftrace_event_call *call)
1289 {
1290  event_remove(call);
1291  trace_destroy_fields(call);
1292  destroy_preds(call);
1294  remove_subsystem_dir(call->class->system);
1295 }
1296 
1297 /* Remove an event_call */
1299 {
1302  __trace_remove_event_call(call);
1305 }
1306 
1307 #define for_each_event(event, start, end) \
1308  for (event = start; \
1309  (unsigned long)event < (unsigned long)end; \
1310  event++)
1311 
1312 #ifdef CONFIG_MODULES
1313 
1314 static LIST_HEAD(ftrace_module_file_list);
1315 
1316 /*
1317  * Modules must own their file_operations to keep up with
1318  * reference counting.
1319  */
1320 struct ftrace_module_file_ops {
1321  struct list_head list;
1322  struct module *mod;
1323  struct file_operations id;
1324  struct file_operations enable;
1325  struct file_operations format;
1326  struct file_operations filter;
1327 };
1328 
1329 static struct ftrace_module_file_ops *
1330 trace_create_file_ops(struct module *mod)
1331 {
1332  struct ftrace_module_file_ops *file_ops;
1333 
1334  /*
1335  * This is a bit of a PITA. To allow for correct reference
1336  * counting, modules must "own" their file_operations.
1337  * To do this, we allocate the file operations that will be
1338  * used in the event directory.
1339  */
1340 
1341  file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1342  if (!file_ops)
1343  return NULL;
1344 
1345  file_ops->mod = mod;
1346 
1347  file_ops->id = ftrace_event_id_fops;
1348  file_ops->id.owner = mod;
1349 
1350  file_ops->enable = ftrace_enable_fops;
1351  file_ops->enable.owner = mod;
1352 
1353  file_ops->filter = ftrace_event_filter_fops;
1354  file_ops->filter.owner = mod;
1355 
1356  file_ops->format = ftrace_event_format_fops;
1357  file_ops->format.owner = mod;
1358 
1359  list_add(&file_ops->list, &ftrace_module_file_list);
1360 
1361  return file_ops;
1362 }
1363 
1364 static void trace_module_add_events(struct module *mod)
1365 {
1366  struct ftrace_module_file_ops *file_ops = NULL;
1367  struct ftrace_event_call **call, **start, **end;
1368 
1369  start = mod->trace_events;
1370  end = mod->trace_events + mod->num_trace_events;
1371 
1372  if (start == end)
1373  return;
1374 
1375  file_ops = trace_create_file_ops(mod);
1376  if (!file_ops)
1377  return;
1378 
1379  for_each_event(call, start, end) {
1380  __trace_add_event_call(*call, mod,
1381  &file_ops->id, &file_ops->enable,
1382  &file_ops->filter, &file_ops->format);
1383  }
1384 }
1385 
1386 static void trace_module_remove_events(struct module *mod)
1387 {
1388  struct ftrace_module_file_ops *file_ops;
1389  struct ftrace_event_call *call, *p;
1390  bool found = false;
1391 
1392  down_write(&trace_event_mutex);
1393  list_for_each_entry_safe(call, p, &ftrace_events, list) {
1394  if (call->mod == mod) {
1395  found = true;
1396  __trace_remove_event_call(call);
1397  }
1398  }
1399 
1400  /* Now free the file_operations */
1401  list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1402  if (file_ops->mod == mod)
1403  break;
1404  }
1405  if (&file_ops->list != &ftrace_module_file_list) {
1406  list_del(&file_ops->list);
1407  kfree(file_ops);
1408  }
1409 
1410  /*
1411  * It is safest to reset the ring buffer if the module being unloaded
1412  * registered any events.
1413  */
1414  if (found)
1416  up_write(&trace_event_mutex);
1417 }
1418 
1419 static int trace_module_notify(struct notifier_block *self,
1420  unsigned long val, void *data)
1421 {
1422  struct module *mod = data;
1423 
1424  mutex_lock(&event_mutex);
1425  switch (val) {
1426  case MODULE_STATE_COMING:
1427  trace_module_add_events(mod);
1428  break;
1429  case MODULE_STATE_GOING:
1430  trace_module_remove_events(mod);
1431  break;
1432  }
1433  mutex_unlock(&event_mutex);
1434 
1435  return 0;
1436 }
1437 #else
1438 static int trace_module_notify(struct notifier_block *self,
1439  unsigned long val, void *data)
1440 {
1441  return 0;
1442 }
1443 #endif /* CONFIG_MODULES */
1444 
1445 static struct notifier_block trace_module_nb = {
1446  .notifier_call = trace_module_notify,
1447  .priority = 0,
1448 };
1449 
1450 extern struct ftrace_event_call *__start_ftrace_events[];
1451 extern struct ftrace_event_call *__stop_ftrace_events[];
1452 
1453 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
1454 
1455 static __init int setup_trace_event(char *str)
1456 {
1457  strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
1460 
1461  return 1;
1462 }
1463 __setup("trace_event=", setup_trace_event);
1464 
1465 static __init int event_trace_enable(void)
1466 {
1467  struct ftrace_event_call **iter, *call;
1468  char *buf = bootup_event_buf;
1469  char *token;
1470  int ret;
1471 
1472  for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
1473 
1474  call = *iter;
1475  ret = event_init(call);
1476  if (!ret)
1477  list_add(&call->list, &ftrace_events);
1478  }
1479 
1480  while (true) {
1481  token = strsep(&buf, ",");
1482 
1483  if (!token)
1484  break;
1485  if (!*token)
1486  continue;
1487 
1488  ret = ftrace_set_clr_event(token, 1);
1489  if (ret)
1490  pr_warn("Failed to enable trace event: %s\n", token);
1491  }
1492  return 0;
1493 }
1494 
1495 static __init int event_trace_init(void)
1496 {
1497  struct ftrace_event_call *call;
1498  struct dentry *d_tracer;
1499  struct dentry *entry;
1500  struct dentry *d_events;
1501  int ret;
1502 
1503  d_tracer = tracing_init_dentry();
1504  if (!d_tracer)
1505  return 0;
1506 
1507  entry = debugfs_create_file("available_events", 0444, d_tracer,
1508  (void *)&show_event_seq_ops,
1509  &ftrace_avail_fops);
1510  if (!entry)
1511  pr_warning("Could not create debugfs "
1512  "'available_events' entry\n");
1513 
1514  entry = debugfs_create_file("set_event", 0644, d_tracer,
1515  (void *)&show_set_event_seq_ops,
1516  &ftrace_set_event_fops);
1517  if (!entry)
1518  pr_warning("Could not create debugfs "
1519  "'set_event' entry\n");
1520 
1521  d_events = event_trace_events_dir();
1522  if (!d_events)
1523  return 0;
1524 
1525  /* ring buffer internal formats */
1526  trace_create_file("header_page", 0444, d_events,
1528  &ftrace_show_header_fops);
1529 
1530  trace_create_file("header_event", 0444, d_events,
1532  &ftrace_show_header_fops);
1533 
1534  trace_create_file("enable", 0644, d_events,
1535  NULL, &ftrace_system_enable_fops);
1536 
1537  if (trace_define_common_fields())
1538  pr_warning("tracing: Failed to allocate common fields");
1539 
1540  /*
1541  * Early initialization already enabled ftrace event.
1542  * Now it's only necessary to create the event directory.
1543  */
1544  list_for_each_entry(call, &ftrace_events, list) {
1545 
1546  ret = event_create_dir(call, d_events,
1547  &ftrace_event_id_fops,
1548  &ftrace_enable_fops,
1549  &ftrace_event_filter_fops,
1550  &ftrace_event_format_fops);
1551  if (ret < 0)
1552  event_remove(call);
1553  }
1554 
1555  ret = register_module_notifier(&trace_module_nb);
1556  if (ret)
1557  pr_warning("Failed to register trace events module notifier\n");
1558 
1559  return 0;
1560 }
1561 core_initcall(event_trace_enable);
1562 fs_initcall(event_trace_init);
1563 
1564 #ifdef CONFIG_FTRACE_STARTUP_TEST
1565 
1566 static DEFINE_SPINLOCK(test_spinlock);
1567 static DEFINE_SPINLOCK(test_spinlock_irq);
1568 static DEFINE_MUTEX(test_mutex);
1569 
1570 static __init void test_work(struct work_struct *dummy)
1571 {
1572  spin_lock(&test_spinlock);
1573  spin_lock_irq(&test_spinlock_irq);
1574  udelay(1);
1575  spin_unlock_irq(&test_spinlock_irq);
1576  spin_unlock(&test_spinlock);
1577 
1578  mutex_lock(&test_mutex);
1579  msleep(1);
1580  mutex_unlock(&test_mutex);
1581 }
1582 
1583 static __init int event_test_thread(void *unused)
1584 {
1585  void *test_malloc;
1586 
1587  test_malloc = kmalloc(1234, GFP_KERNEL);
1588  if (!test_malloc)
1589  pr_info("failed to kmalloc\n");
1590 
1591  schedule_on_each_cpu(test_work);
1592 
1593  kfree(test_malloc);
1594 
1596  while (!kthread_should_stop())
1597  schedule();
1598 
1599  return 0;
1600 }
1601 
1602 /*
1603  * Do various things that may trigger events.
1604  */
1605 static __init void event_test_stuff(void)
1606 {
1607  struct task_struct *test_thread;
1608 
1609  test_thread = kthread_run(event_test_thread, NULL, "test-events");
1610  msleep(1);
1611  kthread_stop(test_thread);
1612 }
1613 
1614 /*
1615  * For every trace event defined, we will test each trace point separately,
1616  * and then by groups, and finally all trace points.
1617  */
1618 static __init void event_trace_self_tests(void)
1619 {
1620  struct ftrace_event_call *call;
1621  struct event_subsystem *system;
1622  int ret;
1623 
1624  pr_info("Running tests on trace events:\n");
1625 
1626  list_for_each_entry(call, &ftrace_events, list) {
1627 
1628  /* Only test those that have a probe */
1629  if (!call->class || !call->class->probe)
1630  continue;
1631 
1632 /*
1633  * Testing syscall events here is pretty useless, but
1634  * we still do it if configured. But this is time consuming.
1635  * What we really need is a user thread to perform the
1636  * syscalls as we test.
1637  */
1638 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
1639  if (call->class->system &&
1640  strcmp(call->class->system, "syscalls") == 0)
1641  continue;
1642 #endif
1643 
1644  pr_info("Testing event %s: ", call->name);
1645 
1646  /*
1647  * If an event is already enabled, someone is using
1648  * it and the self test should not be on.
1649  */
1650  if (call->flags & TRACE_EVENT_FL_ENABLED) {
1651  pr_warning("Enabled event during self test!\n");
1652  WARN_ON_ONCE(1);
1653  continue;
1654  }
1655 
1656  ftrace_event_enable_disable(call, 1);
1657  event_test_stuff();
1658  ftrace_event_enable_disable(call, 0);
1659 
1660  pr_cont("OK\n");
1661  }
1662 
1663  /* Now test at the sub system level */
1664 
1665  pr_info("Running tests on trace event systems:\n");
1666 
1667  list_for_each_entry(system, &event_subsystems, list) {
1668 
1669  /* the ftrace system is special, skip it */
1670  if (strcmp(system->name, "ftrace") == 0)
1671  continue;
1672 
1673  pr_info("Testing event system %s: ", system->name);
1674 
1675  ret = __ftrace_set_clr_event(NULL, system->name, NULL, 1);
1676  if (WARN_ON_ONCE(ret)) {
1677  pr_warning("error enabling system %s\n",
1678  system->name);
1679  continue;
1680  }
1681 
1682  event_test_stuff();
1683 
1684  ret = __ftrace_set_clr_event(NULL, system->name, NULL, 0);
1685  if (WARN_ON_ONCE(ret)) {
1686  pr_warning("error disabling system %s\n",
1687  system->name);
1688  continue;
1689  }
1690 
1691  pr_cont("OK\n");
1692  }
1693 
1694  /* Test with all events enabled */
1695 
1696  pr_info("Running tests on all trace events:\n");
1697  pr_info("Testing all events: ");
1698 
1699  ret = __ftrace_set_clr_event(NULL, NULL, NULL, 1);
1700  if (WARN_ON_ONCE(ret)) {
1701  pr_warning("error enabling all events\n");
1702  return;
1703  }
1704 
1705  event_test_stuff();
1706 
1707  /* reset sysname */
1708  ret = __ftrace_set_clr_event(NULL, NULL, NULL, 0);
1709  if (WARN_ON_ONCE(ret)) {
1710  pr_warning("error disabling all events\n");
1711  return;
1712  }
1713 
1714  pr_cont("OK\n");
1715 }
1716 
1717 #ifdef CONFIG_FUNCTION_TRACER
1718 
1719 static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
1720 
1721 static void
1722 function_test_events_call(unsigned long ip, unsigned long parent_ip,
1723  struct ftrace_ops *op, struct pt_regs *pt_regs)
1724 {
1725  struct ring_buffer_event *event;
1726  struct ring_buffer *buffer;
1727  struct ftrace_entry *entry;
1728  unsigned long flags;
1729  long disabled;
1730  int cpu;
1731  int pc;
1732 
1733  pc = preempt_count();
1735  cpu = raw_smp_processor_id();
1736  disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
1737 
1738  if (disabled != 1)
1739  goto out;
1740 
1741  local_save_flags(flags);
1742 
1743  event = trace_current_buffer_lock_reserve(&buffer,
1744  TRACE_FN, sizeof(*entry),
1745  flags, pc);
1746  if (!event)
1747  goto out;
1748  entry = ring_buffer_event_data(event);
1749  entry->ip = ip;
1750  entry->parent_ip = parent_ip;
1751 
1752  trace_nowake_buffer_unlock_commit(buffer, event, flags, pc);
1753 
1754  out:
1755  atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
1757 }
1758 
1759 static struct ftrace_ops trace_ops __initdata =
1760 {
1761  .func = function_test_events_call,
1762  .flags = FTRACE_OPS_FL_RECURSION_SAFE,
1763 };
1764 
1765 static __init void event_trace_self_test_with_function(void)
1766 {
1767  int ret;
1768  ret = register_ftrace_function(&trace_ops);
1769  if (WARN_ON(ret < 0)) {
1770  pr_info("Failed to enable function tracer for event tests\n");
1771  return;
1772  }
1773  pr_info("Running tests again, along with the function tracer\n");
1774  event_trace_self_tests();
1775  unregister_ftrace_function(&trace_ops);
1776 }
1777 #else
1778 static __init void event_trace_self_test_with_function(void)
1779 {
1780 }
1781 #endif
1782 
1783 static __init int event_trace_self_tests_init(void)
1784 {
1786  event_trace_self_tests();
1787  event_trace_self_test_with_function();
1788  }
1789 
1790  return 0;
1791 }
1792 
1793 late_initcall(event_trace_self_tests_init);
1794 
1795 #endif