History

tracing: Remove logic for registering multiple event triggers at a time

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. Link: https://lkml.kernel.org/r/6149fec7a139d93e84fa4535672fb5bef88006b0.1644010575.git.zanussi@kernel.org

Tom Zanussi committed 4 years ago

Commit b8cc44a1 parent 217d8c03 files · +45 −77Browse files

Unified · Split

3 files
  1. kernel/trace/trace.h +5 −4
  2. kernel/trace/trace_events_hist.c +6 −11
  3. kernel/trace/trace_events_trigger.c +34 −62
kernel/trace/trace.h+5−4
@@ -1629,10 +1629,11 @@ extern void event_trigger_reset_filter(struct event_command *cmd_ops, · 1628 unmodified lines
16291629 extern int event_trigger_register(struct event_command *cmd_ops,
16301630 struct trace_event_file *file,
16311631 char *glob,
1632− char *cmd,
1633− char *trigger,
1634− struct event_trigger_data *trigger_data,
1635− int *n_registered);
1632+ struct event_trigger_data *trigger_data);
1633+extern void event_trigger_unregister(struct event_command *cmd_ops,
1634+ struct trace_event_file *file,
1635+ char *glob,
1636+ struct event_trigger_data *trigger_data);
16361637
16371638 /**
16381639 * struct event_trigger_ops - callbacks for trace event triggers
kernel/trace/trace_events_hist.c+6−11
@@ -6287,7 +6287,7 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 6286 unmodified lines
62876287 goto out_free;
62886288 }
62896289
6290− cmd_ops->unreg(glob+1, trigger_data, file);
6290+ event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
62916291 se_name = trace_event_name(file->event_call);
62926292 se = find_synth_event(se_name);
62936293 if (se)
@@ -6296,13 +6296,10 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 2 unmodified lines
62966296 goto out_free;
62976297 }
62986298
6299− ret = cmd_ops->reg(glob, trigger_data, file);
6300− /*
6301− * The above returns on success the # of triggers registered,
6302− * but if it didn't register any it returns zero. Consider no
6303− * triggers registered a failure too.
6304− */
6305− if (!ret) {
6299+ ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
6300+ if (ret)
6301+ goto out_free;
6302+ if (ret == 0) {
63066303 if (!(attrs->pause || attrs->cont || attrs->clear))
63076304 ret = -ENOENT;
63086305 goto out_free;
@@ -6331,15 +6328,13 @@ enable: · 22 unmodified lines
63316328 se = find_synth_event(se_name);
63326329 if (se)
63336330 se->ref++;
6334− /* Just return zero, not the number of registered triggers */
6335− ret = 0;
63366331 out:
63376332 if (ret == 0)
63386333 hist_err_clear();
63396334
63406335 return ret;
63416336 out_unreg:
6342− cmd_ops->unreg(glob+1, trigger_data, file);
6337+ event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
63436338 out_free:
63446339 if (cmd_ops->set_filter)
63456340 cmd_ops->set_filter(NULL, trigger_data, NULL);
kernel/trace/trace_events_trigger.c+34−62
@@ -587,13 +587,12 @@ static int register_trigger(char *glob, · 586 unmodified lines
587587 }
588588
589589 list_add_rcu(&data->list, &file->triggers);
590− ret++;
591590
592591 update_cond_flag(file);
593− if (trace_event_trigger_enable_disable(file, 1) < 0) {
592+ ret = trace_event_trigger_enable_disable(file, 1);
593+ if (ret < 0) {
594594 list_del_rcu(&data->list);
595595 update_cond_flag(file);
596− ret--;
597596 }
598597 out:
599598 return ret;
@@ -927,48 +926,37 @@ void event_trigger_reset_filter(struct event_command *cmd_ops, · 327 unmodified lines
927926 * @cmd_ops: The event_command operations for the trigger
928927 * @file: The event file for the trigger's event
929928 * @glob: The trigger command string, with optional remove(!) operator
930− * @cmd: The cmd string
931− * @param: The param string
932929 * @trigger_data: The trigger_data for the trigger
933− * @n_registered: optional outparam, the number of triggers registered
934930 *
935931 * Register an event trigger. The @cmd_ops are used to call the
936− * cmd_ops->reg() function which actually does the registration. The
937− * cmd_ops->reg() function returns the number of triggers registered,
938− * which is assigned to n_registered, if n_registered is non-NULL.
932+ * cmd_ops->reg() function which actually does the registration.
939933 *
940934 * Return: 0 on success, errno otherwise
941935 */
942936 int event_trigger_register(struct event_command *cmd_ops,
943937 struct trace_event_file *file,
944938 char *glob,
945− char *cmd,
946− char *param,
947− struct event_trigger_data *trigger_data,
948− int *n_registered)
939+ struct event_trigger_data *trigger_data)
949940 {
950− int ret;
951−
952− if (n_registered)
953− *n_registered = 0;
954−
955− ret = cmd_ops->reg(glob, trigger_data, file);
956− /*
957− * The above returns on success the # of functions enabled,
958− * but if it didn't find any functions it returns zero.
959− * Consider no functions a failure too.
960− */
961− if (!ret) {
962− cmd_ops->unreg(glob, trigger_data, file);
963− ret = -ENOENT;
964− } else if (ret > 0) {
965− if (n_registered)
966− *n_registered = ret;
967− /* Just return zero, not the number of enabled functions */
968− ret = 0;
969− }
941+ return cmd_ops->reg(glob, trigger_data, file);
942+}
970943
971− return ret;
944+/**
945+ * event_trigger_unregister - unregister an event trigger
946+ * @cmd_ops: The event_command operations for the trigger
947+ * @file: The event file for the trigger's event
948+ * @glob: The trigger command string, with optional remove(!) operator
949+ * @trigger_data: The trigger_data for the trigger
950+ *
951+ * Unregister an event trigger. The @cmd_ops are used to call the
952+ * cmd_ops->unreg() function which actually does the unregistration.
953+ */
954+void event_trigger_unregister(struct event_command *cmd_ops,
955+ struct trace_event_file *file,
956+ char *glob,
957+ struct event_trigger_data *trigger_data)
958+{
959+ cmd_ops->unreg(glob, trigger_data, file);
972960 }
973961
974962 /*
@@ -1027,7 +1015,7 @@ event_trigger_parse(struct event_command *cmd_ops, · 52 unmodified lines
10271015 INIT_LIST_HEAD(&trigger_data->named_list);
10281016
10291017 if (glob[0] == '!') {
1030− cmd_ops->unreg(glob+1, trigger_data, file);
1018+ event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
10311019 kfree(trigger_data);
10321020 ret = 0;
10331021 goto out;
@@ -1062,17 +1050,10 @@ event_trigger_parse(struct event_command *cmd_ops, · 28 unmodified lines
10621050 out_reg:
10631051 /* Up the trigger_data count to make sure reg doesn't free it on failure */
10641052 event_trigger_init(trigger_ops, trigger_data);
1065− ret = cmd_ops->reg(glob, trigger_data, file);
1066− /*
1067− * The above returns on success the # of functions enabled,
1068− * but if it didn't find any functions it returns zero.
1069− * Consider no functions a failure too.
1070− */
1071− if (!ret) {
1072− cmd_ops->unreg(glob, trigger_data, file);
1073− ret = -ENOENT;
1074− } else if (ret > 0)
1075− ret = 0;
1053+
1054+ ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1055+ if (ret)
1056+ goto out_free;
10761057
10771058 /* Down the counter of trigger_data or free it if not used anymore */
10781059 event_trigger_free(trigger_ops, trigger_data);
@@ -1854,7 +1835,7 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 775 unmodified lines
18541835 trigger_data->private_data = enable_data;
18551836
18561837 if (glob[0] == '!') {
1857− cmd_ops->unreg(glob+1, trigger_data, file);
1838+ event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
18581839 kfree(trigger_data);
18591840 kfree(enable_data);
18601841 ret = 0;
@@ -1901,19 +1882,11 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 40 unmodified lines
19011882 ret = trace_event_enable_disable(event_enable_file, 1, 1);
19021883 if (ret < 0)
19031884 goto out_put;
1904− ret = cmd_ops->reg(glob, trigger_data, file);
1905− /*
1906− * The above returns on success the # of functions enabled,
1907− * but if it didn't find any functions it returns zero.
1908− * Consider no functions a failure too.
1909− */
1910− if (!ret) {
1911− ret = -ENOENT;
1912− goto out_disable;
1913− } else if (ret < 0)
1885+
1886+ ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1887+ if (ret)
19141888 goto out_disable;
1915− /* Just return zero, not the number of enabled functions */
1916− ret = 0;
1889+
19171890 event_trigger_free(trigger_ops, trigger_data);
19181891 out:
19191892 return ret;
@@ -1959,13 +1932,12 @@ int event_enable_register_trigger(char *glob, · 39 unmodified lines
19591932 }
19601933
19611934 list_add_rcu(&data->list, &file->triggers);
1962− ret++;
19631935
19641936 update_cond_flag(file);
1965− if (trace_event_trigger_enable_disable(file, 1) < 0) {
1937+ ret = trace_event_trigger_enable_disable(file, 1);
1938+ if (ret < 0) {
19661939 list_del_rcu(&data->list);
19671940 update_cond_flag(file);
1968− ret--;
19691941 }
19701942 out:
19711943 return ret;