tracing: Add support for in-kernel dynamic event API

Add a function to get an event file and prevent it from going away on module or instance removal.

get_event_file() will find an event file in a given instance (if instance is NULL, it assumes the top trace array) and return it, pinning the instance's trace array as well as the event's module, if applicable, so they won't go away while in use.

put_event_file() does the matching release.

Signed-off-by Tom Zanussi <[email protected]>

---
 include/linux/trace_events.h |  5 +++
 kernel/trace/trace_events.c  | 87 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)

include/linux/trace_events.h +5 -0

index 4c6e15605766..bc634f4e0158 100644
@@ -348,6 +348,11 @@ enum {
 	EVENT_FILE_FL_WAS_ENABLED_BIT,
 };
 
+extern struct trace_event_file *get_event_file(const char *instance,
+					       const char *system,
+					       const char *event);
+extern void put_event_file(struct trace_event_file *file);
+
 /*
  * Event file flags:
  *  ENABLED	  - The event is enabled

kernel/trace/trace_events.c +29 -0

index c6de3cebc127..184e10d3772d 100644
@@ -2535,6 +2535,93 @@ find_event_file(struct trace_array *tr, const char *system, const char *event)
 	return file;
 }
 
+/**
+ * get_event_file - Find and return a trace event file
+ * @instance: The name of the trace instance containing the event
+ * @system: The name of the system containing the event
+ * @event: The name of the event
+ *
+ * Return a trace event file given the trace instance name, trace
+ * system, and trace event name.  If the instance name is NULL, it
+ * refers to the top-level trace array.
+ *
+ * This function will look it up and return it if found, after calling
+ * trace_array_get() to prevent the instance from going away, and
+ * increment the event's module refcount to prevent it from being
+ * removed.
+ *
+ * To release the file, call put_event_file(), which will call
+ * trace_array_put() and decrement the event's module refcount.
+ *
+ * Return: The trace event on success, ERR_PTR otherwise.
+ */
+struct trace_event_file *get_event_file(const char *instance,
+					const char *system,
+					const char *event)
+{
+	struct trace_array *tr = top_trace_array();
+	struct trace_event_file *file = NULL;
+	int ret = -EINVAL;
+
+	if (instance) {

kernel/trace/trace_events.c +48 -0

+
+	mutex_lock(&event_mutex);
+
+	file = find_event_file(tr, system, event);
+	if (!file) {
+		trace_array_put(tr);
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Don't let event modules unload while in use */
+	ret = try_module_get(file->event_call->mod);
+	if (!ret) {
+		trace_array_put(tr);
+		ret = -EBUSY;
+		goto out;
+	}
+
+	ret = 0;
+ out:
+	mutex_unlock(&event_mutex);
+
+	if (ret)
+		file = ERR_PTR(ret);
+
+	return file;
+}
+EXPORT_SYMBOL_GPL(get_event_file);
+
+/**
+ * put_event_file - Release a file from get_event_file()
+ * @file: The trace event file
+ *
+ * If a file was retrieved using get_event_file(), this should be
+ * called when it's no longer needed.  It will cancel the previous
+ * trace_array_get() called by that function, and decrement the
+ * event's module refcount.
+ */
+void put_event_file(struct trace_event_file *file)
+{
+	trace_array_put(file->tr);
+
+	mutex_lock(&event_mutex);
+	module_put(file->event_call->mod);
+	mutex_unlock(&event_mutex);
+}
+EXPORT_SYMBOL_GPL(put_event_file);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 /* Avoid typos */

Signature · 1 line

2.14.1

Hi Tom,

Quoted 77 lines · On Fri, 10 Jan 2020 14:35:08 -0600 Tom Zanussi <[email protected]> wrote:

Add a function to get an event file and prevent it from going away on
module or instance removal.

get_event_file() will find an event file in a given instance (if instance is NULL, it assumes the top trace array) and return it, pinning the instance's trace array as well as the event's module, if
applicable, so they won't go away while in use.

put_event_file() does the matching release.

Signed-off-by Tom Zanussi <[email protected]>

---
 include/linux/trace_events.h |  5 +++
 kernel/trace/trace_events.c  | 87
++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)

include/linux/trace_events.h +5 -0

index 4c6e15605766..bc634f4e0158 100644
@@ -348,6 +348,11 @@ enum {
 	EVENT_FILE_FL_WAS_ENABLED_BIT,
 };
 
+extern struct trace_event_file *get_event_file(const char
 *instance,
+					       const char *system,
+					       const char *event);
+extern void put_event_file(struct trace_event_file *file);
+
 /*
  * Event file flags:

* ENABLED - The event is enabled

kernel/trace/trace_events.c +11 -0

index c6de3cebc127..184e10d3772d 100644
@@ -2535,6 +2535,93 @@ find_event_file(struct trace_array *tr,
 const char *system, const char *event)
 	return file;
 }
 
+/**
+ * get_event_file - Find and return a trace event file
+ * @instance: The name of the trace instance containing the event
+ * @system: The name of the system containing the event
+ * @event: The name of the event
+ *
+ * Return a trace event file given the trace instance name, trace
+ * system, and trace event name.  If the instance name is NULL, it
+ * refers to the top-level trace array.
+ *
+ * This function will look it up and return it if found, after

calling
+ * trace_array_get() to prevent the instance from going away, and
+ * increment the event's module refcount to prevent it from being
+ * removed.
+ *
+ * To release the file, call put_event_file(), which will call
+ * trace_array_put() and decrement the event's module refcount.
+ *
+ * Return: The trace event on success, ERR_PTR otherwise.
+ */

kernel/trace/trace_events.c +9 -0

+struct trace_event_file *get_event_file(const char *instance,
+					const char *system,
+					const char *event)
+{
+	struct trace_array *tr = top_trace_array();
+	struct trace_event_file *file = NULL;
+	int ret = -EINVAL;
+
+	if (instance) {

kernel/trace/trace_events.c find_event_file(struct trace_array *tr, const char *system, const char *event) · line 2576

Quoted 10 lines

kernel/trace/trace_events.c +10 -0

+		mutex_lock(&trace_types_lock);
+		tr = trace_array_find(instance);
+		mutex_unlock(&trace_types_lock);
+		if (!tr)
+			return ERR_PTR(ret);
+	}
+
+	ret = trace_array_get(tr);
+	if (ret)
+		return ERR_PTR(ret);

This seems a bit odd. I think we should introduce trace_array_find_get(instance) so that we don't take care of loosing tr there. It should be something like

trace_array_find_get(instance) {
	mutex_lock(&trace_types_lock);
	tr = trace_array_find(instance);
	if (tr)
		tr->ref++;
	mutex_unlock(&trace_types_lock);
	return tr;
}

Then we can write it as below;

	struct trace_array *tr = top_trace_array();

	if (instance) {
		tr = trace_array_find_get(instance);
		if (!tr)
			return -ENOENT;
	} else
		trace_array_get(tr);/* We never loose top trace_array
*/
	...

This will fail only if there is no instance.

BTW, I think the function name should be get_trace_event_file() because "event_file" sounds a bit generic. (or trace_get_event_file() will give us a good namespace)

Thank you,

Quoted 54 lines

kernel/trace/trace_events.c +48 -0

+
+	mutex_lock(&event_mutex);
+
+	file = find_event_file(tr, system, event);
+	if (!file) {
+		trace_array_put(tr);
+		ret = -EINVAL;
+		goto out;
+	}
+
+	/* Don't let event modules unload while in use */
+	ret = try_module_get(file->event_call->mod);
+	if (!ret) {
+		trace_array_put(tr);
+		ret = -EBUSY;
+		goto out;
+	}
+
+	ret = 0;
+ out:
+	mutex_unlock(&event_mutex);
+
+	if (ret)
+		file = ERR_PTR(ret);
+
+	return file;
+}
+EXPORT_SYMBOL_GPL(get_event_file);
+
+/**
+ * put_event_file - Release a file from get_event_file()
+ * @file: The trace event file
+ *
+ * If a file was retrieved using get_event_file(), this should be
+ * called when it's no longer needed.  It will cancel the previous
+ * trace_array_get() called by that function, and decrement the
+ * event's module refcount.
+ */
+void put_event_file(struct trace_event_file *file)
+{
+	trace_array_put(file->tr);
+
+	mutex_lock(&event_mutex);
+	module_put(file->event_call->mod);
+	mutex_unlock(&event_mutex);
+}
+EXPORT_SYMBOL_GPL(put_event_file);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 /* Avoid typos */

Signature · 1 line

2.14.1

Add an interface used to build up dynamic event creation commands, such as synthetic and kprobe events. Interfaces specific to those particular types of events and others can be built on top of this interface.

Command creation is started by first using the dynevent_cmd_init() function to initialize the dynevent_cmd object. Following that, args are appended and optionally checked by the add_dynevent_arg() and add_dynevent_arg_pair() functions, which use objects representing arguments and pairs of arguments, initialized respectively by dynevent_arg_init() and dynevent_arg_pair_init(). Finally, once all args have been successfully added, the command is finalized and actually created using create_dynevent().

The code here for actually printing into the dyn_event->cmd buffer using snprintf() etc was adapted from v4 of Masami's 'tracing/boot:
Add synthetic event support' patch.

Signed-off-by Tom Zanussi <[email protected]>

Signed-off-by Masami Hiramatsu <[email protected]>

---
 include/linux/trace_events.h |  54 +++++++++++
 kernel/trace/trace_events.c  | 217 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 271 insertions(+)

include/linux/trace_events.h +54 -0

index c8038d1a1a48..bf4cc2e56125 100644
@@ -353,6 +353,60 @@ extern struct trace_event_file *get_event_file(const char *instance,
 					       const char *event);
 extern void put_event_file(struct trace_event_file *file);
 
+struct dynevent_cmd;
+
+typedef int (*dynevent_check_arg_fn_t)(void *data);
+typedef int (*dynevent_create_fn_t)(struct dynevent_cmd *cmd);
+
+struct dynevent_arg {
+	const char		*str;
+	char			separator; /* e.g. ';', ',', or nothing */
+	dynevent_check_arg_fn_t	check_arg;
+};
+
+extern void dynevent_arg_init(struct dynevent_arg *arg,
+			      dynevent_check_arg_fn_t check_arg,
+			      char separator);
+extern int add_dynevent_arg(struct dynevent_cmd *cmd,
+			    struct dynevent_arg *arg);
+
+struct dynevent_arg_pair {
+	const char		*lhs;
+	const char		*rhs;
+	char			operator; /* e.g. '=' or nothing */
+	char			separator; /* e.g. ';', ',', or nothing */
+	dynevent_check_arg_fn_t	check_arg;
+};
+
+extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
+				   dynevent_check_arg_fn_t check_arg,
+				   char operator, char separator);
+extern int add_dynevent_arg_pair(struct dynevent_cmd *cmd,
+				 struct dynevent_arg_pair *arg_pair);
+
+#define MAX_DYNEVENT_CMD_LEN	(2048)
+
+enum dynevent_type {
+	DYNEVENT_TYPE_SYNTH,
+	DYNEVENT_TYPE_KPROBE,
+};
+
+struct dynevent_cmd {
+	char			*buf;
+	const char		*event_name;
+	int			maxlen;
+	int			remaining;
+	unsigned int		n_fields;
+	enum dynevent_type	type;
+	dynevent_create_fn_t	run_command;
+	void			*private_data;
+};
+
+extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
+			      enum dynevent_type type,
+			      dynevent_create_fn_t run_command);
+extern int create_dynevent(struct dynevent_cmd *cmd);
+
 extern int delete_synth_event(const char *name);
 
 /*

kernel/trace/trace_events.c +217 -0

index 184e10d3772d..751a2c887953 100644
@@ -3301,6 +3301,223 @@ void __init trace_event_init(void)
 	event_trace_enable();
 }
 
+/**
+ * add_dynevent_arg - Add an arg to a dynevent_cmd
+ * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd
+ * @arg: The argument to append to the current cmd
+ *
+ * Append an argument to a dynevent_cmd.  The argument string will be
+ * appended to the current cmd string, followed by a separator, if
+ * applicable.  Before the argument is added, the check_arg()
+ * function, if defined, is called.
+ *
+ * The cmd string, separator, and check_arg() function should be set
+ * using the dynevent_arg_init() before any arguments are added using
+ * this function.
+ *
+ * Return: 0 if successful, error otherwise.
+ */
+int add_dynevent_arg(struct dynevent_cmd *cmd,
+		     struct dynevent_arg *arg)
+{
+	int ret = 0;
+	int delta;
+	char *q;
+
+	if (arg->check_arg) {
+		ret = arg->check_arg(arg);
+		if (ret)
+			return ret;
+	}
+
+	q = cmd->buf + (cmd->maxlen - cmd->remaining);
+
+	delta = snprintf(q, cmd->remaining, " %s%c", arg->str, arg->separator);
+	if (delta >= cmd->remaining) {
+		pr_err("String is too long: %s\n", arg->str);
+		return -E2BIG;
+	}
+	cmd->remaining -= delta;
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(add_dynevent_arg);
+
+/**
+ * add_dynevent_arg_pair - Add an arg pair to a dynevent_cmd
+ * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd
+ * @arg_pair: The argument pair to append to the current cmd
+ *
+ * Append an argument pair to a dynevent_cmd.  An argument pair
+ * consists of a left-hand-side argument and a right-hand-side
+ * argument separated by an operator, which can be whitespace, all
+ * followed by a separator, if applicable.  This can be used to add
+ * arguments of the form 'type variable_name;' or 'x+y'.
+ *
+ * The lhs argument string will be appended to the current cmd string,
+ * followed by an operator, if applicable, followd by the rhs string,
+ * followed finally by a separator, if applicable.  Before anything is
+ * added, the check_arg() function, if defined, is called.
+ *
+ * The cmd strings, operator, separator, and check_arg() function
+ * should be set using the dynevent_arg_init() before any arguments
+ * are added using this function.
+ *
+ * Return: 0 if successful, error otherwise.
+ */
+int add_dynevent_arg_pair(struct dynevent_cmd *cmd,
+			  struct dynevent_arg_pair *arg_pair)
+{
+	int ret = 0;
+	int delta;
+	char *q;
+
+	if (arg_pair->check_arg) {
+		ret = arg_pair->check_arg(arg_pair);
+		if (ret)
+			return ret;
+	}
+
+	q = cmd->buf + (cmd->maxlen - cmd->remaining);
+
+	delta = snprintf(q, cmd->remaining, " %s%c", arg_pair->lhs,
+			 arg_pair->operator);
+	if (delta >= cmd->remaining) {
+		pr_err("field string is too long: %s\n", arg_pair->lhs);
+		return -E2BIG;
+	}
+	cmd->remaining -= delta; q += delta;
+
+	delta = snprintf(q, cmd->remaining, "%s%c", arg_pair->rhs,
+			 arg_pair->separator);
+	if (delta >= cmd->remaining) {
+		pr_err("field string is too long: %s\n", arg_pair->rhs);
+		return -E2BIG;
+	}
+	cmd->remaining -= delta; q += delta;
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(add_dynevent_arg_pair);
+
+/**
+ * dynevent_cmd_init - Initialize a dynevent_cmd object
+ * @cmd: A pointer to the dynevent_cmd struct representing the cmd
+ * @buf: A pointer to the buffer to generate the command into
+ * @maxlen: The length of the buffer the command will be generated into
+ * @type: The type of the cmd, checked against further operations
+ * @run_command: The type-specific function that will actually run the command
+ *
+ * Initialize a dynevent_cmd.  A dynevent_cmd is used to build up and
+ * run dynamic event creation commands, such as commands for creating
+ * synthetic and kprobe events.  Before calling any of the functions
+ * used to build the command, a dynevent_cmd object should be
+ * instantiated and initialized using this function.
+ *
+ * The initialization sets things up by saving a pointer to the
+ * user-supplied buffer and its length via the @buf and @maxlen
+ * params, and by saving the cmd-specific @type and @run_command
+ * params which are used to check subsequent dynevent_cmd operations
+ * and actually run the command when complete.
+ */
+void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
+		       enum dynevent_type type,
+		       dynevent_create_fn_t run_command)
+{
+	memset(cmd, '\0', sizeof(*cmd));
+
+	cmd->buf = buf;
+	cmd->maxlen = maxlen;
+	cmd->remaining = cmd->maxlen;
+	cmd->type = type;
+	cmd->run_command = run_command;
+}
+EXPORT_SYMBOL_GPL(dynevent_cmd_init);
+
+/**
+ * dynevent_arg_init - Initialize a dynevent_arg object
+ * @arg: A pointer to the dynevent_arg struct representing the arg
+ * @check_arg: An (optional) pointer to a function checking arg sanity
+ * @separator: An (optional) separator, appended after adding the arg
+ *
+ * Initialize a dynevent_arg object.  A dynevent_arg represents an
+ * object used to append single arguments to the current command
+ * string.  The @check_arg function, if present, will be used to check
+ * the sanity of the current arg string (which is directly set by the
+ * caller).  After the arg string is successfully appended to the
+ * command string, the optional @separator is appended.  If no
+ * separator was specified when initializing the arg, a space will be
+ * appended.
+ */
+void dynevent_arg_init(struct dynevent_arg *arg,
+		       dynevent_check_arg_fn_t check_arg,
+		       char separator)
+{
+	memset(arg, '\0', sizeof(*arg));
+
+	if (!separator)
+		separator = ' ';
+	arg->separator = separator;
+
+	arg->check_arg = check_arg;
+}
+EXPORT_SYMBOL_GPL(dynevent_arg_init);
+
+/**
+ * dynevent_arg_pair_init - Initialize a dynevent_arg_pair object
+ * @arg_pair: A pointer to the dynevent_arg_pair struct representing the arg
+ * @check_arg: An (optional) pointer to a function checking arg sanity
+ * @operator: An (optional) operator, appended after adding the first arg
+ * @separator: An (optional) separator, appended after adding the second arg
+ *
+ * Initialize a dynevent_arg_pair object.  A dynevent_arg_pair
+ * represents an object used to append argument pairs such as 'type
+ * variable_name;' or 'x+y' to the current command string.  An
+ * argument pair consists of a left-hand-side argument and a
+ * right-hand-side argument separated by an operator, which can be
+ * whitespace, all followed by a separator, if applicable. The
+ * @check_arg function, if present, will be used to check the sanity
+ * of the current arg strings (which is directly set by the caller).
+ * After the first arg string is successfully appended to the command
+ * string, the optional @operator is appended, followed by the second
+ * arg and and optional @separator.  If no separator was specified
+ * when initializing the arg, a space will be appended.
+ */
+void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
+			    dynevent_check_arg_fn_t check_arg,
+			    char operator, char separator)
+{
+	memset(arg_pair, '\0', sizeof(*arg_pair));
+
+	if (!operator)
+		operator = ' ';
+	arg_pair->operator = operator;
+
+	if (!separator)
+		separator = ' ';
+	arg_pair->separator = separator;
+
+	arg_pair->check_arg = check_arg;
+}
+EXPORT_SYMBOL_GPL(dynevent_arg_pair_init);
+
+/**
+ * create_dynevent - Create the dynamic event contained in dynevent_cmd
+ * @cmd: The dynevent_cmd object containing the dynamic event creation command
+ *
+ * Once a dynevent_cmd object has been successfully built up via the
+ * dynevent_cmd_init(), add_dynevent_arg() and add_dynevent_arg_pair()
+ * functions, this function runs the final command to actually create
+ * the event.
+ *
+ * Return: 0 if the event was successfully created, error otherwise.
+ */
+int create_dynevent(struct dynevent_cmd *cmd)
+{
+	return cmd->run_command(cmd);
+}
+EXPORT_SYMBOL_GPL(create_dynevent);
+
 #ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
 
 static DEFINE_SPINLOCK(test_spinlock);

Signature · 1 line

2.14.1

Hi Tom,

Would you have any reason to export these raw interface to modules? (add_dynevent_arg() and add_dynevent_arg_pair())

I'm OK to export wrapped interfaces, but I can't find any good reason to export these raw interfaces. Especially since the argument format has been defined by each event type (synthetic, kprobe and uprobe), so modules may not be able to add new one...

Thank you,

Quoted 375 lines · On Fri, 10 Jan 2020 14:35:10 -0600 Tom Zanussi <[email protected]> wrote:

Add an interface used to build up dynamic event creation commands, such as synthetic and kprobe events. Interfaces specific to those particular types of events and others can be built on top of this interface.

Command creation is started by first using the dynevent_cmd_init() function to initialize the dynevent_cmd object. Following that, args
are appended and optionally checked by the add_dynevent_arg() and add_dynevent_arg_pair() functions, which use objects representing arguments and pairs of arguments, initialized respectively by dynevent_arg_init() and dynevent_arg_pair_init(). Finally, once all
args have been successfully added, the command is finalized and actually created using create_dynevent().

The code here for actually printing into the dyn_event->cmd buffer using snprintf() etc was adapted from v4 of Masami's 'tracing/boot:
Add synthetic event support' patch.

Signed-off-by Tom Zanussi <[email protected]>

Signed-off-by Masami Hiramatsu <[email protected]>

---
 include/linux/trace_events.h |  54 +++++++++++
 kernel/trace/trace_events.c  | 217
+++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 271 insertions(+)

include/linux/trace_events.h +8 -0

index c8038d1a1a48..bf4cc2e56125 100644
@@ -353,6 +353,60 @@ extern struct trace_event_file
 *get_event_file(const char *instance,
 					       const char *event);
 extern void put_event_file(struct trace_event_file *file);
 
+struct dynevent_cmd;
+
+typedef int (*dynevent_check_arg_fn_t)(void *data);
+typedef int (*dynevent_create_fn_t)(struct dynevent_cmd *cmd);
+
+struct dynevent_arg {
+	const char		*str;
+	char			separator; /* e.g. ';', ',',

or nothing */

include/linux/trace_events.h +13 -0

+	dynevent_check_arg_fn_t	check_arg;
+};
+
+extern void dynevent_arg_init(struct dynevent_arg *arg,
+			      dynevent_check_arg_fn_t check_arg,
+			      char separator);
+extern int add_dynevent_arg(struct dynevent_cmd *cmd,
+			    struct dynevent_arg *arg);
+
+struct dynevent_arg_pair {
+	const char		*lhs;
+	const char		*rhs;
+	char			operator; /* e.g. '=' or

nothing */

include/linux/trace_events.h +1 -0

+	char			separator; /* e.g. ';', ',',

or nothing */

include/linux/trace_events.h +4 -0

+	dynevent_check_arg_fn_t	check_arg;
+};
+
+extern void dynevent_arg_pair_init(struct dynevent_arg_pair

*arg_pair,

include/linux/trace_events.h +1 -0

+				   dynevent_check_arg_fn_t

check_arg,

include/linux/trace_events.h +3 -0

+				   char operator, char separator);
+extern int add_dynevent_arg_pair(struct dynevent_cmd *cmd,
+				 struct dynevent_arg_pair

*arg_pair);

include/linux/trace_events.h +20 -0

+
+#define MAX_DYNEVENT_CMD_LEN	(2048)
+
+enum dynevent_type {
+	DYNEVENT_TYPE_SYNTH,
+	DYNEVENT_TYPE_KPROBE,
+};
+
+struct dynevent_cmd {
+	char			*buf;
+	const char		*event_name;
+	int			maxlen;
+	int			remaining;
+	unsigned int		n_fields;
+	enum dynevent_type	type;
+	dynevent_create_fn_t	run_command;
+	void			*private_data;
+};
+
+extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf,

int maxlen,

include/linux/trace_events.h +4 -0

+			      enum dynevent_type type,
+			      dynevent_create_fn_t run_command);
+extern int create_dynevent(struct dynevent_cmd *cmd);
+
 extern int delete_synth_event(const char *name);
 
 /*

kernel/trace/trace_events.c +3 -0

index 184e10d3772d..751a2c887953 100644
@@ -3301,6 +3301,223 @@ void __init trace_event_init(void)
 	event_trace_enable();
 }
 
+/**
+ * add_dynevent_arg - Add an arg to a dynevent_cmd
+ * @cmd: A pointer to the dynevent_cmd struct representing the new

event cmd
+ * @arg: The argument to append to the current cmd
+ *
+ * Append an argument to a dynevent_cmd. The argument string will be
+ * appended to the current cmd string, followed by a separator, if
+ * applicable. Before the argument is added, the check_arg()
+ * function, if defined, is called.
+ *
+ * The cmd string, separator, and check_arg() function should be set
+ * using the dynevent_arg_init() before any arguments are added using
+ * this function.
+ *
+ * Return: 0 if successful, error otherwise.
+ */

kernel/trace/trace_events.c +16 -0

+int add_dynevent_arg(struct dynevent_cmd *cmd,
+		     struct dynevent_arg *arg)
+{
+	int ret = 0;
+	int delta;
+	char *q;
+
+	if (arg->check_arg) {
+		ret = arg->check_arg(arg);
+		if (ret)
+			return ret;
+	}
+
+	q = cmd->buf + (cmd->maxlen - cmd->remaining);
+
+	delta = snprintf(q, cmd->remaining, " %s%c", arg->str,

arg->separator);

kernel/trace/trace_events.c +13 -0

+	if (delta >= cmd->remaining) {
+		pr_err("String is too long: %s\n", arg->str);
+		return -E2BIG;
+	}
+	cmd->remaining -= delta;
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(add_dynevent_arg);
+
+/**
+ * add_dynevent_arg_pair - Add an arg pair to a dynevent_cmd
+ * @cmd: A pointer to the dynevent_cmd struct representing the new

event cmd
+ * @arg_pair: The argument pair to append to the current cmd
+ *
+ * Append an argument pair to a dynevent_cmd. An argument pair
+ * consists of a left-hand-side argument and a right-hand-side
+ * argument separated by an operator, which can be whitespace, all
+ * followed by a separator, if applicable. This can be used to add
+ * arguments of the form 'type variable_name;' or 'x+y'.
+ *
+ * The lhs argument string will be appended to the current cmd string,
+ * followed by an operator, if applicable, followd by the rhs string,
+ * followed finally by a separator, if applicable. Before anything is
+ * added, the check_arg() function, if defined, is called.
+ *
+ * The cmd strings, operator, separator, and check_arg() function
+ * should be set using the dynevent_arg_init() before any arguments
+ * are added using this function.
+ *
+ * Return: 0 if successful, error otherwise.
+ */

kernel/trace/trace_events.c +16 -0

+int add_dynevent_arg_pair(struct dynevent_cmd *cmd,
+			  struct dynevent_arg_pair *arg_pair)
+{
+	int ret = 0;
+	int delta;
+	char *q;
+
+	if (arg_pair->check_arg) {
+		ret = arg_pair->check_arg(arg_pair);
+		if (ret)
+			return ret;
+	}
+
+	q = cmd->buf + (cmd->maxlen - cmd->remaining);
+
+	delta = snprintf(q, cmd->remaining, " %s%c", arg_pair-

Quoted 1 line

lhs,

kernel/trace/trace_events.c +3 -0

+			 arg_pair->operator);
+	if (delta >= cmd->remaining) {
+		pr_err("field string is too long: %s\n", arg_pair-

Quoted 1 line

lhs);

kernel/trace/trace_events.c +8 -0

+		return -E2BIG;
+	}
+	cmd->remaining -= delta; q += delta;
+
+	delta = snprintf(q, cmd->remaining, "%s%c", arg_pair->rhs,
+			 arg_pair->separator);
+	if (delta >= cmd->remaining) {
+		pr_err("field string is too long: %s\n", arg_pair-

Quoted 1 line

rhs);

kernel/trace/trace_events.c +13 -0

+		return -E2BIG;
+	}
+	cmd->remaining -= delta; q += delta;
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(add_dynevent_arg_pair);
+
+/**
+ * dynevent_cmd_init - Initialize a dynevent_cmd object
+ * @cmd: A pointer to the dynevent_cmd struct representing the cmd
+ * @buf: A pointer to the buffer to generate the command into
+ * @maxlen: The length of the buffer the command will be generated

into
+ * @type: The type of the cmd, checked against further operations
+ * @run_command: The type-specific function that will actually run the command
+ *
+ * Initialize a dynevent_cmd. A dynevent_cmd is used to build up and
+ * run dynamic event creation commands, such as commands for creating
+ * synthetic and kprobe events. Before calling any of the functions
+ * used to build the command, a dynevent_cmd object should be
+ * instantiated and initialized using this function.
+ *
+ * The initialization sets things up by saving a pointer to the
+ * user-supplied buffer and its length via the @buf and @maxlen
+ * params, and by saving the cmd-specific @type and @run_command
+ * params which are used to check subsequent dynevent_cmd operations
+ * and actually run the command when complete.
+ */
+void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,

kernel/trace/trace_events.c +17 -0

+		       enum dynevent_type type,
+		       dynevent_create_fn_t run_command)
+{
+	memset(cmd, '\0', sizeof(*cmd));
+
+	cmd->buf = buf;
+	cmd->maxlen = maxlen;
+	cmd->remaining = cmd->maxlen;
+	cmd->type = type;
+	cmd->run_command = run_command;
+}
+EXPORT_SYMBOL_GPL(dynevent_cmd_init);
+
+/**
+ * dynevent_arg_init - Initialize a dynevent_arg object
+ * @arg: A pointer to the dynevent_arg struct representing the arg
+ * @check_arg: An (optional) pointer to a function checking arg

sanity
+ * @separator: An (optional) separator, appended after adding the arg
+ *
+ * Initialize a dynevent_arg object. A dynevent_arg represents an
+ * object used to append single arguments to the current command
+ * string. The @check_arg function, if present, will be used to check
+ * the sanity of the current arg string (which is directly set by the
+ * caller). After the arg string is successfully appended to the
+ * command string, the optional @separator is appended. If no
+ * separator was specified when initializing the arg, a space will be
+ * appended.
+ */

kernel/trace/trace_events.c +17 -0

+void dynevent_arg_init(struct dynevent_arg *arg,
+		       dynevent_check_arg_fn_t check_arg,
+		       char separator)
+{
+	memset(arg, '\0', sizeof(*arg));
+
+	if (!separator)
+		separator = ' ';
+	arg->separator = separator;
+
+	arg->check_arg = check_arg;
+}
+EXPORT_SYMBOL_GPL(dynevent_arg_init);
+
+/**
+ * dynevent_arg_pair_init - Initialize a dynevent_arg_pair object
+ * @arg_pair: A pointer to the dynevent_arg_pair struct

representing the arg
+ * @check_arg: An (optional) pointer to a function checking arg sanity
+ * @operator: An (optional) operator, appended after adding the first arg
+ * @separator: An (optional) separator, appended after adding the second arg
+ *
+ * Initialize a dynevent_arg_pair object. A dynevent_arg_pair
+ * represents an object used to append argument pairs such as 'type
+ * variable_name;' or 'x+y' to the current command string. An
+ * argument pair consists of a left-hand-side argument and a
+ * right-hand-side argument separated by an operator, which can be
+ * whitespace, all followed by a separator, if applicable. The
+ * @check_arg function, if present, will be used to check the sanity
+ * of the current arg strings (which is directly set by the caller).
+ * After the first arg string is successfully appended to the command
+ * string, the optional @operator is appended, followed by the second
+ * arg and and optional @separator. If no separator was specified
+ * when initializing the arg, a space will be appended.
+ */

kernel/trace/trace_events.c +20 -0

+void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
+			    dynevent_check_arg_fn_t check_arg,
+			    char operator, char separator)
+{
+	memset(arg_pair, '\0', sizeof(*arg_pair));
+
+	if (!operator)
+		operator = ' ';
+	arg_pair->operator = operator;
+
+	if (!separator)
+		separator = ' ';
+	arg_pair->separator = separator;
+
+	arg_pair->check_arg = check_arg;
+}
+EXPORT_SYMBOL_GPL(dynevent_arg_pair_init);
+
+/**
+ * create_dynevent - Create the dynamic event contained in

dynevent_cmd
+ * @cmd: The dynevent_cmd object containing the dynamic event creation command
+ *
+ * Once a dynevent_cmd object has been successfully built up via the
+ * dynevent_cmd_init(), add_dynevent_arg() and add_dynevent_arg_pair()
+ * functions, this function runs the final command to actually create
+ * the event.
+ *
+ * Return: 0 if the event was successfully created, error otherwise.
+ */

kernel/trace/trace_events.c +6 -0

+int create_dynevent(struct dynevent_cmd *cmd)
+{
+	return cmd->run_command(cmd);
+}
+EXPORT_SYMBOL_GPL(create_dynevent);
+
 #ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
 
 static DEFINE_SPINLOCK(test_spinlock);

Signature · 1 line

2.14.1

From: Masami Hiramatsu <[email protected]>

This snippet was taken from v4 of Masami's 'tracing/boot: Add synthetic event support' patch.

Quoted 1 line

From the original: 'The synthetic node requires "fields" string

arraies, which defines the fields as same as tracing/synth_events interface.'

synth_event_run_command() provides the means to execute the synthetic event create command using the synthetic event command string.

Signed-off-by Masami Hiramatsu <[email protected]>

Signed-off-by Tom Zanussi <[email protected]>

---
 kernel/trace/trace_events_hist.c | 5 +++++
 1 file changed, 5 insertions(+)

kernel/trace/trace_events_hist.c +5 -0

index 8c9894681100..0886ca6da255 100644
@@ -1390,6 +1390,11 @@ static int create_or_delete_synth_event(int argc, char **argv)
 	return ret == -ECANCELED ? -EINVAL : ret;
 }
 
+int synth_event_run_command(const char *command)
+{
+	return trace_run_command(command, create_or_delete_synth_event);
+}
+
 static int synth_event_create(int argc, const char **argv)
 {
 	const char *name = argv[0];

Add functions used to generate synthetic event commands, built on top of the dynevent_cmd interface.

gen_synth_cmd() is used to create a synthetic event command using a variable arg list and gen_synth_cmd_array() does the same thing but using an array of field descriptors. add_synth_field() and add_synth_fields() can be used to add single fields one by one or as a group. Once all desired fields are added, create_dynevent() is used to actually execute the command and create the event.

create_synth_event() does everything, including creating the event, in a single call.

Signed-off-by Tom Zanussi <[email protected]>

---
 include/linux/trace_events.h     |  30 ++++
 kernel/trace/trace_events_hist.c | 325 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 352 insertions(+), 3 deletions(-)

include/linux/trace_events.h +19 -0

index bf4cc2e56125..4228407d4736 100644
@@ -409,6 +409,36 @@ extern int create_dynevent(struct dynevent_cmd *cmd);
 
 extern int delete_synth_event(const char *name);
 
+extern void synth_dynevent_cmd_init(struct dynevent_cmd *cmd,
+				    char *buf, int maxlen);
+
+extern int __gen_synth_cmd(struct dynevent_cmd *cmd, const char *name,
+			   struct module *mod, ...);
+
+#define gen_synth_cmd(cmd, name, mod, ...)	\
+	__gen_synth_cmd(cmd, name, mod, ## __VA_ARGS__, NULL)
+
+struct synth_field_desc {
+	const char *type;
+	const char *name;
+};
+
+extern int gen_synth_cmd_array(struct dynevent_cmd *cmd, const char *name,
+			       struct module *mod,
+			       struct synth_field_desc *fields,
+			       unsigned int n_fields);
+extern int create_synth_event(const char *name,

include/linux/trace_events.h +1 -0

+
 /*
  * Event file flags:
  *  ENABLED	  - The event is enabled

Quoted 58 lines · On Fri, 10 Jan 2020 14:35:12 -0600 Tom Zanussi <[email protected]> wrote:

Add functions used to generate synthetic event commands, built on top
of the dynevent_cmd interface.

gen_synth_cmd() is used to create a synthetic event command using a variable arg list and gen_synth_cmd_array() does the same thing but using an array of field descriptors. add_synth_field() and add_synth_fields() can be used to add single fields one by one or as a
group. Once all desired fields are added, create_dynevent() is used
to actually execute the command and create the event.

create_synth_event() does everything, including creating the event, in
a single call.

Signed-off-by Tom Zanussi <[email protected]>

---
 include/linux/trace_events.h     |  30 ++++
 kernel/trace/trace_events_hist.c | 325
++++++++++++++++++++++++++++++++++++++-
 2 files changed, 352 insertions(+), 3 deletions(-)

include/linux/trace_events.h +21 -0

index bf4cc2e56125..4228407d4736 100644
@@ -409,6 +409,36 @@ extern int create_dynevent(struct dynevent_cmd
 *cmd);
 
 extern int delete_synth_event(const char *name);
 
+extern void synth_dynevent_cmd_init(struct dynevent_cmd *cmd,
+				    char *buf, int maxlen);
+
+extern int __gen_synth_cmd(struct dynevent_cmd *cmd, const char
 *name,
+			   struct module *mod, ...);
+
+#define gen_synth_cmd(cmd, name, mod, ...)	\
+	__gen_synth_cmd(cmd, name, mod, ## __VA_ARGS__, NULL)
+
+struct synth_field_desc {
+	const char *type;
+	const char *name;
+};
+
+extern int gen_synth_cmd_array(struct dynevent_cmd *cmd, const
 char *name,
+			       struct module *mod,
+			       struct synth_field_desc *fields,
+			       unsigned int n_fields);
+extern int create_synth_event(const char *name,
+			      struct synth_field_desc *fields,
+			      unsigned int n_fields, struct module

*mod);

include/linux/trace_events.h extern int create_dynevent(struct dynevent_cmd *cmd); · line 440

Quoted 8 lines

include/linux/trace_events.h +8 -0

+
+
+extern int add_synth_field(struct dynevent_cmd *cmd,
+			   const char *type,
+			   const char *name);
+extern int add_synth_fields(struct dynevent_cmd *cmd,
+			    struct synth_field_desc *fields,
+			    unsigned int n_fields);

As these are in a global header and globally visible, let's rename them
to be more name space aware.

Have them all start with "synth_event_".

synth_event_gen_cmd_array()
synth_event_create()
synth_event_add_field()
synth_event_add_fields()

Makes it easier to grep for synth_event functions too.

-- Steve

Quoted 4 lines

+
/*
* Event file flags:
* ENABLED - The event is enabled

include/linux/trace_events.h +4 -0

+struct synth_event;
+
+struct synth_gen_state {
+	struct trace_event_buffer fbuffer;

Quoted 10 lines · On Fri, 10 Jan 2020 14:35:13 -0600 Tom Zanussi <[email protected]> wrote:

include/linux/trace_events.h +10 -0

+struct synth_event;
+
+struct synth_gen_state {
+	struct trace_event_buffer fbuffer;
+	struct synth_trace_event *entry;
+	struct ring_buffer *buffer;
+	struct synth_event *event;
+	unsigned int cur_field;
+	unsigned int n_u64;
+	bool enabled;

include/linux/trace_events.h extern int add_synth_fields(struct dynevent_cmd *cmd, · line 455

Quoted 4 lines

include/linux/trace_events.h +4 -0

+	bool add_next;
+	bool add_name;
+};
+

Yes, please rebase on my for-next branch, as the ring_buffer structure
has been renamed, and will break these patches :-/

-- Steve