From nobody Tue Jun 30 19:34:03 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 E4E98C433F5 for ; Fri, 4 Feb 2022 22:12:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1346135AbiBDWMS (ORCPT ); Fri, 4 Feb 2022 17:12:18 -0500 Received: from dfw.source.kernel.org ([139.178.84.217]:55586 "EHLO dfw.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1346216AbiBDWMQ (ORCPT ); Fri, 4 Feb 2022 17:12:16 -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 dfw.source.kernel.org (Postfix) with ESMTPS id DF1AF618C4 for ; Fri, 4 Feb 2022 22:12:15 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BB8FAC340EF; Fri, 4 Feb 2022 22:12:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1644012735; bh=twNjX80CKflf33wosDQ9W9fbrpqLmS/TvMAWZC6DVv4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=QYjf6MaQKCgVxlOuPoqJZhJ5f7nqvNgaSEhFQ3eRfv0Y8xotqPRCgIF1bLOrNUqBl YDcfNuvSgbB0zM7kQh5E9ZOUpmcy2+s/YBc+DUCPdDiAQM/fJrH2jRjvgD2snVU8fj o2z0ayIW1JrFwe7vce3qZ63EFZJxokNzUZjwfXtsQ/iCInDtAKAxsBl+34BxnYGyci WtNFWbuFQmFuHf6RF4A3h8lg7hlcMspFx/SV3FmyiZHL16kDmUGz/XaamLVUrjtPJh Y4djIfVh1PgfqdC3yRlNiolyA66YPnjyYmpF06jAhPbUhd97GSa5qlM9AZQFDUaNbA y+o3Sp4MdO9JQ== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v8 1/4] tracing: Remove logic for registering multiple event triggers at a time Date: Fri, 4 Feb 2022 16:12:04 -0600 Message-Id: <6149fec7a139d93e84fa4535672fb5bef88006b0.1644010575.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" Code for registering triggers assumes it's possible to register more than one trigger at a time. In fact, it's unimplemented and there doesn't seem to be a reason to do that. Remove the n_registered param from event_trigger_register() and fix up callers. Doing so simplifies the logic in event_trigger_register to the point that it just becomes a wrapper calling event_command.reg(). It also removes the problematic call to event_command.unreg() in case of failure. A new function, event_trigger_unregister() is also added for callers to call themselves. The changes to trace_events_hist.c simply allow compilation; a separate patch follows which updates the hist triggers to work correctly with the new changes. Signed-off-by: Tom Zanussi --- kernel/trace/trace.h | 9 +-- kernel/trace/trace_events_hist.c | 17 ++--- kernel/trace/trace_events_trigger.c | 96 ++++++++++------------------- 3 files changed, 45 insertions(+), 77 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 0f5e22238cd2..835f1e3d9924 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1630,10 +1630,11 @@ extern void event_trigger_reset_filter(struct event= _command *cmd_ops, 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); + struct event_trigger_data *trigger_data); +extern void event_trigger_unregister(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, + struct event_trigger_data *trigger_data); =20 /** * struct event_trigger_ops - callbacks for trace event triggers diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index be4a001a607f..8df815bc0ac5 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -6284,7 +6284,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, goto out_free; } =20 - cmd_ops->unreg(glob+1, trigger_data, file); + event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); se_name =3D trace_event_name(file->event_call); se =3D find_synth_event(se_name); if (se) @@ -6293,13 +6293,10 @@ 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, trigger_data); + if (ret) + goto out_free; + if (ret =3D=3D 0) { if (!(attrs->pause || attrs->cont || attrs->clear)) ret =3D -ENOENT; goto out_free; @@ -6328,15 +6325,13 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, se =3D find_synth_event(se_name); if (se) se->ref++; - /* Just return zero, not the number of registered triggers */ - ret =3D 0; out: if (ret =3D=3D 0) hist_err_clear(); =20 return ret; out_unreg: - cmd_ops->unreg(glob+1, trigger_data, file); + event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); 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 d00fee705f9c..0ab86b5449d7 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -573,13 +573,12 @@ static int register_trigger(char *glob, } =20 list_add_rcu(&data->list, &file->triggers); - ret++; =20 update_cond_flag(file); - if (trace_event_trigger_enable_disable(file, 1) < 0) { + ret =3D trace_event_trigger_enable_disable(file, 1); + if (ret < 0) { list_del_rcu(&data->list); update_cond_flag(file); - ret--; } out: return ret; @@ -913,48 +912,37 @@ void event_trigger_reset_filter(struct event_command = *cmd_ops, * @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. + * cmd_ops->reg() function which actually does the registration. * * 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) + struct event_trigger_data *trigger_data) { - 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 cmd_ops->reg(glob, trigger_data, file); +} =20 - return ret; +/** + * event_trigger_unregister - unregister 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 + * @trigger_data: The trigger_data for the trigger + * + * Unregister an event trigger. The @cmd_ops are used to call the + * cmd_ops->unreg() function which actually does the unregistration. + */ +void event_trigger_unregister(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, + struct event_trigger_data *trigger_data) +{ + cmd_ops->unreg(glob, trigger_data, file); } =20 /* @@ -1013,7 +1001,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_data, file); + event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); kfree(trigger_data); ret =3D 0; goto out; @@ -1048,17 +1036,10 @@ 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_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; + + ret =3D event_trigger_register(cmd_ops, file, glob, trigger_data); + 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); @@ -1795,7 +1776,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_data, file); + event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); kfree(trigger_data); kfree(enable_data); ret =3D 0; @@ -1842,19 +1823,11 @@ 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, trigger_data); + if (ret) goto out_disable; - /* Just return zero, not the number of enabled functions */ - ret =3D 0; + event_trigger_free(trigger_ops, trigger_data); out: return ret; @@ -1900,13 +1873,12 @@ int event_enable_register_trigger(char *glob, } =20 list_add_rcu(&data->list, &file->triggers); - ret++; =20 update_cond_flag(file); - if (trace_event_trigger_enable_disable(file, 1) < 0) { + ret =3D trace_event_trigger_enable_disable(file, 1); + if (ret < 0) { list_del_rcu(&data->list); update_cond_flag(file); - ret--; } out: return ret; --=20 2.17.1 From nobody Tue Jun 30 19:34:03 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 89CDEC433F5 for ; Fri, 4 Feb 2022 22:12:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347707AbiBDWM1 (ORCPT ); Fri, 4 Feb 2022 17:12:27 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:56956 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1346216AbiBDWMT (ORCPT ); Fri, 4 Feb 2022 17:12:19 -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 E6CD1B83938 for ; Fri, 4 Feb 2022 22:12:17 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 36A8AC004E1; Fri, 4 Feb 2022 22:12:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1644012736; bh=+2HpRRHAX64zavC0oxxdhTf2E3AVpFDY+I85D/cs/3M=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=tvvK8yj0M+OQ/EL+dVgeYUh8+v3/K16lwTN5iOwFy8DAmRRcVaFvbJL3Qwe+PtYIx vlyUNzkH69ykVbP0oYn7hMuGPtbR1WvWt9eK1trCC74xy36DSBIDTmXMo72oo0uXry JYIDN/iCeobVgwdFnfkSqKmK6x9Jil4RZrshoZ6mjLamSGrgY/zT8FD1PZ6lQcSrWM 5JH8l6jEUHLkrjFJd0Axu1p9/vIRSAlI4AcBD0CwfreY+ljEGiBxzoWgUaGs5mxg8N fSh9M3zoOEcnG41fAeF7tg5AAAXm+Fg/euMQQRsrjf7FyyiLdAxLSxH2SJEgrl53gy W83Zsap09Snqg== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v8 2/4] tracing: Remove redundant trigger_ops params Date: Fri, 4 Feb 2022 16:12:05 -0600 Message-Id: <9856c9bc81bde57077f5b8d6f8faa47156c6354a.1644010575.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 | 29 ++++++++---------- kernel/trace/trace_events_trigger.c | 46 +++++++++++------------------ 4 files changed, 36 insertions(+), 60 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 835f1e3d9924..2e9d4919b367 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, char *param); @@ -1588,8 +1586,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 191db32dec46..328b5f7c0039 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 8df815bc0ac5..2ec27500a030 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5249,7 +5249,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; @@ -5481,7 +5481,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->ops, data); + data->ops->print(m, data); seq_puts(m, "#\n\n"); =20 hist_data =3D data->private_data; @@ -5618,7 +5618,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; @@ -5726,8 +5725,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 @@ -5755,8 +5753,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 @@ -5785,25 +5782,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) { @@ -5990,7 +5985,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; } @@ -6108,7 +6103,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) @@ -6161,7 +6156,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); } } } @@ -6455,7 +6450,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 0ab86b5449d7..e87b1b88900e 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; } @@ -615,7 +611,7 @@ static void unregister_trigger(char *glob, } =20 if (unregistered && data->ops->free) - data->ops->free(data->ops, data); + data->ops->free(data); } =20 /* @@ -1035,14 +1031,14 @@ event_trigger_parse(struct event_command *cmd_ops, =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); + event_trigger_init(trigger_data); =20 ret =3D event_trigger_register(cmd_ops, file, glob, trigger_data); 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); out: return ret; =20 @@ -1328,16 +1324,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); @@ -1448,8 +1442,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); @@ -1539,8 +1532,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); @@ -1630,7 +1622,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; @@ -1655,8 +1646,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 @@ -1784,7 +1774,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_ops, trigger_data); + event_trigger_init(trigger_data); =20 if (trigger) { number =3D strsep(&trigger, ":"); @@ -1828,7 +1818,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, if (ret) goto out_disable; =20 - event_trigger_free(trigger_ops, trigger_data); + event_trigger_free(trigger_data); out: return ret; =20 @@ -1839,7 +1829,7 @@ int event_enable_trigger_parse(struct event_command *= cmd_ops, out_free: if (cmd_ops->set_filter) cmd_ops->set_filter(NULL, trigger_data, NULL); - event_trigger_free(trigger_ops, trigger_data); + event_trigger_free(trigger_data); kfree(enable_data); goto out; } @@ -1867,7 +1857,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; } @@ -1910,7 +1900,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 From nobody Tue Jun 30 19:34:03 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 931E0C433EF for ; Fri, 4 Feb 2022 22:12:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1346580AbiBDWMV (ORCPT ); Fri, 4 Feb 2022 17:12:21 -0500 Received: from dfw.source.kernel.org ([139.178.84.217]:55616 "EHLO dfw.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1346234AbiBDWMS (ORCPT ); Fri, 4 Feb 2022 17:12:18 -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 dfw.source.kernel.org (Postfix) with ESMTPS id A41A86199F for ; Fri, 4 Feb 2022 22:12:18 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 89C6AC340F0; Fri, 4 Feb 2022 22:12:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1644012738; bh=CvN53tiYDbeyRg8KejWhuiYrr8P8CvD0z4SkrIljYXA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=fSDELtbijXCOx6qZqFRHC/lHIKPrCh3H0eV/LSLeueBwvjmAHu0/JUhOBTLUABaNc WlI8WkNWw5AfvYzq2byktqAnUnnbcqsu0KDWukwGvlPC4vzkyUPsDePnGXIn0AszCk 1gIW6s06RXVcLoRytb1QMkbrUWlBTvGVjZJKUJXg5juOlX6FJclGxRvnTeOqo3nsOD QdMqPgPsSL0g7KDX55jXf9mweCZpndh8cwY1Wjy09CtqNzZDkGSAqgSleJ5S/+k8mx OL16kB/h2TgNNyDTo2wgs2ZLxXukBKkLqTJyIaIcP+WCR3Af2/WEMY56xD3hF8PyBj RTfn/yNkrd+4Q== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v8 3/4] tracing: Have existing event_command.parse() implementations use helpers Date: Fri, 4 Feb 2022 16:12:06 -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" 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 | 64 +++++------- kernel/trace/trace_events_trigger.c | 150 ++++++++-------------------- 4 files changed, 69 insertions(+), 151 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 2e9d4919b367..cb6d5d5c2452 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -1578,7 +1578,8 @@ extern int event_enable_trigger_print(struct seq_file= *m, 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, 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 328b5f7c0039..f8270214ee96 100644 --- a/kernel/trace/trace_eprobe.c +++ b/kernel/trace/trace_eprobe.c @@ -548,7 +548,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 2ec27500a030..28604e17bc73 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -2782,7 +2782,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, @@ -6163,17 +6164,17 @@ 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; + bool remove; int ret =3D 0; =20 lockdep_assert_held(&event_mutex); @@ -6182,31 +6183,30 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, =20 if (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++; @@ -6216,24 +6216,24 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, } while (1); =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 @@ -6246,29 +6246,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)) @@ -6295,8 +6281,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, 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; @@ -6328,8 +6313,7 @@ static int event_hist_trigger_parse(struct event_comm= and *cmd_ops, out_unreg: event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); 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 e87b1b88900e..6d3d493c34f7 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -951,7 +951,7 @@ void event_trigger_unregister(struct event_command *cmd= _ops, * @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. @@ -964,72 +964,39 @@ void event_trigger_unregister(struct event_command *c= md_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) { event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); 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_data); =20 @@ -1043,8 +1010,7 @@ event_trigger_parse(struct event_command *cmd_ops, return ret; =20 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; } @@ -1693,39 +1659,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); @@ -1741,31 +1701,23 @@ 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; =20 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) { event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); kfree(trigger_data); kfree(enable_data); @@ -1776,33 +1728,14 @@ int event_enable_trigger_parse(struct event_command= *cmd_ops, /* Up the trigger_data count to make sure nothing frees it on failure */ event_trigger_init(trigger_data); =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: /* Don't let event modules unload while probe registered */ ret =3D trace_event_try_get_ref(event_enable_file->event_call); if (!ret) { @@ -1821,16 +1754,15 @@ int event_enable_trigger_parse(struct event_command= *cmd_ops, event_trigger_free(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_reset_filter(cmd_ops, trigger_data); event_trigger_free(trigger_data); kfree(enable_data); + goto out; } =20 --=20 2.17.1 From nobody Tue Jun 30 19:34:03 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 91AEFC433EF for ; Fri, 4 Feb 2022 22:12:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1348247AbiBDWMb (ORCPT ); Fri, 4 Feb 2022 17:12:31 -0500 Received: from dfw.source.kernel.org ([139.178.84.217]:55660 "EHLO dfw.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1346694AbiBDWMU (ORCPT ); Fri, 4 Feb 2022 17:12: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 dfw.source.kernel.org (Postfix) with ESMTPS id 3DBA86199F for ; Fri, 4 Feb 2022 22:12:20 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 354D9C004E1; Fri, 4 Feb 2022 22:12:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1644012739; bh=y1dpcwaROiGNIsdVFNTBw0iucvP+KvehfPTvsCdkpjQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=SWtE4mmD/c+3cOTfA0RIAsJqgcEyvo8bSkb0VyNeVB7nE107L5tESG91ZPTWFpOFT bfjocuAZO+SPH6fnT5yNwd0aToSRe2ZK2FYUr3Xm6rKcI0WJdToHC8dMzvAO2zpQ1A KxG8iPIgzXccenq+e4HO958bMcH5r4D5Iu7U4SLdn7UyKhkzbnEaJe4TbbZ+qz8KEY 8Vy3YqXirYeqcgoi8dkQjWpDJR3OtcC0TaO6IQhn5HVk32ulTeAcxcRCrzX2ImNjgL JK11Re9uZY0Qk5aEMn/zFhnr+xroiFggkelWmqyOGL9wsqGPNMS2l/hJQWIPBqspyk 6xF+gQsLe48Dg== From: Tom Zanussi To: rostedt@goodmis.org Cc: mhiramat@kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v8 4/4] tracing: Separate hist state updates from hist registration Date: Fri, 4 Feb 2022 16:12:07 -0600 Message-Id: <211b2cd3e3d7e00f4f8ad45ef8b33063da6a7e05.1644010576.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" hist_register_trigger() handles both new hist registration as well as existing hist registration through event_command.reg(). Adding a new function, existing_hist_update_only(), that checks and updates existing histograms and exits after doing so allows the confusing logic in event_hist_trigger_parse() to be simplified. Signed-off-by: Tom Zanussi --- kernel/trace/trace_events_hist.c | 66 +++++++++++++++++++++++--------- 1 file changed, 48 insertions(+), 18 deletions(-) diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_h= ist.c index 28604e17bc73..bc52b03be11a 100644 --- a/kernel/trace/trace_events_hist.c +++ b/kernel/trace/trace_events_hist.c @@ -5926,6 +5926,48 @@ static bool hist_trigger_match(struct event_trigger_= data *data, return true; } =20 +static bool existing_hist_update_only(char *glob, + struct event_trigger_data *data, + struct trace_event_file *file) +{ + struct hist_trigger_data *hist_data =3D data->private_data; + struct event_trigger_data *test, *named_data =3D NULL; + bool updated =3D false; + + if (!hist_data->attrs->pause && !hist_data->attrs->cont && + !hist_data->attrs->clear) + goto out; + + if (hist_data->attrs->name) { + named_data =3D find_named_trigger(hist_data->attrs->name); + if (named_data) { + if (!hist_trigger_match(data, named_data, named_data, + true)) + goto out; + } + } + + if (hist_data->attrs->name && !named_data) + goto out; + + list_for_each_entry(test, &file->triggers, list) { + if (test->cmd_ops->trigger_type =3D=3D ETT_EVENT_HIST) { + if (!hist_trigger_match(data, test, named_data, false)) + continue; + if (hist_data->attrs->pause) + test->paused =3D true; + else if (hist_data->attrs->cont) + test->paused =3D false; + else if (hist_data->attrs->clear) + hist_clear(test); + updated =3D true; + goto out; + } + } + out: + return updated; +} + static int hist_register_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) @@ -5954,19 +5996,11 @@ static int hist_register_trigger(char *glob, =20 list_for_each_entry(test, &file->triggers, list) { if (test->cmd_ops->trigger_type =3D=3D ETT_EVENT_HIST) { - if (!hist_trigger_match(data, test, named_data, false)) - continue; - if (hist_data->attrs->pause) - test->paused =3D true; - else if (hist_data->attrs->cont) - test->paused =3D false; - else if (hist_data->attrs->clear) - hist_clear(test); - else { + if (hist_trigger_match(data, test, named_data, false)) { hist_err(tr, HIST_ERR_TRIGGER_EEXIST, 0); ret =3D -EEXIST; + goto out; } - goto out; } } new: @@ -6005,8 +6039,6 @@ static int hist_register_trigger(char *glob, =20 if (named_data) destroy_hist_data(hist_data); - - ret++; out: return ret; } @@ -6274,14 +6306,12 @@ static int event_hist_trigger_parse(struct event_co= mmand *cmd_ops, goto out_free; } =20 - ret =3D event_trigger_register(cmd_ops, file, glob, trigger_data); - if (ret) + if (existing_hist_update_only(glob, trigger_data, file)) goto out_free; - if (ret =3D=3D 0) { - if (!(attrs->pause || attrs->cont || attrs->clear)) - ret =3D -ENOENT; + + ret =3D event_trigger_register(cmd_ops, file, glob, trigger_data); + if (ret < 0) goto out_free; - } =20 if (get_named_trigger_data(trigger_data)) goto enable; --=20 2.17.1