From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BB999C433FE for ; Mon, 10 Jan 2022 00:04:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237517AbiAJAEX (ORCPT ); Sun, 9 Jan 2022 19:04:23 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:35150 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237438AbiAJAEU (ORCPT ); Sun, 9 Jan 2022 19:04:20 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 3EB28B80D84 for ; Mon, 10 Jan 2022 00:04:19 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id A23A5C36AF3; Mon, 10 Jan 2022 00:04:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773058; bh=+ghuVjxt7IGWnTnXmpCM+zMDS9tD9lEnGr5PcOt4+E0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=GbE5lnSZJfH3hRwBMxs8PSCgqbwheshSpJI4ZmC5qi4Ul4tWoMTLfom9iUCe3Vc91 gcfwabzMRO+IqBRxJhiJboP0KuHQEoN+vFoJsMDJgqMFB24RmamkO1x44/O9rlfsd+ 36U0+ap6mWD9mAoXC+FGaLoC/1fU9JyObfdbaZIkmT+mYgN7Qm2wYQfC978IP6LgWw qpVEpoJBSuf2bjFnsQ8FBZxqhj3yY97RsIL/HcV4XTvUf/2OXuCeeszJ63Hyp8Srdd GwIz9WtnDpl1EG5vwIAttltj4EWaytGXtQJevzanxgcLrWkYeIYS8KkndGh2G1Rrns julj8cNeciMbA== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 1/6] tracing: Change event_command func() to parse() Date: Sun, 9 Jan 2022 18:04:05 -0600 Message-Id: <7784e321840752ed88aac0b349c0c685fc9247b1.1641772259.git.zanussi@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" The name of the func() callback on event_command is too generic and is easily confused with other callbacks with that name, so change it to something that reflects its actual purpose. In this case, the main purpose of the callback is to parse an event command, so call it parse() instead. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 19 +++++++++++------- kernel/trace/trace_eprobe.c | 8 ++++---- kernel/trace/trace_events_hist.c | 26 ++++++++++++------------- kernel/trace/trace_events_trigger.c | 30 ++++++++++++++--------------- 4 files changed, 44 insertions(+), 39 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 8bd1a815ce90..25bd5706ef0b 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1578,9 +1578,9 @@ extern int event_enable_trigger_print(struct seq_file= *m, struct event_trigger_data *data); extern void event_enable_trigger_free(struct event_trigger_ops *ops, struct event_trigger_data *data); -extern int event_enable_trigger_func(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param); +extern int event_enable_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param); extern int event_enable_register_trigger(char *glob, struct event_trigger_ops *ops, struct event_trigger_data *data, @@ -1702,7 +1702,7 @@ struct event_trigger_ops { * All the methods below, except for @set_filter() and @unreg_all(), * must be implemented. * - * @func: The callback function responsible for parsing and + * @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 @@ -1737,15 +1737,20 @@ struct event_trigger_ops { * * @get_trigger_ops: The callback function invoked to retrieve the * event_trigger_ops implementation associated with the command. + * This callback function allows a single event_command to + * support multiple trigger implementations via different sets of + * event_trigger_ops, depending on the value of the @param + * string. */ struct event_command { struct list_head list; char *name; enum event_trigger_type trigger_type; int flags; - int (*func)(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *params); + int (*parse)(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, + char *param_and_filter); int (*reg)(char *glob, struct event_trigger_ops *ops, struct event_trigger_data *data, diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index 88487752d307..84d5bfa34a99 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -549,9 +549,9 @@ static struct event_trigger_ops eprobe_trigger_ops =3D { .free =3D eprobe_trigger_free, }; =20 -static int eprobe_trigger_cmd_func(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param) +static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param) { return -1; } @@ -580,7 +580,7 @@ static struct event_command event_trigger_cmd =3D { .name =3D "eprobe", .trigger_type =3D ETT_EVENT_EPROBE, .flags =3D EVENT_CMD_FL_NEEDS_REC, - .func =3D eprobe_trigger_cmd_func, + .parse =3D eprobe_trigger_cmd_parse, .reg =3D eprobe_trigger_reg_func, .unreg =3D eprobe_trigger_unreg_func, .unreg_all =3D NULL, diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index 9b8da439149c..89bbbbd3a3f5 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -2761,9 +2761,9 @@ static char *find_trigger_filter(struct hist_trigger_= data *hist_data, } =20 static struct event_command trigger_hist_cmd; -static int event_hist_trigger_func(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param); +static int event_hist_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param); =20 static bool compatible_keys(struct hist_trigger_data *target_hist_data, struct hist_trigger_data *hist_data, @@ -2966,8 +2966,8 @@ create_field_var_hist(struct hist_trigger_data *targe= t_hist_data, var_hist->hist_data =3D hist_data; =20 /* Create the new histogram with our variable */ - ret =3D event_hist_trigger_func(&trigger_hist_cmd, file, - "", "hist", cmd); + ret =3D event_hist_trigger_parse(&trigger_hist_cmd, file, + "", "hist", cmd); if (ret) { kfree(cmd); kfree(var_hist->cmd); @@ -5729,8 +5729,8 @@ static void unregister_field_var_hists(struct hist_tr= igger_data *hist_data) for (i =3D 0; i < hist_data->n_field_var_hists; i++) { file =3D hist_data->field_var_hists[i]->hist_data->event_file; cmd =3D hist_data->field_var_hists[i]->cmd; - ret =3D event_hist_trigger_func(&trigger_hist_cmd, file, - "!hist", "hist", cmd); + ret =3D event_hist_trigger_parse(&trigger_hist_cmd, file, + "!hist", "hist", cmd); WARN_ON_ONCE(ret < 0); } } @@ -6146,9 +6146,9 @@ static void hist_unreg_all(struct trace_event_file *f= ile) } } =20 -static int event_hist_trigger_func(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param) +static int event_hist_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param) { unsigned int hist_trigger_bits =3D TRACING_MAP_BITS_DEFAULT; struct event_trigger_data *trigger_data; @@ -6331,7 +6331,7 @@ static struct event_command trigger_hist_cmd =3D { .name =3D "hist", .trigger_type =3D ETT_EVENT_HIST, .flags =3D EVENT_CMD_FL_NEEDS_REC, - .func =3D event_hist_trigger_func, + .parse =3D event_hist_trigger_parse, .reg =3D hist_register_trigger, .unreg =3D hist_unregister_trigger, .unreg_all =3D hist_unreg_all, @@ -6446,7 +6446,7 @@ static void hist_enable_unreg_all(struct trace_event_= file *file) static struct event_command trigger_hist_enable_cmd =3D { .name =3D ENABLE_HIST_STR, .trigger_type =3D ETT_HIST_ENABLE, - .func =3D event_enable_trigger_func, + .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, @@ -6457,7 +6457,7 @@ static struct event_command trigger_hist_enable_cmd = =3D { static struct event_command trigger_hist_disable_cmd =3D { .name =3D DISABLE_HIST_STR, .trigger_type =3D ETT_HIST_ENABLE, - .func =3D event_enable_trigger_func, + .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, diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index 3d5c07239a2a..15aae07cbe61 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -245,7 +245,7 @@ int trigger_process_regex(struct trace_event_file *file= , char *buff) mutex_lock(&trigger_cmd_mutex); list_for_each_entry(p, &trigger_commands, list) { if (strcmp(p->name, command) =3D=3D 0) { - ret =3D p->func(p, file, buff, command, next); + ret =3D p->parse(p, file, buff, command, next); goto out_unlock; } } @@ -622,7 +622,7 @@ static void unregister_trigger(char *glob, struct event= _trigger_ops *ops, } =20 /** - * event_trigger_callback - Generic event_command @func implementation + * event_trigger_parse - Generic event_command @parse implementation * @cmd_ops: The command ops, used for trigger registration * @file: The trace_event_file associated with the event * @glob: The raw string used to register the trigger @@ -632,15 +632,15 @@ static void unregister_trigger(char *glob, struct eve= nt_trigger_ops *ops, * Common implementation for event command parsing and trigger * instantiation. * - * Usually used directly as the @func method in event command + * Usually used directly as the @parse method in event command * implementations. * * Return: 0 on success, errno otherwise */ static int -event_trigger_callback(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param) +event_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param) { struct event_trigger_data *trigger_data; struct event_trigger_ops *trigger_ops; @@ -1069,7 +1069,7 @@ onoff_get_trigger_ops(char *cmd, char *param) static struct event_command trigger_traceon_cmd =3D { .name =3D "traceon", .trigger_type =3D ETT_TRACE_ONOFF, - .func =3D event_trigger_callback, + .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .get_trigger_ops =3D onoff_get_trigger_ops, @@ -1080,7 +1080,7 @@ static struct event_command trigger_traceoff_cmd =3D { .name =3D "traceoff", .trigger_type =3D ETT_TRACE_ONOFF, .flags =3D EVENT_CMD_FL_POST_TRIGGER, - .func =3D event_trigger_callback, + .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .get_trigger_ops =3D onoff_get_trigger_ops, @@ -1157,7 +1157,7 @@ snapshot_get_trigger_ops(char *cmd, char *param) static struct event_command trigger_snapshot_cmd =3D { .name =3D "snapshot", .trigger_type =3D ETT_SNAPSHOT, - .func =3D event_trigger_callback, + .parse =3D event_trigger_parse, .reg =3D register_snapshot_trigger, .unreg =3D unregister_trigger, .get_trigger_ops =3D snapshot_get_trigger_ops, @@ -1249,7 +1249,7 @@ static struct event_command trigger_stacktrace_cmd = =3D { .name =3D "stacktrace", .trigger_type =3D ETT_STACKTRACE, .flags =3D EVENT_CMD_FL_POST_TRIGGER, - .func =3D event_trigger_callback, + .parse =3D event_trigger_parse, .reg =3D register_trigger, .unreg =3D unregister_trigger, .get_trigger_ops =3D stacktrace_get_trigger_ops, @@ -1380,9 +1380,9 @@ static struct event_trigger_ops event_disable_count_t= rigger_ops =3D { .free =3D event_enable_trigger_free, }; =20 -int event_enable_trigger_func(struct event_command *cmd_ops, - struct trace_event_file *file, - char *glob, char *cmd, char *param) +int event_enable_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param) { struct trace_event_file *event_enable_file; struct enable_trigger_data *enable_data; @@ -1628,7 +1628,7 @@ event_enable_get_trigger_ops(char *cmd, char *param) static struct event_command trigger_enable_cmd =3D { .name =3D ENABLE_EVENT_STR, .trigger_type =3D ETT_EVENT_ENABLE, - .func =3D event_enable_trigger_func, + .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .get_trigger_ops =3D event_enable_get_trigger_ops, @@ -1638,7 +1638,7 @@ static struct event_command trigger_enable_cmd =3D { static struct event_command trigger_disable_cmd =3D { .name =3D DISABLE_EVENT_STR, .trigger_type =3D ETT_EVENT_ENABLE, - .func =3D event_enable_trigger_func, + .parse =3D event_enable_trigger_parse, .reg =3D event_enable_register_trigger, .unreg =3D event_enable_unregister_trigger, .get_trigger_ops =3D event_enable_get_trigger_ops, --=20 2.17.1 From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CAF82C433F5 for ; Mon, 10 Jan 2022 00:04:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237533AbiAJAEY (ORCPT ); Sun, 9 Jan 2022 19:04:24 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35964 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237499AbiAJAEU (ORCPT ); Sun, 9 Jan 2022 19:04:20 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BF21DC06173F for ; Sun, 9 Jan 2022 16:04:20 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 41B1E60FD9 for ; Mon, 10 Jan 2022 00:04:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 19D52C36AE3; Mon, 10 Jan 2022 00:04:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773059; bh=yE2q+xnkfSNyw3eRPs9WaUSPN7vUF0dmIhBs7LZbHFg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=HPLUGRuHZ44FN+TDjQ3/DIyfxdIKOfJ+l8wxuXUL6YPAhJqZMmSMCzp5m43RuMFOP KpR93Z/NXSrLh7knIPdiWh21WAPqCYG5Kf0LVZqu8uuR0iF6/ndGZxs7MzGNaq3iX1 FSHo19nmxKLCApS9c0fU5V9uvGfXJ4WfAVO5BIm1511nKJ1ein/5mBXD39aFs58oN2 Xtj8uJF+IRSVhHz9+yTK57hHcXo6m/PSvTaxUQlFtO2eQCqevIGr9kUIL87LcgRER7 KN6LgwgUVTlSL4ZE9Tk+dNT/qyCnP+Z6dmlMMxEHZR7XEogbnJr6FrqzS3KIXD3eMF JsT/zwJaJbwzQ== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 2/6] tracing: Change event_trigger_ops func() to trigger() Date: Sun, 9 Jan 2022 18:04:06 -0600 Message-Id: <36ab812e3ee74ee03ae0043fda41a858ee728c00.1641772260.git.zanussi@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" The name of the func() callback on event_trigger_ops is too generic and is easily confused with other callbacks with that name, so change it to something that reflects its actual purpose. In this case, the main purpose of the callback is to implement an event trigger, so call it trigger() instead. Also add some more documentation to event_trigger_ops describing the callbacks a bit better. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 19 ++++++++++++++---- kernel/trace/trace_eprobe.c | 2 +- kernel/trace/trace_events_hist.c | 12 ++++++------ kernel/trace/trace_events_trigger.c | 30 ++++++++++++++--------------- 4 files changed, 37 insertions(+), 26 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 25bd5706ef0b..1a73659222d4 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1619,10 +1619,20 @@ extern int register_trigger_hist_enable_disable_cmd= s(void); * 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. * - * @func: The trigger 'probe' function called when the triggering + * @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 @@ -1651,9 +1661,10 @@ extern int register_trigger_hist_enable_disable_cmds= (void); * (see trace_event_triggers.c). */ struct event_trigger_ops { - void (*func)(struct event_trigger_data *data, - struct trace_buffer *buffer, void *rec, - struct ring_buffer_event *rbe); + void (*trigger)(struct event_trigger_data *data, + struct trace_buffer *buffer, + void *rec, + struct ring_buffer_event *rbe); int (*init)(struct event_trigger_ops *ops, struct event_trigger_data *data); void (*free)(struct event_trigger_ops *ops, diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index 84d5bfa34a99..6d363fd8a1e4 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -543,7 +543,7 @@ static void eprobe_trigger_func(struct event_trigger_da= ta *data, } =20 static struct event_trigger_ops eprobe_trigger_ops =3D { - .func =3D eprobe_trigger_func, + .trigger =3D eprobe_trigger_func, .print =3D eprobe_trigger_print, .init =3D eprobe_trigger_init, .free =3D eprobe_trigger_free, diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index 89bbbbd3a3f5..229ce5c2dfd3 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5759,7 +5759,7 @@ static void event_hist_trigger_free(struct event_trig= ger_ops *ops, } =20 static struct event_trigger_ops event_hist_trigger_ops =3D { - .func =3D event_hist_trigger, + .trigger =3D event_hist_trigger, .print =3D event_hist_trigger_print, .init =3D event_hist_trigger_init, .free =3D event_hist_trigger_free, @@ -5793,7 +5793,7 @@ static void event_hist_trigger_named_free(struct even= t_trigger_ops *ops, } =20 static struct event_trigger_ops event_hist_trigger_named_ops =3D { - .func =3D event_hist_trigger, + .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, @@ -6383,28 +6383,28 @@ hist_enable_count_trigger(struct event_trigger_data= *data, } =20 static struct event_trigger_ops hist_enable_trigger_ops =3D { - .func =3D hist_enable_trigger, + .trigger =3D hist_enable_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops hist_enable_count_trigger_ops =3D { - .func =3D hist_enable_count_trigger, + .trigger =3D hist_enable_count_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops hist_disable_trigger_ops =3D { - .func =3D hist_enable_trigger, + .trigger =3D hist_enable_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops hist_disable_count_trigger_ops =3D { - .func =3D hist_enable_count_trigger, + .trigger =3D hist_enable_count_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index 15aae07cbe61..24aceeb50dc0 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -68,7 +68,7 @@ event_triggers_call(struct trace_event_file *file, if (data->paused) continue; if (!rec) { - data->ops->func(data, buffer, rec, event); + data->ops->trigger(data, buffer, rec, event); continue; } filter =3D rcu_dereference_sched(data->filter); @@ -78,7 +78,7 @@ event_triggers_call(struct trace_event_file *file, tt |=3D data->cmd_ops->trigger_type; continue; } - data->ops->func(data, buffer, rec, event); + data->ops->trigger(data, buffer, rec, event); } return tt; } @@ -106,7 +106,7 @@ event_triggers_post_call(struct trace_event_file *file, if (data->paused) continue; if (data->cmd_ops->trigger_type & tt) - data->ops->func(data, NULL, NULL, NULL); + data->ops->trigger(data, NULL, NULL, NULL); } } EXPORT_SYMBOL_GPL(event_triggers_post_call); @@ -1023,28 +1023,28 @@ traceoff_trigger_print(struct seq_file *m, struct e= vent_trigger_ops *ops, } =20 static struct event_trigger_ops traceon_trigger_ops =3D { - .func =3D traceon_trigger, + .trigger =3D traceon_trigger, .print =3D traceon_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, }; =20 static struct event_trigger_ops traceon_count_trigger_ops =3D { - .func =3D traceon_count_trigger, + .trigger =3D traceon_count_trigger, .print =3D traceon_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, }; =20 static struct event_trigger_ops traceoff_trigger_ops =3D { - .func =3D traceoff_trigger, + .trigger =3D traceoff_trigger, .print =3D traceoff_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, }; =20 static struct event_trigger_ops traceoff_count_trigger_ops =3D { - .func =3D traceoff_count_trigger, + .trigger =3D traceoff_count_trigger, .print =3D traceoff_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, @@ -1135,14 +1135,14 @@ snapshot_trigger_print(struct seq_file *m, struct e= vent_trigger_ops *ops, } =20 static struct event_trigger_ops snapshot_trigger_ops =3D { - .func =3D snapshot_trigger, + .trigger =3D snapshot_trigger, .print =3D snapshot_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, }; =20 static struct event_trigger_ops snapshot_count_trigger_ops =3D { - .func =3D snapshot_count_trigger, + .trigger =3D snapshot_count_trigger, .print =3D snapshot_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, @@ -1226,14 +1226,14 @@ stacktrace_trigger_print(struct seq_file *m, struct= event_trigger_ops *ops, } =20 static struct event_trigger_ops stacktrace_trigger_ops =3D { - .func =3D stacktrace_trigger, + .trigger =3D stacktrace_trigger, .print =3D stacktrace_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, }; =20 static struct event_trigger_ops stacktrace_count_trigger_ops =3D { - .func =3D stacktrace_count_trigger, + .trigger =3D stacktrace_count_trigger, .print =3D stacktrace_trigger_print, .init =3D event_trigger_init, .free =3D event_trigger_free, @@ -1353,28 +1353,28 @@ void event_enable_trigger_free(struct event_trigger= _ops *ops, } =20 static struct event_trigger_ops event_enable_trigger_ops =3D { - .func =3D event_enable_trigger, + .trigger =3D event_enable_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops event_enable_count_trigger_ops =3D { - .func =3D event_enable_count_trigger, + .trigger =3D event_enable_count_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops event_disable_trigger_ops =3D { - .func =3D event_enable_trigger, + .trigger =3D event_enable_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, }; =20 static struct event_trigger_ops event_disable_count_trigger_ops =3D { - .func =3D event_enable_count_trigger, + .trigger =3D event_enable_count_trigger, .print =3D event_enable_trigger_print, .init =3D event_trigger_init, .free =3D event_enable_trigger_free, --=20 2.17.1 From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DEB32C4332F for ; Mon, 10 Jan 2022 00:04:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237539AbiAJAE1 (ORCPT ); Sun, 9 Jan 2022 19:04:27 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:35174 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237508AbiAJAEX (ORCPT ); Sun, 9 Jan 2022 19:04:23 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id E1EEBB80D85 for ; Mon, 10 Jan 2022 00:04:21 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 579C1C36AEF; Mon, 10 Jan 2022 00:04:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773060; bh=B5zWgXsQcgRT6W6IUP5g8RBZV0TrOHQBpoOF4CxU7E4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=LzaIP8E5GZPJ6GfEd+oxlxfANWeCv8gigb9cH/qXBr9CuGFplNtjLb2L6pGzaEc4b /ZHc7Bl2zYbixkQyX3LDBkC6OBuTVwObJQOIPJMoHXf4Ee5Hv6LMmJubNADK+RXE9g dEfblCV3FX8pmu0iID4SZh5ggdi5OFkUTxzUPs4xGR0ciA3rcXKS/5hjwjwKUGuqIL u0JpKUZ9bcnzhVXz5yPWj3fyCmmvuEsgF/AqffCa/ts4jNjSSezGaIO1ywBL1rR1m9 QySiWws350aDQ+/h9JoHHYRuIsi/kRXAFojsD00iEbo6mld1Bh1cTBAlef+cs62Xxq cmsT3+SEChFew== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 3/6] tracing: Remove ops param from event_command reg()/unreg() callbacks Date: Sun, 9 Jan 2022 18:04:07 -0600 Message-Id: <4c6f2a41820452f9cacddc7634ad442928aa2aa6.1641772260.git.zanussi@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" The event_trigger_ops for an event_command are already accessible via event_trigger_data.ops so remove the redundant ops from the callback. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 4 ---- kernel/trace/trace_eprobe.c | 12 ++++++------ kernel/trace/trace_events_hist.c | 10 +++++----- kernel/trace/trace_events_trigger.c | 22 +++++++++------------- 4 files changed, 20 insertions(+), 28 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 1a73659222d4..7d981af10b8f 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1582,11 +1582,9 @@ extern int event_enable_trigger_parse(struct event_c= ommand *cmd_ops, struct trace_event_file *file, char *glob, char *cmd, char *param); extern int event_enable_register_trigger(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *data, struct trace_event_file *file); extern void event_enable_unregister_trigger(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *test, struct trace_event_file *file); extern void trigger_data_free(struct event_trigger_data *data); @@ -1763,11 +1761,9 @@ struct event_command { char *glob, char *cmd, char *param_and_filter); int (*reg)(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *data, struct trace_event_file *file); void (*unreg)(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *data, struct trace_event_file *file); void (*unreg_all)(struct trace_event_file *file); diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index 6d363fd8a1e4..191db32dec46 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -556,16 +556,16 @@ static int eprobe_trigger_cmd_parse(struct event_comm= and *cmd_ops, return -1; } =20 -static int eprobe_trigger_reg_func(char *glob, struct event_trigger_ops *o= ps, - struct event_trigger_data *data, - struct trace_event_file *file) +static int eprobe_trigger_reg_func(char *glob, + struct event_trigger_data *data, + struct trace_event_file *file) { return -1; } =20 -static void eprobe_trigger_unreg_func(char *glob, struct event_trigger_ops= *ops, - struct event_trigger_data *data, - struct trace_event_file *file) +static void eprobe_trigger_unreg_func(char *glob, + struct event_trigger_data *data, + struct trace_event_file *file) { =20 } diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index 229ce5c2dfd3..5e6a988a8a51 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5910,7 +5910,7 @@ static bool hist_trigger_match(struct event_trigger_d= ata *data, return true; } =20 -static int hist_register_trigger(char *glob, struct event_trigger_ops *ops, +static int hist_register_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { @@ -6062,7 +6062,7 @@ static bool hist_trigger_check_refs(struct event_trig= ger_data *data, return false; } =20 -static void hist_unregister_trigger(char *glob, struct event_trigger_ops *= ops, +static void hist_unregister_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { @@ -6262,7 +6262,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, goto out_free; } =20 - cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + cmd_ops->unreg(glob+1, trigger_data, file); se_name =3D trace_event_name(file->event_call); se =3D find_synth_event(se_name); if (se) @@ -6271,7 +6271,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, goto out_free; } =20 - ret =3D cmd_ops->reg(glob, trigger_ops, trigger_data, file); + ret =3D cmd_ops->reg(glob, trigger_data, file); /* * The above returns on success the # of triggers registered, * but if it didn't register any it returns zero. Consider no @@ -6314,7 +6314,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, =20 return ret; out_unreg: - cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + cmd_ops->unreg(glob+1, trigger_data, file); out_free: if (cmd_ops->set_filter) cmd_ops->set_filter(NULL, trigger_data, NULL); diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index 24aceeb50dc0..d40b857db572 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -540,7 +540,6 @@ void update_cond_flag(struct trace_event_file *file) /** * register_trigger - Generic event_command @reg implementation * @glob: The raw string used to register the trigger - * @ops: The trigger ops associated with the trigger * @data: Trigger-specific data to associate with the trigger * @file: The trace_event_file associated with the event * @@ -551,7 +550,7 @@ void update_cond_flag(struct trace_event_file *file) * * Return: 0 on success, errno otherwise */ -static int register_trigger(char *glob, struct event_trigger_ops *ops, +static int register_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { @@ -589,7 +588,6 @@ static int register_trigger(char *glob, struct event_tr= igger_ops *ops, /** * unregister_trigger - Generic event_command @unreg implementation * @glob: The raw string used to register the trigger - * @ops: The trigger ops associated with the trigger * @test: Trigger-specific data used to find the trigger to remove * @file: The trace_event_file associated with the event * @@ -598,7 +596,7 @@ static int register_trigger(char *glob, struct event_tr= igger_ops *ops, * Usually used directly as the @unreg method in event command * implementations. */ -static void unregister_trigger(char *glob, struct event_trigger_ops *ops, +static void unregister_trigger(char *glob, struct event_trigger_data *test, struct trace_event_file *file) { @@ -673,7 +671,7 @@ event_trigger_parse(struct event_command *cmd_ops, INIT_LIST_HEAD(&trigger_data->named_list); =20 if (glob[0] =3D=3D '!') { - cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + cmd_ops->unreg(glob+1, trigger_data, file); kfree(trigger_data); ret =3D 0; goto out; @@ -708,14 +706,14 @@ event_trigger_parse(struct event_command *cmd_ops, out_reg: /* Up the trigger_data count to make sure reg doesn't free it on failure = */ event_trigger_init(trigger_ops, trigger_data); - ret =3D cmd_ops->reg(glob, trigger_ops, trigger_data, file); + ret =3D cmd_ops->reg(glob, trigger_data, file); /* * The above returns on success the # of functions enabled, * but if it didn't find any functions it returns zero. * Consider no functions a failure too. */ if (!ret) { - cmd_ops->unreg(glob, trigger_ops, trigger_data, file); + cmd_ops->unreg(glob, trigger_data, file); ret =3D -ENOENT; } else if (ret > 0) ret =3D 0; @@ -1116,14 +1114,14 @@ snapshot_count_trigger(struct event_trigger_data *d= ata, } =20 static int -register_snapshot_trigger(char *glob, struct event_trigger_ops *ops, +register_snapshot_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { if (tracing_alloc_snapshot_instance(file->tr) !=3D 0) return 0; =20 - return register_trigger(glob, ops, data, file); + return register_trigger(glob, data, file); } =20 static int @@ -1455,7 +1453,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, trigger_data->private_data =3D enable_data; =20 if (glob[0] =3D=3D '!') { - cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + cmd_ops->unreg(glob+1, trigger_data, file); kfree(trigger_data); kfree(enable_data); ret =3D 0; @@ -1502,7 +1500,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, ret =3D trace_event_enable_disable(event_enable_file, 1, 1); if (ret < 0) goto out_put; - ret =3D cmd_ops->reg(glob, trigger_ops, trigger_data, file); + ret =3D cmd_ops->reg(glob, trigger_data, file); /* * The above returns on success the # of functions enabled, * but if it didn't find any functions it returns zero. @@ -1532,7 +1530,6 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, } =20 int event_enable_register_trigger(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *data, struct trace_event_file *file) { @@ -1574,7 +1571,6 @@ int event_enable_register_trigger(char *glob, } =20 void event_enable_unregister_trigger(char *glob, - struct event_trigger_ops *ops, struct event_trigger_data *test, struct trace_event_file *file) { --=20 2.17.1 From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A3B1EC433EF for ; Mon, 10 Jan 2022 00:04:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237544AbiAJAEa (ORCPT ); Sun, 9 Jan 2022 19:04:30 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:35180 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237526AbiAJAEY (ORCPT ); Sun, 9 Jan 2022 19:04:24 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 31250B80D84 for ; Mon, 10 Jan 2022 00:04:23 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9402AC36AE3; Mon, 10 Jan 2022 00:04:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773062; bh=wxC/k9DTiCueU+9kK3Rvdnid9bGgfJB8uQ2pgPmdpA8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=f3flYg0ibN0IGBtVvEuE/wYJQmW1WGmU0yyBlyEF1xB+eReREVOxW/uoS55p8JaYg 4w1XWdCZnGo1XYwodMGPRMx6RkCc0MEWPodubM2FO+SCz2vXChQXWj8IKS5aqgsyV+ QlLoI5K2eQXcRh/Y2yC11NBYaY8wvrZXs4RRTZw1ugVJAwhyXbvzUxwi+fF8nyAih7 EksZlIP2dY/J5qk84hNu/lpA+HpdhbsaKNskMH4bUD/BgdvMx09zmpeLQu7mOlFmiX wrXAgFx/datKY6uqeEZoZmVuUvBtf6QnYDmjpPvwneOjdAomFAdxkBoObhDtJ0RDaP soc1JSfi+qcbA== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 4/6] tracing: Add helper functions to simplify event_command.parse() callback handling Date: Sun, 9 Jan 2022 18:04:08 -0600 Message-Id: X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" The event_command.parse() callback is responsible for parsing and registering triggers. The existing command implementions for this callback duplicate a lot of the same code, so to clean up and consolidate those implementations, introduce a handful of helper functions for implementors to use. This also makes it easier for new commands to be implemented and allows them to focus more on the customizations they provide rather than obscuring and complicating it with boilerplate code. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 24 ++ kernel/trace/trace_events_trigger.c | 342 ++++++++++++++++++++++++++++ 2 files changed, 366 insertions(+) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 7d981af10b8f..23c16018bb4f 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1610,6 +1610,30 @@ get_named_trigger_data(struct event_trigger_data *da= ta); extern int register_event_command(struct event_command *cmd); extern int unregister_event_command(struct event_command *cmd); extern int register_trigger_hist_enable_disable_cmds(void); +extern bool event_trigger_check_remove(const char *glob); +extern bool event_trigger_empty_param(const char *param); +extern int event_trigger_separate_filter(char *param_and_filter, char **pa= ram, + char **filter, bool param_required); +extern struct event_trigger_data * +event_trigger_alloc(struct event_command *cmd_ops, + char *cmd, + char *param, + void *private_data); +extern int event_trigger_parse_num(char *trigger, + struct event_trigger_data *trigger_data); +extern int event_trigger_set_filter(struct event_command *cmd_ops, + struct trace_event_file *file, + char *param, + struct event_trigger_data *trigger_data); +extern void event_trigger_reset_filter(struct event_command *cmd_ops, + struct event_trigger_data *trigger_data); +extern int event_trigger_register(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, + char *cmd, + char *trigger, + struct event_trigger_data *trigger_data, + int *n_registered); =20 /** * struct event_trigger_ops - callbacks for trace event triggers diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index d40b857db572..d00fee705f9c 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -619,6 +619,348 @@ static void unregister_trigger(char *glob, data->ops->free(data->ops, data); } =20 +/* + * Event trigger parsing helper functions. + * + * These functions help make it easier to write an event trigger + * parsing function i.e. the struct event_command.parse() callback + * function responsible for parsing and registering a trigger command + * written to the 'trigger' file. + * + * A trigger command (or just 'trigger' for short) takes the form: + * [trigger] [if filter] + * + * The struct event_command.parse() callback (and other struct + * event_command functions) refer to several components of a trigger + * command. Those same components are referenced by the event trigger + * parsing helper functions defined below. These components are: + * + * cmd - the trigger command name + * glob - the trigger command name optionally prefaced with= '!' + * param_and_filter - text following cmd and ':' + * param - text following cmd and ':' and stripped of filter + * filter - the optional filter text following (and including= ) 'if' + * + * To illustrate the use of these componenents, here are some concrete + * examples. For the following triggers: + * + * echo 'traceon:5 if pid =3D=3D 0' > trigger + * - 'traceon' is both cmd and glob + * - '5 if pid =3D=3D 0' is the param_and_filter + * - '5' is the param + * - 'if pid =3D=3D 0' is the filter + * + * echo 'enable_event:sys:event:n' > trigger + * - 'enable_event' is both cmd and glob + * - 'sys:event:n' is the param_and_filter + * - 'sys:event:n' is the param + * - there is no filter + * + * echo 'hist:keys=3Dpid if prio > 50' > trigger + * - 'hist' is both cmd and glob + * - 'keys=3Dpid if prio > 50' is the param_and_filter + * - 'keys=3Dpid' is the param + * - 'if prio > 50' is the filter + * + * echo '!enable_event:sys:event:n' > trigger + * - 'enable_event' the cmd + * - '!enable_event' is the glob + * - 'sys:event:n' is the param_and_filter + * - 'sys:event:n' is the param + * - there is no filter + * + * echo 'traceoff' > trigger + * - 'traceoff' is both cmd and glob + * - there is no param_and_filter + * - there is no param + * - there is no filter + * + * There are a few different categories of event trigger covered by + * these helpers: + * + * - triggers that don't require a parameter e.g. traceon + * - triggers that do require a parameter e.g. enable_event and hist + * - triggers that though they may not require a param may support an + * optional 'n' param (n =3D number of times the trigger should fire) + * e.g.: traceon:5 or enable_event:sys:event:n + * - triggers that do not support an 'n' param e.g. hist + * + * These functions can be used or ignored as necessary - it all + * depends on the complexity of the trigger, and the granularity of + * the functions supported reflects the fact that some implementations + * may need to customize certain aspects of their implementations and + * won't need certain functions. For instance, the hist trigger + * implementation doesn't use event_trigger_separate_filter() because + * it has special requirements for handling the filter. + */ + +/** + * event_trigger_check_remove - check whether an event trigger specifies r= emove + * @glob: The trigger command string, with optional remove(!) operator + * + * The event trigger callback implementations pass in 'glob' as a + * parameter. This is the command name either with or without a + * remove(!) operator. This function simply parses the glob and + * determines whether the command corresponds to a trigger removal or + * a trigger addition. + * + * Return: true if this is a remove command, false otherwise + */ +bool event_trigger_check_remove(const char *glob) +{ + return (glob && glob[0] =3D=3D '!') ? true : false; +} + +/** + * event_trigger_empty_param - check whether the param is empty + * @param: The trigger param string + * + * The event trigger callback implementations pass in 'param' as a + * parameter. This corresponds to the string following the command + * name minus the command name. This function can be called by a + * callback implementation for any command that requires a param; a + * callback that doesn't require a param can ignore it. + * + * Return: true if this is an empty param, false otherwise + */ +bool event_trigger_empty_param(const char *param) +{ + return !param; +} + +/** + * event_trigger_separate_filter - separate an event trigger from a filter + * @param: The param string containing trigger and possibly filter + * @trigger: outparam, will be filled with a pointer to the trigger + * @filter: outparam, will be filled with a pointer to the filter + * @param_required: Specifies whether or not the param string is required + * + * Given a param string of the form '[trigger] [if filter]', this + * function separates the filter from the trigger and returns the + * trigger in *trigger and the filter in *filter. Either the *trigger + * or the *filter may be set to NULL by this function - if not set to + * NULL, they will contain strings corresponding to the trigger and + * filter. + * + * There are two cases that need to be handled with respect to the + * passed-in param: either the param is required, or it is not + * required. If @param_required is set, and there's no param, it will + * return -EINVAL. If @param_required is not set and there's a param + * that starts with a number, that corresponds to the case of a + * trigger with :n (n =3D number of times the trigger should fire) and + * the parsing continues normally; otherwise the function just returns + * and assumes param just contains a filter and there's nothing else + * to do. + * + * Return: 0 on success, errno otherwise + */ +int event_trigger_separate_filter(char *param_and_filter, char **param, + char **filter, bool param_required) +{ + int ret =3D 0; + + *param =3D *filter =3D NULL; + + if (!param_and_filter) { + if (param_required) + ret =3D -EINVAL; + goto out; + } + + /* + * Here we check for an optional param. The only legal + * optional param is :n, and if that's the case, continue + * below. Otherwise we assume what's left is a filter and + * return it as the filter string for the caller to deal with. + */ + if (!param_required && param_and_filter && !isdigit(param_and_filter[0]))= { + *filter =3D param_and_filter; + goto out; + } + + /* + * Separate the param from the filter (param [if filter]). + * Here we have either an optional :n param or a required + * param and an optional filter. + */ + *param =3D strsep(¶m_and_filter, " \t"); + + /* + * Here we have a filter, though it may be empty. + */ + if (param_and_filter) { + *filter =3D skip_spaces(param_and_filter); + if (!**filter) + *filter =3D NULL; + } +out: + return ret; +} + +/** + * event_trigger_alloc - allocate and init event_trigger_data for a trigger + * @cmd_ops: The event_command operations for the trigger + * @cmd: The cmd string + * @param: The param string + * @private_data: User data to associate with the event trigger + * + * Allocate an event_trigger_data instance and initialize it. The + * @cmd_ops are used along with the @cmd and @param to get the + * trigger_ops to assign to the event_trigger_data. @private_data can + * also be passed in and associated with the event_trigger_data. + * + * Use event_trigger_free() to free an event_trigger_data object. + * + * Return: The trigger_data object success, NULL otherwise + */ +struct event_trigger_data *event_trigger_alloc(struct event_command *cmd_o= ps, + char *cmd, + char *param, + void *private_data) +{ + struct event_trigger_data *trigger_data; + struct event_trigger_ops *trigger_ops; + + trigger_ops =3D cmd_ops->get_trigger_ops(cmd, param); + + trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); + if (!trigger_data) + return NULL; + + trigger_data->count =3D -1; + trigger_data->ops =3D trigger_ops; + trigger_data->cmd_ops =3D cmd_ops; + trigger_data->private_data =3D private_data; + + INIT_LIST_HEAD(&trigger_data->list); + INIT_LIST_HEAD(&trigger_data->named_list); + RCU_INIT_POINTER(trigger_data->filter, NULL); + + return trigger_data; +} + +/** + * event_trigger_parse_num - parse and return the number param for a trigg= er + * @param: The param string + * @trigger_data: The trigger_data for the trigger + * + * Parse the :n (n =3D number of times the trigger should fire) param + * and set the count variable in the trigger_data to the parsed count. + * + * Return: 0 on success, errno otherwise + */ +int event_trigger_parse_num(char *param, + struct event_trigger_data *trigger_data) +{ + char *number; + int ret =3D 0; + + if (param) { + number =3D strsep(¶m, ":"); + + if (!strlen(number)) + return -EINVAL; + + /* + * We use the callback data field (which is a pointer) + * as our counter. + */ + ret =3D kstrtoul(number, 0, &trigger_data->count); + } + + return ret; +} + +/** + * event_trigger_set_filter - set an event trigger's filter + * @cmd_ops: The event_command operations for the trigger + * @file: The event file for the trigger's event + * @param: The string containing the filter + * @trigger_data: The trigger_data for the trigger + * + * Set the filter for the trigger. If the filter is NULL, just return + * without error. + * + * Return: 0 on success, errno otherwise + */ +int event_trigger_set_filter(struct event_command *cmd_ops, + struct trace_event_file *file, + char *param, + struct event_trigger_data *trigger_data) +{ + if (param && cmd_ops->set_filter) + return cmd_ops->set_filter(param, trigger_data, file); + + return 0; +} + +/** + * event_trigger_reset_filter - reset an event trigger's filter + * @cmd_ops: The event_command operations for the trigger + * @trigger_data: The trigger_data for the trigger + * + * Reset the filter for the trigger to no filter. + */ +void event_trigger_reset_filter(struct event_command *cmd_ops, + struct event_trigger_data *trigger_data) +{ + if (cmd_ops->set_filter) + cmd_ops->set_filter(NULL, trigger_data, NULL); +} + +/** + * event_trigger_register - register an event trigger + * @cmd_ops: The event_command operations for the trigger + * @file: The event file for the trigger's event + * @glob: The trigger command string, with optional remove(!) operator + * @cmd: The cmd string + * @param: The param string + * @trigger_data: The trigger_data for the trigger + * @n_registered: optional outparam, the number of triggers registered + * + * Register an event trigger. The @cmd_ops are used to call the + * cmd_ops->reg() function which actually does the registration. The + * cmd_ops->reg() function returns the number of triggers registered, + * which is assigned to n_registered, if n_registered is non-NULL. + * + * Return: 0 on success, errno otherwise + */ +int event_trigger_register(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, + char *cmd, + char *param, + struct event_trigger_data *trigger_data, + int *n_registered) +{ + int ret; + + if (n_registered) + *n_registered =3D 0; + + ret =3D cmd_ops->reg(glob, trigger_data, file); + /* + * The above returns on success the # of functions enabled, + * but if it didn't find any functions it returns zero. + * Consider no functions a failure too. + */ + if (!ret) { + cmd_ops->unreg(glob, trigger_data, file); + ret =3D -ENOENT; + } else if (ret > 0) { + if (n_registered) + *n_registered =3D ret; + /* Just return zero, not the number of enabled functions */ + ret =3D 0; + } + + return ret; +} + +/* + * End event trigger parsing helper functions. + */ + /** * event_trigger_parse - Generic event_command @parse implementation * @cmd_ops: The command ops, used for trigger registration --=20 2.17.1 From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BABE1C433FE for ; Mon, 10 Jan 2022 00:04:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237565AbiAJAEc (ORCPT ); Sun, 9 Jan 2022 19:04:32 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:35190 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237534AbiAJAEZ (ORCPT ); Sun, 9 Jan 2022 19:04:25 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 901FFB80D85 for ; Mon, 10 Jan 2022 00:04:24 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 01E84C36AEF; Mon, 10 Jan 2022 00:04:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773063; bh=T/PEYJEMS/+afJxWUuDdP0saiLziMCI0xOToOQIPzqg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=shfJYH1dXNyw7liZChJxQhdtF1HJDoDNF1VmyN4coxQd4oFvUNo43O73lWLjj8tvz Dme8XeghYotYsDJKdaRBs9bDW8MxTdriNbkOW2EjUlWSDEwtY7ig+29MuRGCH4OV4v BEE9+iQIIvuatrdoVUp4YUVOaVYv0w1LlcL3YkERET4kPa2IEgV1giEcmo9L1ceuyc XnvlpfNn5d5W4OqZnB/NC7txKkB0XSgqCCdakgYdoCkmdSP4Z5vflR54fbASwk2NCY tLw6NgcTlLr6a99EyIyLn3DOCc7vb7y95OS9wgELS+0MjfPKmMVzrF2Y0owG4PQ+SA MZvLWhjZR+JrQ== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 5/6] tracing: Have existing event_command.parse() implementations use helpers Date: Sun, 9 Jan 2022 18:04:09 -0600 Message-Id: <0ed90e6dd9b8ef984e5af8b7a200f35a80d069ef.1641772260.git.zanussi@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Simplify the existing event_command.parse() implementations by having them make use of the helper functions previously introduced. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 3 +- kernel/trace/trace_eprobe.c | 3 +- kernel/trace/trace_events_hist.c | 76 +++++------ kernel/trace/trace_events_trigger.c | 192 ++++++++-------------------- 4 files changed, 86 insertions(+), 188 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 23c16018bb4f..fd2334771bdc 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1580,7 +1580,8 @@ extern void event_enable_trigger_free(struct event_tr= igger_ops *ops, struct event_trigger_data *data); extern int event_enable_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param); + char *glob, char *cmd, + char *param_and_filter); extern int event_enable_register_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file); diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index 191db32dec46..f5c8dc1a5b5f 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -551,7 +551,8 @@ static struct event_trigger_ops eprobe_trigger_ops =3D { =20 static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param) + char *glob, char *cmd, + char *param_and_filter) { return -1; } diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index 5e6a988a8a51..f9f7fd9ecc3d 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -2763,7 +2763,8 @@ static char *find_trigger_filter(struct hist_trigger_= data *hist_data, static struct event_command trigger_hist_cmd; static int event_hist_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param); + char *glob, char *cmd, + char *param_and_filter); =20 static bool compatible_keys(struct hist_trigger_data *target_hist_data, struct hist_trigger_data *hist_data, @@ -6148,48 +6149,48 @@ static void hist_unreg_all(struct trace_event_file = *file) =20 static int event_hist_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param) + char *glob, char *cmd, + char *param_and_filter) { unsigned int hist_trigger_bits =3D TRACING_MAP_BITS_DEFAULT; struct event_trigger_data *trigger_data; struct hist_trigger_attrs *attrs; - struct event_trigger_ops *trigger_ops; struct hist_trigger_data *hist_data; + char *param, *filter, *p, *start; struct synth_event *se; const char *se_name; - bool remove =3D false; - char *trigger, *p, *start; + int n_registered; + bool remove; int ret =3D 0; =20 lockdep_assert_held(&event_mutex); =20 if (glob && strlen(glob)) { hist_err_clear(); - last_cmd_set(file, param); + last_cmd_set(file, param_and_filter); } =20 - if (!param) - return -EINVAL; + remove =3D event_trigger_check_remove(glob); =20 - if (glob[0] =3D=3D '!') - remove =3D true; + if (event_trigger_empty_param(param_and_filter)) + return -EINVAL; =20 /* * separate the trigger from the filter (k:v [if filter]) * allowing for whitespace in the trigger */ - p =3D trigger =3D param; + p =3D param =3D param_and_filter; do { p =3D strstr(p, "if"); if (!p) break; - if (p =3D=3D param) + if (p =3D=3D param_and_filter) return -EINVAL; if (*(p - 1) !=3D ' ' && *(p - 1) !=3D '\t') { p++; continue; } - if (p >=3D param + strlen(param) - (sizeof("if") - 1) - 1) + if (p >=3D param_and_filter + strlen(param_and_filter) - (sizeof("if") -= 1) - 1) return -EINVAL; if (*(p + sizeof("if") - 1) !=3D ' ' && *(p + sizeof("if") - 1) !=3D '\t= ') { p++; @@ -6199,24 +6200,24 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, } while (p); =20 if (!p) - param =3D NULL; + filter =3D NULL; else { *(p - 1) =3D '\0'; - param =3D strstrip(p); - trigger =3D strstrip(trigger); + filter =3D strstrip(p); + param =3D strstrip(param); } =20 /* * To simplify arithmetic expression parsing, replace occurrences of * '.sym-offset' modifier with '.symXoffset' */ - start =3D strstr(trigger, ".sym-offset"); + start =3D strstr(param, ".sym-offset"); while (start) { *(start + 4) =3D 'X'; start =3D strstr(start + 11, ".sym-offset"); } =20 - attrs =3D parse_hist_trigger_attrs(file->tr, trigger); + attrs =3D parse_hist_trigger_attrs(file->tr, param); if (IS_ERR(attrs)) return PTR_ERR(attrs); =20 @@ -6229,29 +6230,15 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, return PTR_ERR(hist_data); } =20 - trigger_ops =3D cmd_ops->get_trigger_ops(cmd, trigger); - - trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); + trigger_data =3D event_trigger_alloc(cmd_ops, cmd, param, hist_data); if (!trigger_data) { ret =3D -ENOMEM; goto out_free; } =20 - trigger_data->count =3D -1; - trigger_data->ops =3D trigger_ops; - trigger_data->cmd_ops =3D cmd_ops; - - INIT_LIST_HEAD(&trigger_data->list); - RCU_INIT_POINTER(trigger_data->filter, NULL); - - trigger_data->private_data =3D hist_data; - - /* if param is non-empty, it's supposed to be a filter */ - if (param && cmd_ops->set_filter) { - ret =3D cmd_ops->set_filter(param, trigger_data, file); - if (ret < 0) - goto out_free; - } + ret =3D event_trigger_set_filter(cmd_ops, file, filter, trigger_data); + if (ret < 0) + goto out_free; =20 if (remove) { if (!have_hist_trigger_match(trigger_data, file)) @@ -6271,18 +6258,14 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, goto out_free; } =20 - ret =3D cmd_ops->reg(glob, trigger_data, file); - /* - * The above returns on success the # of triggers registered, - * but if it didn't register any it returns zero. Consider no - * triggers registered a failure too. - */ - if (!ret) { + ret =3D event_trigger_register(cmd_ops, file, glob, cmd, param, trigger_d= ata, &n_registered); + if (ret) + goto out_free; + if ((ret =3D=3D 0) && (n_registered =3D=3D 0)) { if (!(attrs->pause || attrs->cont || attrs->clear)) ret =3D -ENOENT; goto out_free; - } else if (ret < 0) - goto out_free; + } =20 if (get_named_trigger_data(trigger_data)) goto enable; @@ -6316,8 +6299,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, out_unreg: cmd_ops->unreg(glob+1, trigger_data, file); out_free: - if (cmd_ops->set_filter) - cmd_ops->set_filter(NULL, trigger_data, NULL); + event_trigger_reset_filter(cmd_ops, trigger_data); =20 remove_hist_vars(hist_data); =20 diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index d00fee705f9c..2ab5837bc141 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -967,7 +967,7 @@ int event_trigger_register(struct event_command *cmd_op= s, * @file: The trace_event_file associated with the event * @glob: The raw string used to register the trigger * @cmd: The cmd portion of the string used to register the trigger - * @param: The params portion of the string used to register the trigger + * @param_and_filter: The param and filter portion of the string used to r= egister the trigger * * Common implementation for event command parsing and trigger * instantiation. @@ -980,94 +980,52 @@ int event_trigger_register(struct event_command *cmd_= ops, static int event_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param) + char *glob, char *cmd, char *param_and_filter) { struct event_trigger_data *trigger_data; - struct event_trigger_ops *trigger_ops; - char *trigger =3D NULL; - char *number; + char *param, *filter; + bool remove; int ret; =20 - /* separate the trigger from the filter (t:n [if filter]) */ - if (param && isdigit(param[0])) { - trigger =3D strsep(¶m, " \t"); - if (param) { - param =3D skip_spaces(param); - if (!*param) - param =3D NULL; - } - } + remove =3D event_trigger_check_remove(glob); =20 - trigger_ops =3D cmd_ops->get_trigger_ops(cmd, trigger); + ret =3D event_trigger_separate_filter(param_and_filter, ¶m, &filter, = false); + if (ret) + return ret; =20 ret =3D -ENOMEM; - trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); + trigger_data =3D event_trigger_alloc(cmd_ops, cmd, param, file); if (!trigger_data) goto out; =20 - trigger_data->count =3D -1; - trigger_data->ops =3D trigger_ops; - trigger_data->cmd_ops =3D cmd_ops; - trigger_data->private_data =3D file; - INIT_LIST_HEAD(&trigger_data->list); - INIT_LIST_HEAD(&trigger_data->named_list); - - if (glob[0] =3D=3D '!') { + if (remove) { cmd_ops->unreg(glob+1, trigger_data, file); kfree(trigger_data); ret =3D 0; goto out; } =20 - if (trigger) { - number =3D strsep(&trigger, ":"); - - ret =3D -EINVAL; - if (!strlen(number)) - goto out_free; - - /* - * We use the callback data field (which is a pointer) - * as our counter. - */ - ret =3D kstrtoul(number, 0, &trigger_data->count); - if (ret) - goto out_free; - } - - if (!param) /* if param is non-empty, it's supposed to be a filter */ - goto out_reg; - - if (!cmd_ops->set_filter) - goto out_reg; + ret =3D event_trigger_parse_num(param, trigger_data); + if (ret) + goto out_free; =20 - ret =3D cmd_ops->set_filter(param, trigger_data, file); + ret =3D event_trigger_set_filter(cmd_ops, file, filter, trigger_data); if (ret < 0) goto out_free; =20 - out_reg: /* Up the trigger_data count to make sure reg doesn't free it on failure = */ - event_trigger_init(trigger_ops, trigger_data); - ret =3D cmd_ops->reg(glob, trigger_data, file); - /* - * The above returns on success the # of functions enabled, - * but if it didn't find any functions it returns zero. - * Consider no functions a failure too. - */ - if (!ret) { - cmd_ops->unreg(glob, trigger_data, file); - ret =3D -ENOENT; - } else if (ret > 0) - ret =3D 0; + event_trigger_init(trigger_data->ops, trigger_data); + + ret =3D event_trigger_register(cmd_ops, file, glob, cmd, param, trigger_d= ata, NULL); + if (ret) + goto out_free; =20 /* Down the counter of trigger_data or free it if not used anymore */ - event_trigger_free(trigger_ops, trigger_data); + event_trigger_free(trigger_data->ops, trigger_data); out: return ret; - out_free: - if (cmd_ops->set_filter) - cmd_ops->set_filter(NULL, trigger_data, NULL); + event_trigger_reset_filter(cmd_ops, trigger_data); kfree(trigger_data); goto out; } @@ -1722,39 +1680,33 @@ static struct event_trigger_ops event_disable_count= _trigger_ops =3D { =20 int event_enable_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, - char *glob, char *cmd, char *param) + char *glob, char *cmd, char *param_and_filter) { struct trace_event_file *event_enable_file; struct enable_trigger_data *enable_data; struct event_trigger_data *trigger_data; - struct event_trigger_ops *trigger_ops; struct trace_array *tr =3D file->tr; + char *param, *filter; + bool enable, remove; const char *system; const char *event; bool hist =3D false; - char *trigger; - char *number; - bool enable; int ret; =20 - if (!param) - return -EINVAL; + remove =3D event_trigger_check_remove(glob); =20 - /* separate the trigger from the filter (s:e:n [if filter]) */ - trigger =3D strsep(¶m, " \t"); - if (!trigger) + if (event_trigger_empty_param(param_and_filter)) return -EINVAL; - if (param) { - param =3D skip_spaces(param); - if (!*param) - param =3D NULL; - } =20 - system =3D strsep(&trigger, ":"); - if (!trigger) + ret =3D event_trigger_separate_filter(param_and_filter, ¶m, &filter, = true); + if (ret) + return ret; + + system =3D strsep(¶m, ":"); + if (!param) return -EINVAL; =20 - event =3D strsep(&trigger, ":"); + event =3D strsep(¶m, ":"); =20 ret =3D -EINVAL; event_enable_file =3D find_event_file(tr, system, event); @@ -1770,31 +1722,22 @@ int event_enable_trigger_parse(struct event_command= *cmd_ops, #else enable =3D strcmp(cmd, ENABLE_EVENT_STR) =3D=3D 0; #endif - trigger_ops =3D cmd_ops->get_trigger_ops(cmd, trigger); - ret =3D -ENOMEM; - trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); - if (!trigger_data) - goto out; - enable_data =3D kzalloc(sizeof(*enable_data), GFP_KERNEL); - if (!enable_data) { - kfree(trigger_data); + if (!enable_data) goto out; - } - - trigger_data->count =3D -1; - trigger_data->ops =3D trigger_ops; - trigger_data->cmd_ops =3D cmd_ops; - INIT_LIST_HEAD(&trigger_data->list); - RCU_INIT_POINTER(trigger_data->filter, NULL); =20 enable_data->hist =3D hist; enable_data->enable =3D enable; enable_data->file =3D event_enable_file; - trigger_data->private_data =3D enable_data; =20 - if (glob[0] =3D=3D '!') { + trigger_data =3D event_trigger_alloc(cmd_ops, cmd, param, enable_data); + if (!trigger_data) { + kfree(enable_data); + goto out; + } + + if (remove) { cmd_ops->unreg(glob+1, trigger_data, file); kfree(trigger_data); kfree(enable_data); @@ -1803,35 +1746,16 @@ int event_enable_trigger_parse(struct event_command= *cmd_ops, } =20 /* Up the trigger_data count to make sure nothing frees it on failure */ - event_trigger_init(trigger_ops, trigger_data); - - if (trigger) { - number =3D strsep(&trigger, ":"); + event_trigger_init(trigger_data->ops, trigger_data); =20 - ret =3D -EINVAL; - if (!strlen(number)) - goto out_free; - - /* - * We use the callback data field (which is a pointer) - * as our counter. - */ - ret =3D kstrtoul(number, 0, &trigger_data->count); - if (ret) - goto out_free; - } - - if (!param) /* if param is non-empty, it's supposed to be a filter */ - goto out_reg; - - if (!cmd_ops->set_filter) - goto out_reg; + ret =3D event_trigger_parse_num(param, trigger_data); + if (ret) + goto out_free; =20 - ret =3D cmd_ops->set_filter(param, trigger_data, file); + ret =3D event_trigger_set_filter(cmd_ops, file, filter, trigger_data); if (ret < 0) goto out_free; =20 - out_reg: /* Don't let event modules unload while probe registered */ ret =3D trace_event_try_get_ref(event_enable_file->event_call); if (!ret) { @@ -1842,31 +1766,21 @@ int event_enable_trigger_parse(struct event_command= *cmd_ops, ret =3D trace_event_enable_disable(event_enable_file, 1, 1); if (ret < 0) goto out_put; - ret =3D cmd_ops->reg(glob, trigger_data, file); - /* - * The above returns on success the # of functions enabled, - * but if it didn't find any functions it returns zero. - * Consider no functions a failure too. - */ - if (!ret) { - ret =3D -ENOENT; - goto out_disable; - } else if (ret < 0) + + ret =3D event_trigger_register(cmd_ops, file, glob, cmd, param, trigger_d= ata, NULL); + if (ret) goto out_disable; - /* Just return zero, not the number of enabled functions */ - ret =3D 0; - event_trigger_free(trigger_ops, trigger_data); + + event_trigger_free(trigger_data->ops, trigger_data); out: return ret; - out_disable: trace_event_enable_disable(event_enable_file, 0, 1); out_put: trace_event_put_ref(event_enable_file->event_call); out_free: - if (cmd_ops->set_filter) - cmd_ops->set_filter(NULL, trigger_data, NULL); - event_trigger_free(trigger_ops, trigger_data); + event_trigger_reset_filter(cmd_ops, trigger_data); + event_trigger_free(trigger_data->ops, trigger_data); kfree(enable_data); goto out; } --=20 2.17.1 From nobody Tue Jun 30 21:18:00 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CA73AC433F5 for ; Mon, 10 Jan 2022 00:04:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237585AbiAJAEd (ORCPT ); Sun, 9 Jan 2022 19:04:33 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:35202 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237540AbiAJAE1 (ORCPT ); Sun, 9 Jan 2022 19:04:27 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 5732EB80D85 for ; Mon, 10 Jan 2022 00:04:26 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CC289C36AE3; Mon, 10 Jan 2022 00:04:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1641773065; bh=PWKIkbXBfD+HvZ/yIzak40cPKEIuHj+7a313VJ1aOtc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=ITNupEULzaY++Vf9XJeFydwuEqtYbtmWm51BJwBXpy9Olld8NvCRySbxavw07c+P0 t6Uv3Vr6RIPo+NsENBLPqNQunGdt3vYmNI/++1sKWe9JCkd/zKO/OXH6DvyAYahDkE cni93dw6K8W3LJjxqOb+XGyMSIgIgrq8TaKgSk/gaKSxfBUlW5Ypfh5h9RXGdzUh6B 04tajbAT5fgjzE0EO9zRCtBajkmD4onYGXe0Y0DPsipoAXmbxRE+l4ugCn0zJDALkZ H2n4lvoslZVmRl6/luFFo3tkb3W8aIYu/CCVGEi5b5+DJx4WHlBhz88gAr6PVLuB+C uPUPjc2WTnSBg== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 6/6] tracing: Remove redundant trigger_ops params Date: Sun, 9 Jan 2022 18:04:10 -0600 Message-Id: <256da8e5e9f9c780ad20f13893ac356b9265f8f9.1641772260.git.zanussi@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Since event_trigger_data contains the .ops trigger_ops field, there's no reason to pass the trigger_ops separately. Remove it as a param from functions whenever event_trigger_data is passed. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 14 +++------ kernel/trace/trace_eprobe.c | 7 ++--- kernel/trace/trace_events_hist.c | 27 +++++++---------- kernel/trace/trace_events_trigger.c | 46 +++++++++++------------------ 4 files changed, 35 insertions(+), 59 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index fd2334771bdc..8072f57331dc 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1574,10 +1574,8 @@ struct enable_trigger_data { }; =20 extern int event_enable_trigger_print(struct seq_file *m, - struct event_trigger_ops *ops, - struct event_trigger_data *data); -extern void event_enable_trigger_free(struct event_trigger_ops *ops, struct event_trigger_data *data); +extern void event_enable_trigger_free(struct event_trigger_data *data); extern int event_enable_trigger_parse(struct event_command *cmd_ops, struct trace_event_file *file, char *glob, char *cmd, @@ -1589,8 +1587,7 @@ extern void event_enable_unregister_trigger(char *glo= b, struct event_trigger_data *test, struct trace_event_file *file); extern void trigger_data_free(struct event_trigger_data *data); -extern int event_trigger_init(struct event_trigger_ops *ops, - struct event_trigger_data *data); +extern int event_trigger_init(struct event_trigger_data *data); extern int trace_event_trigger_enable_disable(struct trace_event_file *fil= e, int trigger_enable); extern void update_cond_flag(struct trace_event_file *file); @@ -1688,12 +1685,9 @@ struct event_trigger_ops { struct trace_buffer *buffer, void *rec, struct ring_buffer_event *rbe); - int (*init)(struct event_trigger_ops *ops, - struct event_trigger_data *data); - void (*free)(struct event_trigger_ops *ops, - struct event_trigger_data *data); + int (*init)(struct event_trigger_data *data); + void (*free)(struct event_trigger_data *data); int (*print)(struct seq_file *m, - struct event_trigger_ops *ops, struct event_trigger_data *data); }; =20 diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c index f5c8dc1a5b5f..f8270214ee96 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -513,20 +513,17 @@ __eprobe_trace_func(struct eprobe_data *edata, void *= rec) * functions are just stubs to fulfill what is needed to use the trigger * infrastructure. */ -static int eprobe_trigger_init(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static int eprobe_trigger_init(struct event_trigger_data *data) { return 0; } =20 -static void eprobe_trigger_free(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static void eprobe_trigger_free(struct event_trigger_data *data) { =20 } =20 static int eprobe_trigger_print(struct seq_file *m, - struct event_trigger_ops *ops, struct event_trigger_data *data) { /* Do not print eprobe event triggers */ diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index f9f7fd9ecc3d..98e6b579b39f 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5230,7 +5230,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->ops, data); + data->ops->print(m, data); seq_puts(m, "#\n\n"); =20 hist_data =3D data->private_data; @@ -5599,7 +5599,6 @@ static void hist_field_print(struct seq_file *m, stru= ct hist_field *hist_field) } =20 static int event_hist_trigger_print(struct seq_file *m, - struct event_trigger_ops *ops, struct event_trigger_data *data) { struct hist_trigger_data *hist_data =3D data->private_data; @@ -5707,8 +5706,7 @@ static int event_hist_trigger_print(struct seq_file *= m, return 0; } =20 -static int event_hist_trigger_init(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static int event_hist_trigger_init(struct event_trigger_data *data) { struct hist_trigger_data *hist_data =3D data->private_data; =20 @@ -5736,8 +5734,7 @@ static void unregister_field_var_hists(struct hist_tr= igger_data *hist_data) } } =20 -static void event_hist_trigger_free(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static void event_hist_trigger_free(struct event_trigger_data *data) { struct hist_trigger_data *hist_data =3D data->private_data; =20 @@ -5766,25 +5763,23 @@ static struct event_trigger_ops event_hist_trigger_= ops =3D { .free =3D event_hist_trigger_free, }; =20 -static int event_hist_trigger_named_init(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static int event_hist_trigger_named_init(struct event_trigger_data *data) { data->ref++; =20 save_named_trigger(data->named_data->name, data); =20 - event_hist_trigger_init(ops, data->named_data); + event_hist_trigger_init(data->named_data); =20 return 0; } =20 -static void event_hist_trigger_named_free(struct event_trigger_ops *ops, - struct event_trigger_data *data) +static void event_hist_trigger_named_free(struct event_trigger_data *data) { if (WARN_ON_ONCE(data->ref <=3D 0)) return; =20 - event_hist_trigger_free(ops, data->named_data); + event_hist_trigger_free(data->named_data); =20 data->ref--; if (!data->ref) { @@ -5971,7 +5966,7 @@ static int hist_register_trigger(char *glob, } =20 if (data->ops->init) { - ret =3D data->ops->init(data->ops, data); + ret =3D data->ops->init(data); if (ret < 0) goto out; } @@ -6089,7 +6084,7 @@ static void hist_unregister_trigger(char *glob, } =20 if (unregistered && test->ops->free) - test->ops->free(test->ops, test); + test->ops->free(test); =20 if (hist_data->enable_timestamps) { if (!hist_data->remove || unregistered) @@ -6142,7 +6137,7 @@ static void hist_unreg_all(struct trace_event_file *f= ile) if (hist_data->enable_timestamps) tracing_set_filter_buffering(file->tr, false); if (test->ops->free) - test->ops->free(test->ops, test); + test->ops->free(test); } } } @@ -6420,7 +6415,7 @@ static void hist_enable_unreg_all(struct trace_event_= file *file) update_cond_flag(file); trace_event_trigger_enable_disable(file, 0); if (test->ops->free) - test->ops->free(test->ops, test); + test->ops->free(test); } } } diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index 2ab5837bc141..2a51db416cee 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -174,7 +174,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->ops, data); + data->ops->print(m, data); =20 return 0; } @@ -418,7 +418,6 @@ event_trigger_print(const char *name, struct seq_file *= m, =20 /** * event_trigger_init - Generic event_trigger_ops @init implementation - * @ops: The trigger ops associated with the trigger * @data: Trigger-specific data * * Common implementation of event trigger initialization. @@ -428,8 +427,7 @@ event_trigger_print(const char *name, struct seq_file *= m, * * Return: 0 on success, errno otherwise */ -int event_trigger_init(struct event_trigger_ops *ops, - struct event_trigger_data *data) +int event_trigger_init(struct event_trigger_data *data) { data->ref++; return 0; @@ -437,7 +435,6 @@ int event_trigger_init(struct event_trigger_ops *ops, =20 /** * event_trigger_free - Generic event_trigger_ops @free implementation - * @ops: The trigger ops associated with the trigger * @data: Trigger-specific data * * Common implementation of event trigger de-initialization. @@ -446,8 +443,7 @@ int event_trigger_init(struct event_trigger_ops *ops, * implementations. */ static void -event_trigger_free(struct event_trigger_ops *ops, - struct event_trigger_data *data) +event_trigger_free(struct event_trigger_data *data) { if (WARN_ON_ONCE(data->ref <=3D 0)) return; @@ -501,7 +497,7 @@ clear_event_triggers(struct trace_array *tr) trace_event_trigger_enable_disable(file, 0); list_del_rcu(&data->list); if (data->ops->free) - data->ops->free(data->ops, data); + data->ops->free(data); } } } @@ -567,7 +563,7 @@ static int register_trigger(char *glob, } =20 if (data->ops->init) { - ret =3D data->ops->init(data->ops, data); + ret =3D data->ops->init(data); if (ret < 0) goto out; } @@ -616,7 +612,7 @@ static void unregister_trigger(char *glob, } =20 if (unregistered && data->ops->free) - data->ops->free(data->ops, data); + data->ops->free(data); } =20 /* @@ -1014,14 +1010,14 @@ event_trigger_parse(struct event_command *cmd_ops, goto out_free; =20 /* Up the trigger_data count to make sure reg doesn't free it on failure = */ - event_trigger_init(trigger_data->ops, trigger_data); + event_trigger_init(trigger_data); =20 ret =3D event_trigger_register(cmd_ops, file, glob, cmd, param, trigger_d= ata, NULL); if (ret) goto out_free; =20 /* Down the counter of trigger_data or free it if not used anymore */ - event_trigger_free(trigger_data->ops, trigger_data); + event_trigger_free(trigger_data); out: return ret; out_free: @@ -1305,16 +1301,14 @@ traceoff_count_trigger(struct event_trigger_data *d= ata, } =20 static int -traceon_trigger_print(struct seq_file *m, struct event_trigger_ops *ops, - struct event_trigger_data *data) +traceon_trigger_print(struct seq_file *m, struct event_trigger_data *data) { return event_trigger_print("traceon", m, (void *)data->count, data->filter_str); } =20 static int -traceoff_trigger_print(struct seq_file *m, struct event_trigger_ops *ops, - struct event_trigger_data *data) +traceoff_trigger_print(struct seq_file *m, struct event_trigger_data *data) { return event_trigger_print("traceoff", m, (void *)data->count, data->filter_str); @@ -1425,8 +1419,7 @@ register_snapshot_trigger(char *glob, } =20 static int -snapshot_trigger_print(struct seq_file *m, struct event_trigger_ops *ops, - struct event_trigger_data *data) +snapshot_trigger_print(struct seq_file *m, struct event_trigger_data *data) { return event_trigger_print("snapshot", m, (void *)data->count, data->filter_str); @@ -1516,8 +1509,7 @@ stacktrace_count_trigger(struct event_trigger_data *d= ata, } =20 static int -stacktrace_trigger_print(struct seq_file *m, struct event_trigger_ops *ops, - struct event_trigger_data *data) +stacktrace_trigger_print(struct seq_file *m, struct event_trigger_data *da= ta) { return event_trigger_print("stacktrace", m, (void *)data->count, data->filter_str); @@ -1607,7 +1599,6 @@ event_enable_count_trigger(struct event_trigger_data = *data, } =20 int event_enable_trigger_print(struct seq_file *m, - struct event_trigger_ops *ops, struct event_trigger_data *data) { struct enable_trigger_data *enable_data =3D data->private_data; @@ -1632,8 +1623,7 @@ int event_enable_trigger_print(struct seq_file *m, return 0; } =20 -void event_enable_trigger_free(struct event_trigger_ops *ops, - struct event_trigger_data *data) +void event_enable_trigger_free(struct event_trigger_data *data) { struct enable_trigger_data *enable_data =3D data->private_data; =20 @@ -1746,7 +1736,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, } =20 /* Up the trigger_data count to make sure nothing frees it on failure */ - event_trigger_init(trigger_data->ops, trigger_data); + event_trigger_init(trigger_data); =20 ret =3D event_trigger_parse_num(param, trigger_data); if (ret) @@ -1771,7 +1761,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, if (ret) goto out_disable; =20 - event_trigger_free(trigger_data->ops, trigger_data); + event_trigger_free(trigger_data); out: return ret; out_disable: @@ -1780,7 +1770,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, trace_event_put_ref(event_enable_file->event_call); out_free: event_trigger_reset_filter(cmd_ops, trigger_data); - event_trigger_free(trigger_data->ops, trigger_data); + event_trigger_free(trigger_data); kfree(enable_data); goto out; } @@ -1808,7 +1798,7 @@ int event_enable_register_trigger(char *glob, } =20 if (data->ops->init) { - ret =3D data->ops->init(data->ops, data); + ret =3D data->ops->init(data); if (ret < 0) goto out; } @@ -1852,7 +1842,7 @@ void event_enable_unregister_trigger(char *glob, } =20 if (unregistered && data->ops->free) - data->ops->free(data->ops, data); + data->ops->free(data); } =20 static struct event_trigger_ops * --=20 2.17.1