tracing: Change remove_event_file_dir() to clear "d_subdirs"->i_private
[linux-3.10.git] / kernel / trace / trace_events.c
1 /*
2  * event tracer
3  *
4  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
5  *
6  *  - Added format output of fields of the trace point.
7  *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
8  *
9  */
10
11 #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
33 char event_storage[EVENT_STORAGE_SIZE];
34 EXPORT_SYMBOL_GPL(event_storage);
35
36 LIST_HEAD(ftrace_events);
37 static LIST_HEAD(ftrace_common_fields);
38
39 #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
40
41 static struct kmem_cache *field_cachep;
42 static struct kmem_cache *file_cachep;
43
44 #define SYSTEM_FL_FREE_NAME             (1 << 31)
45
46 static inline int system_refcount(struct event_subsystem *system)
47 {
48         return system->ref_count & ~SYSTEM_FL_FREE_NAME;
49 }
50
51 static int system_refcount_inc(struct event_subsystem *system)
52 {
53         return (system->ref_count++) & ~SYSTEM_FL_FREE_NAME;
54 }
55
56 static int system_refcount_dec(struct event_subsystem *system)
57 {
58         return (--system->ref_count) & ~SYSTEM_FL_FREE_NAME;
59 }
60
61 /* Double loops, do not use break, only goto's work */
62 #define do_for_each_event_file(tr, file)                        \
63         list_for_each_entry(tr, &ftrace_trace_arrays, list) {   \
64                 list_for_each_entry(file, &tr->events, list)
65
66 #define do_for_each_event_file_safe(tr, file)                   \
67         list_for_each_entry(tr, &ftrace_trace_arrays, list) {   \
68                 struct ftrace_event_file *___n;                         \
69                 list_for_each_entry_safe(file, ___n, &tr->events, list)
70
71 #define while_for_each_event_file()             \
72         }
73
74 static struct list_head *
75 trace_get_fields(struct ftrace_event_call *event_call)
76 {
77         if (!event_call->class->get_fields)
78                 return &event_call->class->fields;
79         return event_call->class->get_fields(event_call);
80 }
81
82 static struct ftrace_event_field *
83 __find_event_field(struct list_head *head, char *name)
84 {
85         struct ftrace_event_field *field;
86
87         list_for_each_entry(field, head, link) {
88                 if (!strcmp(field->name, name))
89                         return field;
90         }
91
92         return NULL;
93 }
94
95 struct ftrace_event_field *
96 trace_find_event_field(struct ftrace_event_call *call, char *name)
97 {
98         struct ftrace_event_field *field;
99         struct list_head *head;
100
101         field = __find_event_field(&ftrace_common_fields, name);
102         if (field)
103                 return field;
104
105         head = trace_get_fields(call);
106         return __find_event_field(head, name);
107 }
108
109 static int __trace_define_field(struct list_head *head, const char *type,
110                                 const char *name, int offset, int size,
111                                 int is_signed, int filter_type)
112 {
113         struct ftrace_event_field *field;
114
115         field = kmem_cache_alloc(field_cachep, GFP_TRACE);
116         if (!field)
117                 return -ENOMEM;
118
119         field->name = name;
120         field->type = type;
121
122         if (filter_type == FILTER_OTHER)
123                 field->filter_type = filter_assign_type(type);
124         else
125                 field->filter_type = filter_type;
126
127         field->offset = offset;
128         field->size = size;
129         field->is_signed = is_signed;
130
131         list_add(&field->link, head);
132
133         return 0;
134 }
135
136 int trace_define_field(struct ftrace_event_call *call, const char *type,
137                        const char *name, int offset, int size, int is_signed,
138                        int filter_type)
139 {
140         struct list_head *head;
141
142         if (WARN_ON(!call->class))
143                 return 0;
144
145         head = trace_get_fields(call);
146         return __trace_define_field(head, type, name, offset, size,
147                                     is_signed, filter_type);
148 }
149 EXPORT_SYMBOL_GPL(trace_define_field);
150
151 #define __common_field(type, item)                                      \
152         ret = __trace_define_field(&ftrace_common_fields, #type,        \
153                                    "common_" #item,                     \
154                                    offsetof(typeof(ent), item),         \
155                                    sizeof(ent.item),                    \
156                                    is_signed_type(type), FILTER_OTHER); \
157         if (ret)                                                        \
158                 return ret;
159
160 static int trace_define_common_fields(void)
161 {
162         int ret;
163         struct trace_entry ent;
164
165         __common_field(unsigned short, type);
166         __common_field(unsigned char, flags);
167         __common_field(unsigned char, preempt_count);
168         __common_field(int, pid);
169
170         return ret;
171 }
172
173 static void trace_destroy_fields(struct ftrace_event_call *call)
174 {
175         struct ftrace_event_field *field, *next;
176         struct list_head *head;
177
178         head = trace_get_fields(call);
179         list_for_each_entry_safe(field, next, head, link) {
180                 list_del(&field->link);
181                 kmem_cache_free(field_cachep, field);
182         }
183 }
184
185 int trace_event_raw_init(struct ftrace_event_call *call)
186 {
187         int id;
188
189         id = register_ftrace_event(&call->event);
190         if (!id)
191                 return -ENODEV;
192
193         return 0;
194 }
195 EXPORT_SYMBOL_GPL(trace_event_raw_init);
196
197 int ftrace_event_reg(struct ftrace_event_call *call,
198                      enum trace_reg type, void *data)
199 {
200         struct ftrace_event_file *file = data;
201
202         switch (type) {
203         case TRACE_REG_REGISTER:
204                 return tracepoint_probe_register(call->name,
205                                                  call->class->probe,
206                                                  file);
207         case TRACE_REG_UNREGISTER:
208                 tracepoint_probe_unregister(call->name,
209                                             call->class->probe,
210                                             file);
211                 return 0;
212
213 #ifdef CONFIG_PERF_EVENTS
214         case TRACE_REG_PERF_REGISTER:
215                 return tracepoint_probe_register(call->name,
216                                                  call->class->perf_probe,
217                                                  call);
218         case TRACE_REG_PERF_UNREGISTER:
219                 tracepoint_probe_unregister(call->name,
220                                             call->class->perf_probe,
221                                             call);
222                 return 0;
223         case TRACE_REG_PERF_OPEN:
224         case TRACE_REG_PERF_CLOSE:
225         case TRACE_REG_PERF_ADD:
226         case TRACE_REG_PERF_DEL:
227                 return 0;
228 #endif
229         }
230         return 0;
231 }
232 EXPORT_SYMBOL_GPL(ftrace_event_reg);
233
234 void trace_event_enable_cmd_record(bool enable)
235 {
236         struct ftrace_event_file *file;
237         struct trace_array *tr;
238
239         mutex_lock(&event_mutex);
240         do_for_each_event_file(tr, file) {
241
242                 if (!(file->flags & FTRACE_EVENT_FL_ENABLED))
243                         continue;
244
245                 if (enable) {
246                         tracing_start_cmdline_record();
247                         set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
248                 } else {
249                         tracing_stop_cmdline_record();
250                         clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
251                 }
252         } while_for_each_event_file();
253         mutex_unlock(&event_mutex);
254 }
255
256 static int __ftrace_event_enable_disable(struct ftrace_event_file *file,
257                                          int enable, int soft_disable)
258 {
259         struct ftrace_event_call *call = file->event_call;
260         int ret = 0;
261         int disable;
262
263         switch (enable) {
264         case 0:
265                 /*
266                  * When soft_disable is set and enable is cleared, the sm_ref
267                  * reference counter is decremented. If it reaches 0, we want
268                  * to clear the SOFT_DISABLED flag but leave the event in the
269                  * state that it was. That is, if the event was enabled and
270                  * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
271                  * is set we do not want the event to be enabled before we
272                  * clear the bit.
273                  *
274                  * When soft_disable is not set but the SOFT_MODE flag is,
275                  * we do nothing. Do not disable the tracepoint, otherwise
276                  * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
277                  */
278                 if (soft_disable) {
279                         if (atomic_dec_return(&file->sm_ref) > 0)
280                                 break;
281                         disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED;
282                         clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);
283                 } else
284                         disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE);
285
286                 if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) {
287                         clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);
288                         if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) {
289                                 tracing_stop_cmdline_record();
290                                 clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
291                         }
292                         call->class->reg(call, TRACE_REG_UNREGISTER, file);
293                 }
294                 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT */
295                 if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)
296                         set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
297                 break;
298         case 1:
299                 /*
300                  * When soft_disable is set and enable is set, we want to
301                  * register the tracepoint for the event, but leave the event
302                  * as is. That means, if the event was already enabled, we do
303                  * nothing (but set SOFT_MODE). If the event is disabled, we
304                  * set SOFT_DISABLED before enabling the event tracepoint, so
305                  * it still seems to be disabled.
306                  */
307                 if (!soft_disable)
308                         clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
309                 else {
310                         if (atomic_inc_return(&file->sm_ref) > 1)
311                                 break;
312                         set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);
313                 }
314
315                 if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) {
316
317                         /* Keep the event disabled, when going to SOFT_MODE. */
318                         if (soft_disable)
319                                 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
320
321                         if (trace_flags & TRACE_ITER_RECORD_CMD) {
322                                 tracing_start_cmdline_record();
323                                 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
324                         }
325                         ret = call->class->reg(call, TRACE_REG_REGISTER, file);
326                         if (ret) {
327                                 tracing_stop_cmdline_record();
328                                 pr_info("event trace: Could not enable event "
329                                         "%s\n", call->name);
330                                 break;
331                         }
332                         set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);
333
334                         /* WAS_ENABLED gets set but never cleared. */
335                         call->flags |= TRACE_EVENT_FL_WAS_ENABLED;
336                 }
337                 break;
338         }
339
340         return ret;
341 }
342
343 static int ftrace_event_enable_disable(struct ftrace_event_file *file,
344                                        int enable)
345 {
346         return __ftrace_event_enable_disable(file, enable, 0);
347 }
348
349 static void ftrace_clear_events(struct trace_array *tr)
350 {
351         struct ftrace_event_file *file;
352
353         mutex_lock(&event_mutex);
354         list_for_each_entry(file, &tr->events, list) {
355                 ftrace_event_enable_disable(file, 0);
356         }
357         mutex_unlock(&event_mutex);
358 }
359
360 static void __put_system(struct event_subsystem *system)
361 {
362         struct event_filter *filter = system->filter;
363
364         WARN_ON_ONCE(system_refcount(system) == 0);
365         if (system_refcount_dec(system))
366                 return;
367
368         list_del(&system->list);
369
370         if (filter) {
371                 kfree(filter->filter_string);
372                 kfree(filter);
373         }
374         if (system->ref_count & SYSTEM_FL_FREE_NAME)
375                 kfree(system->name);
376         kfree(system);
377 }
378
379 static void __get_system(struct event_subsystem *system)
380 {
381         WARN_ON_ONCE(system_refcount(system) == 0);
382         system_refcount_inc(system);
383 }
384
385 static void __get_system_dir(struct ftrace_subsystem_dir *dir)
386 {
387         WARN_ON_ONCE(dir->ref_count == 0);
388         dir->ref_count++;
389         __get_system(dir->subsystem);
390 }
391
392 static void __put_system_dir(struct ftrace_subsystem_dir *dir)
393 {
394         WARN_ON_ONCE(dir->ref_count == 0);
395         /* If the subsystem is about to be freed, the dir must be too */
396         WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
397
398         __put_system(dir->subsystem);
399         if (!--dir->ref_count)
400                 kfree(dir);
401 }
402
403 static void put_system(struct ftrace_subsystem_dir *dir)
404 {
405         mutex_lock(&event_mutex);
406         __put_system_dir(dir);
407         mutex_unlock(&event_mutex);
408 }
409
410 static void remove_subsystem(struct ftrace_subsystem_dir *dir)
411 {
412         if (!dir)
413                 return;
414
415         if (!--dir->nr_events) {
416                 debugfs_remove_recursive(dir->entry);
417                 list_del(&dir->list);
418                 __put_system_dir(dir);
419         }
420 }
421
422 static void *event_file_data(struct file *filp)
423 {
424         return ACCESS_ONCE(file_inode(filp)->i_private);
425 }
426
427 static void remove_event_file_dir(struct ftrace_event_file *file)
428 {
429         struct dentry *dir = file->dir;
430         struct dentry *child;
431
432         if (dir) {
433                 spin_lock(&dir->d_lock);        /* probably unneeded */
434                 list_for_each_entry(child, &dir->d_subdirs, d_u.d_child) {
435                         if (child->d_inode)     /* probably unneeded */
436                                 child->d_inode->i_private = NULL;
437                 }
438                 spin_unlock(&dir->d_lock);
439
440                 debugfs_remove_recursive(dir);
441         }
442
443         list_del(&file->list);
444         remove_subsystem(file->system);
445         kmem_cache_free(file_cachep, file);
446 }
447
448 /*
449  * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
450  */
451 static int
452 __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
453                               const char *sub, const char *event, int set)
454 {
455         struct ftrace_event_file *file;
456         struct ftrace_event_call *call;
457         int ret = -EINVAL;
458
459         list_for_each_entry(file, &tr->events, list) {
460
461                 call = file->event_call;
462
463                 if (!call->name || !call->class || !call->class->reg)
464                         continue;
465
466                 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
467                         continue;
468
469                 if (match &&
470                     strcmp(match, call->name) != 0 &&
471                     strcmp(match, call->class->system) != 0)
472                         continue;
473
474                 if (sub && strcmp(sub, call->class->system) != 0)
475                         continue;
476
477                 if (event && strcmp(event, call->name) != 0)
478                         continue;
479
480                 ftrace_event_enable_disable(file, set);
481
482                 ret = 0;
483         }
484
485         return ret;
486 }
487
488 static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
489                                   const char *sub, const char *event, int set)
490 {
491         int ret;
492
493         mutex_lock(&event_mutex);
494         ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
495         mutex_unlock(&event_mutex);
496
497         return ret;
498 }
499
500 static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
501 {
502         char *event = NULL, *sub = NULL, *match;
503
504         /*
505          * The buf format can be <subsystem>:<event-name>
506          *  *:<event-name> means any event by that name.
507          *  :<event-name> is the same.
508          *
509          *  <subsystem>:* means all events in that subsystem
510          *  <subsystem>: means the same.
511          *
512          *  <name> (no ':') means all events in a subsystem with
513          *  the name <name> or any event that matches <name>
514          */
515
516         match = strsep(&buf, ":");
517         if (buf) {
518                 sub = match;
519                 event = buf;
520                 match = NULL;
521
522                 if (!strlen(sub) || strcmp(sub, "*") == 0)
523                         sub = NULL;
524                 if (!strlen(event) || strcmp(event, "*") == 0)
525                         event = NULL;
526         }
527
528         return __ftrace_set_clr_event(tr, match, sub, event, set);
529 }
530
531 /**
532  * trace_set_clr_event - enable or disable an event
533  * @system: system name to match (NULL for any system)
534  * @event: event name to match (NULL for all events, within system)
535  * @set: 1 to enable, 0 to disable
536  *
537  * This is a way for other parts of the kernel to enable or disable
538  * event recording.
539  *
540  * Returns 0 on success, -EINVAL if the parameters do not match any
541  * registered events.
542  */
543 int trace_set_clr_event(const char *system, const char *event, int set)
544 {
545         struct trace_array *tr = top_trace_array();
546
547         return __ftrace_set_clr_event(tr, NULL, system, event, set);
548 }
549 EXPORT_SYMBOL_GPL(trace_set_clr_event);
550
551 /* 128 should be much more than enough */
552 #define EVENT_BUF_SIZE          127
553
554 static ssize_t
555 ftrace_event_write(struct file *file, const char __user *ubuf,
556                    size_t cnt, loff_t *ppos)
557 {
558         struct trace_parser parser;
559         struct seq_file *m = file->private_data;
560         struct trace_array *tr = m->private;
561         ssize_t read, ret;
562
563         if (!cnt)
564                 return 0;
565
566         ret = tracing_update_buffers();
567         if (ret < 0)
568                 return ret;
569
570         if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
571                 return -ENOMEM;
572
573         read = trace_get_user(&parser, ubuf, cnt, ppos);
574
575         if (read >= 0 && trace_parser_loaded((&parser))) {
576                 int set = 1;
577
578                 if (*parser.buffer == '!')
579                         set = 0;
580
581                 parser.buffer[parser.idx] = 0;
582
583                 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);
584                 if (ret)
585                         goto out_put;
586         }
587
588         ret = read;
589
590  out_put:
591         trace_parser_put(&parser);
592
593         return ret;
594 }
595
596 static void *
597 t_next(struct seq_file *m, void *v, loff_t *pos)
598 {
599         struct ftrace_event_file *file = v;
600         struct ftrace_event_call *call;
601         struct trace_array *tr = m->private;
602
603         (*pos)++;
604
605         list_for_each_entry_continue(file, &tr->events, list) {
606                 call = file->event_call;
607                 /*
608                  * The ftrace subsystem is for showing formats only.
609                  * They can not be enabled or disabled via the event files.
610                  */
611                 if (call->class && call->class->reg)
612                         return file;
613         }
614
615         return NULL;
616 }
617
618 static void *t_start(struct seq_file *m, loff_t *pos)
619 {
620         struct ftrace_event_file *file;
621         struct trace_array *tr = m->private;
622         loff_t l;
623
624         mutex_lock(&event_mutex);
625
626         file = list_entry(&tr->events, struct ftrace_event_file, list);
627         for (l = 0; l <= *pos; ) {
628                 file = t_next(m, file, &l);
629                 if (!file)
630                         break;
631         }
632         return file;
633 }
634
635 static void *
636 s_next(struct seq_file *m, void *v, loff_t *pos)
637 {
638         struct ftrace_event_file *file = v;
639         struct trace_array *tr = m->private;
640
641         (*pos)++;
642
643         list_for_each_entry_continue(file, &tr->events, list) {
644                 if (file->flags & FTRACE_EVENT_FL_ENABLED)
645                         return file;
646         }
647
648         return NULL;
649 }
650
651 static void *s_start(struct seq_file *m, loff_t *pos)
652 {
653         struct ftrace_event_file *file;
654         struct trace_array *tr = m->private;
655         loff_t l;
656
657         mutex_lock(&event_mutex);
658
659         file = list_entry(&tr->events, struct ftrace_event_file, list);
660         for (l = 0; l <= *pos; ) {
661                 file = s_next(m, file, &l);
662                 if (!file)
663                         break;
664         }
665         return file;
666 }
667
668 static int t_show(struct seq_file *m, void *v)
669 {
670         struct ftrace_event_file *file = v;
671         struct ftrace_event_call *call = file->event_call;
672
673         if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
674                 seq_printf(m, "%s:", call->class->system);
675         seq_printf(m, "%s\n", call->name);
676
677         return 0;
678 }
679
680 static void t_stop(struct seq_file *m, void *p)
681 {
682         mutex_unlock(&event_mutex);
683 }
684
685 static ssize_t
686 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
687                   loff_t *ppos)
688 {
689         struct ftrace_event_file *file;
690         unsigned long flags;
691         char *buf;
692
693         mutex_lock(&event_mutex);
694         file = event_file_data(filp);
695         if (likely(file))
696                 flags = file->flags;
697         mutex_unlock(&event_mutex);
698
699         if (!file)
700                 return -ENODEV;
701
702         if (flags & FTRACE_EVENT_FL_ENABLED) {
703                 if (flags & FTRACE_EVENT_FL_SOFT_DISABLED)
704                         buf = "0*\n";
705                 else if (flags & FTRACE_EVENT_FL_SOFT_MODE)
706                         buf = "1*\n";
707                 else
708                         buf = "1\n";
709         } else
710                 buf = "0\n";
711
712         return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
713 }
714
715 static ssize_t
716 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
717                    loff_t *ppos)
718 {
719         struct ftrace_event_file *file;
720         unsigned long val;
721         int ret;
722
723         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
724         if (ret)
725                 return ret;
726
727         ret = tracing_update_buffers();
728         if (ret < 0)
729                 return ret;
730
731         switch (val) {
732         case 0:
733         case 1:
734                 ret = -ENODEV;
735                 mutex_lock(&event_mutex);
736                 file = event_file_data(filp);
737                 if (likely(file))
738                         ret = ftrace_event_enable_disable(file, val);
739                 mutex_unlock(&event_mutex);
740                 break;
741
742         default:
743                 return -EINVAL;
744         }
745
746         *ppos += cnt;
747
748         return ret ? ret : cnt;
749 }
750
751 static ssize_t
752 system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
753                    loff_t *ppos)
754 {
755         const char set_to_char[4] = { '?', '0', '1', 'X' };
756         struct ftrace_subsystem_dir *dir = filp->private_data;
757         struct event_subsystem *system = dir->subsystem;
758         struct ftrace_event_call *call;
759         struct ftrace_event_file *file;
760         struct trace_array *tr = dir->tr;
761         char buf[2];
762         int set = 0;
763         int ret;
764
765         mutex_lock(&event_mutex);
766         list_for_each_entry(file, &tr->events, list) {
767                 call = file->event_call;
768                 if (!call->name || !call->class || !call->class->reg)
769                         continue;
770
771                 if (system && strcmp(call->class->system, system->name) != 0)
772                         continue;
773
774                 /*
775                  * We need to find out if all the events are set
776                  * or if all events or cleared, or if we have
777                  * a mixture.
778                  */
779                 set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED));
780
781                 /*
782                  * If we have a mixture, no need to look further.
783                  */
784                 if (set == 3)
785                         break;
786         }
787         mutex_unlock(&event_mutex);
788
789         buf[0] = set_to_char[set];
790         buf[1] = '\n';
791
792         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
793
794         return ret;
795 }
796
797 static ssize_t
798 system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
799                     loff_t *ppos)
800 {
801         struct ftrace_subsystem_dir *dir = filp->private_data;
802         struct event_subsystem *system = dir->subsystem;
803         const char *name = NULL;
804         unsigned long val;
805         ssize_t ret;
806
807         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
808         if (ret)
809                 return ret;
810
811         ret = tracing_update_buffers();
812         if (ret < 0)
813                 return ret;
814
815         if (val != 0 && val != 1)
816                 return -EINVAL;
817
818         /*
819          * Opening of "enable" adds a ref count to system,
820          * so the name is safe to use.
821          */
822         if (system)
823                 name = system->name;
824
825         ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);
826         if (ret)
827                 goto out;
828
829         ret = cnt;
830
831 out:
832         *ppos += cnt;
833
834         return ret;
835 }
836
837 enum {
838         FORMAT_HEADER           = 1,
839         FORMAT_FIELD_SEPERATOR  = 2,
840         FORMAT_PRINTFMT         = 3,
841 };
842
843 static void *f_next(struct seq_file *m, void *v, loff_t *pos)
844 {
845         struct ftrace_event_call *call = event_file_data(m->private);
846         struct ftrace_event_field *field;
847         struct list_head *common_head = &ftrace_common_fields;
848         struct list_head *head = trace_get_fields(call);
849
850         (*pos)++;
851
852         switch ((unsigned long)v) {
853         case FORMAT_HEADER:
854                 if (unlikely(list_empty(common_head)))
855                         return NULL;
856
857                 field = list_entry(common_head->prev,
858                                    struct ftrace_event_field, link);
859                 return field;
860
861         case FORMAT_FIELD_SEPERATOR:
862                 if (unlikely(list_empty(head)))
863                         return NULL;
864
865                 field = list_entry(head->prev, struct ftrace_event_field, link);
866                 return field;
867
868         case FORMAT_PRINTFMT:
869                 /* all done */
870                 return NULL;
871         }
872
873         field = v;
874         if (field->link.prev == common_head)
875                 return (void *)FORMAT_FIELD_SEPERATOR;
876         else if (field->link.prev == head)
877                 return (void *)FORMAT_PRINTFMT;
878
879         field = list_entry(field->link.prev, struct ftrace_event_field, link);
880
881         return field;
882 }
883
884 static void *f_start(struct seq_file *m, loff_t *pos)
885 {
886         loff_t l = 0;
887         void *p;
888
889         /* ->stop() is called even if ->start() fails */
890         mutex_lock(&event_mutex);
891         if (!event_file_data(m->private))
892                 return ERR_PTR(-ENODEV);
893
894         /* Start by showing the header */
895         if (!*pos)
896                 return (void *)FORMAT_HEADER;
897
898         p = (void *)FORMAT_HEADER;
899         do {
900                 p = f_next(m, p, &l);
901         } while (p && l < *pos);
902
903         return p;
904 }
905
906 static int f_show(struct seq_file *m, void *v)
907 {
908         struct ftrace_event_call *call = event_file_data(m->private);
909         struct ftrace_event_field *field;
910         const char *array_descriptor;
911
912         switch ((unsigned long)v) {
913         case FORMAT_HEADER:
914                 seq_printf(m, "name: %s\n", call->name);
915                 seq_printf(m, "ID: %d\n", call->event.type);
916                 seq_printf(m, "format:\n");
917                 return 0;
918
919         case FORMAT_FIELD_SEPERATOR:
920                 seq_putc(m, '\n');
921                 return 0;
922
923         case FORMAT_PRINTFMT:
924                 seq_printf(m, "\nprint fmt: %s\n",
925                            call->print_fmt);
926                 return 0;
927         }
928
929         field = v;
930
931         /*
932          * Smartly shows the array type(except dynamic array).
933          * Normal:
934          *      field:TYPE VAR
935          * If TYPE := TYPE[LEN], it is shown:
936          *      field:TYPE VAR[LEN]
937          */
938         array_descriptor = strchr(field->type, '[');
939
940         if (!strncmp(field->type, "__data_loc", 10))
941                 array_descriptor = NULL;
942
943         if (!array_descriptor)
944                 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
945                            field->type, field->name, field->offset,
946                            field->size, !!field->is_signed);
947         else
948                 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
949                            (int)(array_descriptor - field->type),
950                            field->type, field->name,
951                            array_descriptor, field->offset,
952                            field->size, !!field->is_signed);
953
954         return 0;
955 }
956
957 static void f_stop(struct seq_file *m, void *p)
958 {
959         mutex_unlock(&event_mutex);
960 }
961
962 static const struct seq_operations trace_format_seq_ops = {
963         .start          = f_start,
964         .next           = f_next,
965         .stop           = f_stop,
966         .show           = f_show,
967 };
968
969 static int trace_format_open(struct inode *inode, struct file *file)
970 {
971         struct seq_file *m;
972         int ret;
973
974         ret = seq_open(file, &trace_format_seq_ops);
975         if (ret < 0)
976                 return ret;
977
978         m = file->private_data;
979         m->private = file;
980
981         return 0;
982 }
983
984 static ssize_t
985 event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
986 {
987         int id = (long)event_file_data(filp);
988         struct trace_seq *s;
989         int r;
990
991         if (*ppos)
992                 return 0;
993
994         if (unlikely(!id))
995                 return -ENODEV;
996
997         s = kmalloc(sizeof(*s), GFP_KERNEL);
998         if (!s)
999                 return -ENOMEM;
1000
1001         trace_seq_init(s);
1002         trace_seq_printf(s, "%d\n", id);
1003
1004         r = simple_read_from_buffer(ubuf, cnt, ppos,
1005                                     s->buffer, s->len);
1006         kfree(s);
1007         return r;
1008 }
1009
1010 static ssize_t
1011 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1012                   loff_t *ppos)
1013 {
1014         struct ftrace_event_call *call;
1015         struct trace_seq *s;
1016         int r = -ENODEV;
1017
1018         if (*ppos)
1019                 return 0;
1020
1021         s = kmalloc(sizeof(*s), GFP_KERNEL);
1022
1023         if (!s)
1024                 return -ENOMEM;
1025
1026         trace_seq_init(s);
1027
1028         mutex_lock(&event_mutex);
1029         call = event_file_data(filp);
1030         if (call)
1031                 print_event_filter(call, s);
1032         mutex_unlock(&event_mutex);
1033
1034         if (call)
1035                 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
1036
1037         kfree(s);
1038
1039         return r;
1040 }
1041
1042 static ssize_t
1043 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1044                    loff_t *ppos)
1045 {
1046         struct ftrace_event_call *call;
1047         char *buf;
1048         int err = -ENODEV;
1049
1050         if (cnt >= PAGE_SIZE)
1051                 return -EINVAL;
1052
1053         buf = (char *)__get_free_page(GFP_TEMPORARY);
1054         if (!buf)
1055                 return -ENOMEM;
1056
1057         if (copy_from_user(buf, ubuf, cnt)) {
1058                 free_page((unsigned long) buf);
1059                 return -EFAULT;
1060         }
1061         buf[cnt] = '\0';
1062
1063         mutex_lock(&event_mutex);
1064         call = event_file_data(filp);
1065         if (call)
1066                 err = apply_event_filter(call, buf);
1067         mutex_unlock(&event_mutex);
1068
1069         free_page((unsigned long) buf);
1070         if (err < 0)
1071                 return err;
1072
1073         *ppos += cnt;
1074
1075         return cnt;
1076 }
1077
1078 static LIST_HEAD(event_subsystems);
1079
1080 static int subsystem_open(struct inode *inode, struct file *filp)
1081 {
1082         struct event_subsystem *system = NULL;
1083         struct ftrace_subsystem_dir *dir = NULL; /* Initialize for gcc */
1084         struct trace_array *tr;
1085         int ret;
1086
1087         /* Make sure the system still exists */
1088         mutex_lock(&trace_types_lock);
1089         mutex_lock(&event_mutex);
1090         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
1091                 list_for_each_entry(dir, &tr->systems, list) {
1092                         if (dir == inode->i_private) {
1093                                 /* Don't open systems with no events */
1094                                 if (dir->nr_events) {
1095                                         __get_system_dir(dir);
1096                                         system = dir->subsystem;
1097                                 }
1098                                 goto exit_loop;
1099                         }
1100                 }
1101         }
1102  exit_loop:
1103         mutex_unlock(&event_mutex);
1104         mutex_unlock(&trace_types_lock);
1105
1106         if (!system)
1107                 return -ENODEV;
1108
1109         /* Some versions of gcc think dir can be uninitialized here */
1110         WARN_ON(!dir);
1111
1112         /* Still need to increment the ref count of the system */
1113         if (trace_array_get(tr) < 0) {
1114                 put_system(dir);
1115                 return -ENODEV;
1116         }
1117
1118         ret = tracing_open_generic(inode, filp);
1119         if (ret < 0) {
1120                 trace_array_put(tr);
1121                 put_system(dir);
1122         }
1123
1124         return ret;
1125 }
1126
1127 static int system_tr_open(struct inode *inode, struct file *filp)
1128 {
1129         struct ftrace_subsystem_dir *dir;
1130         struct trace_array *tr = inode->i_private;
1131         int ret;
1132
1133         if (trace_array_get(tr) < 0)
1134                 return -ENODEV;
1135
1136         /* Make a temporary dir that has no system but points to tr */
1137         dir = kzalloc(sizeof(*dir), GFP_KERNEL);
1138         if (!dir) {
1139                 trace_array_put(tr);
1140                 return -ENOMEM;
1141         }
1142
1143         dir->tr = tr;
1144
1145         ret = tracing_open_generic(inode, filp);
1146         if (ret < 0) {
1147                 trace_array_put(tr);
1148                 kfree(dir);
1149         }
1150
1151         filp->private_data = dir;
1152
1153         return ret;
1154 }
1155
1156 static int subsystem_release(struct inode *inode, struct file *file)
1157 {
1158         struct ftrace_subsystem_dir *dir = file->private_data;
1159
1160         trace_array_put(dir->tr);
1161
1162         /*
1163          * If dir->subsystem is NULL, then this is a temporary
1164          * descriptor that was made for a trace_array to enable
1165          * all subsystems.
1166          */
1167         if (dir->subsystem)
1168                 put_system(dir);
1169         else
1170                 kfree(dir);
1171
1172         return 0;
1173 }
1174
1175 static ssize_t
1176 subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1177                       loff_t *ppos)
1178 {
1179         struct ftrace_subsystem_dir *dir = filp->private_data;
1180         struct event_subsystem *system = dir->subsystem;
1181         struct trace_seq *s;
1182         int r;
1183
1184         if (*ppos)
1185                 return 0;
1186
1187         s = kmalloc(sizeof(*s), GFP_KERNEL);
1188         if (!s)
1189                 return -ENOMEM;
1190
1191         trace_seq_init(s);
1192
1193         print_subsystem_event_filter(system, s);
1194         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
1195
1196         kfree(s);
1197
1198         return r;
1199 }
1200
1201 static ssize_t
1202 subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1203                        loff_t *ppos)
1204 {
1205         struct ftrace_subsystem_dir *dir = filp->private_data;
1206         char *buf;
1207         int err;
1208
1209         if (cnt >= PAGE_SIZE)
1210                 return -EINVAL;
1211
1212         buf = (char *)__get_free_page(GFP_TEMPORARY);
1213         if (!buf)
1214                 return -ENOMEM;
1215
1216         if (copy_from_user(buf, ubuf, cnt)) {
1217                 free_page((unsigned long) buf);
1218                 return -EFAULT;
1219         }
1220         buf[cnt] = '\0';
1221
1222         err = apply_subsystem_event_filter(dir, buf);
1223         free_page((unsigned long) buf);
1224         if (err < 0)
1225                 return err;
1226
1227         *ppos += cnt;
1228
1229         return cnt;
1230 }
1231
1232 static ssize_t
1233 show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1234 {
1235         int (*func)(struct trace_seq *s) = filp->private_data;
1236         struct trace_seq *s;
1237         int r;
1238
1239         if (*ppos)
1240                 return 0;
1241
1242         s = kmalloc(sizeof(*s), GFP_KERNEL);
1243         if (!s)
1244                 return -ENOMEM;
1245
1246         trace_seq_init(s);
1247
1248         func(s);
1249         r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
1250
1251         kfree(s);
1252
1253         return r;
1254 }
1255
1256 static int ftrace_event_avail_open(struct inode *inode, struct file *file);
1257 static int ftrace_event_set_open(struct inode *inode, struct file *file);
1258 static int ftrace_event_release(struct inode *inode, struct file *file);
1259
1260 static const struct seq_operations show_event_seq_ops = {
1261         .start = t_start,
1262         .next = t_next,
1263         .show = t_show,
1264         .stop = t_stop,
1265 };
1266
1267 static const struct seq_operations show_set_event_seq_ops = {
1268         .start = s_start,
1269         .next = s_next,
1270         .show = t_show,
1271         .stop = t_stop,
1272 };
1273
1274 static const struct file_operations ftrace_avail_fops = {
1275         .open = ftrace_event_avail_open,
1276         .read = seq_read,
1277         .llseek = seq_lseek,
1278         .release = seq_release,
1279 };
1280
1281 static const struct file_operations ftrace_set_event_fops = {
1282         .open = ftrace_event_set_open,
1283         .read = seq_read,
1284         .write = ftrace_event_write,
1285         .llseek = seq_lseek,
1286         .release = ftrace_event_release,
1287 };
1288
1289 static const struct file_operations ftrace_enable_fops = {
1290         .open = tracing_open_generic,
1291         .read = event_enable_read,
1292         .write = event_enable_write,
1293         .llseek = default_llseek,
1294 };
1295
1296 static const struct file_operations ftrace_event_format_fops = {
1297         .open = trace_format_open,
1298         .read = seq_read,
1299         .llseek = seq_lseek,
1300         .release = seq_release,
1301 };
1302
1303 static const struct file_operations ftrace_event_id_fops = {
1304         .read = event_id_read,
1305         .llseek = default_llseek,
1306 };
1307
1308 static const struct file_operations ftrace_event_filter_fops = {
1309         .open = tracing_open_generic,
1310         .read = event_filter_read,
1311         .write = event_filter_write,
1312         .llseek = default_llseek,
1313 };
1314
1315 static const struct file_operations ftrace_subsystem_filter_fops = {
1316         .open = subsystem_open,
1317         .read = subsystem_filter_read,
1318         .write = subsystem_filter_write,
1319         .llseek = default_llseek,
1320         .release = subsystem_release,
1321 };
1322
1323 static const struct file_operations ftrace_system_enable_fops = {
1324         .open = subsystem_open,
1325         .read = system_enable_read,
1326         .write = system_enable_write,
1327         .llseek = default_llseek,
1328         .release = subsystem_release,
1329 };
1330
1331 static const struct file_operations ftrace_tr_enable_fops = {
1332         .open = system_tr_open,
1333         .read = system_enable_read,
1334         .write = system_enable_write,
1335         .llseek = default_llseek,
1336         .release = subsystem_release,
1337 };
1338
1339 static const struct file_operations ftrace_show_header_fops = {
1340         .open = tracing_open_generic,
1341         .read = show_header,
1342         .llseek = default_llseek,
1343 };
1344
1345 static int
1346 ftrace_event_open(struct inode *inode, struct file *file,
1347                   const struct seq_operations *seq_ops)
1348 {
1349         struct seq_file *m;
1350         int ret;
1351
1352         ret = seq_open(file, seq_ops);
1353         if (ret < 0)
1354                 return ret;
1355         m = file->private_data;
1356         /* copy tr over to seq ops */
1357         m->private = inode->i_private;
1358
1359         return ret;
1360 }
1361
1362 static int ftrace_event_release(struct inode *inode, struct file *file)
1363 {
1364         struct trace_array *tr = inode->i_private;
1365
1366         trace_array_put(tr);
1367
1368         return seq_release(inode, file);
1369 }
1370
1371 static int
1372 ftrace_event_avail_open(struct inode *inode, struct file *file)
1373 {
1374         const struct seq_operations *seq_ops = &show_event_seq_ops;
1375
1376         return ftrace_event_open(inode, file, seq_ops);
1377 }
1378
1379 static int
1380 ftrace_event_set_open(struct inode *inode, struct file *file)
1381 {
1382         const struct seq_operations *seq_ops = &show_set_event_seq_ops;
1383         struct trace_array *tr = inode->i_private;
1384         int ret;
1385
1386         if (trace_array_get(tr) < 0)
1387                 return -ENODEV;
1388
1389         if ((file->f_mode & FMODE_WRITE) &&
1390             (file->f_flags & O_TRUNC))
1391                 ftrace_clear_events(tr);
1392
1393         ret = ftrace_event_open(inode, file, seq_ops);
1394         if (ret < 0)
1395                 trace_array_put(tr);
1396         return ret;
1397 }
1398
1399 static struct event_subsystem *
1400 create_new_subsystem(const char *name)
1401 {
1402         struct event_subsystem *system;
1403
1404         /* need to create new entry */
1405         system = kmalloc(sizeof(*system), GFP_KERNEL);
1406         if (!system)
1407                 return NULL;
1408
1409         system->ref_count = 1;
1410
1411         /* Only allocate if dynamic (kprobes and modules) */
1412         if (!core_kernel_data((unsigned long)name)) {
1413                 system->ref_count |= SYSTEM_FL_FREE_NAME;
1414                 system->name = kstrdup(name, GFP_KERNEL);
1415                 if (!system->name)
1416                         goto out_free;
1417         } else
1418                 system->name = name;
1419
1420         system->filter = NULL;
1421
1422         system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
1423         if (!system->filter)
1424                 goto out_free;
1425
1426         list_add(&system->list, &event_subsystems);
1427
1428         return system;
1429
1430  out_free:
1431         if (system->ref_count & SYSTEM_FL_FREE_NAME)
1432                 kfree(system->name);
1433         kfree(system);
1434         return NULL;
1435 }
1436
1437 static struct dentry *
1438 event_subsystem_dir(struct trace_array *tr, const char *name,
1439                     struct ftrace_event_file *file, struct dentry *parent)
1440 {
1441         struct ftrace_subsystem_dir *dir;
1442         struct event_subsystem *system;
1443         struct dentry *entry;
1444
1445         /* First see if we did not already create this dir */
1446         list_for_each_entry(dir, &tr->systems, list) {
1447                 system = dir->subsystem;
1448                 if (strcmp(system->name, name) == 0) {
1449                         dir->nr_events++;
1450                         file->system = dir;
1451                         return dir->entry;
1452                 }
1453         }
1454
1455         /* Now see if the system itself exists. */
1456         list_for_each_entry(system, &event_subsystems, list) {
1457                 if (strcmp(system->name, name) == 0)
1458                         break;
1459         }
1460         /* Reset system variable when not found */
1461         if (&system->list == &event_subsystems)
1462                 system = NULL;
1463
1464         dir = kmalloc(sizeof(*dir), GFP_KERNEL);
1465         if (!dir)
1466                 goto out_fail;
1467
1468         if (!system) {
1469                 system = create_new_subsystem(name);
1470                 if (!system)
1471                         goto out_free;
1472         } else
1473                 __get_system(system);
1474
1475         dir->entry = debugfs_create_dir(name, parent);
1476         if (!dir->entry) {
1477                 pr_warning("Failed to create system directory %s\n", name);
1478                 __put_system(system);
1479                 goto out_free;
1480         }
1481
1482         dir->tr = tr;
1483         dir->ref_count = 1;
1484         dir->nr_events = 1;
1485         dir->subsystem = system;
1486         file->system = dir;
1487
1488         entry = debugfs_create_file("filter", 0644, dir->entry, dir,
1489                                     &ftrace_subsystem_filter_fops);
1490         if (!entry) {
1491                 kfree(system->filter);
1492                 system->filter = NULL;
1493                 pr_warning("Could not create debugfs '%s/filter' entry\n", name);
1494         }
1495
1496         trace_create_file("enable", 0644, dir->entry, dir,
1497                           &ftrace_system_enable_fops);
1498
1499         list_add(&dir->list, &tr->systems);
1500
1501         return dir->entry;
1502
1503  out_free:
1504         kfree(dir);
1505  out_fail:
1506         /* Only print this message if failed on memory allocation */
1507         if (!dir || !system)
1508                 pr_warning("No memory to create event subsystem %s\n",
1509                            name);
1510         return NULL;
1511 }
1512
1513 static int
1514 event_create_dir(struct dentry *parent,
1515                  struct ftrace_event_file *file,
1516                  const struct file_operations *id,
1517                  const struct file_operations *enable,
1518                  const struct file_operations *filter,
1519                  const struct file_operations *format)
1520 {
1521         struct ftrace_event_call *call = file->event_call;
1522         struct trace_array *tr = file->tr;
1523         struct list_head *head;
1524         struct dentry *d_events;
1525         int ret;
1526
1527         /*
1528          * If the trace point header did not define TRACE_SYSTEM
1529          * then the system would be called "TRACE_SYSTEM".
1530          */
1531         if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
1532                 d_events = event_subsystem_dir(tr, call->class->system, file, parent);
1533                 if (!d_events)
1534                         return -ENOMEM;
1535         } else
1536                 d_events = parent;
1537
1538         file->dir = debugfs_create_dir(call->name, d_events);
1539         if (!file->dir) {
1540                 pr_warning("Could not create debugfs '%s' directory\n",
1541                            call->name);
1542                 return -1;
1543         }
1544
1545         if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
1546                 trace_create_file("enable", 0644, file->dir, file,
1547                                   enable);
1548
1549 #ifdef CONFIG_PERF_EVENTS
1550         if (call->event.type && call->class->reg)
1551                 trace_create_file("id", 0444, file->dir,
1552                                   (void *)(long)call->event.type, id);
1553 #endif
1554
1555         /*
1556          * Other events may have the same class. Only update
1557          * the fields if they are not already defined.
1558          */
1559         head = trace_get_fields(call);
1560         if (list_empty(head)) {
1561                 ret = call->class->define_fields(call);
1562                 if (ret < 0) {
1563                         pr_warning("Could not initialize trace point"
1564                                    " events/%s\n", call->name);
1565                         return -1;
1566                 }
1567         }
1568         trace_create_file("filter", 0644, file->dir, call,
1569                           filter);
1570
1571         trace_create_file("format", 0444, file->dir, call,
1572                           format);
1573
1574         return 0;
1575 }
1576
1577 static void remove_event_from_tracers(struct ftrace_event_call *call)
1578 {
1579         struct ftrace_event_file *file;
1580         struct trace_array *tr;
1581
1582         do_for_each_event_file_safe(tr, file) {
1583                 if (file->event_call != call)
1584                         continue;
1585
1586                 remove_event_file_dir(file);
1587                 /*
1588                  * The do_for_each_event_file_safe() is
1589                  * a double loop. After finding the call for this
1590                  * trace_array, we use break to jump to the next
1591                  * trace_array.
1592                  */
1593                 break;
1594         } while_for_each_event_file();
1595 }
1596
1597 static void event_remove(struct ftrace_event_call *call)
1598 {
1599         struct trace_array *tr;
1600         struct ftrace_event_file *file;
1601
1602         do_for_each_event_file(tr, file) {
1603                 if (file->event_call != call)
1604                         continue;
1605                 ftrace_event_enable_disable(file, 0);
1606                 /*
1607                  * The do_for_each_event_file() is
1608                  * a double loop. After finding the call for this
1609                  * trace_array, we use break to jump to the next
1610                  * trace_array.
1611                  */
1612                 break;
1613         } while_for_each_event_file();
1614
1615         if (call->event.funcs)
1616                 __unregister_ftrace_event(&call->event);
1617         remove_event_from_tracers(call);
1618         list_del(&call->list);
1619 }
1620
1621 static int event_init(struct ftrace_event_call *call)
1622 {
1623         int ret = 0;
1624
1625         if (WARN_ON(!call->name))
1626                 return -EINVAL;
1627
1628         if (call->class->raw_init) {
1629                 ret = call->class->raw_init(call);
1630                 if (ret < 0 && ret != -ENOSYS)
1631                         pr_warn("Could not initialize trace events/%s\n",
1632                                 call->name);
1633         }
1634
1635         return ret;
1636 }
1637
1638 static int
1639 __register_event(struct ftrace_event_call *call, struct module *mod)
1640 {
1641         int ret;
1642
1643         ret = event_init(call);
1644         if (ret < 0)
1645                 return ret;
1646
1647         list_add(&call->list, &ftrace_events);
1648         call->mod = mod;
1649
1650         return 0;
1651 }
1652
1653 static struct ftrace_event_file *
1654 trace_create_new_event(struct ftrace_event_call *call,
1655                        struct trace_array *tr)
1656 {
1657         struct ftrace_event_file *file;
1658
1659         file = kmem_cache_alloc(file_cachep, GFP_TRACE);
1660         if (!file)
1661                 return NULL;
1662
1663         file->event_call = call;
1664         file->tr = tr;
1665         atomic_set(&file->sm_ref, 0);
1666         list_add(&file->list, &tr->events);
1667
1668         return file;
1669 }
1670
1671 /* Add an event to a trace directory */
1672 static int
1673 __trace_add_new_event(struct ftrace_event_call *call,
1674                       struct trace_array *tr,
1675                       const struct file_operations *id,
1676                       const struct file_operations *enable,
1677                       const struct file_operations *filter,
1678                       const struct file_operations *format)
1679 {
1680         struct ftrace_event_file *file;
1681
1682         file = trace_create_new_event(call, tr);
1683         if (!file)
1684                 return -ENOMEM;
1685
1686         return event_create_dir(tr->event_dir, file, id, enable, filter, format);
1687 }
1688
1689 /*
1690  * Just create a decriptor for early init. A descriptor is required
1691  * for enabling events at boot. We want to enable events before
1692  * the filesystem is initialized.
1693  */
1694 static __init int
1695 __trace_early_add_new_event(struct ftrace_event_call *call,
1696                             struct trace_array *tr)
1697 {
1698         struct ftrace_event_file *file;
1699
1700         file = trace_create_new_event(call, tr);
1701         if (!file)
1702                 return -ENOMEM;
1703
1704         return 0;
1705 }
1706
1707 struct ftrace_module_file_ops;
1708 static void __add_event_to_tracers(struct ftrace_event_call *call,
1709                                    struct ftrace_module_file_ops *file_ops);
1710
1711 /* Add an additional event_call dynamically */
1712 int trace_add_event_call(struct ftrace_event_call *call)
1713 {
1714         int ret;
1715         mutex_lock(&trace_types_lock);
1716         mutex_lock(&event_mutex);
1717
1718         ret = __register_event(call, NULL);
1719         if (ret >= 0)
1720                 __add_event_to_tracers(call, NULL);
1721
1722         mutex_unlock(&event_mutex);
1723         mutex_unlock(&trace_types_lock);
1724         return ret;
1725 }
1726
1727 /*
1728  * Must be called under locking of trace_types_lock, event_mutex and
1729  * trace_event_sem.
1730  */
1731 static void __trace_remove_event_call(struct ftrace_event_call *call)
1732 {
1733         event_remove(call);
1734         trace_destroy_fields(call);
1735         destroy_preds(call);
1736 }
1737
1738 /* Remove an event_call */
1739 void trace_remove_event_call(struct ftrace_event_call *call)
1740 {
1741         mutex_lock(&trace_types_lock);
1742         mutex_lock(&event_mutex);
1743         down_write(&trace_event_sem);
1744         __trace_remove_event_call(call);
1745         up_write(&trace_event_sem);
1746         mutex_unlock(&event_mutex);
1747         mutex_unlock(&trace_types_lock);
1748 }
1749
1750 #define for_each_event(event, start, end)                       \
1751         for (event = start;                                     \
1752              (unsigned long)event < (unsigned long)end;         \
1753              event++)
1754
1755 #ifdef CONFIG_MODULES
1756
1757 static LIST_HEAD(ftrace_module_file_list);
1758
1759 /*
1760  * Modules must own their file_operations to keep up with
1761  * reference counting.
1762  */
1763 struct ftrace_module_file_ops {
1764         struct list_head                list;
1765         struct module                   *mod;
1766         struct file_operations          id;
1767         struct file_operations          enable;
1768         struct file_operations          format;
1769         struct file_operations          filter;
1770 };
1771
1772 static struct ftrace_module_file_ops *
1773 find_ftrace_file_ops(struct ftrace_module_file_ops *file_ops, struct module *mod)
1774 {
1775         /*
1776          * As event_calls are added in groups by module,
1777          * when we find one file_ops, we don't need to search for
1778          * each call in that module, as the rest should be the
1779          * same. Only search for a new one if the last one did
1780          * not match.
1781          */
1782         if (file_ops && mod == file_ops->mod)
1783                 return file_ops;
1784
1785         list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1786                 if (file_ops->mod == mod)
1787                         return file_ops;
1788         }
1789         return NULL;
1790 }
1791
1792 static struct ftrace_module_file_ops *
1793 trace_create_file_ops(struct module *mod)
1794 {
1795         struct ftrace_module_file_ops *file_ops;
1796
1797         /*
1798          * This is a bit of a PITA. To allow for correct reference
1799          * counting, modules must "own" their file_operations.
1800          * To do this, we allocate the file operations that will be
1801          * used in the event directory.
1802          */
1803
1804         file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1805         if (!file_ops)
1806                 return NULL;
1807
1808         file_ops->mod = mod;
1809
1810         file_ops->id = ftrace_event_id_fops;
1811         file_ops->id.owner = mod;
1812
1813         file_ops->enable = ftrace_enable_fops;
1814         file_ops->enable.owner = mod;
1815
1816         file_ops->filter = ftrace_event_filter_fops;
1817         file_ops->filter.owner = mod;
1818
1819         file_ops->format = ftrace_event_format_fops;
1820         file_ops->format.owner = mod;
1821
1822         list_add(&file_ops->list, &ftrace_module_file_list);
1823
1824         return file_ops;
1825 }
1826
1827 static void trace_module_add_events(struct module *mod)
1828 {
1829         struct ftrace_module_file_ops *file_ops = NULL;
1830         struct ftrace_event_call **call, **start, **end;
1831
1832         start = mod->trace_events;
1833         end = mod->trace_events + mod->num_trace_events;
1834
1835         if (start == end)
1836                 return;
1837
1838         file_ops = trace_create_file_ops(mod);
1839         if (!file_ops)
1840                 return;
1841
1842         for_each_event(call, start, end) {
1843                 __register_event(*call, mod);
1844                 __add_event_to_tracers(*call, file_ops);
1845         }
1846 }
1847
1848 static void trace_module_remove_events(struct module *mod)
1849 {
1850         struct ftrace_module_file_ops *file_ops;
1851         struct ftrace_event_call *call, *p;
1852         bool clear_trace = false;
1853
1854         down_write(&trace_event_sem);
1855         list_for_each_entry_safe(call, p, &ftrace_events, list) {
1856                 if (call->mod == mod) {
1857                         if (call->flags & TRACE_EVENT_FL_WAS_ENABLED)
1858                                 clear_trace = true;
1859                         __trace_remove_event_call(call);
1860                 }
1861         }
1862
1863         /* Now free the file_operations */
1864         list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1865                 if (file_ops->mod == mod)
1866                         break;
1867         }
1868         if (&file_ops->list != &ftrace_module_file_list) {
1869                 list_del(&file_ops->list);
1870                 kfree(file_ops);
1871         }
1872         up_write(&trace_event_sem);
1873
1874         /*
1875          * It is safest to reset the ring buffer if the module being unloaded
1876          * registered any events that were used. The only worry is if
1877          * a new module gets loaded, and takes on the same id as the events
1878          * of this module. When printing out the buffer, traced events left
1879          * over from this module may be passed to the new module events and
1880          * unexpected results may occur.
1881          */
1882         if (clear_trace)
1883                 tracing_reset_all_online_cpus();
1884 }
1885
1886 static int trace_module_notify(struct notifier_block *self,
1887                                unsigned long val, void *data)
1888 {
1889         struct module *mod = data;
1890
1891         mutex_lock(&trace_types_lock);
1892         mutex_lock(&event_mutex);
1893         switch (val) {
1894         case MODULE_STATE_COMING:
1895                 trace_module_add_events(mod);
1896                 break;
1897         case MODULE_STATE_GOING:
1898                 trace_module_remove_events(mod);
1899                 break;
1900         }
1901         mutex_unlock(&event_mutex);
1902         mutex_unlock(&trace_types_lock);
1903
1904         return 0;
1905 }
1906
1907 static int
1908 __trace_add_new_mod_event(struct ftrace_event_call *call,
1909                           struct trace_array *tr,
1910                           struct ftrace_module_file_ops *file_ops)
1911 {
1912         return __trace_add_new_event(call, tr,
1913                                      &file_ops->id, &file_ops->enable,
1914                                      &file_ops->filter, &file_ops->format);
1915 }
1916
1917 #else
1918 static inline struct ftrace_module_file_ops *
1919 find_ftrace_file_ops(struct ftrace_module_file_ops *file_ops, struct module *mod)
1920 {
1921         return NULL;
1922 }
1923 static inline int trace_module_notify(struct notifier_block *self,
1924                                       unsigned long val, void *data)
1925 {
1926         return 0;
1927 }
1928 static inline int
1929 __trace_add_new_mod_event(struct ftrace_event_call *call,
1930                           struct trace_array *tr,
1931                           struct ftrace_module_file_ops *file_ops)
1932 {
1933         return -ENODEV;
1934 }
1935 #endif /* CONFIG_MODULES */
1936
1937 /* Create a new event directory structure for a trace directory. */
1938 static void
1939 __trace_add_event_dirs(struct trace_array *tr)
1940 {
1941         struct ftrace_module_file_ops *file_ops = NULL;
1942         struct ftrace_event_call *call;
1943         int ret;
1944
1945         list_for_each_entry(call, &ftrace_events, list) {
1946                 if (call->mod) {
1947                         /*
1948                          * Directories for events by modules need to
1949                          * keep module ref counts when opened (as we don't
1950                          * want the module to disappear when reading one
1951                          * of these files). The file_ops keep account of
1952                          * the module ref count.
1953                          */
1954                         file_ops = find_ftrace_file_ops(file_ops, call->mod);
1955                         if (!file_ops)
1956                                 continue; /* Warn? */
1957                         ret = __trace_add_new_mod_event(call, tr, file_ops);
1958                         if (ret < 0)
1959                                 pr_warning("Could not create directory for event %s\n",
1960                                            call->name);
1961                         continue;
1962                 }
1963                 ret = __trace_add_new_event(call, tr,
1964                                             &ftrace_event_id_fops,
1965                                             &ftrace_enable_fops,
1966                                             &ftrace_event_filter_fops,
1967                                             &ftrace_event_format_fops);
1968                 if (ret < 0)
1969                         pr_warning("Could not create directory for event %s\n",
1970                                    call->name);
1971         }
1972 }
1973
1974 #ifdef CONFIG_DYNAMIC_FTRACE
1975
1976 /* Avoid typos */
1977 #define ENABLE_EVENT_STR        "enable_event"
1978 #define DISABLE_EVENT_STR       "disable_event"
1979
1980 struct event_probe_data {
1981         struct ftrace_event_file        *file;
1982         unsigned long                   count;
1983         int                             ref;
1984         bool                            enable;
1985 };
1986
1987 static struct ftrace_event_file *
1988 find_event_file(struct trace_array *tr, const char *system,  const char *event)
1989 {
1990         struct ftrace_event_file *file;
1991         struct ftrace_event_call *call;
1992
1993         list_for_each_entry(file, &tr->events, list) {
1994
1995                 call = file->event_call;
1996
1997                 if (!call->name || !call->class || !call->class->reg)
1998                         continue;
1999
2000                 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
2001                         continue;
2002
2003                 if (strcmp(event, call->name) == 0 &&
2004                     strcmp(system, call->class->system) == 0)
2005                         return file;
2006         }
2007         return NULL;
2008 }
2009
2010 static void
2011 event_enable_probe(unsigned long ip, unsigned long parent_ip, void **_data)
2012 {
2013         struct event_probe_data **pdata = (struct event_probe_data **)_data;
2014         struct event_probe_data *data = *pdata;
2015
2016         if (!data)
2017                 return;
2018
2019         if (data->enable)
2020                 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);
2021         else
2022                 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);
2023 }
2024
2025 static void
2026 event_enable_count_probe(unsigned long ip, unsigned long parent_ip, void **_data)
2027 {
2028         struct event_probe_data **pdata = (struct event_probe_data **)_data;
2029         struct event_probe_data *data = *pdata;
2030
2031         if (!data)
2032                 return;
2033
2034         if (!data->count)
2035                 return;
2036
2037         /* Skip if the event is in a state we want to switch to */
2038         if (data->enable == !(data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED))
2039                 return;
2040
2041         if (data->count != -1)
2042                 (data->count)--;
2043
2044         event_enable_probe(ip, parent_ip, _data);
2045 }
2046
2047 static int
2048 event_enable_print(struct seq_file *m, unsigned long ip,
2049                       struct ftrace_probe_ops *ops, void *_data)
2050 {
2051         struct event_probe_data *data = _data;
2052
2053         seq_printf(m, "%ps:", (void *)ip);
2054
2055         seq_printf(m, "%s:%s:%s",
2056                    data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
2057                    data->file->event_call->class->system,
2058                    data->file->event_call->name);
2059
2060         if (data->count == -1)
2061                 seq_printf(m, ":unlimited\n");
2062         else
2063                 seq_printf(m, ":count=%ld\n", data->count);
2064
2065         return 0;
2066 }
2067
2068 static int
2069 event_enable_init(struct ftrace_probe_ops *ops, unsigned long ip,
2070                   void **_data)
2071 {
2072         struct event_probe_data **pdata = (struct event_probe_data **)_data;
2073         struct event_probe_data *data = *pdata;
2074
2075         data->ref++;
2076         return 0;
2077 }
2078
2079 static void
2080 event_enable_free(struct ftrace_probe_ops *ops, unsigned long ip,
2081                   void **_data)
2082 {
2083         struct event_probe_data **pdata = (struct event_probe_data **)_data;
2084         struct event_probe_data *data = *pdata;
2085
2086         if (WARN_ON_ONCE(data->ref <= 0))
2087                 return;
2088
2089         data->ref--;
2090         if (!data->ref) {
2091                 /* Remove the SOFT_MODE flag */
2092                 __ftrace_event_enable_disable(data->file, 0, 1);
2093                 module_put(data->file->event_call->mod);
2094                 kfree(data);
2095         }
2096         *pdata = NULL;
2097 }
2098
2099 static struct ftrace_probe_ops event_enable_probe_ops = {
2100         .func                   = event_enable_probe,
2101         .print                  = event_enable_print,
2102         .init                   = event_enable_init,
2103         .free                   = event_enable_free,
2104 };
2105
2106 static struct ftrace_probe_ops event_enable_count_probe_ops = {
2107         .func                   = event_enable_count_probe,
2108         .print                  = event_enable_print,
2109         .init                   = event_enable_init,
2110         .free                   = event_enable_free,
2111 };
2112
2113 static struct ftrace_probe_ops event_disable_probe_ops = {
2114         .func                   = event_enable_probe,
2115         .print                  = event_enable_print,
2116         .init                   = event_enable_init,
2117         .free                   = event_enable_free,
2118 };
2119
2120 static struct ftrace_probe_ops event_disable_count_probe_ops = {
2121         .func                   = event_enable_count_probe,
2122         .print                  = event_enable_print,
2123         .init                   = event_enable_init,
2124         .free                   = event_enable_free,
2125 };
2126
2127 static int
2128 event_enable_func(struct ftrace_hash *hash,
2129                   char *glob, char *cmd, char *param, int enabled)
2130 {
2131         struct trace_array *tr = top_trace_array();
2132         struct ftrace_event_file *file;
2133         struct ftrace_probe_ops *ops;
2134         struct event_probe_data *data;
2135         const char *system;
2136         const char *event;
2137         char *number;
2138         bool enable;
2139         int ret;
2140
2141         /* hash funcs only work with set_ftrace_filter */
2142         if (!enabled)
2143                 return -EINVAL;
2144
2145         if (!param)
2146                 return -EINVAL;
2147
2148         system = strsep(&param, ":");
2149         if (!param)
2150                 return -EINVAL;
2151
2152         event = strsep(&param, ":");
2153
2154         mutex_lock(&event_mutex);
2155
2156         ret = -EINVAL;
2157         file = find_event_file(tr, system, event);
2158         if (!file)
2159                 goto out;
2160
2161         enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
2162
2163         if (enable)
2164                 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
2165         else
2166                 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
2167
2168         if (glob[0] == '!') {
2169                 unregister_ftrace_function_probe_func(glob+1, ops);
2170                 ret = 0;
2171                 goto out;
2172         }
2173
2174         ret = -ENOMEM;
2175         data = kzalloc(sizeof(*data), GFP_KERNEL);
2176         if (!data)
2177                 goto out;
2178
2179         data->enable = enable;
2180         data->count = -1;
2181         data->file = file;
2182
2183         if (!param)
2184                 goto out_reg;
2185
2186         number = strsep(&param, ":");
2187
2188         ret = -EINVAL;
2189         if (!strlen(number))
2190                 goto out_free;
2191
2192         /*
2193          * We use the callback data field (which is a pointer)
2194          * as our counter.
2195          */
2196         ret = kstrtoul(number, 0, &data->count);
2197         if (ret)
2198                 goto out_free;
2199
2200  out_reg:
2201         /* Don't let event modules unload while probe registered */
2202         ret = try_module_get(file->event_call->mod);
2203         if (!ret) {
2204                 ret = -EBUSY;
2205                 goto out_free;
2206         }
2207
2208         ret = __ftrace_event_enable_disable(file, 1, 1);
2209         if (ret < 0)
2210                 goto out_put;
2211         ret = register_ftrace_function_probe(glob, ops, data);
2212         /*
2213          * The above returns on success the # of functions enabled,
2214          * but if it didn't find any functions it returns zero.
2215          * Consider no functions a failure too.
2216          */
2217         if (!ret) {
2218                 ret = -ENOENT;
2219                 goto out_disable;
2220         } else if (ret < 0)
2221                 goto out_disable;
2222         /* Just return zero, not the number of enabled functions */
2223         ret = 0;
2224  out:
2225         mutex_unlock(&event_mutex);
2226         return ret;
2227
2228  out_disable:
2229         __ftrace_event_enable_disable(file, 0, 1);
2230  out_put:
2231         module_put(file->event_call->mod);
2232  out_free:
2233         kfree(data);
2234         goto out;
2235 }
2236
2237 static struct ftrace_func_command event_enable_cmd = {
2238         .name                   = ENABLE_EVENT_STR,
2239         .func                   = event_enable_func,
2240 };
2241
2242 static struct ftrace_func_command event_disable_cmd = {
2243         .name                   = DISABLE_EVENT_STR,
2244         .func                   = event_enable_func,
2245 };
2246
2247 static __init int register_event_cmds(void)
2248 {
2249         int ret;
2250
2251         ret = register_ftrace_command(&event_enable_cmd);
2252         if (WARN_ON(ret < 0))
2253                 return ret;
2254         ret = register_ftrace_command(&event_disable_cmd);
2255         if (WARN_ON(ret < 0))
2256                 unregister_ftrace_command(&event_enable_cmd);
2257         return ret;
2258 }
2259 #else
2260 static inline int register_event_cmds(void) { return 0; }
2261 #endif /* CONFIG_DYNAMIC_FTRACE */
2262
2263 /*
2264  * The top level array has already had its ftrace_event_file
2265  * descriptors created in order to allow for early events to
2266  * be recorded. This function is called after the debugfs has been
2267  * initialized, and we now have to create the files associated
2268  * to the events.
2269  */
2270 static __init void
2271 __trace_early_add_event_dirs(struct trace_array *tr)
2272 {
2273         struct ftrace_event_file *file;
2274         int ret;
2275
2276
2277         list_for_each_entry(file, &tr->events, list) {
2278                 ret = event_create_dir(tr->event_dir, file,
2279                                        &ftrace_event_id_fops,
2280                                        &ftrace_enable_fops,
2281                                        &ftrace_event_filter_fops,
2282                                        &ftrace_event_format_fops);
2283                 if (ret < 0)
2284                         pr_warning("Could not create directory for event %s\n",
2285                                    file->event_call->name);
2286         }
2287 }
2288
2289 /*
2290  * For early boot up, the top trace array requires to have
2291  * a list of events that can be enabled. This must be done before
2292  * the filesystem is set up in order to allow events to be traced
2293  * early.
2294  */
2295 static __init void
2296 __trace_early_add_events(struct trace_array *tr)
2297 {
2298         struct ftrace_event_call *call;
2299         int ret;
2300
2301         list_for_each_entry(call, &ftrace_events, list) {
2302                 /* Early boot up should not have any modules loaded */
2303                 if (WARN_ON_ONCE(call->mod))
2304                         continue;
2305
2306                 ret = __trace_early_add_new_event(call, tr);
2307                 if (ret < 0)
2308                         pr_warning("Could not create early event %s\n",
2309                                    call->name);
2310         }
2311 }
2312
2313 /* Remove the event directory structure for a trace directory. */
2314 static void
2315 __trace_remove_event_dirs(struct trace_array *tr)
2316 {
2317         struct ftrace_event_file *file, *next;
2318
2319         list_for_each_entry_safe(file, next, &tr->events, list)
2320                 remove_event_file_dir(file);
2321 }
2322
2323 static void
2324 __add_event_to_tracers(struct ftrace_event_call *call,
2325                        struct ftrace_module_file_ops *file_ops)
2326 {
2327         struct trace_array *tr;
2328
2329         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
2330                 if (file_ops)
2331                         __trace_add_new_mod_event(call, tr, file_ops);
2332                 else
2333                         __trace_add_new_event(call, tr,
2334                                               &ftrace_event_id_fops,
2335                                               &ftrace_enable_fops,
2336                                               &ftrace_event_filter_fops,
2337                                               &ftrace_event_format_fops);
2338         }
2339 }
2340
2341 static struct notifier_block trace_module_nb = {
2342         .notifier_call = trace_module_notify,
2343         .priority = 0,
2344 };
2345
2346 extern struct ftrace_event_call *__start_ftrace_events[];
2347 extern struct ftrace_event_call *__stop_ftrace_events[];
2348
2349 static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
2350
2351 static __init int setup_trace_event(char *str)
2352 {
2353         strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
2354         ring_buffer_expanded = true;
2355         tracing_selftest_disabled = true;
2356
2357         return 1;
2358 }
2359 __setup("trace_event=", setup_trace_event);
2360
2361 /* Expects to have event_mutex held when called */
2362 static int
2363 create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
2364 {
2365         struct dentry *d_events;
2366         struct dentry *entry;
2367
2368         entry = debugfs_create_file("set_event", 0644, parent,
2369                                     tr, &ftrace_set_event_fops);
2370         if (!entry) {
2371                 pr_warning("Could not create debugfs 'set_event' entry\n");
2372                 return -ENOMEM;
2373         }
2374
2375         d_events = debugfs_create_dir("events", parent);
2376         if (!d_events) {
2377                 pr_warning("Could not create debugfs 'events' directory\n");
2378                 return -ENOMEM;
2379         }
2380
2381         /* ring buffer internal formats */
2382         trace_create_file("header_page", 0444, d_events,
2383                           ring_buffer_print_page_header,
2384                           &ftrace_show_header_fops);
2385
2386         trace_create_file("header_event", 0444, d_events,
2387                           ring_buffer_print_entry_header,
2388                           &ftrace_show_header_fops);
2389
2390         trace_create_file("enable", 0644, d_events,
2391                           tr, &ftrace_tr_enable_fops);
2392
2393         tr->event_dir = d_events;
2394
2395         return 0;
2396 }
2397
2398 /**
2399  * event_trace_add_tracer - add a instance of a trace_array to events
2400  * @parent: The parent dentry to place the files/directories for events in
2401  * @tr: The trace array associated with these events
2402  *
2403  * When a new instance is created, it needs to set up its events
2404  * directory, as well as other files associated with events. It also
2405  * creates the event hierachry in the @parent/events directory.
2406  *
2407  * Returns 0 on success.
2408  */
2409 int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
2410 {
2411         int ret;
2412
2413         mutex_lock(&event_mutex);
2414
2415         ret = create_event_toplevel_files(parent, tr);
2416         if (ret)
2417                 goto out_unlock;
2418
2419         down_write(&trace_event_sem);
2420         __trace_add_event_dirs(tr);
2421         up_write(&trace_event_sem);
2422
2423  out_unlock:
2424         mutex_unlock(&event_mutex);
2425
2426         return ret;
2427 }
2428
2429 /*
2430  * The top trace array already had its file descriptors created.
2431  * Now the files themselves need to be created.
2432  */
2433 static __init int
2434 early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
2435 {
2436         int ret;
2437
2438         mutex_lock(&event_mutex);
2439
2440         ret = create_event_toplevel_files(parent, tr);
2441         if (ret)
2442                 goto out_unlock;
2443
2444         down_write(&trace_event_sem);
2445         __trace_early_add_event_dirs(tr);
2446         up_write(&trace_event_sem);
2447
2448  out_unlock:
2449         mutex_unlock(&event_mutex);
2450
2451         return ret;
2452 }
2453
2454 int event_trace_del_tracer(struct trace_array *tr)
2455 {
2456         mutex_lock(&event_mutex);
2457
2458         /* Disable any running events */
2459         __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
2460
2461         down_write(&trace_event_sem);
2462         __trace_remove_event_dirs(tr);
2463         debugfs_remove_recursive(tr->event_dir);
2464         up_write(&trace_event_sem);
2465
2466         tr->event_dir = NULL;
2467
2468         mutex_unlock(&event_mutex);
2469
2470         return 0;
2471 }
2472
2473 static __init int event_trace_memsetup(void)
2474 {
2475         field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
2476         file_cachep = KMEM_CACHE(ftrace_event_file, SLAB_PANIC);
2477         return 0;
2478 }
2479
2480 static __init int event_trace_enable(void)
2481 {
2482         struct trace_array *tr = top_trace_array();
2483         struct ftrace_event_call **iter, *call;
2484         char *buf = bootup_event_buf;
2485         char *token;
2486         int ret;
2487
2488         for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
2489
2490                 call = *iter;
2491                 ret = event_init(call);
2492                 if (!ret)
2493                         list_add(&call->list, &ftrace_events);
2494         }
2495
2496         /*
2497          * We need the top trace array to have a working set of trace
2498          * points at early init, before the debug files and directories
2499          * are created. Create the file entries now, and attach them
2500          * to the actual file dentries later.
2501          */
2502         __trace_early_add_events(tr);
2503
2504         while (true) {
2505                 token = strsep(&buf, ",");
2506
2507                 if (!token)
2508                         break;
2509                 if (!*token)
2510                         continue;
2511
2512                 ret = ftrace_set_clr_event(tr, token, 1);
2513                 if (ret)
2514                         pr_warn("Failed to enable trace event: %s\n", token);
2515         }
2516
2517         trace_printk_start_comm();
2518
2519         register_event_cmds();
2520
2521         return 0;
2522 }
2523
2524 static __init int event_trace_init(void)
2525 {
2526         struct trace_array *tr;
2527         struct dentry *d_tracer;
2528         struct dentry *entry;
2529         int ret;
2530
2531         tr = top_trace_array();
2532
2533         d_tracer = tracing_init_dentry();
2534         if (!d_tracer)
2535                 return 0;
2536
2537         entry = debugfs_create_file("available_events", 0444, d_tracer,
2538                                     tr, &ftrace_avail_fops);
2539         if (!entry)
2540                 pr_warning("Could not create debugfs "
2541                            "'available_events' entry\n");
2542
2543         if (trace_define_common_fields())
2544                 pr_warning("tracing: Failed to allocate common fields");
2545
2546         ret = early_event_add_tracer(d_tracer, tr);
2547         if (ret)
2548                 return ret;
2549
2550         ret = register_module_notifier(&trace_module_nb);
2551         if (ret)
2552                 pr_warning("Failed to register trace events module notifier\n");
2553
2554         return 0;
2555 }
2556 early_initcall(event_trace_memsetup);
2557 core_initcall(event_trace_enable);
2558 fs_initcall(event_trace_init);
2559
2560 #ifdef CONFIG_FTRACE_STARTUP_TEST
2561
2562 static DEFINE_SPINLOCK(test_spinlock);
2563 static DEFINE_SPINLOCK(test_spinlock_irq);
2564 static DEFINE_MUTEX(test_mutex);
2565
2566 static __init void test_work(struct work_struct *dummy)
2567 {
2568         spin_lock(&test_spinlock);
2569         spin_lock_irq(&test_spinlock_irq);
2570         udelay(1);
2571         spin_unlock_irq(&test_spinlock_irq);
2572         spin_unlock(&test_spinlock);
2573
2574         mutex_lock(&test_mutex);
2575         msleep(1);
2576         mutex_unlock(&test_mutex);
2577 }
2578
2579 static __init int event_test_thread(void *unused)
2580 {
2581         void *test_malloc;
2582
2583         test_malloc = kmalloc(1234, GFP_KERNEL);
2584         if (!test_malloc)
2585                 pr_info("failed to kmalloc\n");
2586
2587         schedule_on_each_cpu(test_work);
2588
2589         kfree(test_malloc);
2590
2591         set_current_state(TASK_INTERRUPTIBLE);
2592         while (!kthread_should_stop())
2593                 schedule();
2594
2595         return 0;
2596 }
2597
2598 /*
2599  * Do various things that may trigger events.
2600  */
2601 static __init void event_test_stuff(void)
2602 {
2603         struct task_struct *test_thread;
2604
2605         test_thread = kthread_run(event_test_thread, NULL, "test-events");
2606         msleep(1);
2607         kthread_stop(test_thread);
2608 }
2609
2610 /*
2611  * For every trace event defined, we will test each trace point separately,
2612  * and then by groups, and finally all trace points.
2613  */
2614 static __init void event_trace_self_tests(void)
2615 {
2616         struct ftrace_subsystem_dir *dir;
2617         struct ftrace_event_file *file;
2618         struct ftrace_event_call *call;
2619         struct event_subsystem *system;
2620         struct trace_array *tr;
2621         int ret;
2622
2623         tr = top_trace_array();
2624
2625         pr_info("Running tests on trace events:\n");
2626
2627         list_for_each_entry(file, &tr->events, list) {
2628
2629                 call = file->event_call;
2630
2631                 /* Only test those that have a probe */
2632                 if (!call->class || !call->class->probe)
2633                         continue;
2634
2635 /*
2636  * Testing syscall events here is pretty useless, but
2637  * we still do it if configured. But this is time consuming.
2638  * What we really need is a user thread to perform the
2639  * syscalls as we test.
2640  */
2641 #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
2642                 if (call->class->system &&
2643                     strcmp(call->class->system, "syscalls") == 0)
2644                         continue;
2645 #endif
2646
2647                 pr_info("Testing event %s: ", call->name);
2648
2649                 /*
2650                  * If an event is already enabled, someone is using
2651                  * it and the self test should not be on.
2652                  */
2653                 if (file->flags & FTRACE_EVENT_FL_ENABLED) {
2654                         pr_warning("Enabled event during self test!\n");
2655                         WARN_ON_ONCE(1);
2656                         continue;
2657                 }
2658
2659                 ftrace_event_enable_disable(file, 1);
2660                 event_test_stuff();
2661                 ftrace_event_enable_disable(file, 0);
2662
2663                 pr_cont("OK\n");
2664         }
2665
2666         /* Now test at the sub system level */
2667
2668         pr_info("Running tests on trace event systems:\n");
2669
2670         list_for_each_entry(dir, &tr->systems, list) {
2671
2672                 system = dir->subsystem;
2673
2674                 /* the ftrace system is special, skip it */
2675                 if (strcmp(system->name, "ftrace") == 0)
2676                         continue;
2677
2678                 pr_info("Testing event system %s: ", system->name);
2679
2680                 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1);
2681                 if (WARN_ON_ONCE(ret)) {
2682                         pr_warning("error enabling system %s\n",
2683                                    system->name);
2684                         continue;
2685                 }
2686
2687                 event_test_stuff();
2688
2689                 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0);
2690                 if (WARN_ON_ONCE(ret)) {
2691                         pr_warning("error disabling system %s\n",
2692                                    system->name);
2693                         continue;
2694                 }
2695
2696                 pr_cont("OK\n");
2697         }
2698
2699         /* Test with all events enabled */
2700
2701         pr_info("Running tests on all trace events:\n");
2702         pr_info("Testing all events: ");
2703
2704         ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1);
2705         if (WARN_ON_ONCE(ret)) {
2706                 pr_warning("error enabling all events\n");
2707                 return;
2708         }
2709
2710         event_test_stuff();
2711
2712         /* reset sysname */
2713         ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
2714         if (WARN_ON_ONCE(ret)) {
2715                 pr_warning("error disabling all events\n");
2716                 return;
2717         }
2718
2719         pr_cont("OK\n");
2720 }
2721
2722 #ifdef CONFIG_FUNCTION_TRACER
2723
2724 static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
2725
2726 static void
2727 function_test_events_call(unsigned long ip, unsigned long parent_ip,
2728                           struct ftrace_ops *op, struct pt_regs *pt_regs)
2729 {
2730         struct ring_buffer_event *event;
2731         struct ring_buffer *buffer;
2732         struct ftrace_entry *entry;
2733         unsigned long flags;
2734         long disabled;
2735         int cpu;
2736         int pc;
2737
2738         pc = preempt_count();
2739         preempt_disable_notrace();
2740         cpu = raw_smp_processor_id();
2741         disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
2742
2743         if (disabled != 1)
2744                 goto out;
2745
2746         local_save_flags(flags);
2747
2748         event = trace_current_buffer_lock_reserve(&buffer,
2749                                                   TRACE_FN, sizeof(*entry),
2750                                                   flags, pc);
2751         if (!event)
2752                 goto out;
2753         entry   = ring_buffer_event_data(event);
2754         entry->ip                       = ip;
2755         entry->parent_ip                = parent_ip;
2756
2757         trace_buffer_unlock_commit(buffer, event, flags, pc);
2758
2759  out:
2760         atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
2761         preempt_enable_notrace();
2762 }
2763
2764 static struct ftrace_ops trace_ops __initdata  =
2765 {
2766         .func = function_test_events_call,
2767         .flags = FTRACE_OPS_FL_RECURSION_SAFE,
2768 };
2769
2770 static __init void event_trace_self_test_with_function(void)
2771 {
2772         int ret;
2773         ret = register_ftrace_function(&trace_ops);
2774         if (WARN_ON(ret < 0)) {
2775                 pr_info("Failed to enable function tracer for event tests\n");
2776                 return;
2777         }
2778         pr_info("Running tests again, along with the function tracer\n");
2779         event_trace_self_tests();
2780         unregister_ftrace_function(&trace_ops);
2781 }
2782 #else
2783 static __init void event_trace_self_test_with_function(void)
2784 {
2785 }
2786 #endif
2787
2788 static __init int event_trace_self_tests_init(void)
2789 {
2790         if (!tracing_selftest_disabled) {
2791                 event_trace_self_tests();
2792                 event_trace_self_test_with_function();
2793         }
2794
2795         return 0;
2796 }
2797
2798 late_initcall(event_trace_self_tests_init);
2799
2800 #endif