jsauer/torvalds-linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-01-11 17:10:13 +00:00
Code

tracing: Merge struct event_trigger_ops into struct event_command

Browse Source 
Now that there's pretty much a one to one mapping between the struct
event_trigger_ops and struct event_command, there's no reason to have two
different structures. Merge the function pointers of event_trigger_ops
into event_command.

There's one exception in trace_events_hist.c for the
event_hist_trigger_named_ops. This has special logic for the init and free
function pointers for "named histograms". In this case, allocate the
cmd_ops of the event_trigger_data and set it to the proper init and free
functions, which are used to initialize and free the event_trigger_data
respectively. Have the free function and the init function (on failure)
free the cmd_ops of the data element.

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://patch.msgid.link/20251125200932.446322765@kernel.org
Reviewed-by: Tom Zanussi <zanussi@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
This commit is contained in:
Steven Rostedt 2025-11-25 15:08:59 -05:00 committed by Steven Rostedt (Google)
parent bdafb4d4cb
commit b052d70f7c
4 changed files with 186 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
kernel/trace/trace.h
View File

@ -1798,7 +1798,6 @@ struct event_trigger_data {
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;
@ -1890,20 +1889,76 @@ 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
* struct event_command - callbacks and data members for event commands
*
* The methods in this structure provide per-event trigger hooks for
* various trigger operations.
* Event commands are invoked by users by writing the command name
* into the 'trigger' file associated with a trace event. The
* parameters associated with a specific invocation of an event
* command are used to create an event trigger instance, which is
* added to the list of trigger instances associated with that trace
* event. When the event is hit, the set of triggers associated with
* that event is invoked.
*
* The @init and @free methods are used during trigger setup and
* teardown, typically called from an event_command's @parse()
* function implementation.
* The data members in this structure provide per-event command data
* for various event commands.
*
* The @print method is used to print the trigger spec.
* All the data members below, except for @post_trigger, must be set
* for each event command.
*
* 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.
* @name: The unique name that identifies the event command. This is
* the name used when setting triggers via trigger files.
*
* @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
* for a particular event e.g. it doesn't make sense to have both
* a traceon and traceoff trigger attached to a single event at
* the same time, so traceon and traceoff have the same type
* though they have different names. The @trigger_type value is
* also used as a bit value for deferring the actual trigger
* action until after the current event is finished. Some
* commands need to do this if they themselves log to the trace
* buffer (see the @post_trigger() member below). @trigger_type
* values are defined by adding new values to the trigger_type
* enum in include/linux/trace_events.h.
*
* @flags: See the enum event_command_flags below.
*
* All the methods below, except for @set_filter() and @unreg_all(),
* must be implemented.
*
* @parse: The callback function responsible for parsing and
* registering the trigger written to the 'trigger' file by the
* user. It allocates the trigger instance and registers it with
* the appropriate trace event. It makes use of the other
* event_command callback functions to orchestrate this, and is
* usually implemented by the generic utility function
* @event_trigger_callback() (see trace_event_triggers.c).
*
* @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_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
* the generic utility function @register_trigger() (see
* trace_event_triggers.c).
*
* @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_command @free() function).
* This is usually implemented by the generic utility function
* @unregister_trigger() (see trace_event_triggers.c).
*
* @unreg_all: An optional function called to remove all the triggers
* from the list of triggers associated with the event. Called
* when a trigger file is opened in truncate mode.
*
* @set_filter: An optional function called to parse and set a filter
* for the trigger. If no @set_filter() method is set for the
* 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.
@ -1941,100 +1996,9 @@ extern void event_file_put(struct trace_event_file *file);
* 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
*
* Event commands are invoked by users by writing the command name
* into the 'trigger' file associated with a trace event. The
* parameters associated with a specific invocation of an event
* command are used to create an event trigger instance, which is
* added to the list of trigger instances associated with that trace
* event. When the event is hit, the set of triggers associated with
* that event is invoked.
*
* The data members in this structure provide per-event command data
* for various event commands.
*
* All the data members below, except for @post_trigger, must be set
* for each event command.
*
* @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
* for a particular event e.g. it doesn't make sense to have both
* a traceon and traceoff trigger attached to a single event at
* the same time, so traceon and traceoff have the same type
* though they have different names. The @trigger_type value is
* also used as a bit value for deferring the actual trigger
* action until after the current event is finished. Some
* commands need to do this if they themselves log to the trace
* buffer (see the @post_trigger() member below). @trigger_type
* values are defined by adding new values to the trigger_type
* enum in include/linux/trace_events.h.
*
* @flags: See the enum event_command_flags below.
*
* All the methods below, except for @set_filter() and @unreg_all(),
* must be implemented.
*
* @parse: The callback function responsible for parsing and
* registering the trigger written to the 'trigger' file by the
* user. It allocates the trigger instance and registers it with
* the appropriate trace event. It makes use of the other
* event_command callback functions to orchestrate this, and is
* usually implemented by the generic utility function
* @event_trigger_callback() (see trace_event_triggers.c).
*
* @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).
* 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
* the generic utility function @register_trigger() (see
* trace_event_triggers.c).
*
* @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).
* This is usually implemented by the generic utility function
* @unregister_trigger() (see trace_event_triggers.c).
*
* @unreg_all: An optional function called to remove all the triggers
* from the list of triggers associated with the event. Called
* when a trigger file is opened in truncate mode.
*
* @set_filter: An optional function called to parse and set a filter
* for the trigger. If no @set_filter() method is set for the
* 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).
*/
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,
@ -2051,6 +2015,18 @@ struct event_command {
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);
};
/**
@ -2071,7 +2047,7 @@ struct event_command {
* 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.
*

13
kernel/trace/trace_eprobe.c
View File

@ -484,13 +484,6 @@ static void eprobe_trigger_func(struct event_trigger_data *data,
__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,
@ -517,12 +510,15 @@ static struct event_command event_trigger_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 *
@ -542,7 +538,6 @@ new_eprobe_trigger(struct trace_eprobe *ep, struct trace_event_file *file)
trigger->flags = EVENT_TRIGGER_FL_PROBE;
trigger->count = -1;
trigger->ops = &eprobe_trigger_ops;
/*
* EVENT PROBE triggers are not registered as commands with

93
kernel/trace/trace_events_hist.c
View File

@ -5694,7 +5694,7 @@ static void hist_trigger_show(struct seq_file *m,
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;
@ -6016,7 +6016,7 @@ static void hist_trigger_debug_show(struct seq_file *m,
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;
@ -6326,20 +6326,21 @@ static void event_hist_trigger_free(struct event_trigger_data *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)
@ -6351,18 +6352,14 @@ 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;
@ -6556,13 +6553,24 @@ static int hist_register_trigger(char *glob,
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;
}
@ -6676,8 +6684,8 @@ static void hist_unregister_trigger(char *glob,
}
}
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)
@ -6729,8 +6737,8 @@ static void hist_unreg_all(struct trace_event_file *file)
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);
}
}
}
@ -6902,12 +6910,15 @@ static struct event_command trigger_hist_cmd = {
.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)
@ -6939,22 +6950,6 @@ hist_enable_trigger(struct event_trigger_data *data,
}
}
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;
@ -6964,8 +6959,8 @@ static void hist_enable_unreg_all(struct trace_event_file *file)
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);
}
}
}
@ -6973,23 +6968,31 @@ static void hist_enable_unreg_all(struct trace_event_file *file)
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)

135
kernel/trace/trace_events_trigger.c
View File

@ -32,14 +32,14 @@ static inline void data_ops_trigger(struct event_trigger_data *data,
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);
}
/**
@ -205,7 +205,7 @@ static int trigger_show(struct seq_file *m, void *v)
}
data = list_entry(v, struct event_trigger_data, list);
data->ops->print(m, data);
data->cmd_ops->print(m, data);
return 0;
}
@ -422,7 +422,7 @@ bool event_trigger_count(struct event_trigger_data *data,
}
/**
* 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
@ -457,7 +457,7 @@ event_trigger_print(const char *name, struct seq_file *m,
}
/**
* 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.
@ -474,7 +474,7 @@ int event_trigger_init(struct event_trigger_data *data)
}
/**
* 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.
@ -536,8 +536,8 @@ clear_event_triggers(struct trace_array *tr)
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);
}
}
}
@ -600,8 +600,8 @@ static int register_trigger(char *glob,
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;
}
@ -639,8 +639,8 @@ static bool try_unregister_trigger(char *glob,
}
if (data) {
if (data->ops->free)
data->ops->free(data);
if (data->cmd_ops->free)
data->cmd_ops->free(data);
return true;
}
@ -875,10 +875,9 @@ struct event_trigger_data *trigger_data_alloc(struct event_command *cmd_ops,
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);
@ -1401,7 +1400,13 @@ traceoff_trigger_print(struct seq_file *m, struct event_trigger_data *data)
data->filter_str);
}
static const struct event_trigger_ops traceon_trigger_ops = {
static struct event_command trigger_traceon_cmd = {
.name = "traceon",
.trigger_type = ETT_TRACE_ONOFF,
.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,
@ -1409,7 +1414,14 @@ static const struct event_trigger_ops traceon_trigger_ops = {
.free = event_trigger_free,
};
static const struct event_trigger_ops traceoff_trigger_ops = {
static struct event_command trigger_traceoff_cmd = {
.name = "traceoff",
.trigger_type = ETT_TRACE_ONOFF,
.flags = EVENT_CMD_FL_POST_TRIGGER,
.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,
@ -1417,27 +1429,6 @@ static const struct event_trigger_ops traceoff_trigger_ops = {
.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,
};
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,
};
#ifdef CONFIG_TRACER_SNAPSHOT
static void
snapshot_trigger(struct event_trigger_data *data,
@ -1483,7 +1474,13 @@ snapshot_trigger_print(struct seq_file *m, struct event_trigger_data *data)
data->filter_str);
}
static const struct event_trigger_ops snapshot_trigger_ops = {
static struct event_command trigger_snapshot_cmd = {
.name = "snapshot",
.trigger_type = ETT_SNAPSHOT,
.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,
@ -1491,16 +1488,6 @@ static const struct event_trigger_ops snapshot_trigger_ops = {
.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,
};
static __init int register_trigger_snapshot_cmd(void)
{
int ret;
@ -1552,23 +1539,19 @@ stacktrace_trigger_print(struct seq_file *m, struct event_trigger_data *data)
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)
@ -1665,22 +1648,6 @@ void event_enable_trigger_free(struct event_trigger_data *data)
}
}
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)
@ -1810,8 +1777,8 @@ int event_enable_register_trigger(char *glob,
}
}
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;
}
@ -1851,28 +1818,36 @@ void event_enable_unregister_trigger(char *glob,
}
}
if (data && data->ops->free)
data->ops->free(data);
if (data && data->cmd_ops->free)
data->cmd_ops->free(data);
}
static struct event_command trigger_enable_cmd = {
.name = ENABLE_EVENT_STR,
.trigger_type = ETT_EVENT_ENABLE,
.trigger_ops = &event_enable_trigger_ops,
.parse = event_enable_trigger_parse,
.reg = event_enable_register_trigger,
.unreg = event_enable_unregister_trigger,
.set_filter = set_trigger_filter,
.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 struct event_command trigger_disable_cmd = {
.name = DISABLE_EVENT_STR,
.trigger_type = ETT_EVENT_ENABLE,
.trigger_ops = &event_disable_trigger_ops,
.parse = event_enable_trigger_parse,
.reg = event_enable_register_trigger,
.unreg = event_enable_unregister_trigger,
.set_filter = set_trigger_filter,
.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 __init void unregister_trigger_enable_disable_cmds(void)