~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_events.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp