/*
   * event tracer
   *
   * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   *

   *  - Added format output of fields of the trace point.
   *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
   *

   */

  #define pr_fmt(fmt) fmt

  #include <linux/workqueue.h>
  #include <linux/spinlock.h>
  #include <linux/kthread.h>

  #include <linux/debugfs.h>
  #include <linux/uaccess.h>
  #include <linux/module.h>
  #include <linux/ctype.h>

  #include <linux/slab.h>

  #include <linux/delay.h>

  #include <asm/setup.h>

  #include "trace_output.h"

  #undef TRACE_SYSTEM

  #define TRACE_SYSTEM "TRACE_SYSTEM"

  DEFINE_MUTEX(event_mutex);

  LIST_HEAD(ftrace_events);

  static LIST_HEAD(ftrace_common_fields);

  #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
  
  static struct kmem_cache *field_cachep;
  static struct kmem_cache *file_cachep;

  #define SYSTEM_FL_FREE_NAME		(1 << 31)
  
  static inline int system_refcount(struct event_subsystem *system)
  {
  	return system->ref_count & ~SYSTEM_FL_FREE_NAME;
  }
  
  static int system_refcount_inc(struct event_subsystem *system)
  {
  	return (system->ref_count++) & ~SYSTEM_FL_FREE_NAME;
  }
  
  static int system_refcount_dec(struct event_subsystem *system)
  {
  	return (--system->ref_count) & ~SYSTEM_FL_FREE_NAME;
  }

  /* Double loops, do not use break, only goto's work */
  #define do_for_each_event_file(tr, file)			\
  	list_for_each_entry(tr, &ftrace_trace_arrays, list) {	\
  		list_for_each_entry(file, &tr->events, list)
  
  #define do_for_each_event_file_safe(tr, file)			\
  	list_for_each_entry(tr, &ftrace_trace_arrays, list) {	\
  		struct ftrace_event_file *___n;				\
  		list_for_each_entry_safe(file, ___n, &tr->events, list)
  
  #define while_for_each_event_file()		\
  	}

  static struct list_head *

  trace_get_fields(struct ftrace_event_call *event_call)
  {
  	if (!event_call->class->get_fields)
  		return &event_call->class->fields;
  	return event_call->class->get_fields(event_call);
  }

  static struct ftrace_event_field *
  __find_event_field(struct list_head *head, char *name)
  {
  	struct ftrace_event_field *field;
  
  	list_for_each_entry(field, head, link) {
  		if (!strcmp(field->name, name))
  			return field;
  	}
  
  	return NULL;
  }
  
  struct ftrace_event_field *
  trace_find_event_field(struct ftrace_event_call *call, char *name)
  {
  	struct ftrace_event_field *field;
  	struct list_head *head;
  
  	field = __find_event_field(&ftrace_common_fields, name);
  	if (field)
  		return field;
  
  	head = trace_get_fields(call);
  	return __find_event_field(head, name);
  }

  static int __trace_define_field(struct list_head *head, const char *type,
  				const char *name, int offset, int size,
  				int is_signed, int filter_type)

  {
  	struct ftrace_event_field *field;

  	field = kmem_cache_alloc(field_cachep, GFP_TRACE);

  	if (!field)

  		return -ENOMEM;

  	field->name = name;
  	field->type = type;

  	if (filter_type == FILTER_OTHER)
  		field->filter_type = filter_assign_type(type);
  	else
  		field->filter_type = filter_type;

  	field->offset = offset;
  	field->size = size;

  	field->is_signed = is_signed;

  	list_add(&field->link, head);

  
  	return 0;

  }

  
  int trace_define_field(struct ftrace_event_call *call, const char *type,
  		       const char *name, int offset, int size, int is_signed,
  		       int filter_type)
  {
  	struct list_head *head;
  
  	if (WARN_ON(!call->class))
  		return 0;
  
  	head = trace_get_fields(call);
  	return __trace_define_field(head, type, name, offset, size,
  				    is_signed, filter_type);
  }

  EXPORT_SYMBOL_GPL(trace_define_field);

  #define __common_field(type, item)					\

  	ret = __trace_define_field(&ftrace_common_fields, #type,	\
  				   "common_" #item,			\
  				   offsetof(typeof(ent), item),		\
  				   sizeof(ent.item),			\
  				   is_signed_type(type), FILTER_OTHER);	\

  	if (ret)							\
  		return ret;

  static int trace_define_common_fields(void)

  {
  	int ret;
  	struct trace_entry ent;
  
  	__common_field(unsigned short, type);
  	__common_field(unsigned char, flags);
  	__common_field(unsigned char, preempt_count);
  	__common_field(int, pid);

  
  	return ret;
  }

  static void trace_destroy_fields(struct ftrace_event_call *call)

  {
  	struct ftrace_event_field *field, *next;

  	struct list_head *head;

  	head = trace_get_fields(call);
  	list_for_each_entry_safe(field, next, head, link) {

  		list_del(&field->link);

  		kmem_cache_free(field_cachep, field);

  	}
  }

  int trace_event_raw_init(struct ftrace_event_call *call)
  {
  	int id;

  	id = register_ftrace_event(&call->event);

  	if (!id)
  		return -ENODEV;

  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(trace_event_raw_init);

  void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
  				  struct ftrace_event_file *ftrace_file,
  				  unsigned long len)
  {
  	struct ftrace_event_call *event_call = ftrace_file->event_call;
  
  	local_save_flags(fbuffer->flags);
  	fbuffer->pc = preempt_count();
  	fbuffer->ftrace_file = ftrace_file;
  
  	fbuffer->event =
  		trace_event_buffer_lock_reserve(&fbuffer->buffer, ftrace_file,
  						event_call->event.type, len,
  						fbuffer->flags, fbuffer->pc);
  	if (!fbuffer->event)
  		return NULL;
  
  	fbuffer->entry = ring_buffer_event_data(fbuffer->event);
  	return fbuffer->entry;
  }
  EXPORT_SYMBOL_GPL(ftrace_event_buffer_reserve);

  static DEFINE_SPINLOCK(tracepoint_iter_lock);
  
  static void output_printk(struct ftrace_event_buffer *fbuffer)
  {
  	struct ftrace_event_call *event_call;
  	struct trace_event *event;
  	unsigned long flags;
  	struct trace_iterator *iter = tracepoint_print_iter;
  
  	if (!iter)
  		return;
  
  	event_call = fbuffer->ftrace_file->event_call;
  	if (!event_call || !event_call->event.funcs ||
  	    !event_call->event.funcs->trace)
  		return;
  
  	event = &fbuffer->ftrace_file->event_call->event;
  
  	spin_lock_irqsave(&tracepoint_iter_lock, flags);
  	trace_seq_init(&iter->seq);
  	iter->ent = fbuffer->entry;
  	event_call->event.funcs->trace(iter, 0, event);
  	trace_seq_putc(&iter->seq, 0);
  	printk("%s", iter->seq.buffer);
  
  	spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
  }

  void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer)
  {

  	if (tracepoint_printk)
  		output_printk(fbuffer);

  	event_trigger_unlock_commit(fbuffer->ftrace_file, fbuffer->buffer,
  				    fbuffer->event, fbuffer->entry,
  				    fbuffer->flags, fbuffer->pc);
  }
  EXPORT_SYMBOL_GPL(ftrace_event_buffer_commit);

  int ftrace_event_reg(struct ftrace_event_call *call,
  		     enum trace_reg type, void *data)

  {

  	struct ftrace_event_file *file = data;

  	WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));

  	switch (type) {
  	case TRACE_REG_REGISTER:

  		return tracepoint_probe_register(call->tp,

  						 call->class->probe,

  						 file);

  	case TRACE_REG_UNREGISTER:

  		tracepoint_probe_unregister(call->tp,

  					    call->class->probe,

  					    file);

  		return 0;
  
  #ifdef CONFIG_PERF_EVENTS
  	case TRACE_REG_PERF_REGISTER:

  		return tracepoint_probe_register(call->tp,

  						 call->class->perf_probe,
  						 call);
  	case TRACE_REG_PERF_UNREGISTER:

  		tracepoint_probe_unregister(call->tp,

  					    call->class->perf_probe,
  					    call);
  		return 0;

  	case TRACE_REG_PERF_OPEN:
  	case TRACE_REG_PERF_CLOSE:

  	case TRACE_REG_PERF_ADD:
  	case TRACE_REG_PERF_DEL:

  		return 0;

  #endif
  	}
  	return 0;
  }
  EXPORT_SYMBOL_GPL(ftrace_event_reg);

  void trace_event_enable_cmd_record(bool enable)
  {

  	struct ftrace_event_file *file;
  	struct trace_array *tr;

  
  	mutex_lock(&event_mutex);

  	do_for_each_event_file(tr, file) {
  
  		if (!(file->flags & FTRACE_EVENT_FL_ENABLED))

  			continue;
  
  		if (enable) {
  			tracing_start_cmdline_record();

  			set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

  		} else {
  			tracing_stop_cmdline_record();

  			clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

  		}

  	} while_for_each_event_file();

  	mutex_unlock(&event_mutex);
  }

  static int __ftrace_event_enable_disable(struct ftrace_event_file *file,
  					 int enable, int soft_disable)

  {

  	struct ftrace_event_call *call = file->event_call;

  	int ret = 0;

  	int disable;

  	switch (enable) {
  	case 0:

  		/*

  		 * When soft_disable is set and enable is cleared, the sm_ref
  		 * reference counter is decremented. If it reaches 0, we want

  		 * to clear the SOFT_DISABLED flag but leave the event in the
  		 * state that it was. That is, if the event was enabled and
  		 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
  		 * is set we do not want the event to be enabled before we
  		 * clear the bit.
  		 *
  		 * When soft_disable is not set but the SOFT_MODE flag is,
  		 * we do nothing. Do not disable the tracepoint, otherwise
  		 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
  		 */
  		if (soft_disable) {

  			if (atomic_dec_return(&file->sm_ref) > 0)
  				break;

  			disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED;
  			clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);
  		} else
  			disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE);
  
  		if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) {
  			clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);

  			if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) {

  				tracing_stop_cmdline_record();

  				clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

  			}

  			call->class->reg(call, TRACE_REG_UNREGISTER, file);

  		}

  		/* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */

  		if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)
  			set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

  		else
  			clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

  		break;
  	case 1:

  		/*
  		 * When soft_disable is set and enable is set, we want to
  		 * register the tracepoint for the event, but leave the event
  		 * as is. That means, if the event was already enabled, we do
  		 * nothing (but set SOFT_MODE). If the event is disabled, we
  		 * set SOFT_DISABLED before enabling the event tracepoint, so
  		 * it still seems to be disabled.
  		 */
  		if (!soft_disable)
  			clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

  		else {
  			if (atomic_inc_return(&file->sm_ref) > 1)
  				break;

  			set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);

  		}

  		if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) {

  
  			/* Keep the event disabled, when going to SOFT_MODE. */
  			if (soft_disable)
  				set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);

  			if (trace_flags & TRACE_ITER_RECORD_CMD) {
  				tracing_start_cmdline_record();

  				set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);

  			}

  			ret = call->class->reg(call, TRACE_REG_REGISTER, file);

  			if (ret) {
  				tracing_stop_cmdline_record();
  				pr_info("event trace: Could not enable event "

  					"%s
  ", ftrace_event_name(call));

  				break;
  			}

  			set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);

  
  			/* WAS_ENABLED gets set but never cleared. */
  			call->flags |= TRACE_EVENT_FL_WAS_ENABLED;

  		}

  		break;
  	}

  
  	return ret;

  }

  int trace_event_enable_disable(struct ftrace_event_file *file,
  			       int enable, int soft_disable)
  {
  	return __ftrace_event_enable_disable(file, enable, soft_disable);
  }

  static int ftrace_event_enable_disable(struct ftrace_event_file *file,
  				       int enable)
  {
  	return __ftrace_event_enable_disable(file, enable, 0);
  }

  static void ftrace_clear_events(struct trace_array *tr)

  {

  	struct ftrace_event_file *file;

  
  	mutex_lock(&event_mutex);

  	list_for_each_entry(file, &tr->events, list) {
  		ftrace_event_enable_disable(file, 0);

  	}
  	mutex_unlock(&event_mutex);
  }

  static void __put_system(struct event_subsystem *system)
  {
  	struct event_filter *filter = system->filter;

  	WARN_ON_ONCE(system_refcount(system) == 0);
  	if (system_refcount_dec(system))

  		return;

  	list_del(&system->list);

  	if (filter) {
  		kfree(filter->filter_string);
  		kfree(filter);
  	}

  	if (system->ref_count & SYSTEM_FL_FREE_NAME)
  		kfree(system->name);

  	kfree(system);
  }
  
  static void __get_system(struct event_subsystem *system)
  {

  	WARN_ON_ONCE(system_refcount(system) == 0);
  	system_refcount_inc(system);

  }

  static void __get_system_dir(struct ftrace_subsystem_dir *dir)
  {
  	WARN_ON_ONCE(dir->ref_count == 0);
  	dir->ref_count++;
  	__get_system(dir->subsystem);
  }
  
  static void __put_system_dir(struct ftrace_subsystem_dir *dir)
  {
  	WARN_ON_ONCE(dir->ref_count == 0);
  	/* If the subsystem is about to be freed, the dir must be too */

  	WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);

  
  	__put_system(dir->subsystem);
  	if (!--dir->ref_count)
  		kfree(dir);
  }
  
  static void put_system(struct ftrace_subsystem_dir *dir)

  {
  	mutex_lock(&event_mutex);

  	__put_system_dir(dir);

  	mutex_unlock(&event_mutex);
  }

  static void remove_subsystem(struct ftrace_subsystem_dir *dir)
  {
  	if (!dir)
  		return;
  
  	if (!--dir->nr_events) {
  		debugfs_remove_recursive(dir->entry);
  		list_del(&dir->list);
  		__put_system_dir(dir);
  	}
  }

  static void remove_event_file_dir(struct ftrace_event_file *file)
  {

  	struct dentry *dir = file->dir;
  	struct dentry *child;
  
  	if (dir) {
  		spin_lock(&dir->d_lock);	/* probably unneeded */

  		list_for_each_entry(child, &dir->d_subdirs, d_child) {

  			if (child->d_inode)	/* probably unneeded */
  				child->d_inode->i_private = NULL;
  		}
  		spin_unlock(&dir->d_lock);
  
  		debugfs_remove_recursive(dir);
  	}

  	list_del(&file->list);

  	remove_subsystem(file->system);

  	free_event_filter(file->filter);

  	kmem_cache_free(file_cachep, file);
  }

  /*
   * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
   */

  static int
  __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
  			      const char *sub, const char *event, int set)

  {

  	struct ftrace_event_file *file;

  	struct ftrace_event_call *call;

  	const char *name;

  	int ret = -EINVAL;

  	list_for_each_entry(file, &tr->events, list) {
  
  		call = file->event_call;

  		name = ftrace_event_name(call);

  		if (!name || !call->class || !call->class->reg)

  			continue;

  		if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
  			continue;

  		if (match &&

  		    strcmp(match, name) != 0 &&

  		    strcmp(match, call->class->system) != 0)

  			continue;

  		if (sub && strcmp(sub, call->class->system) != 0)

  			continue;

  		if (event && strcmp(event, name) != 0)

  			continue;

  		ftrace_event_enable_disable(file, set);

  
  		ret = 0;
  	}

  
  	return ret;
  }
  
  static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
  				  const char *sub, const char *event, int set)
  {
  	int ret;
  
  	mutex_lock(&event_mutex);
  	ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);

  	mutex_unlock(&event_mutex);
  
  	return ret;
  }

  static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)

  {

  	char *event = NULL, *sub = NULL, *match;

  
  	/*
  	 * The buf format can be <subsystem>:<event-name>
  	 *  *:<event-name> means any event by that name.
  	 *  :<event-name> is the same.
  	 *
  	 *  <subsystem>:* means all events in that subsystem
  	 *  <subsystem>: means the same.
  	 *
  	 *  <name> (no ':') means all events in a subsystem with
  	 *  the name <name> or any event that matches <name>
  	 */
  
  	match = strsep(&buf, ":");
  	if (buf) {
  		sub = match;
  		event = buf;
  		match = NULL;
  
  		if (!strlen(sub) || strcmp(sub, "*") == 0)
  			sub = NULL;
  		if (!strlen(event) || strcmp(event, "*") == 0)
  			event = NULL;
  	}

  	return __ftrace_set_clr_event(tr, match, sub, event, set);

  }

  /**
   * trace_set_clr_event - enable or disable an event
   * @system: system name to match (NULL for any system)
   * @event: event name to match (NULL for all events, within system)
   * @set: 1 to enable, 0 to disable
   *
   * This is a way for other parts of the kernel to enable or disable
   * event recording.
   *
   * Returns 0 on success, -EINVAL if the parameters do not match any
   * registered events.
   */
  int trace_set_clr_event(const char *system, const char *event, int set)
  {

  	struct trace_array *tr = top_trace_array();

  	if (!tr)
  		return -ENODEV;

  	return __ftrace_set_clr_event(tr, NULL, system, event, set);

  }

  EXPORT_SYMBOL_GPL(trace_set_clr_event);

  /* 128 should be much more than enough */
  #define EVENT_BUF_SIZE		127
  
  static ssize_t
  ftrace_event_write(struct file *file, const char __user *ubuf,
  		   size_t cnt, loff_t *ppos)
  {

  	struct trace_parser parser;

  	struct seq_file *m = file->private_data;
  	struct trace_array *tr = m->private;

  	ssize_t read, ret;

  	if (!cnt)

  		return 0;

  	ret = tracing_update_buffers();
  	if (ret < 0)
  		return ret;

  	if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))

  		return -ENOMEM;

  	read = trace_get_user(&parser, ubuf, cnt, ppos);

  	if (read >= 0 && trace_parser_loaded((&parser))) {

  		int set = 1;

  		if (*parser.buffer == '!')

  			set = 0;

  		parser.buffer[parser.idx] = 0;

  		ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);

  		if (ret)

  			goto out_put;

  	}

  
  	ret = read;

   out_put:
  	trace_parser_put(&parser);

  
  	return ret;
  }
  
  static void *
  t_next(struct seq_file *m, void *v, loff_t *pos)
  {

  	struct ftrace_event_file *file = v;
  	struct ftrace_event_call *call;
  	struct trace_array *tr = m->private;

  
  	(*pos)++;

  	list_for_each_entry_continue(file, &tr->events, list) {
  		call = file->event_call;

  		/*
  		 * The ftrace subsystem is for showing formats only.
  		 * They can not be enabled or disabled via the event files.
  		 */

  		if (call->class && call->class->reg)

  			return file;

  	}

  	return NULL;

  }
  
  static void *t_start(struct seq_file *m, loff_t *pos)
  {

  	struct ftrace_event_file *file;
  	struct trace_array *tr = m->private;

  	loff_t l;

  	mutex_lock(&event_mutex);

  	file = list_entry(&tr->events, struct ftrace_event_file, list);

  	for (l = 0; l <= *pos; ) {

  		file = t_next(m, file, &l);
  		if (!file)

  			break;
  	}

  	return file;

  }
  
  static void *
  s_next(struct seq_file *m, void *v, loff_t *pos)
  {

  	struct ftrace_event_file *file = v;
  	struct trace_array *tr = m->private;

  
  	(*pos)++;

  	list_for_each_entry_continue(file, &tr->events, list) {
  		if (file->flags & FTRACE_EVENT_FL_ENABLED)
  			return file;

  	}

  	return NULL;

  }
  
  static void *s_start(struct seq_file *m, loff_t *pos)
  {

  	struct ftrace_event_file *file;
  	struct trace_array *tr = m->private;

  	loff_t l;

  	mutex_lock(&event_mutex);

  	file = list_entry(&tr->events, struct ftrace_event_file, list);

  	for (l = 0; l <= *pos; ) {

  		file = s_next(m, file, &l);
  		if (!file)

  			break;
  	}

  	return file;

  }
  
  static int t_show(struct seq_file *m, void *v)
  {

  	struct ftrace_event_file *file = v;
  	struct ftrace_event_call *call = file->event_call;

  	if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
  		seq_printf(m, "%s:", call->class->system);

  	seq_printf(m, "%s
  ", ftrace_event_name(call));

  
  	return 0;
  }
  
  static void t_stop(struct seq_file *m, void *p)
  {

  	mutex_unlock(&event_mutex);

  }

  static ssize_t
  event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
  		  loff_t *ppos)
  {

  	struct ftrace_event_file *file;
  	unsigned long flags;

  	char buf[4] = "0";

  	mutex_lock(&event_mutex);
  	file = event_file_data(filp);
  	if (likely(file))
  		flags = file->flags;
  	mutex_unlock(&event_mutex);
  
  	if (!file)
  		return -ENODEV;
  
  	if (flags & FTRACE_EVENT_FL_ENABLED &&
  	    !(flags & FTRACE_EVENT_FL_SOFT_DISABLED))

  		strcpy(buf, "1");

  	if (flags & FTRACE_EVENT_FL_SOFT_DISABLED ||
  	    flags & FTRACE_EVENT_FL_SOFT_MODE)

  		strcat(buf, "*");
  
  	strcat(buf, "
  ");

  	return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));

  }
  
  static ssize_t
  event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
  		   loff_t *ppos)
  {

  	struct ftrace_event_file *file;

  	unsigned long val;
  	int ret;

  	ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
  	if (ret)

  		return ret;

  	ret = tracing_update_buffers();
  	if (ret < 0)
  		return ret;

  	switch (val) {
  	case 0:

  	case 1:

  		ret = -ENODEV;

  		mutex_lock(&event_mutex);

  		file = event_file_data(filp);
  		if (likely(file))
  			ret = ftrace_event_enable_disable(file, val);

  		mutex_unlock(&event_mutex);

  		break;
  
  	default:
  		return -EINVAL;
  	}
  
  	*ppos += cnt;

  	return ret ? ret : cnt;

  }

  static ssize_t
  system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
  		   loff_t *ppos)
  {

  	const char set_to_char[4] = { '?', '0', '1', 'X' };

  	struct ftrace_subsystem_dir *dir = filp->private_data;
  	struct event_subsystem *system = dir->subsystem;

  	struct ftrace_event_call *call;

  	struct ftrace_event_file *file;
  	struct trace_array *tr = dir->tr;

  	char buf[2];

  	int set = 0;

  	int ret;

  	mutex_lock(&event_mutex);

  	list_for_each_entry(file, &tr->events, list) {
  		call = file->event_call;

  		if (!ftrace_event_name(call) || !call->class || !call->class->reg)

  			continue;

  		if (system && strcmp(call->class->system, system->name) != 0)

  			continue;
  
  		/*
  		 * We need to find out if all the events are set
  		 * or if all events or cleared, or if we have
  		 * a mixture.
  		 */

  		set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED));

  		/*
  		 * If we have a mixture, no need to look further.
  		 */

  		if (set == 3)

  			break;
  	}
  	mutex_unlock(&event_mutex);

  	buf[0] = set_to_char[set];

  	buf[1] = '
  ';

  
  	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
  
  	return ret;
  }
  
  static ssize_t
  system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
  		    loff_t *ppos)
  {

  	struct ftrace_subsystem_dir *dir = filp->private_data;
  	struct event_subsystem *system = dir->subsystem;

  	const char *name = NULL;

  	unsigned long val;

  	ssize_t ret;

  	ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
  	if (ret)

  		return ret;
  
  	ret = tracing_update_buffers();
  	if (ret < 0)
  		return ret;

  	if (val != 0 && val != 1)

  		return -EINVAL;

  	/*
  	 * Opening of "enable" adds a ref count to system,
  	 * so the name is safe to use.
  	 */
  	if (system)
  		name = system->name;

  	ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);

  	if (ret)

  		goto out;

  
  	ret = cnt;

  out:

  	*ppos += cnt;
  
  	return ret;
  }

  enum {
  	FORMAT_HEADER		= 1,

  	FORMAT_FIELD_SEPERATOR	= 2,
  	FORMAT_PRINTFMT		= 3,

  };
  
  static void *f_next(struct seq_file *m, void *v, loff_t *pos)

  {

  	struct ftrace_event_call *call = event_file_data(m->private);

  	struct list_head *common_head = &ftrace_common_fields;
  	struct list_head *head = trace_get_fields(call);

  	struct list_head *node = v;

  	(*pos)++;

  	switch ((unsigned long)v) {
  	case FORMAT_HEADER:

  		node = common_head;
  		break;

  	case FORMAT_FIELD_SEPERATOR:

  		node = head;
  		break;

  	case FORMAT_PRINTFMT:
  		/* all done */
  		return NULL;

  	}

  	node = node->prev;
  	if (node == common_head)

  		return (void *)FORMAT_FIELD_SEPERATOR;

  	else if (node == head)

  		return (void *)FORMAT_PRINTFMT;

  	else
  		return node;

  }
  
  static int f_show(struct seq_file *m, void *v)
  {

  	struct ftrace_event_call *call = event_file_data(m->private);

  	struct ftrace_event_field *field;
  	const char *array_descriptor;
  
  	switch ((unsigned long)v) {
  	case FORMAT_HEADER:

  		seq_printf(m, "name: %s
  ", ftrace_event_name(call));

  		seq_printf(m, "ID: %d
  ", call->event.type);

  		seq_puts(m, "format:
  ");

  		return 0;

  	case FORMAT_FIELD_SEPERATOR:
  		seq_putc(m, '
  ');
  		return 0;

  	case FORMAT_PRINTFMT:
  		seq_printf(m, "
  print fmt: %s
  ",
  			   call->print_fmt);
  		return 0;

  	}

  	field = list_entry(v, struct ftrace_event_field, link);

  	/*
  	 * Smartly shows the array type(except dynamic array).
  	 * Normal:
  	 *	field:TYPE VAR
  	 * If TYPE := TYPE[LEN], it is shown:
  	 *	field:TYPE VAR[LEN]
  	 */
  	array_descriptor = strchr(field->type, '[');

  	if (!strncmp(field->type, "__data_loc", 10))
  		array_descriptor = NULL;

  	if (!array_descriptor)
  		seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;
  ",
  			   field->type, field->name, field->offset,
  			   field->size, !!field->is_signed);
  	else
  		seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;
  ",
  			   (int)(array_descriptor - field->type),
  			   field->type, field->name,
  			   array_descriptor, field->offset,
  			   field->size, !!field->is_signed);

  	return 0;
  }

  static void *f_start(struct seq_file *m, loff_t *pos)
  {
  	void *p = (void *)FORMAT_HEADER;
  	loff_t l = 0;

  	/* ->stop() is called even if ->start() fails */
  	mutex_lock(&event_mutex);
  	if (!event_file_data(m->private))
  		return ERR_PTR(-ENODEV);

  	while (l < *pos && p)
  		p = f_next(m, p, &l);
  
  	return p;
  }

  static void f_stop(struct seq_file *m, void *p)
  {

  	mutex_unlock(&event_mutex);

  }

  static const struct seq_operations trace_format_seq_ops = {
  	.start		= f_start,
  	.next		= f_next,
  	.stop		= f_stop,
  	.show		= f_show,
  };
  
  static int trace_format_open(struct inode *inode, struct file *file)
  {

  	struct seq_file *m;
  	int ret;
  
  	ret = seq_open(file, &trace_format_seq_ops);
  	if (ret < 0)
  		return ret;
  
  	m = file->private_data;

  	m->private = file;

  
  	return 0;

  }

  static ssize_t
  event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
  {

  	int id = (long)event_file_data(filp);

  	char buf[32];
  	int len;

  
  	if (*ppos)
  		return 0;

  	if (unlikely(!id))
  		return -ENODEV;
  
  	len = sprintf(buf, "%d
  ", id);

  	return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);

  }

  static ssize_t
  event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
  		  loff_t *ppos)
  {

  	struct ftrace_event_file *file;

  	struct trace_seq *s;

  	int r = -ENODEV;

  
  	if (*ppos)
  		return 0;
  
  	s = kmalloc(sizeof(*s), GFP_KERNEL);

  	if (!s)
  		return -ENOMEM;
  
  	trace_seq_init(s);

  	mutex_lock(&event_mutex);

  	file = event_file_data(filp);
  	if (file)
  		print_event_filter(file, s);

  	mutex_unlock(&event_mutex);

  	if (file)

  		r = simple_read_from_buffer(ubuf, cnt, ppos,
  					    s->buffer, trace_seq_used(s));

  
  	kfree(s);
  
  	return r;
  }
  
  static ssize_t
  event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
  		   loff_t *ppos)
  {

  	struct ftrace_event_file *file;

  	char *buf;

  	int err = -ENODEV;

  	if (cnt >= PAGE_SIZE)

  		return -EINVAL;

  	buf = (char *)__get_free_page(GFP_TEMPORARY);
  	if (!buf)

  		return -ENOMEM;

  	if (copy_from_user(buf, ubuf, cnt)) {
  		free_page((unsigned long) buf);
  		return -EFAULT;

  	}

  	buf[cnt] = '\0';

  	mutex_lock(&event_mutex);

  	file = event_file_data(filp);
  	if (file)
  		err = apply_event_filter(file, buf);

  	mutex_unlock(&event_mutex);

  	free_page((unsigned long) buf);
  	if (err < 0)

  		return err;

  	*ppos += cnt;
  
  	return cnt;
  }

  static LIST_HEAD(event_subsystems);
  
  static int subsystem_open(struct inode *inode, struct file *filp)
  {
  	struct event_subsystem *system = NULL;

  	struct ftrace_subsystem_dir *dir = NULL; /* Initialize for gcc */
  	struct trace_array *tr;

  	int ret;

  	if (tracing_is_disabled())
  		return -ENODEV;

  	/* Make sure the system still exists */

  	mutex_lock(&trace_types_lock);

  	mutex_lock(&event_mutex);

  	list_for_each_entry(tr, &ftrace_trace_arrays, list) {
  		list_for_each_entry(dir, &tr->systems, list) {
  			if (dir == inode->i_private) {
  				/* Don't open systems with no events */
  				if (dir->nr_events) {
  					__get_system_dir(dir);
  					system = dir->subsystem;
  				}
  				goto exit_loop;

  			}

  		}
  	}

   exit_loop:

  	mutex_unlock(&event_mutex);

  	mutex_unlock(&trace_types_lock);

  	if (!system)

  		return -ENODEV;

  	/* Some versions of gcc think dir can be uninitialized here */
  	WARN_ON(!dir);

  	/* Still need to increment the ref count of the system */
  	if (trace_array_get(tr) < 0) {
  		put_system(dir);
  		return -ENODEV;
  	}

  	ret = tracing_open_generic(inode, filp);

  	if (ret < 0) {
  		trace_array_put(tr);

  		put_system(dir);

  	}

  
  	return ret;
  }
  
  static int system_tr_open(struct inode *inode, struct file *filp)
  {
  	struct ftrace_subsystem_dir *dir;
  	struct trace_array *tr = inode->i_private;
  	int ret;

  	if (tracing_is_disabled())
  		return -ENODEV;

  	if (trace_array_get(tr) < 0)
  		return -ENODEV;

  	/* Make a temporary dir that has no system but points to tr */
  	dir = kzalloc(sizeof(*dir), GFP_KERNEL);

  	if (!dir) {
  		trace_array_put(tr);

  		return -ENOMEM;

  	}

  
  	dir->tr = tr;
  
  	ret = tracing_open_generic(inode, filp);

  	if (ret < 0) {
  		trace_array_put(tr);

  		kfree(dir);

  		return ret;

  	}

  
  	filp->private_data = dir;

  	return 0;

  }
  
  static int subsystem_release(struct inode *inode, struct file *file)
  {

  	struct ftrace_subsystem_dir *dir = file->private_data;

  	trace_array_put(dir->tr);

  	/*
  	 * If dir->subsystem is NULL, then this is a temporary
  	 * descriptor that was made for a trace_array to enable
  	 * all subsystems.
  	 */
  	if (dir->subsystem)
  		put_system(dir);
  	else
  		kfree(dir);

  
  	return 0;
  }

  static ssize_t
  subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
  		      loff_t *ppos)
  {

  	struct ftrace_subsystem_dir *dir = filp->private_data;
  	struct event_subsystem *system = dir->subsystem;

  	struct trace_seq *s;
  	int r;
  
  	if (*ppos)
  		return 0;
  
  	s = kmalloc(sizeof(*s), GFP_KERNEL);
  	if (!s)
  		return -ENOMEM;
  
  	trace_seq_init(s);

  	print_subsystem_event_filter(system, s);

  	r = simple_read_from_buffer(ubuf, cnt, ppos,
  				    s->buffer, trace_seq_used(s));

  
  	kfree(s);
  
  	return r;
  }
  
  static ssize_t
  subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
  		       loff_t *ppos)
  {

  	struct ftrace_subsystem_dir *dir = filp->private_data;

  	char *buf;

  	int err;

  	if (cnt >= PAGE_SIZE)

  		return -EINVAL;

  	buf = (char *)__get_free_page(GFP_TEMPORARY);
  	if (!buf)

  		return -ENOMEM;

  	if (copy_from_user(buf, ubuf, cnt)) {
  		free_page((unsigned long) buf);
  		return -EFAULT;

  	}

  	buf[cnt] = '\0';

  	err = apply_subsystem_event_filter(dir, buf);

  	free_page((unsigned long) buf);
  	if (err < 0)

  		return err;

  
  	*ppos += cnt;
  
  	return cnt;
  }

  static ssize_t
  show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
  {
  	int (*func)(struct trace_seq *s) = filp->private_data;
  	struct trace_seq *s;
  	int r;
  
  	if (*ppos)
  		return 0;
  
  	s = kmalloc(sizeof(*s), GFP_KERNEL);
  	if (!s)
  		return -ENOMEM;
  
  	trace_seq_init(s);
  
  	func(s);

  	r = simple_read_from_buffer(ubuf, cnt, ppos,
  				    s->buffer, trace_seq_used(s));

  
  	kfree(s);
  
  	return r;
  }

  static int ftrace_event_avail_open(struct inode *inode, struct file *file);
  static int ftrace_event_set_open(struct inode *inode, struct file *file);

  static int ftrace_event_release(struct inode *inode, struct file *file);

  static const struct seq_operations show_event_seq_ops = {
  	.start = t_start,
  	.next = t_next,
  	.show = t_show,
  	.stop = t_stop,
  };
  
  static const struct seq_operations show_set_event_seq_ops = {
  	.start = s_start,
  	.next = s_next,
  	.show = t_show,
  	.stop = t_stop,
  };

  static const struct file_operations ftrace_avail_fops = {

  	.open = ftrace_event_avail_open,

  	.read = seq_read,
  	.llseek = seq_lseek,
  	.release = seq_release,
  };

  static const struct file_operations ftrace_set_event_fops = {

  	.open = ftrace_event_set_open,

  	.read = seq_read,
  	.write = ftrace_event_write,
  	.llseek = seq_lseek,

  	.release = ftrace_event_release,

  };

  static const struct file_operations ftrace_enable_fops = {

  	.open = tracing_open_generic,

  	.read = event_enable_read,
  	.write = event_enable_write,

  	.llseek = default_llseek,

  };

  static const struct file_operations ftrace_event_format_fops = {

  	.open = trace_format_open,
  	.read = seq_read,
  	.llseek = seq_lseek,
  	.release = seq_release,

  };

  static const struct file_operations ftrace_event_id_fops = {

  	.read = event_id_read,

  	.llseek = default_llseek,

  };

  static const struct file_operations ftrace_event_filter_fops = {
  	.open = tracing_open_generic,
  	.read = event_filter_read,
  	.write = event_filter_write,

  	.llseek = default_llseek,

  };

  static const struct file_operations ftrace_subsystem_filter_fops = {

  	.open = subsystem_open,

  	.read = subsystem_filter_read,
  	.write = subsystem_filter_write,

  	.llseek = default_llseek,

  	.release = subsystem_release,

  };

  static const struct file_operations ftrace_system_enable_fops = {

  	.open = subsystem_open,

  	.read = system_enable_read,
  	.write = system_enable_write,

  	.llseek = default_llseek,

  	.release = subsystem_release,

  };

  static const struct file_operations ftrace_tr_enable_fops = {
  	.open = system_tr_open,
  	.read = system_enable_read,
  	.write = system_enable_write,
  	.llseek = default_llseek,
  	.release = subsystem_release,
  };

  static const struct file_operations ftrace_show_header_fops = {
  	.open = tracing_open_generic,
  	.read = show_header,

  	.llseek = default_llseek,

  };

  static int
  ftrace_event_open(struct inode *inode, struct file *file,
  		  const struct seq_operations *seq_ops)

  {

  	struct seq_file *m;
  	int ret;

  	ret = seq_open(file, seq_ops);
  	if (ret < 0)
  		return ret;
  	m = file->private_data;
  	/* copy tr over to seq ops */
  	m->private = inode->i_private;

  	return ret;

  }

  static int ftrace_event_release(struct inode *inode, struct file *file)
  {
  	struct trace_array *tr = inode->i_private;
  
  	trace_array_put(tr);
  
  	return seq_release(inode, file);
  }

  static int
  ftrace_event_avail_open(struct inode *inode, struct file *file)
  {
  	const struct seq_operations *seq_ops = &show_event_seq_ops;

  	return ftrace_event_open(inode, file, seq_ops);

  }
  
  static int
  ftrace_event_set_open(struct inode *inode, struct file *file)
  {
  	const struct seq_operations *seq_ops = &show_set_event_seq_ops;

  	struct trace_array *tr = inode->i_private;

  	int ret;
  
  	if (trace_array_get(tr) < 0)
  		return -ENODEV;

  
  	if ((file->f_mode & FMODE_WRITE) &&
  	    (file->f_flags & O_TRUNC))

  		ftrace_clear_events(tr);

  	ret = ftrace_event_open(inode, file, seq_ops);
  	if (ret < 0)
  		trace_array_put(tr);
  	return ret;

  }
  
  static struct event_subsystem *
  create_new_subsystem(const char *name)
  {
  	struct event_subsystem *system;
  
  	/* need to create new entry */
  	system = kmalloc(sizeof(*system), GFP_KERNEL);
  	if (!system)
  		return NULL;
  
  	system->ref_count = 1;

  
  	/* Only allocate if dynamic (kprobes and modules) */
  	if (!core_kernel_data((unsigned long)name)) {
  		system->ref_count |= SYSTEM_FL_FREE_NAME;
  		system->name = kstrdup(name, GFP_KERNEL);
  		if (!system->name)
  			goto out_free;
  	} else
  		system->name = name;

  
  	system->filter = NULL;
  
  	system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
  	if (!system->filter)
  		goto out_free;
  
  	list_add(&system->list, &event_subsystems);
  
  	return system;
  
   out_free:

  	if (system->ref_count & SYSTEM_FL_FREE_NAME)
  		kfree(system->name);

  	kfree(system);
  	return NULL;

  }

  static struct dentry *

  event_subsystem_dir(struct trace_array *tr, const char *name,
  		    struct ftrace_event_file *file, struct dentry *parent)

  {

  	struct ftrace_subsystem_dir *dir;

  	struct event_subsystem *system;

  	struct dentry *entry;

  
  	/* First see if we did not already create this dir */

  	list_for_each_entry(dir, &tr->systems, list) {
  		system = dir->subsystem;

  		if (strcmp(system->name, name) == 0) {

  			dir->nr_events++;
  			file->system = dir;
  			return dir->entry;

  		}

  	}

  	/* Now see if the system itself exists. */
  	list_for_each_entry(system, &event_subsystems, list) {
  		if (strcmp(system->name, name) == 0)
  			break;

  	}

  	/* Reset system variable when not found */
  	if (&system->list == &event_subsystems)
  		system = NULL;

  	dir = kmalloc(sizeof(*dir), GFP_KERNEL);
  	if (!dir)
  		goto out_fail;

  	if (!system) {
  		system = create_new_subsystem(name);
  		if (!system)
  			goto out_free;
  	} else
  		__get_system(system);
  
  	dir->entry = debugfs_create_dir(name, parent);
  	if (!dir->entry) {

  		pr_warn("Failed to create system directory %s
  ", name);

  		__put_system(system);
  		goto out_free;

  	}

  	dir->tr = tr;
  	dir->ref_count = 1;
  	dir->nr_events = 1;
  	dir->subsystem = system;
  	file->system = dir;

  	entry = debugfs_create_file("filter", 0644, dir->entry, dir,

  				    &ftrace_subsystem_filter_fops);

  	if (!entry) {
  		kfree(system->filter);
  		system->filter = NULL;

  		pr_warn("Could not create debugfs '%s/filter' entry
  ", name);

  	}

  	trace_create_file("enable", 0644, dir->entry, dir,

  			  &ftrace_system_enable_fops);

  	list_add(&dir->list, &tr->systems);
  
  	return dir->entry;
  
   out_free:
  	kfree(dir);
   out_fail:
  	/* Only print this message if failed on memory allocation */
  	if (!dir || !system)

  		pr_warn("No memory to create event subsystem %s
  ", name);

  	return NULL;

  }

  static int

  event_create_dir(struct dentry *parent, struct ftrace_event_file *file)

  {

  	struct ftrace_event_call *call = file->event_call;
  	struct trace_array *tr = file->tr;

  	struct list_head *head;

  	struct dentry *d_events;

  	const char *name;

  	int ret;

  	/*
  	 * If the trace point header did not define TRACE_SYSTEM
  	 * then the system would be called "TRACE_SYSTEM".
  	 */

  	if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
  		d_events = event_subsystem_dir(tr, call->class->system, file, parent);
  		if (!d_events)
  			return -ENOMEM;
  	} else
  		d_events = parent;

  	name = ftrace_event_name(call);
  	file->dir = debugfs_create_dir(name, d_events);

  	if (!file->dir) {

  		pr_warn("Could not create debugfs '%s' directory
  ", name);

  		return -1;
  	}

  	if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))

  		trace_create_file("enable", 0644, file->dir, file,

  				  &ftrace_enable_fops);

  #ifdef CONFIG_PERF_EVENTS

  	if (call->event.type && call->class->reg)

  		trace_create_file("id", 0444, file->dir,

  				  (void *)(long)call->event.type,
  				  &ftrace_event_id_fops);

  #endif

  	/*
  	 * Other events may have the same class. Only update
  	 * the fields if they are not already defined.
  	 */
  	head = trace_get_fields(call);
  	if (list_empty(head)) {
  		ret = call->class->define_fields(call);
  		if (ret < 0) {

  			pr_warn("Could not initialize trace point events/%s
  ",
  				name);

  			return -1;

  		}
  	}

  	trace_create_file("filter", 0644, file->dir, file,

  			  &ftrace_event_filter_fops);

  	trace_create_file("trigger", 0644, file->dir, file,
  			  &event_trigger_fops);

  	trace_create_file("format", 0444, file->dir, call,

  			  &ftrace_event_format_fops);

  
  	return 0;
  }

  static void remove_event_from_tracers(struct ftrace_event_call *call)
  {
  	struct ftrace_event_file *file;
  	struct trace_array *tr;
  
  	do_for_each_event_file_safe(tr, file) {

  		if (file->event_call != call)
  			continue;

  		remove_event_file_dir(file);

  		/*
  		 * The do_for_each_event_file_safe() is
  		 * a double loop. After finding the call for this
  		 * trace_array, we use break to jump to the next
  		 * trace_array.
  		 */
  		break;
  	} while_for_each_event_file();
  }

  static void event_remove(struct ftrace_event_call *call)
  {

  	struct trace_array *tr;
  	struct ftrace_event_file *file;
  
  	do_for_each_event_file(tr, file) {
  		if (file->event_call != call)
  			continue;
  		ftrace_event_enable_disable(file, 0);
  		/*
  		 * The do_for_each_event_file() is
  		 * a double loop. After finding the call for this
  		 * trace_array, we use break to jump to the next
  		 * trace_array.
  		 */
  		break;
  	} while_for_each_event_file();

  	if (call->event.funcs)
  		__unregister_ftrace_event(&call->event);

  	remove_event_from_tracers(call);

  	list_del(&call->list);
  }
  
  static int event_init(struct ftrace_event_call *call)
  {
  	int ret = 0;

  	const char *name;

  	name = ftrace_event_name(call);
  	if (WARN_ON(!name))

  		return -EINVAL;
  
  	if (call->class->raw_init) {
  		ret = call->class->raw_init(call);
  		if (ret < 0 && ret != -ENOSYS)

  			pr_warn("Could not initialize trace events/%s
  ", name);

  	}
  
  	return ret;
  }

  static int

  __register_event(struct ftrace_event_call *call, struct module *mod)

  {

  	int ret;