tracing: Merge struct event_trigger_ops into struct event_command

	unsigned long			count;

	int				ref;

	int				flags;

	const struct event_trigger_ops	*ops;

	struct event_command		*cmd_ops;

	struct event_filter __rcu	*filter;

	char				*filter_str;

extern void event_file_get(struct trace_event_file *file);

extern void event_file_put(struct trace_event_file *file);

/**

 * struct event_trigger_ops - callbacks for trace event triggers

 *

 * The methods in this structure provide per-event trigger hooks for

 * various trigger operations.

 *

 * The @init and @free methods are used during trigger setup and

 * teardown, typically called from an event_command's @parse()

 * function implementation.

 *

 * The @print method is used to print the trigger spec.

 *

 * The @trigger method is the function that actually implements the

 * trigger and is called in the context of the triggering event

 * whenever that event occurs.

 *

 * All the methods below, except for @init() and @free(), must be

 * implemented.

 *

 * @trigger: The trigger 'probe' function called when the triggering

 *	event occurs.  The data passed into this callback is the data

 *	that was supplied to the event_command @reg() function that

 *	registered the trigger (see struct event_command) along with

 *	the trace record, rec.

 *

 * @count_func: If defined and a numeric parameter is passed to the

 *	trigger, then this function will be called before @trigger

 *	is called. If this function returns false, then @trigger is not

 *	executed.

 *

 * @init: An optional initialization function called for the trigger

 *	when the trigger is registered (via the event_command reg()

 *	function).  This can be used to perform per-trigger

 *	initialization such as incrementing a per-trigger reference

 *	count, for instance.  This is usually implemented by the

 *	generic utility function @event_trigger_init() (see

 *	trace_event_triggers.c).

 *

 * @free: An optional de-initialization function called for the

 *	trigger when the trigger is unregistered (via the

 *	event_command @reg() function).  This can be used to perform

 *	per-trigger de-initialization such as decrementing a

 *	per-trigger reference count and freeing corresponding trigger

 *	data, for instance.  This is usually implemented by the

 *	generic utility function @event_trigger_free() (see

 *	trace_event_triggers.c).

 *

 * @print: The callback function invoked to have the trigger print

 *	itself.  This is usually implemented by a wrapper function

 *	that calls the generic utility function @event_trigger_print()

 *	(see trace_event_triggers.c).

 */

struct event_trigger_ops {

	void			(*trigger)(struct event_trigger_data *data,

					   struct trace_buffer *buffer,

					   void *rec,

					   struct ring_buffer_event *rbe);

	bool			(*count_func)(struct event_trigger_data *data,

					      struct trace_buffer *buffer,

					      void *rec,

					      struct ring_buffer_event *rbe);

	int			(*init)(struct event_trigger_data *data);

	void			(*free)(struct event_trigger_data *data);

	int			(*print)(struct seq_file *m,

					 struct event_trigger_data *data);

};

/**

 * struct event_command - callbacks and data members for event commands

 *

 * @name: The unique name that identifies the event command.  This is

 *	the name used when setting triggers via trigger files.

 *

 * @trigger_ops: The event_trigger_ops implementation associated with

 *	the command.

 *

 * @trigger_type: A unique id that identifies the event command

 *	'type'.  This value has two purposes, the first to ensure that

 *	only one trigger of the same type can be set at a given time

 *

 * @reg: Adds the trigger to the list of triggers associated with the

 *	event, and enables the event trigger itself, after

 *	initializing it (via the event_trigger_ops @init() function).

 *	initializing it (via the event_command @init() function).

 *	This is also where commands can use the @trigger_type value to

 *	make the decision as to whether or not multiple instances of

 *	the trigger should be allowed.  This is usually implemented by

 *

 * @unreg: Removes the trigger from the list of triggers associated

 *	with the event, and disables the event trigger itself, after

 *	initializing it (via the event_trigger_ops @free() function).

 *	initializing it (via the event_command @free() function).

 *	This is usually implemented by the generic utility function

 *	@unregister_trigger() (see trace_event_triggers.c).

 *

 *	event command, filters set by the user for the command will be

 *	ignored.  This is usually implemented by the generic utility

 *	function @set_trigger_filter() (see trace_event_triggers.c).

 *

 * All the methods below, except for @init() and @free(), must be

 * implemented.

 *

 * @trigger: The trigger 'probe' function called when the triggering

 *	event occurs.  The data passed into this callback is the data

 *	that was supplied to the event_command @reg() function that

 *	registered the trigger (see struct event_command) along with

 *	the trace record, rec.

 *

 * @count_func: If defined and a numeric parameter is passed to the

 *	trigger, then this function will be called before @trigger

 *	is called. If this function returns false, then @trigger is not

 *	executed.

 *

 * @init: An optional initialization function called for the trigger

 *	when the trigger is registered (via the event_command reg()

 *	function).  This can be used to perform per-trigger

 *	initialization such as incrementing a per-trigger reference

 *	count, for instance.  This is usually implemented by the

 *	generic utility function @event_trigger_init() (see

 *	trace_event_triggers.c).

 *

 * @free: An optional de-initialization function called for the

 *	trigger when the trigger is unregistered (via the

 *	event_command @reg() function).  This can be used to perform

 *	per-trigger de-initialization such as decrementing a

 *	per-trigger reference count and freeing corresponding trigger

 *	data, for instance.  This is usually implemented by the

 *	generic utility function @event_trigger_free() (see

 *	trace_event_triggers.c).

 *

 * @print: The callback function invoked to have the trigger print

 *	itself.  This is usually implemented by a wrapper function

 *	that calls the generic utility function @event_trigger_print()

 *	(see trace_event_triggers.c).

 */

struct event_command {

	struct list_head	list;

	char			*name;

	const struct event_trigger_ops *trigger_ops;

	enum event_trigger_type	trigger_type;

	int			flags;

	int			(*parse)(struct event_command *cmd_ops,

	int			(*set_filter)(char *filter_str,

					      struct event_trigger_data *data,

					      struct trace_event_file *file);

	void			(*trigger)(struct event_trigger_data *data,

					   struct trace_buffer *buffer,

					   void *rec,

					   struct ring_buffer_event *rbe);

	bool			(*count_func)(struct event_trigger_data *data,

					      struct trace_buffer *buffer,

					      void *rec,

					      struct ring_buffer_event *rbe);

	int			(*init)(struct event_trigger_data *data);

	void			(*free)(struct event_trigger_data *data);

	int			(*print)(struct seq_file *m,

					 struct event_trigger_data *data);

};

/**

 *	either committed or discarded.  At that point, if any commands

 *	have deferred their triggers, those commands are finally

 *	invoked following the close of the current event.  In other

 *	words, if the event_trigger_ops @func() probe implementation

 *	words, if the event_command @func() probe implementation

 *	itself logs to the trace buffer, this flag should be set,

 *	otherwise it can be left unspecified.

 *

	__eprobe_trace_func(edata, rec);

}

static const struct event_trigger_ops eprobe_trigger_ops = {

	.trigger		= eprobe_trigger_func,

	.print			= eprobe_trigger_print,

	.init			= eprobe_trigger_init,

	.free			= eprobe_trigger_free,

};

static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops,

				    struct trace_event_file *file,

				    char *glob, char *cmd,

	.name			= "eprobe",

	.trigger_type		= ETT_EVENT_EPROBE,

	.flags			= EVENT_CMD_FL_NEEDS_REC,

	.trigger_ops		= &eprobe_trigger_ops,

	.parse			= eprobe_trigger_cmd_parse,

	.reg			= eprobe_trigger_reg_func,

	.unreg			= eprobe_trigger_unreg_func,

	.unreg_all		= NULL,

	.set_filter		= NULL,

	.trigger		= eprobe_trigger_func,

	.print			= eprobe_trigger_print,

	.init			= eprobe_trigger_init,

	.free			= eprobe_trigger_free,

};

static struct event_trigger_data *

	trigger->flags = EVENT_TRIGGER_FL_PROBE;

	trigger->count = -1;

	trigger->ops = &eprobe_trigger_ops;

	/*

	 * EVENT PROBE triggers are not registered as commands with

		seq_puts(m, "\n\n");

	seq_puts(m, "# event histogram\n#\n# trigger info: ");

	data->ops->print(m, data);

	data->cmd_ops->print(m, data);

	seq_puts(m, "#\n\n");

	hist_data = data->private_data;

		seq_puts(m, "\n\n");

	seq_puts(m, "# event histogram\n#\n# trigger info: ");

	data->ops->print(m, data);

	data->cmd_ops->print(m, data);

	seq_puts(m, "#\n\n");

	hist_data = data->private_data;

	free_hist_pad();

}

static const struct event_trigger_ops event_hist_trigger_ops = {

	.trigger		= event_hist_trigger,

	.print			= event_hist_trigger_print,

	.init			= event_hist_trigger_init,

	.free			= event_hist_trigger_free,

};

static int event_hist_trigger_named_init(struct event_trigger_data *data)

{

	int ret;

	data->ref++;

	save_named_trigger(data->named_data->name, data);

	return event_hist_trigger_init(data->named_data);

	ret = event_hist_trigger_init(data->named_data);

	if (ret < 0) {

		kfree(data->cmd_ops);

		data->cmd_ops = &trigger_hist_cmd;

	}

	return ret;

}

static void event_hist_trigger_named_free(struct event_trigger_data *data)

	data->ref--;

	if (!data->ref) {

		struct event_command *cmd_ops = data->cmd_ops;

		del_named_trigger(data);

		trigger_data_free(data);

		kfree(cmd_ops);

	}

}

static const struct event_trigger_ops event_hist_trigger_named_ops = {

	.trigger		= event_hist_trigger,

	.print			= event_hist_trigger_print,

	.init			= event_hist_trigger_named_init,

	.free			= event_hist_trigger_named_free,

};

static void hist_clear(struct event_trigger_data *data)

{

	struct hist_trigger_data *hist_data = data->private_data;

		data->paused = true;

	if (named_data) {

		struct event_command *cmd_ops;

		data->private_data = named_data->private_data;

		set_named_trigger_data(data, named_data);

		data->ops = &event_hist_trigger_named_ops;

		/* Copy the command ops and update some of the functions */

		cmd_ops = kmalloc(sizeof(*cmd_ops), GFP_KERNEL);

		if (!cmd_ops) {

			ret = -ENOMEM;

			goto out;

		}

		*cmd_ops = *data->cmd_ops;

		cmd_ops->init = event_hist_trigger_named_init;

		cmd_ops->free = event_hist_trigger_named_free;

		data->cmd_ops = cmd_ops;

	}

	if (data->ops->init) {

		ret = data->ops->init(data);

	if (data->cmd_ops->init) {

		ret = data->cmd_ops->init(data);

		if (ret < 0)

			goto out;

	}

		}

	}

	if (test && test->ops->free)

		test->ops->free(test);

	if (test && test->cmd_ops->free)

		test->cmd_ops->free(test);

	if (hist_data->enable_timestamps) {

		if (!hist_data->remove || test)

			update_cond_flag(file);

			if (hist_data->enable_timestamps)

				tracing_set_filter_buffering(file->tr, false);

			if (test->ops->free)

				test->ops->free(test);

			if (test->cmd_ops->free)

				test->cmd_ops->free(test);

		}

	}

}

	.name			= "hist",

	.trigger_type		= ETT_EVENT_HIST,

	.flags			= EVENT_CMD_FL_NEEDS_REC,

	.trigger_ops		= &event_hist_trigger_ops,

	.parse			= event_hist_trigger_parse,

	.reg			= hist_register_trigger,

	.unreg			= hist_unregister_trigger,

	.unreg_all		= hist_unreg_all,

	.set_filter		= set_trigger_filter,

	.trigger		= event_hist_trigger,

	.print			= event_hist_trigger_print,

	.init			= event_hist_trigger_init,

	.free			= event_hist_trigger_free,

};

__init int register_trigger_hist_cmd(void)

	}

}

static const struct event_trigger_ops hist_enable_trigger_ops = {

	.trigger		= hist_enable_trigger,

	.count_func		= event_trigger_count,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

static const struct event_trigger_ops hist_disable_trigger_ops = {

	.trigger		= hist_enable_trigger,

	.count_func		= event_trigger_count,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

static void hist_enable_unreg_all(struct trace_event_file *file)

{

	struct event_trigger_data *test, *n;

			list_del_rcu(&test->list);

			update_cond_flag(file);

			trace_event_trigger_enable_disable(file, 0);

			if (test->ops->free)

				test->ops->free(test);

			if (test->cmd_ops->free)

				test->cmd_ops->free(test);

		}

	}

}

static struct event_command trigger_hist_enable_cmd = {

	.name			= ENABLE_HIST_STR,

	.trigger_type		= ETT_HIST_ENABLE,

	.trigger_ops		= &hist_enable_trigger_ops,

	.parse			= event_enable_trigger_parse,

	.reg			= event_enable_register_trigger,

	.unreg			= event_enable_unregister_trigger,

	.unreg_all		= hist_enable_unreg_all,

	.set_filter		= set_trigger_filter,

	.trigger		= hist_enable_trigger,

	.count_func		= event_trigger_count,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

static struct event_command trigger_hist_disable_cmd = {

	.name			= DISABLE_HIST_STR,

	.trigger_type		= ETT_HIST_ENABLE,

	.trigger_ops		= &hist_disable_trigger_ops,

	.parse			= event_enable_trigger_parse,

	.reg			= event_enable_register_trigger,

	.unreg			= event_enable_unregister_trigger,

	.unreg_all		= hist_enable_unreg_all,

	.set_filter		= set_trigger_filter,

	.trigger		= hist_enable_trigger,

	.count_func		= event_trigger_count,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

static __init void unregister_trigger_hist_enable_disable_cmds(void)

				    struct trace_buffer *buffer,  void *rec,

				    struct ring_buffer_event *event)

{

	const struct event_trigger_ops *ops = data->ops;

	const struct event_command *cmd_ops = data->cmd_ops;

	if (data->flags & EVENT_TRIGGER_FL_COUNT) {

		if (!ops->count_func(data, buffer, rec, event))

		if (!cmd_ops->count_func(data, buffer, rec, event))

			return;

	}

	ops->trigger(data, buffer, rec, event);

	cmd_ops->trigger(data, buffer, rec, event);

}

/**

	}

	data = list_entry(v, struct event_trigger_data, list);

	data->ops->print(m, data);

	data->cmd_ops->print(m, data);

	return 0;

}

}

/**

 * event_trigger_print - Generic event_trigger_ops @print implementation

 * event_trigger_print - Generic event_command @print implementation

 * @name: The name of the event trigger

 * @m: The seq_file being printed to

 * @data: Trigger-specific data

}

/**

 * event_trigger_init - Generic event_trigger_ops @init implementation

 * event_trigger_init - Generic event_command @init implementation

 * @data: Trigger-specific data

 *

 * Common implementation of event trigger initialization.

}

/**

 * event_trigger_free - Generic event_trigger_ops @free implementation

 * event_trigger_free - Generic event_command @free implementation

 * @data: Trigger-specific data

 *

 * Common implementation of event trigger de-initialization.

		list_for_each_entry_safe(data, n, &file->triggers, list) {

			trace_event_trigger_enable_disable(file, 0);

			list_del_rcu(&data->list);

			if (data->ops->free)

				data->ops->free(data);

			if (data->cmd_ops->free)

				data->cmd_ops->free(data);

		}

	}

}

			return -EEXIST;

	}

	if (data->ops->init) {

		ret = data->ops->init(data);

	if (data->cmd_ops->init) {

		ret = data->cmd_ops->init(data);

		if (ret < 0)

			return ret;

	}

	}

	if (data) {

		if (data->ops->free)

			data->ops->free(data);

		if (data->cmd_ops->free)

			data->cmd_ops->free(data);

		return true;

	}

		return NULL;

	trigger_data->count = -1;

	trigger_data->ops = cmd_ops->trigger_ops;

	trigger_data->cmd_ops = cmd_ops;

	trigger_data->private_data = private_data;

	if (param && cmd_ops->trigger_ops->count_func)

	if (param && cmd_ops->count_func)

		trigger_data->flags |= EVENT_TRIGGER_FL_COUNT;

	INIT_LIST_HEAD(&trigger_data->list);

				   data->filter_str);

}

static const struct event_trigger_ops traceon_trigger_ops = {

	.trigger		= traceon_trigger,

	.count_func		= traceon_count_func,

	.print			= traceon_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static const struct event_trigger_ops traceoff_trigger_ops = {

	.trigger		= traceoff_trigger,

	.count_func		= traceoff_count_func,

	.print			= traceoff_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static struct event_command trigger_traceon_cmd = {

	.name			= "traceon",

	.trigger_type		= ETT_TRACE_ONOFF,

	.trigger_ops		= &traceon_trigger_ops,

	.parse			= event_trigger_parse,

	.reg			= register_trigger,

	.unreg			= unregister_trigger,

	.set_filter		= set_trigger_filter,

	.trigger		= traceon_trigger,

	.count_func		= traceon_count_func,

	.print			= traceon_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static struct event_command trigger_traceoff_cmd = {

	.name			= "traceoff",

	.trigger_type		= ETT_TRACE_ONOFF,

	.flags			= EVENT_CMD_FL_POST_TRIGGER,

	.trigger_ops		= &traceoff_trigger_ops,

	.parse			= event_trigger_parse,

	.reg			= register_trigger,

	.unreg			= unregister_trigger,

	.set_filter		= set_trigger_filter,

	.trigger		= traceoff_trigger,

	.count_func		= traceoff_count_func,

	.print			= traceoff_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

#ifdef CONFIG_TRACER_SNAPSHOT

				   data->filter_str);

}

static const struct event_trigger_ops snapshot_trigger_ops = {

	.trigger		= snapshot_trigger,

	.count_func		= event_trigger_count,

	.print			= snapshot_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static struct event_command trigger_snapshot_cmd = {

	.name			= "snapshot",

	.trigger_type		= ETT_SNAPSHOT,

	.trigger_ops		= &snapshot_trigger_ops,

	.parse			= event_trigger_parse,

	.reg			= register_snapshot_trigger,

	.unreg			= unregister_snapshot_trigger,

	.set_filter		= set_trigger_filter,

	.trigger		= snapshot_trigger,

	.count_func		= event_trigger_count,

	.print			= snapshot_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static __init int register_trigger_snapshot_cmd(void)

				   data->filter_str);

}

static const struct event_trigger_ops stacktrace_trigger_ops = {

	.trigger		= stacktrace_trigger,

	.count_func		= event_trigger_count,

	.print			= stacktrace_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static struct event_command trigger_stacktrace_cmd = {

	.name			= "stacktrace",

	.trigger_type		= ETT_STACKTRACE,

	.trigger_ops		= &stacktrace_trigger_ops,

	.flags			= EVENT_CMD_FL_POST_TRIGGER,

	.parse			= event_trigger_parse,

	.reg			= register_trigger,

	.unreg			= unregister_trigger,

	.set_filter		= set_trigger_filter,

	.trigger		= stacktrace_trigger,

	.count_func		= event_trigger_count,

	.print			= stacktrace_trigger_print,

	.init			= event_trigger_init,

	.free			= event_trigger_free,

};

static __init int register_trigger_stacktrace_cmd(void)

	}

}

static const struct event_trigger_ops event_enable_trigger_ops = {

	.trigger		= event_enable_trigger,

	.count_func		= event_enable_count_func,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

static const struct event_trigger_ops event_disable_trigger_ops = {

	.trigger		= event_enable_trigger,

	.count_func		= event_enable_count_func,

	.print			= event_enable_trigger_print,

	.init			= event_trigger_init,

	.free			= event_enable_trigger_free,

};

int event_enable_trigger_parse(struct event_command *cmd_ops,

			       struct trace_event_file *file,

			       char *glob, char *cmd, char *param_and_filter)

		}

	}

	if (data->ops->init) {

		ret = data->ops->init(data);

	if (data->cmd_ops->init) {