tracing: Remove redundant trigger_ops params

Tom Zanussi · rostedt · commit 476705419518 · 2022-04-26T17:58:50.000-04:00
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. Link: https://lkml.kernel.org/r/9856c9bc81bde57077f5b8d6f8faa47156c6354a.1644010575.git.zanussi@kernel.org Signed-off-by: Tom Zanussi <zanussi@kernel.org> Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
@@ -1573,10 +1573,8 @@ struct enable_trigger_data {
 };
 
 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);
@@ -1587,8 +1585,7 @@ extern void event_enable_unregister_trigger(char *glob,
 					    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 *file,
 					      int trigger_enable);
 extern void update_cond_flag(struct trace_event_file *file);
@@ -1687,12 +1684,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);
 };
 
diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c
@@ -511,20 +511,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;
 }
 
-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)
 {
 
 }
 
 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_hist.c
@@ -5252,7 +5252,7 @@ static void hist_trigger_show(struct seq_file *m,
 		seq_puts(m, "\n\n");
 
 	seq_puts(m, "# event histogram\n#\n# trigger info: ");
-	data->ops->print(m, data->ops, data);
+	data->ops->print(m, data);
 	seq_puts(m, "#\n\n");
 
 	hist_data = data->private_data;
@@ -5484,7 +5484,7 @@ static void hist_trigger_debug_show(struct seq_file *m,
 		seq_puts(m, "\n\n");
 
 	seq_puts(m, "# event histogram\n#\n# trigger info: ");
-	data->ops->print(m, data->ops, data);
+	data->ops->print(m, data);
 	seq_puts(m, "#\n\n");
 
 	hist_data = data->private_data;
@@ -5621,7 +5621,6 @@ static void hist_field_print(struct seq_file *m, struct hist_field *hist_field)
 }
 
 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 = data->private_data;
@@ -5729,8 +5728,7 @@ static int event_hist_trigger_print(struct seq_file *m,
 	return 0;
 }
 
-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 = data->private_data;
 
@@ -5758,8 +5756,7 @@ static void unregister_field_var_hists(struct hist_trigger_data *hist_data)
 	}
 }
 
-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 = data->private_data;
 
@@ -5788,25 +5785,23 @@ static struct event_trigger_ops event_hist_trigger_ops = {
 	.free			= event_hist_trigger_free,
 };
 
-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++;
 
 	save_named_trigger(data->named_data->name, data);
 
-	event_hist_trigger_init(ops, data->named_data);
+	event_hist_trigger_init(data->named_data);
 
 	return 0;
 }
 
-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 <= 0))
 		return;
 
-	event_hist_trigger_free(ops, data->named_data);
+	event_hist_trigger_free(data->named_data);
 
 	data->ref--;
 	if (!data->ref) {
@@ -5993,7 +5988,7 @@ static int hist_register_trigger(char *glob,
 	}
 
 	if (data->ops->init) {
-		ret = data->ops->init(data->ops, data);
+		ret = data->ops->init(data);
 		if (ret < 0)
 			goto out;
 	}
@@ -6111,7 +6106,7 @@ static void hist_unregister_trigger(char *glob,
 	}
 
 	if (unregistered && test->ops->free)
-		test->ops->free(test->ops, test);
+		test->ops->free(test);
 
 	if (hist_data->enable_timestamps) {
 		if (!hist_data->remove || unregistered)
@@ -6164,7 +6159,7 @@ static void hist_unreg_all(struct trace_event_file *file)
 			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);
 		}
 	}
 }
@@ -6458,7 +6453,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_events_trigger.c
@@ -188,7 +188,7 @@ static int trigger_show(struct seq_file *m, void *v)
 	}
 
 	data = list_entry(v, struct event_trigger_data, list);
-	data->ops->print(m, data->ops, data);
+	data->ops->print(m, data);
 
 	return 0;
 }
@@ -432,7 +432,6 @@ event_trigger_print(const char *name, struct seq_file *m,
 
 /**
  * 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.
@@ -442,16 +441,14 @@ 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;
 }
 
 /**
  * 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.
@@ -460,8 +457,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 <= 0))
 		return;
@@ -515,7 +511,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);
 		}
 	}
 }
@@ -581,7 +577,7 @@ static int register_trigger(char *glob,
 	}
 
 	if (data->ops->init) {
-		ret = data->ops->init(data->ops, data);
+		ret = data->ops->init(data);
 		if (ret < 0)
 			goto out;
 	}
@@ -629,7 +625,7 @@ static void unregister_trigger(char *glob,
 	}
 
 	if (unregistered && data->ops->free)
-		data->ops->free(data->ops, data);
+		data->ops->free(data);
 }
 
 /*
@@ -1049,14 +1045,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);
+	event_trigger_init(trigger_data);
 
 	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
 	if (ret)
 		goto out_free;
 
 	/* 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;
 
@@ -1382,16 +1378,14 @@ traceoff_count_trigger(struct event_trigger_data *data,
 }
 
 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);
 }
 
 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);
@@ -1502,8 +1496,7 @@ register_snapshot_trigger(char *glob,
 }
 
 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);
@@ -1598,8 +1591,7 @@ stacktrace_count_trigger(struct event_trigger_data *data,
 }
 
 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 *data)
 {
 	return event_trigger_print("stacktrace", m, (void *)data->count,
 				   data->filter_str);
@@ -1689,7 +1681,6 @@ event_enable_count_trigger(struct event_trigger_data *data,
 }
 
 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 = data->private_data;
@@ -1714,8 +1705,7 @@ int event_enable_trigger_print(struct seq_file *m,
 	return 0;
 }
 
-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 = data->private_data;
 
@@ -1843,7 +1833,7 @@ 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_ops, trigger_data);
+	event_trigger_init(trigger_data);
 
 	if (trigger) {
 		number = strsep(&trigger, ":");
@@ -1887,7 +1877,7 @@ int event_enable_trigger_parse(struct event_command *cmd_ops,
 	if (ret)
 		goto out_disable;
 
-	event_trigger_free(trigger_ops, trigger_data);
+	event_trigger_free(trigger_data);
  out:
 	return ret;
 
@@ -1898,7 +1888,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;
 }
@@ -1926,7 +1916,7 @@ int event_enable_register_trigger(char *glob,
 	}
 
 	if (data->ops->init) {
-		ret = data->ops->init(data->ops, data);
+		ret = data->ops->init(data);
 		if (ret < 0)
 			goto out;
 	}
@@ -1969,7 +1959,7 @@ void event_enable_unregister_trigger(char *glob,
 	}
 
 	if (unregistered && data->ops->free)
-		data->ops->free(data->ops, data);
+		data->ops->free(data);
 }
 
 static struct event_trigger_ops *

Original file line number	Diff line number	Diff line change
`@@ -511,20 +511,17 @@ __eprobe_trace_func(struct eprobe_data edata, void rec)`
`511`	`511`	`* functions are just stubs to fulfill what is needed to use the trigger`
`512`	`512`	`* infrastructure.`
`513`	`513`	`*/`
`514`		`-static int eprobe_trigger_init(struct event_trigger_ops *ops,`
`515`		`- struct event_trigger_data *data)`
	`514`	`+static int eprobe_trigger_init(struct event_trigger_data *data)`
`516`	`515`	`{`
`517`	`516`	`return 0;`
`518`	`517`	`}`
`519`	`518`
`520`		`-static void eprobe_trigger_free(struct event_trigger_ops *ops,`
`521`		`- struct event_trigger_data *data)`
	`519`	`+static void eprobe_trigger_free(struct event_trigger_data *data)`
`522`	`520`	`{`
`523`	`521`
`524`	`522`	`}`
`525`	`523`
`526`	`524`	`static int eprobe_trigger_print(struct seq_file *m,`
`527`		`- struct event_trigger_ops *ops,`
`528`	`525`	`struct event_trigger_data *data)`
`529`	`526`	`{`
`530`	`527`	`/* Do not print eprobe event triggers */`
Original file line number	Diff line number	Diff line change
`@@ -5252,7 +5252,7 @@ static void hist_trigger_show(struct seq_file *m,`
`5252`	`5252`	`seq_puts(m, "\n\n");`
`5253`	`5253`
`5254`	`5254`	`seq_puts(m, "# event histogram\n#\n# trigger info: ");`
`5255`		`- data->ops->print(m, data->ops, data);`
	`5255`	`+ data->ops->print(m, data);`
`5256`	`5256`	`seq_puts(m, "#\n\n");`
`5257`	`5257`
`5258`	`5258`	`hist_data = data->private_data;`
`@@ -5484,7 +5484,7 @@ static void hist_trigger_debug_show(struct seq_file *m,`
`5484`	`5484`	`seq_puts(m, "\n\n");`
`5485`	`5485`
`5486`	`5486`	`seq_puts(m, "# event histogram\n#\n# trigger info: ");`
`5487`		`- data->ops->print(m, data->ops, data);`
	`5487`	`+ data->ops->print(m, data);`
`5488`	`5488`	`seq_puts(m, "#\n\n");`
`5489`	`5489`
`5490`	`5490`	`hist_data = data->private_data;`
`@@ -5621,7 +5621,6 @@ static void hist_field_print(struct seq_file m, struct hist_field hist_field)`
`5621`	`5621`	`}`
`5622`	`5622`
`5623`	`5623`	`static int event_hist_trigger_print(struct seq_file *m,`
`5624`		`- struct event_trigger_ops *ops,`
`5625`	`5624`	`struct event_trigger_data *data)`
`5626`	`5625`	`{`
`5627`	`5626`	`struct hist_trigger_data *hist_data = data->private_data;`
`@@ -5729,8 +5728,7 @@ static int event_hist_trigger_print(struct seq_file *m,`
`5729`	`5728`	`return 0;`
`5730`	`5729`	`}`
`5731`	`5730`
`5732`		`-static int event_hist_trigger_init(struct event_trigger_ops *ops,`
`5733`		`- struct event_trigger_data *data)`
	`5731`	`+static int event_hist_trigger_init(struct event_trigger_data *data)`
`5734`	`5732`	`{`
`5735`	`5733`	`struct hist_trigger_data *hist_data = data->private_data;`
`5736`	`5734`
`@@ -5758,8 +5756,7 @@ static void unregister_field_var_hists(struct hist_trigger_data *hist_data)`
`5758`	`5756`	`}`
`5759`	`5757`	`}`
`5760`	`5758`
`5761`		`-static void event_hist_trigger_free(struct event_trigger_ops *ops,`
`5762`		`- struct event_trigger_data *data)`
	`5759`	`+static void event_hist_trigger_free(struct event_trigger_data *data)`
`5763`	`5760`	`{`
`5764`	`5761`	`struct hist_trigger_data *hist_data = data->private_data;`
`5765`	`5762`
`@@ -5788,25 +5785,23 @@ static struct event_trigger_ops event_hist_trigger_ops = {`
`5788`	`5785`	`.free = event_hist_trigger_free,`
`5789`	`5786`	`};`
`5790`	`5787`
`5791`		`-static int event_hist_trigger_named_init(struct event_trigger_ops *ops,`
`5792`		`- struct event_trigger_data *data)`
	`5788`	`+static int event_hist_trigger_named_init(struct event_trigger_data *data)`
`5793`	`5789`	`{`
`5794`	`5790`	`data->ref++;`
`5795`	`5791`
`5796`	`5792`	`save_named_trigger(data->named_data->name, data);`
`5797`	`5793`
`5798`		`- event_hist_trigger_init(ops, data->named_data);`
	`5794`	`+ event_hist_trigger_init(data->named_data);`
`5799`	`5795`
`5800`	`5796`	`return 0;`
`5801`	`5797`	`}`
`5802`	`5798`
`5803`		`-static void event_hist_trigger_named_free(struct event_trigger_ops *ops,`
`5804`		`- struct event_trigger_data *data)`
	`5799`	`+static void event_hist_trigger_named_free(struct event_trigger_data *data)`
`5805`	`5800`	`{`
`5806`	`5801`	`if (WARN_ON_ONCE(data->ref <= 0))`
`5807`	`5802`	`return;`
`5808`	`5803`
`5809`		`- event_hist_trigger_free(ops, data->named_data);`
	`5804`	`+ event_hist_trigger_free(data->named_data);`
`5810`	`5805`
`5811`	`5806`	`data->ref--;`
`5812`	`5807`	`if (!data->ref) {`
`@@ -5993,7 +5988,7 @@ static int hist_register_trigger(char *glob,`
`5993`	`5988`	`}`
`5994`	`5989`
`5995`	`5990`	`if (data->ops->init) {`
`5996`		`- ret = data->ops->init(data->ops, data);`
	`5991`	`+ ret = data->ops->init(data);`
`5997`	`5992`	`if (ret < 0)`
`5998`	`5993`	`goto out;`
`5999`	`5994`	`}`
`@@ -6111,7 +6106,7 @@ static void hist_unregister_trigger(char *glob,`
`6111`	`6106`	`}`
`6112`	`6107`
`6113`	`6108`	`if (unregistered && test->ops->free)`
`6114`		`- test->ops->free(test->ops, test);`
	`6109`	`+ test->ops->free(test);`
`6115`	`6110`
`6116`	`6111`	`if (hist_data->enable_timestamps) {`
`6117`	`6112`	`if (!hist_data->remove \|\| unregistered)`
`@@ -6164,7 +6159,7 @@ static void hist_unreg_all(struct trace_event_file *file)`
`6164`	`6159`	`if (hist_data->enable_timestamps)`
`6165`	`6160`	`tracing_set_filter_buffering(file->tr, false);`
`6166`	`6161`	`if (test->ops->free)`
`6167`		`- test->ops->free(test->ops, test);`
	`6162`	`+ test->ops->free(test);`
`6168`	`6163`	`}`
`6169`	`6164`	`}`
`6170`	`6165`	`}`
`@@ -6458,7 +6453,7 @@ static void hist_enable_unreg_all(struct trace_event_file *file)`
`6458`	`6453`	`update_cond_flag(file);`
`6459`	`6454`	`trace_event_trigger_enable_disable(file, 0);`
`6460`	`6455`	`if (test->ops->free)`
`6461`		`- test->ops->free(test->ops, test);`
	`6456`	`+ test->ops->free(test);`
`6462`	`6457`	`}`
`6463`	`6458`	`}`
`6464`	`6459`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ static int trigger_show(struct seq_file m, void v)`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`data = list_entry(v, struct event_trigger_data, list);`
`191`		`- data->ops->print(m, data->ops, data);`
	`191`	`+ data->ops->print(m, data);`
`192`	`192`
`193`	`193`	`return 0;`
`194`	`194`	`}`
`@@ -432,7 +432,6 @@ event_trigger_print(const char name, struct seq_file m,`
`432`	`432`
`433`	`433`	`/**`
`434`	`434`	`* event_trigger_init - Generic event_trigger_ops @init implementation`
`435`		`- * @ops: The trigger ops associated with the trigger`
`436`	`435`	`* @data: Trigger-specific data`
`437`	`436`	`*`
`438`	`437`	`* Common implementation of event trigger initialization.`
`@@ -442,16 +441,14 @@ event_trigger_print(const char name, struct seq_file m,`
`442`	`441`	`*`
`443`	`442`	`* Return: 0 on success, errno otherwise`
`444`	`443`	`*/`
`445`		`-int event_trigger_init(struct event_trigger_ops *ops,`
`446`		`- struct event_trigger_data *data)`
	`444`	`+int event_trigger_init(struct event_trigger_data *data)`
`447`	`445`	`{`
`448`	`446`	`data->ref++;`
`449`	`447`	`return 0;`
`450`	`448`	`}`
`451`	`449`
`452`	`450`	`/**`
`453`	`451`	`* event_trigger_free - Generic event_trigger_ops @free implementation`
`454`		`- * @ops: The trigger ops associated with the trigger`
`455`	`452`	`* @data: Trigger-specific data`
`456`	`453`	`*`
`457`	`454`	`* Common implementation of event trigger de-initialization.`
`@@ -460,8 +457,7 @@ int event_trigger_init(struct event_trigger_ops *ops,`
`460`	`457`	`* implementations.`
`461`	`458`	`*/`
`462`	`459`	`static void`
`463`		`-event_trigger_free(struct event_trigger_ops *ops,`
`464`		`- struct event_trigger_data *data)`
	`460`	`+event_trigger_free(struct event_trigger_data *data)`
`465`	`461`	`{`
`466`	`462`	`if (WARN_ON_ONCE(data->ref <= 0))`
`467`	`463`	`return;`
`@@ -515,7 +511,7 @@ clear_event_triggers(struct trace_array *tr)`
`515`	`511`	`trace_event_trigger_enable_disable(file, 0);`
`516`	`512`	`list_del_rcu(&data->list);`
`517`	`513`	`if (data->ops->free)`
`518`		`- data->ops->free(data->ops, data);`
	`514`	`+ data->ops->free(data);`
`519`	`515`	`}`
`520`	`516`	`}`
`521`	`517`	`}`
`@@ -581,7 +577,7 @@ static int register_trigger(char *glob,`
`581`	`577`	`}`
`582`	`578`
`583`	`579`	`if (data->ops->init) {`
`584`		`- ret = data->ops->init(data->ops, data);`
	`580`	`+ ret = data->ops->init(data);`
`585`	`581`	`if (ret < 0)`
`586`	`582`	`goto out;`
`587`	`583`	`}`
`@@ -629,7 +625,7 @@ static void unregister_trigger(char *glob,`
`629`	`625`	`}`
`630`	`626`
`631`	`627`	`if (unregistered && data->ops->free)`
`632`		`- data->ops->free(data->ops, data);`
	`628`	`+ data->ops->free(data);`
`633`	`629`	`}`
`634`	`630`
`635`	`631`	`/*`
`@@ -1049,14 +1045,14 @@ event_trigger_parse(struct event_command *cmd_ops,`
`1049`	`1045`
`1050`	`1046`	`out_reg:`
`1051`	`1047`	`/* Up the trigger_data count to make sure reg doesn't free it on failure */`
`1052`		`- event_trigger_init(trigger_ops, trigger_data);`
	`1048`	`+ event_trigger_init(trigger_data);`
`1053`	`1049`
`1054`	`1050`	`ret = event_trigger_register(cmd_ops, file, glob, trigger_data);`
`1055`	`1051`	`if (ret)`
`1056`	`1052`	`goto out_free;`
`1057`	`1053`
`1058`	`1054`	`/* Down the counter of trigger_data or free it if not used anymore */`
`1059`		`- event_trigger_free(trigger_ops, trigger_data);`
	`1055`	`+ event_trigger_free(trigger_data);`
`1060`	`1056`	`out:`
`1061`	`1057`	`return ret;`
`1062`	`1058`
`@@ -1382,16 +1378,14 @@ traceoff_count_trigger(struct event_trigger_data *data,`
`1382`	`1378`	`}`
`1383`	`1379`
`1384`	`1380`	`static int`
`1385`		`-traceon_trigger_print(struct seq_file m, struct event_trigger_ops ops,`
`1386`		`- struct event_trigger_data *data)`
	`1381`	`+traceon_trigger_print(struct seq_file m, struct event_trigger_data data)`
`1387`	`1382`	`{`
`1388`	`1383`	`return event_trigger_print("traceon", m, (void *)data->count,`
`1389`	`1384`	`data->filter_str);`
`1390`	`1385`	`}`
`1391`	`1386`
`1392`	`1387`	`static int`
`1393`		`-traceoff_trigger_print(struct seq_file m, struct event_trigger_ops ops,`
`1394`		`- struct event_trigger_data *data)`
	`1388`	`+traceoff_trigger_print(struct seq_file m, struct event_trigger_data data)`
`1395`	`1389`	`{`
`1396`	`1390`	`return event_trigger_print("traceoff", m, (void *)data->count,`
`1397`	`1391`	`data->filter_str);`
`@@ -1502,8 +1496,7 @@ register_snapshot_trigger(char *glob,`
`1502`	`1496`	`}`
`1503`	`1497`
`1504`	`1498`	`static int`
`1505`		`-snapshot_trigger_print(struct seq_file m, struct event_trigger_ops ops,`
`1506`		`- struct event_trigger_data *data)`
	`1499`	`+snapshot_trigger_print(struct seq_file m, struct event_trigger_data data)`
`1507`	`1500`	`{`
`1508`	`1501`	`return event_trigger_print("snapshot", m, (void *)data->count,`
`1509`	`1502`	`data->filter_str);`
`@@ -1598,8 +1591,7 @@ stacktrace_count_trigger(struct event_trigger_data *data,`
`1598`	`1591`	`}`
`1599`	`1592`
`1600`	`1593`	`static int`
`1601`		`-stacktrace_trigger_print(struct seq_file m, struct event_trigger_ops ops,`
`1602`		`- struct event_trigger_data *data)`
	`1594`	`+stacktrace_trigger_print(struct seq_file m, struct event_trigger_data data)`
`1603`	`1595`	`{`
`1604`	`1596`	`return event_trigger_print("stacktrace", m, (void *)data->count,`
`1605`	`1597`	`data->filter_str);`
`@@ -1689,7 +1681,6 @@ event_enable_count_trigger(struct event_trigger_data *data,`
`1689`	`1681`	`}`
`1690`	`1682`
`1691`	`1683`	`int event_enable_trigger_print(struct seq_file *m,`
`1692`		`- struct event_trigger_ops *ops,`
`1693`	`1684`	`struct event_trigger_data *data)`
`1694`	`1685`	`{`
`1695`	`1686`	`struct enable_trigger_data *enable_data = data->private_data;`
`@@ -1714,8 +1705,7 @@ int event_enable_trigger_print(struct seq_file *m,`
`1714`	`1705`	`return 0;`
`1715`	`1706`	`}`
`1716`	`1707`
`1717`		`-void event_enable_trigger_free(struct event_trigger_ops *ops,`
`1718`		`- struct event_trigger_data *data)`
	`1708`	`+void event_enable_trigger_free(struct event_trigger_data *data)`
`1719`	`1709`	`{`
`1720`	`1710`	`struct enable_trigger_data *enable_data = data->private_data;`
`1721`	`1711`
`@@ -1843,7 +1833,7 @@ int event_enable_trigger_parse(struct event_command *cmd_ops,`
`1843`	`1833`	`}`
`1844`	`1834`
`1845`	`1835`	`/* Up the trigger_data count to make sure nothing frees it on failure */`
`1846`		`- event_trigger_init(trigger_ops, trigger_data);`
	`1836`	`+ event_trigger_init(trigger_data);`
`1847`	`1837`
`1848`	`1838`	`if (trigger) {`
`1849`	`1839`	`number = strsep(&trigger, ":");`
`@@ -1887,7 +1877,7 @@ int event_enable_trigger_parse(struct event_command *cmd_ops,`
`1887`	`1877`	`if (ret)`
`1888`	`1878`	`goto out_disable;`
`1889`	`1879`
`1890`		`- event_trigger_free(trigger_ops, trigger_data);`
	`1880`	`+ event_trigger_free(trigger_data);`
`1891`	`1881`	`out:`
`1892`	`1882`	`return ret;`
`1893`	`1883`
`@@ -1898,7 +1888,7 @@ int event_enable_trigger_parse(struct event_command *cmd_ops,`
`1898`	`1888`	`out_free:`
`1899`	`1889`	`if (cmd_ops->set_filter)`
`1900`	`1890`	`cmd_ops->set_filter(NULL, trigger_data, NULL);`
`1901`		`- event_trigger_free(trigger_ops, trigger_data);`
	`1891`	`+ event_trigger_free(trigger_data);`
`1902`	`1892`	`kfree(enable_data);`
`1903`	`1893`	`goto out;`
`1904`	`1894`	`}`
`@@ -1926,7 +1916,7 @@ int event_enable_register_trigger(char *glob,`
`1926`	`1916`	`}`
`1927`	`1917`
`1928`	`1918`	`if (data->ops->init) {`
`1929`		`- ret = data->ops->init(data->ops, data);`
	`1919`	`+ ret = data->ops->init(data);`
`1930`	`1920`	`if (ret < 0)`
`1931`	`1921`	`goto out;`
`1932`	`1922`	`}`
`@@ -1969,7 +1959,7 @@ void event_enable_unregister_trigger(char *glob,`
`1969`	`1959`	`}`
`1970`	`1960`
`1971`	`1961`	`if (unregistered && data->ops->free)`
`1972`		`- data->ops->free(data->ops, data);`
	`1962`	`+ data->ops->free(data);`
`1973`	`1963`	`}`
`1974`	`1964`
`1975`	`1965`	`static struct event_trigger_ops *`