From nobody Mon Dec 1 22:01:09 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8BC00230274 for ; Fri, 28 Nov 2025 01:23:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764293002; cv=none; b=tLJATwCzDPw8r+WvEtgqv8Yw5TGM+89zomFX4kceS2UVHY3dtIaa9y3apvp7s9tGyH2NCUa6Cg08iqE6lvSex8qGMytpKCI0fFL+tjEAPq0wgPx7D4Rqfq6VaT+CQRCNcrPHmGyu9y/6ldujPkrgrg/hsURrDf1uu2I67p5vK6M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1764293002; c=relaxed/simple; bh=dj8CIf3lE9w1L/ozxTiTPU5WhLcqbqF/Vvx8it9JaEA=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=AgmioKjuGM044pOnErLfRd3GAAhjXHLWVuTrsAhbyCsd10BShYG9ZjtdyScwx6GyOvolftUGP0SyH0JLmGCXwRN4twv44JeaBl+Vawz9tYxjVpR7dP3Wlqh+fEsLDE45oXoHDMYgrBI7pPUkPwpE86zJXecTpn2T3dnKwccL4zk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=eWUbf1fH; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="eWUbf1fH" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 484D7C19424; Fri, 28 Nov 2025 01:23:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1764293002; bh=dj8CIf3lE9w1L/ozxTiTPU5WhLcqbqF/Vvx8it9JaEA=; h=Date:From:To:Cc:Subject:References:From; b=eWUbf1fHeFqTMx3Vr+fRnBItpyh6wRXL70MaaZK1JdHzym+XD+ai/NT37MY0U5iv2 ueFechIV+cWqznYnzSHG8sXMW65mEj3qNUFA411H9zl3X/H9bVxRkpsKD9hROg1PB9 iGMb2HZYRrejVtqn9Ii6e3z7LIDZApAII2ZwMXoliLpyTpbjCtExHrZjXGMLDavVKW 4y4wLNc7EKs0AqE9n0r3JyjrRFvw5crz23P7K4xBpsW6G668w+QWe6IfeSO7HSAQxO tVqKwucH40C5gjRfXKYCgLfQFVCMG8TPpLVOTd3/KOXnyGzZjjMunaWW6CJyUkNUnX WqCR+H7Zzaf/A== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1vOnDX-00000006ggF-43rK; Thu, 27 Nov 2025 20:24:11 -0500 Message-ID: <20251128012411.817800726@kernel.org> User-Agent: quilt/0.68 Date: Thu, 27 Nov 2025 20:23:37 -0500 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Tom Zanussi Subject: [for-next][PATCH 06/13] tracing: Merge struct event_trigger_ops into struct event_command References: <20251128012331.307010654@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Steven Rostedt 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 Cc: Mark Rutland Cc: Mathieu Desnoyers Cc: Andrew Morton Link: https://patch.msgid.link/20251125200932.446322765@kernel.org Reviewed-by: Tom Zanussi Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace.h | 126 +++++++++++----------------- kernel/trace/trace_eprobe.c | 13 +-- kernel/trace/trace_events_hist.c | 93 ++++++++++---------- kernel/trace/trace_events_trigger.c | 121 +++++++++++--------------- 4 files changed, 151 insertions(+), 202 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index b9c59d9f9a0c..901aad30099b 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -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; @@ -1889,73 +1888,6 @@ extern void event_trigger_unregister(struct event_co= mmand *cmd_ops, extern void event_file_get(struct trace_event_file *file); extern void event_file_put(struct trace_event_file *file); =20 -/** - * 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 * @@ -1976,9 +1908,6 @@ struct event_trigger_ops { * @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 @@ -2008,7 +1937,7 @@ struct event_trigger_ops { * * @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 @@ -2017,7 +1946,7 @@ struct event_trigger_ops { * * @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). * @@ -2030,11 +1959,46 @@ struct event_trigger_ops { * 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, @@ -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); }; =20 /** @@ -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. * diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index 14ae896dbe75..f3e0442c3b96 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -484,13 +484,6 @@ static void eprobe_trigger_func(struct event_trigger_d= ata *data, __eprobe_trace_func(edata, rec); } =20 -static const struct event_trigger_ops eprobe_trigger_ops =3D { - .trigger =3D eprobe_trigger_func, - .print =3D eprobe_trigger_print, - .init =3D eprobe_trigger_init, - .free =3D 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 =3D { .name =3D "eprobe", .trigger_type =3D ETT_EVENT_EPROBE, .flags =3D EVENT_CMD_FL_NEEDS_REC, - .trigger_ops =3D &eprobe_trigger_ops, .parse =3D eprobe_trigger_cmd_parse, .reg =3D eprobe_trigger_reg_func, .unreg =3D eprobe_trigger_unreg_func, .unreg_all =3D NULL, .set_filter =3D NULL, + .trigger =3D eprobe_trigger_func, + .print =3D eprobe_trigger_print, + .init =3D eprobe_trigger_init, + .free =3D eprobe_trigger_free, }; =20 static struct event_trigger_data * @@ -542,7 +538,6 @@ new_eprobe_trigger(struct trace_eprobe *ep, struct trac= e_event_file *file) =20 trigger->flags =3D EVENT_TRIGGER_FL_PROBE; trigger->count =3D -1; - trigger->ops =3D &eprobe_trigger_ops; =20 /* * EVENT PROBE triggers are not registered as commands with diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index f9cc8d6a215b..f0dafc1f2787 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5694,7 +5694,7 @@ static void hist_trigger_show(struct seq_file *m, seq_puts(m, "\n\n"); =20 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"); =20 hist_data =3D data->private_data; @@ -6016,7 +6016,7 @@ static void hist_trigger_debug_show(struct seq_file *= m, seq_puts(m, "\n\n"); =20 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"); =20 hist_data =3D data->private_data; @@ -6326,20 +6326,21 @@ static void event_hist_trigger_free(struct event_tr= igger_data *data) free_hist_pad(); } =20 -static const struct event_trigger_ops event_hist_trigger_ops =3D { - .trigger =3D event_hist_trigger, - .print =3D event_hist_trigger_print, - .init =3D event_hist_trigger_init, - .free =3D event_hist_trigger_free, -}; - static int event_hist_trigger_named_init(struct event_trigger_data *data) { + int ret; + data->ref++; =20 save_named_trigger(data->named_data->name, data); =20 - return event_hist_trigger_init(data->named_data); + ret =3D event_hist_trigger_init(data->named_data); + if (ret < 0) { + kfree(data->cmd_ops); + data->cmd_ops =3D &trigger_hist_cmd; + } + + return ret; } =20 static void event_hist_trigger_named_free(struct event_trigger_data *data) @@ -6351,18 +6352,14 @@ static void event_hist_trigger_named_free(struct ev= ent_trigger_data *data) =20 data->ref--; if (!data->ref) { + struct event_command *cmd_ops =3D data->cmd_ops; + del_named_trigger(data); trigger_data_free(data); + kfree(cmd_ops); } } =20 -static const struct event_trigger_ops event_hist_trigger_named_ops =3D { - .trigger =3D event_hist_trigger, - .print =3D event_hist_trigger_print, - .init =3D event_hist_trigger_named_init, - .free =3D event_hist_trigger_named_free, -}; - static void hist_clear(struct event_trigger_data *data) { struct hist_trigger_data *hist_data =3D data->private_data; @@ -6556,13 +6553,24 @@ static int hist_register_trigger(char *glob, data->paused =3D true; =20 if (named_data) { + struct event_command *cmd_ops; + data->private_data =3D named_data->private_data; set_named_trigger_data(data, named_data); - data->ops =3D &event_hist_trigger_named_ops; + /* Copy the command ops and update some of the functions */ + cmd_ops =3D kmalloc(sizeof(*cmd_ops), GFP_KERNEL); + if (!cmd_ops) { + ret =3D -ENOMEM; + goto out; + } + *cmd_ops =3D *data->cmd_ops; + cmd_ops->init =3D event_hist_trigger_named_init; + cmd_ops->free =3D event_hist_trigger_named_free; + data->cmd_ops =3D cmd_ops; } =20 - if (data->ops->init) { - ret =3D data->ops->init(data); + if (data->cmd_ops->init) { + ret =3D data->cmd_ops->init(data); if (ret < 0) goto out; } @@ -6676,8 +6684,8 @@ static void hist_unregister_trigger(char *glob, } } =20 - if (test && test->ops->free) - test->ops->free(test); + if (test && test->cmd_ops->free) + test->cmd_ops->free(test); =20 if (hist_data->enable_timestamps) { if (!hist_data->remove || test) @@ -6729,8 +6737,8 @@ static void hist_unreg_all(struct trace_event_file *f= ile) 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 =3D { .name =3D "hist", .trigger_type =3D ETT_EVENT_HIST, .flags =3D EVENT_CMD_FL_NEEDS_REC, - .trigger_ops =3D &event_hist_trigger_ops, .parse =3D event_hist_trigger_parse, .reg =3D hist_register_trigger, .unreg =3D hist_unregister_trigger, .unreg_all =3D hist_unreg_all, .set_filter =3D set_trigger_filter, + .trigger =3D event_hist_trigger, + .print =3D event_hist_trigger_print, + .init =3D event_hist_trigger_init, + .free =3D event_hist_trigger_free, }; =20 __init int register_trigger_hist_cmd(void) @@ -6939,22 +6950,6 @@ hist_enable_trigger(struct event_trigger_data *data, } } =20 -static const struct event_trigger_ops hist_enable_trigger_ops =3D { - .trigger =3D hist_enable_trigger, - .count_func =3D event_trigger_count, - .print =3D event_enable_trigger_print, - .init =3D event_trigger_init, - .free =3D event_enable_trigger_free, -}; - -static const struct event_trigger_ops hist_disable_trigger_ops =3D { - .trigger =3D hist_enable_trigger, - .count_func =3D event_trigger_count, - .print =3D event_enable_trigger_print, - .init =3D event_trigger_init, - .free =3D 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_even= t_file *file) static struct event_command trigger_hist_enable_cmd =3D { .name =3D ENABLE_HIST_STR, .trigger_type =3D ETT_HIST_ENABLE, - .trigger_ops =3D &hist_enable_trigger_ops, .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .unreg_all =3D hist_enable_unreg_all, .set_filter =3D set_trigger_filter, + .trigger =3D hist_enable_trigger, + .count_func =3D event_trigger_count, + .print =3D event_enable_trigger_print, + .init =3D event_trigger_init, + .free =3D event_enable_trigger_free, }; =20 static struct event_command trigger_hist_disable_cmd =3D { .name =3D DISABLE_HIST_STR, .trigger_type =3D ETT_HIST_ENABLE, - .trigger_ops =3D &hist_disable_trigger_ops, .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .unreg_all =3D hist_enable_unreg_all, .set_filter =3D set_trigger_filter, + .trigger =3D hist_enable_trigger, + .count_func =3D event_trigger_count, + .print =3D event_enable_trigger_print, + .init =3D event_trigger_init, + .free =3D event_enable_trigger_free, }; =20 static __init void unregister_trigger_hist_enable_disable_cmds(void) diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index 576bad18bcdb..7795af600466 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -32,14 +32,14 @@ static inline void data_ops_trigger(struct event_trigge= r_data *data, struct trace_buffer *buffer, void *rec, struct ring_buffer_event *event) { - const struct event_trigger_ops *ops =3D data->ops; + const struct event_command *cmd_ops =3D data->cmd_ops; =20 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; } =20 - ops->trigger(data, buffer, rec, event); + cmd_ops->trigger(data, buffer, rec, event); } =20 /** @@ -205,7 +205,7 @@ static int trigger_show(struct seq_file *m, void *v) } =20 data =3D list_entry(v, struct event_trigger_data, list); - data->ops->print(m, data); + data->cmd_ops->print(m, data); =20 return 0; } @@ -422,7 +422,7 @@ bool event_trigger_count(struct event_trigger_data *dat= a, } =20 /** - * 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, } =20 /** - * 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) } =20 /** - * 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; } =20 - if (data->ops->init) { - ret =3D data->ops->init(data); + if (data->cmd_ops->init) { + ret =3D data->cmd_ops->init(data); if (ret < 0) return ret; } @@ -639,8 +639,8 @@ static bool try_unregister_trigger(char *glob, } =20 if (data) { - if (data->ops->free) - data->ops->free(data); + if (data->cmd_ops->free) + data->cmd_ops->free(data); =20 return true; } @@ -875,10 +875,9 @@ struct event_trigger_data *trigger_data_alloc(struct e= vent_command *cmd_ops, return NULL; =20 trigger_data->count =3D -1; - trigger_data->ops =3D cmd_ops->trigger_ops; trigger_data->cmd_ops =3D cmd_ops; trigger_data->private_data =3D private_data; - if (param && cmd_ops->trigger_ops->count_func) + if (param && cmd_ops->count_func) trigger_data->flags |=3D EVENT_TRIGGER_FL_COUNT; =20 INIT_LIST_HEAD(&trigger_data->list); @@ -1401,41 +1400,33 @@ traceoff_trigger_print(struct seq_file *m, struct e= vent_trigger_data *data) data->filter_str); } =20 -static const struct event_trigger_ops traceon_trigger_ops =3D { - .trigger =3D traceon_trigger, - .count_func =3D traceon_count_func, - .print =3D traceon_trigger_print, - .init =3D event_trigger_init, - .free =3D event_trigger_free, -}; - -static const struct event_trigger_ops traceoff_trigger_ops =3D { - .trigger =3D traceoff_trigger, - .count_func =3D traceoff_count_func, - .print =3D traceoff_trigger_print, - .init =3D event_trigger_init, - .free =3D event_trigger_free, -}; - static struct event_command trigger_traceon_cmd =3D { .name =3D "traceon", .trigger_type =3D ETT_TRACE_ONOFF, - .trigger_ops =3D &traceon_trigger_ops, .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D traceon_trigger, + .count_func =3D traceon_count_func, + .print =3D traceon_trigger_print, + .init =3D event_trigger_init, + .free =3D event_trigger_free, }; =20 static struct event_command trigger_traceoff_cmd =3D { .name =3D "traceoff", .trigger_type =3D ETT_TRACE_ONOFF, .flags =3D EVENT_CMD_FL_POST_TRIGGER, - .trigger_ops =3D &traceoff_trigger_ops, .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D traceoff_trigger, + .count_func =3D traceoff_count_func, + .print =3D traceoff_trigger_print, + .init =3D event_trigger_init, + .free =3D event_trigger_free, }; =20 #ifdef CONFIG_TRACER_SNAPSHOT @@ -1483,22 +1474,18 @@ snapshot_trigger_print(struct seq_file *m, struct e= vent_trigger_data *data) data->filter_str); } =20 -static const struct event_trigger_ops snapshot_trigger_ops =3D { - .trigger =3D snapshot_trigger, - .count_func =3D event_trigger_count, - .print =3D snapshot_trigger_print, - .init =3D event_trigger_init, - .free =3D event_trigger_free, -}; - static struct event_command trigger_snapshot_cmd =3D { .name =3D "snapshot", .trigger_type =3D ETT_SNAPSHOT, - .trigger_ops =3D &snapshot_trigger_ops, .parse =3D event_trigger_parse, .reg =3D register_snapshot_trigger, .unreg =3D unregister_snapshot_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D snapshot_trigger, + .count_func =3D event_trigger_count, + .print =3D snapshot_trigger_print, + .init =3D event_trigger_init, + .free =3D event_trigger_free, }; =20 static __init int register_trigger_snapshot_cmd(void) @@ -1552,23 +1539,19 @@ stacktrace_trigger_print(struct seq_file *m, struct= event_trigger_data *data) data->filter_str); } =20 -static const struct event_trigger_ops stacktrace_trigger_ops =3D { - .trigger =3D stacktrace_trigger, - .count_func =3D event_trigger_count, - .print =3D stacktrace_trigger_print, - .init =3D event_trigger_init, - .free =3D event_trigger_free, -}; - static struct event_command trigger_stacktrace_cmd =3D { .name =3D "stacktrace", .trigger_type =3D ETT_STACKTRACE, - .trigger_ops =3D &stacktrace_trigger_ops, .flags =3D EVENT_CMD_FL_POST_TRIGGER, .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D stacktrace_trigger, + .count_func =3D event_trigger_count, + .print =3D stacktrace_trigger_print, + .init =3D event_trigger_init, + .free =3D event_trigger_free, }; =20 static __init int register_trigger_stacktrace_cmd(void) @@ -1665,22 +1648,6 @@ void event_enable_trigger_free(struct event_trigger_= data *data) } } =20 -static const struct event_trigger_ops event_enable_trigger_ops =3D { - .trigger =3D event_enable_trigger, - .count_func =3D event_enable_count_func, - .print =3D event_enable_trigger_print, - .init =3D event_trigger_init, - .free =3D event_enable_trigger_free, -}; - -static const struct event_trigger_ops event_disable_trigger_ops =3D { - .trigger =3D event_enable_trigger, - .count_func =3D event_enable_count_func, - .print =3D event_enable_trigger_print, - .init =3D event_trigger_init, - .free =3D 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, } } =20 - if (data->ops->init) { - ret =3D data->ops->init(data); + if (data->cmd_ops->init) { + ret =3D data->cmd_ops->init(data); if (ret < 0) return ret; } @@ -1851,28 +1818,36 @@ void event_enable_unregister_trigger(char *glob, } } =20 - if (data && data->ops->free) - data->ops->free(data); + if (data && data->cmd_ops->free) + data->cmd_ops->free(data); } =20 static struct event_command trigger_enable_cmd =3D { .name =3D ENABLE_EVENT_STR, .trigger_type =3D ETT_EVENT_ENABLE, - .trigger_ops =3D &event_enable_trigger_ops, .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D event_enable_trigger, + .count_func =3D event_enable_count_func, + .print =3D event_enable_trigger_print, + .init =3D event_trigger_init, + .free =3D event_enable_trigger_free, }; =20 static struct event_command trigger_disable_cmd =3D { .name =3D DISABLE_EVENT_STR, .trigger_type =3D ETT_EVENT_ENABLE, - .trigger_ops =3D &event_disable_trigger_ops, .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .set_filter =3D set_trigger_filter, + .trigger =3D event_enable_trigger, + .count_func =3D event_enable_count_func, + .print =3D event_enable_trigger_print, + .init =3D event_trigger_init, + .free =3D event_enable_trigger_free, }; =20 static __init void unregister_trigger_enable_disable_cmds(void) --=20 2.51.0