tracing: Add synthetic event command generation functions (35ca5207) · Commits · 戴 / test

include/linux/trace_events.h

+37 −0

Original line number	Diff line number	Diff line
		@@ -357,6 +357,7 @@ extern void trace_put_event_file(struct trace_event_file *file);
		#define MAX_DYNEVENT_CMD_LEN (2048)

		enum dynevent_type {
		DYNEVENT_TYPE_SYNTH = 1,
		DYNEVENT_TYPE_NONE,
		};

		@@ -379,6 +380,42 @@ extern int dynevent_create(struct dynevent_cmd *cmd);

		extern int synth_event_delete(const char *name);

		extern void synth_event_cmd_init(struct dynevent_cmd *cmd,
		char *buf, int maxlen);

		extern int __synth_event_gen_cmd_start(struct dynevent_cmd *cmd,
		const char *name,
		struct module *mod, ...);

		#define synth_event_gen_cmd_start(cmd, name, mod, ...) \
		__synth_event_gen_cmd_start(cmd, name, mod, ## __VA_ARGS__, NULL)

		struct synth_field_desc {
		const char *type;
		const char *name;
		};

		extern int synth_event_gen_cmd_array_start(struct dynevent_cmd *cmd,
		const char *name,
		struct module *mod,
		struct synth_field_desc *fields,
		unsigned int n_fields);
		extern int synth_event_create(const char *name,
		struct synth_field_desc *fields,
		unsigned int n_fields, struct module *mod);

		extern int synth_event_add_field(struct dynevent_cmd *cmd,
		const char *type,
		const char *name);
		extern int synth_event_add_field_str(struct dynevent_cmd *cmd,
		const char *type_name);
		extern int synth_event_add_fields(struct dynevent_cmd *cmd,
		struct synth_field_desc *fields,
		unsigned int n_fields);

		#define synth_event_gen_cmd_end(cmd) \
		dynevent_create(cmd)

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

kernel/trace/trace_events_hist.c

+375 −4

Original line number	Diff line number	Diff line
		@@ -379,7 +379,7 @@ struct hist_trigger_data {
		unsigned int n_save_var_str;
		};

		static int synth_event_create(int argc, const char **argv);
		static int create_synth_event(int argc, const char **argv);
		static int synth_event_show(struct seq_file m, struct dyn_event ev);
		static int synth_event_release(struct dyn_event *ev);
		static bool synth_event_is_busy(struct dyn_event *ev);
		@@ -387,7 +387,7 @@ static bool synth_event_match(const char system, const char event,
		int argc, const char *argv, struct dyn_event ev);

		static struct dyn_event_operations synth_event_ops = {
		.create = synth_event_create,
		.create = create_synth_event,
		.show = synth_event_show,
		.is_busy = synth_event_is_busy,
		.free = synth_event_release,
		@@ -412,6 +412,7 @@ struct synth_event {
		struct trace_event_class class;
		struct trace_event_call call;
		struct tracepoint *tp;
		struct module *mod;
		};

		static bool is_synth_event(struct dyn_event *ev)
		@@ -1292,6 +1293,273 @@ struct hist_var_data {
		struct hist_trigger_data *hist_data;
		};

		static int synth_event_check_arg_fn(void *data)
		{
		struct dynevent_arg_pair *arg_pair = data;
		int size;

		size = synth_field_size((char *)arg_pair->lhs);

		return size ? 0 : -EINVAL;
		}

		/**
		* synth_event_add_field - Add a new field to a synthetic event cmd
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @type: The type of the new field to add
		* @name: The name of the new field to add
		*
		* Add a new field to a synthetic event cmd object. Field ordering is in
		* the same order the fields are added.
		*
		* See synth_field_size() for available types. If field_name contains
		* [n] the field is considered to be an array.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int synth_event_add_field(struct dynevent_cmd cmd, const char type,
		const char *name)
		{
		struct dynevent_arg_pair arg_pair;
		int ret;

		if (cmd->type != DYNEVENT_TYPE_SYNTH)
		return -EINVAL;

		if (!type \|\| !name)
		return -EINVAL;

		dynevent_arg_pair_init(&arg_pair, synth_event_check_arg_fn, 0, ';');

		arg_pair.lhs = type;
		arg_pair.rhs = name;

		ret = dynevent_arg_pair_add(cmd, &arg_pair);
		if (ret)
		return ret;

		if (++cmd->n_fields > SYNTH_FIELDS_MAX)
		ret = -EINVAL;

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_add_field);

		/**
		* synth_event_add_field_str - Add a new field to a synthetic event cmd
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @type_name: The type and name of the new field to add, as a single string
		*
		* Add a new field to a synthetic event cmd object, as a single
		* string. The @type_name string is expected to be of the form 'type
		* name', which will be appended by ';'. No sanity checking is done -
		* what's passed in is assumed to already be well-formed. Field
		* ordering is in the same order the fields are added.
		*
		* See synth_field_size() for available types. If field_name contains
		* [n] the field is considered to be an array.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int synth_event_add_field_str(struct dynevent_cmd cmd, const char type_name)
		{
		struct dynevent_arg arg;
		int ret;

		if (cmd->type != DYNEVENT_TYPE_SYNTH)
		return -EINVAL;

		if (!type_name)
		return -EINVAL;

		dynevent_arg_init(&arg, NULL, ';');

		arg.str = type_name;

		ret = dynevent_arg_add(cmd, &arg);
		if (ret)
		return ret;

		if (++cmd->n_fields > SYNTH_FIELDS_MAX)
		ret = -EINVAL;

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_add_field_str);

		/**
		* synth_event_add_fields - Add multiple fields to a synthetic event cmd
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @fields: An array of type/name field descriptions
		* @n_fields: The number of field descriptions contained in the fields array
		*
		* Add a new set of fields to a synthetic event cmd object. The event
		* fields that will be defined for the event should be passed in as an
		* array of struct synth_field_desc, and the number of elements in the
		* array passed in as n_fields. Field ordering will retain the
		* ordering given in the fields array.
		*
		* See synth_field_size() for available types. If field_name contains
		* [n] the field is considered to be an array.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int synth_event_add_fields(struct dynevent_cmd *cmd,
		struct synth_field_desc *fields,
		unsigned int n_fields)
		{
		unsigned int i;
		int ret = 0;

		for (i = 0; i < n_fields; i++) {
		if (fields[i].type == NULL \|\| fields[i].name == NULL) {
		ret = -EINVAL;
		break;
		}

		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
		if (ret)
		break;
		}

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_add_fields);

		/**
		* __synth_event_gen_cmd_start - Start a synthetic event command from arg list
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @name: The name of the synthetic event
		* @mod: The module creating the event, NULL if not created from a module
		* @args: Variable number of arg (pairs), one pair for each field
		*
		* NOTE: Users normally won't want to call this function directly, but
		* rather use the synth_event_gen_cmd_start() wrapper, which
		* automatically adds a NULL to the end of the arg list. If this
		* function is used directly, make sure the last arg in the variable
		* arg list is NULL.
		*
		* Generate a synthetic event command to be executed by
		* synth_event_gen_cmd_end(). This function can be used to generate
		* the complete command or only the first part of it; in the latter
		* case, synth_event_add_field(), synth_event_add_field_str(), or
		* synth_event_add_fields() can be used to add more fields following
		* this.
		*
		* There should be an even number variable args, each pair consisting
		* of a type followed by a field name.
		*
		* See synth_field_size() for available types. If field_name contains
		* [n] the field is considered to be an array.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int __synth_event_gen_cmd_start(struct dynevent_cmd cmd, const char name,
		struct module *mod, ...)
		{
		struct dynevent_arg arg;
		va_list args;
		int ret;

		cmd->event_name = name;
		cmd->private_data = mod;

		if (cmd->type != DYNEVENT_TYPE_SYNTH)
		return -EINVAL;

		dynevent_arg_init(&arg, NULL, 0);
		arg.str = name;
		ret = dynevent_arg_add(cmd, &arg);
		if (ret)
		return ret;

		va_start(args, mod);
		for (;;) {
		const char type, name;

		type = va_arg(args, const char *);
		if (!type)
		break;
		name = va_arg(args, const char *);
		if (!name)
		break;

		if (++cmd->n_fields > SYNTH_FIELDS_MAX) {
		ret = -EINVAL;
		break;
		}

		ret = synth_event_add_field(cmd, type, name);
		if (ret)
		break;
		}
		va_end(args);

		return ret;
		}
		EXPORT_SYMBOL_GPL(__synth_event_gen_cmd_start);

		/**
		* synth_event_gen_cmd_array_start - Start synthetic event command from an array
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @name: The name of the synthetic event
		* @fields: An array of type/name field descriptions
		* @n_fields: The number of field descriptions contained in the fields array
		*
		* Generate a synthetic event command to be executed by
		* synth_event_gen_cmd_end(). This function can be used to generate
		* the complete command or only the first part of it; in the latter
		* case, synth_event_add_field(), synth_event_add_field_str(), or
		* synth_event_add_fields() can be used to add more fields following
		* this.
		*
		* The event fields that will be defined for the event should be
		* passed in as an array of struct synth_field_desc, and the number of
		* elements in the array passed in as n_fields. Field ordering will
		* retain the ordering given in the fields array.
		*
		* See synth_field_size() for available types. If field_name contains
		* [n] the field is considered to be an array.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int synth_event_gen_cmd_array_start(struct dynevent_cmd cmd, const char name,
		struct module *mod,
		struct synth_field_desc *fields,
		unsigned int n_fields)
		{
		struct dynevent_arg arg;
		unsigned int i;
		int ret = 0;

		cmd->event_name = name;
		cmd->private_data = mod;

		if (cmd->type != DYNEVENT_TYPE_SYNTH)
		return -EINVAL;

		if (n_fields > SYNTH_FIELDS_MAX)
		return -EINVAL;

		dynevent_arg_init(&arg, NULL, 0);
		arg.str = name;
		ret = dynevent_arg_add(cmd, &arg);
		if (ret)
		return ret;

		for (i = 0; i < n_fields; i++) {
		if (fields[i].type == NULL \|\| fields[i].name == NULL)
		return -EINVAL;

		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
		if (ret)
		break;
		}

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_gen_cmd_array_start);

		static int __create_synth_event(int argc, const char name, const char *argv)
		{
		struct synth_field field, fields[SYNTH_FIELDS_MAX];
		@@ -1360,6 +1628,56 @@ static int __create_synth_event(int argc, const char name, const char *argv)
		goto out;
		}

		/**
		* synth_event_create - Create a new synthetic event
		* @name: The name of the new sythetic event
		* @fields: An array of type/name field descriptions
		* @n_fields: The number of field descriptions contained in the fields array
		* @mod: The module creating the event, NULL if not created from a module
		*
		* Create a new synthetic event with the given name under the
		* trace/events/synthetic/ directory. The event fields that will be
		* defined for the event should be passed in as an array of struct
		* synth_field_desc, and the number elements in the array passed in as
		* n_fields. Field ordering will retain the ordering given in the
		* fields array.
		*
		* If the new synthetic event is being created from a module, the mod
		* param must be non-NULL. This will ensure that the trace buffer
		* won't contain unreadable events.
		*
		* The new synth event should be deleted using synth_event_delete()
		* function. The new synthetic event can be generated from modules or
		* other kernel code using trace_synth_event() and related functions.
		*
		* Return: 0 if successful, error otherwise.
		*/
		int synth_event_create(const char name, struct synth_field_desc fields,
		unsigned int n_fields, struct module *mod)
		{
		struct dynevent_cmd cmd;
		char *buf;
		int ret;

		buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
		if (!buf)
		return -ENOMEM;

		synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);

		ret = synth_event_gen_cmd_array_start(&cmd, name, mod,
		fields, n_fields);
		if (ret)
		goto out;

		ret = synth_event_gen_cmd_end(&cmd);
		out:
		kfree(buf);

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_create);

		static int destroy_synth_event(struct synth_event *se)
		{
		int ret;
		@@ -1388,14 +1706,33 @@ static int destroy_synth_event(struct synth_event *se)
		int synth_event_delete(const char *event_name)
		{
		struct synth_event *se = NULL;
		struct module *mod = NULL;
		int ret = -ENOENT;

		mutex_lock(&event_mutex);
		se = find_synth_event(event_name);
		if (se)
		if (se) {
		mod = se->mod;
		ret = destroy_synth_event(se);
		}
		mutex_unlock(&event_mutex);

		if (mod) {
		mutex_lock(&trace_types_lock);
		/*
		* It is safest to reset the ring buffer if the module
		* being unloaded registered any events that were
		* used. The only worry is if a new module gets
		* loaded, and takes on the same id as the events of
		* this module. When printing out the buffer, traced
		* events left over from this module may be passed to
		* the new module events and unexpected results may
		* occur.
		*/
		tracing_reset_all_online_cpus();
		mutex_unlock(&trace_types_lock);
		}

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_delete);
		@@ -1420,7 +1757,41 @@ 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)
		static int synth_event_run_cmd(struct dynevent_cmd *cmd)
		{
		struct synth_event *se;
		int ret;

		ret = trace_run_command(cmd->buf, create_or_delete_synth_event);
		if (ret)
		return ret;

		se = find_synth_event(cmd->event_name);
		if (WARN_ON(!se))
		return -ENOENT;

		se->mod = cmd->private_data;

		return ret;
		}

		/**
		* synth_event_cmd_init - Initialize a synthetic event command object
		* @cmd: A pointer to the dynevent_cmd struct representing the new event
		* @buf: A pointer to the buffer used to build the command
		* @maxlen: The length of the buffer passed in @buf
		*
		* Initialize a synthetic event command object. Use this before
		* calling any of the other dyenvent_cmd functions.
		*/
		void synth_event_cmd_init(struct dynevent_cmd cmd, char buf, int maxlen)
		{
		dynevent_cmd_init(cmd, buf, maxlen, DYNEVENT_TYPE_SYNTH,
		synth_event_run_cmd);
		}
		EXPORT_SYMBOL_GPL(synth_event_cmd_init);

		static int create_synth_event(int argc, const char **argv)
		{
		const char *name = argv[0];
		int len;

Admin message