tracing: Add synth_event_trace() and related functions (8dcc53ad) · Commits · 戴 / test

include/linux/trace_events.h

+26 −0

Original line number	Diff line number	Diff line
		@@ -416,6 +416,32 @@ extern int synth_event_add_fields(struct dynevent_cmd *cmd,
		#define synth_event_gen_cmd_end(cmd) \
		dynevent_create(cmd)

		struct synth_event;

		struct synth_event_trace_state {
		struct trace_event_buffer fbuffer;
		struct synth_trace_event *entry;
		struct trace_buffer *buffer;
		struct synth_event *event;
		unsigned int cur_field;
		unsigned int n_u64;
		bool enabled;
		bool add_next;
		bool add_name;
		};

		extern int synth_event_trace(struct trace_event_file *file,
		unsigned int n_vals, ...);
		extern int synth_event_trace_array(struct trace_event_file file, u64 vals,
		unsigned int n_vals);
		extern int synth_event_trace_start(struct trace_event_file *file,
		struct synth_event_trace_state *trace_state);
		extern int synth_event_add_next_val(u64 val,
		struct synth_event_trace_state *trace_state);
		extern int synth_event_add_val(const char *field_name, u64 val,
		struct synth_event_trace_state *trace_state);
		extern int synth_event_trace_end(struct synth_event_trace_state *trace_state);

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

kernel/trace/trace_events_hist.c

+463 −0

Original line number	Diff line number	Diff line
		@@ -398,6 +398,7 @@ struct synth_field {
		char *type;
		char *name;
		size_t size;
		unsigned int offset;
		bool is_signed;
		bool is_string;
		};
		@@ -668,6 +669,8 @@ static int synth_event_define_fields(struct trace_event_call *call)
		if (ret)
		break;

		event->fields[i]->offset = n_u64;

		if (event->fields[i]->is_string) {
		offset += STR_VAR_LEN_MAX;
		n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
		@@ -1791,6 +1794,466 @@ void synth_event_cmd_init(struct dynevent_cmd cmd, char buf, int maxlen)
		}
		EXPORT_SYMBOL_GPL(synth_event_cmd_init);

		/**
		* synth_event_trace - Trace a synthetic event
		* @file: The trace_event_file representing the synthetic event
		* @n_vals: The number of values in vals
		* @args: Variable number of args containing the event values
		*
		* Trace a synthetic event using the values passed in the variable
		* argument list.
		*
		* The argument list should be a list 'n_vals' u64 values. The number
		* of vals must match the number of field in the synthetic event, and
		* must be in the same order as the synthetic event fields.
		*
		* All vals should be cast to u64, and string vals are just pointers
		* to strings, cast to u64. Strings will be copied into space
		* reserved in the event for the string, using these pointers.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_trace(struct trace_event_file *file, unsigned int n_vals, ...)
		{
		struct trace_event_buffer fbuffer;
		struct synth_trace_event *entry;
		struct trace_buffer *buffer;
		struct synth_event *event;
		unsigned int i, n_u64;
		int fields_size = 0;
		va_list args;
		int ret = 0;

		/*
		* Normal event generation doesn't get called at all unless
		* the ENABLED bit is set (which attaches the probe thus
		* allowing this code to be called, etc). Because this is
		* called directly by the user, we don't have that but we
		* still need to honor not logging when disabled.
		*/
		if (!(file->flags & EVENT_FILE_FL_ENABLED))
		return 0;

		event = file->event_call->data;

		if (n_vals != event->n_fields)
		return -EINVAL;

		if (trace_trigger_soft_disabled(file))
		return -EINVAL;

		fields_size = event->n_u64 * sizeof(u64);

		/*
		* Avoid ring buffer recursion detection, as this event
		* is being performed within another event.
		*/
		buffer = file->tr->array_buffer.buffer;
		ring_buffer_nest_start(buffer);

		entry = trace_event_buffer_reserve(&fbuffer, file,
		sizeof(*entry) + fields_size);
		if (!entry) {
		ret = -EINVAL;
		goto out;
		}

		va_start(args, n_vals);
		for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
		u64 val;

		val = va_arg(args, u64);

		if (event->fields[i]->is_string) {
		char str_val = (char )(long)val;
		char str_field = (char )&entry->fields[n_u64];

		strscpy(str_field, str_val, STR_VAR_LEN_MAX);
		n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
		} else {
		entry->fields[n_u64] = val;
		n_u64++;
		}
		}
		va_end(args);

		trace_event_buffer_commit(&fbuffer);
		out:
		ring_buffer_nest_end(buffer);

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_trace);

		/**
		* synth_event_trace_array - Trace a synthetic event from an array
		* @file: The trace_event_file representing the synthetic event
		* @vals: Array of values
		* @n_vals: The number of values in vals
		*
		* Trace a synthetic event using the values passed in as 'vals'.
		*
		* The 'vals' array is just an array of 'n_vals' u64. The number of
		* vals must match the number of field in the synthetic event, and
		* must be in the same order as the synthetic event fields.
		*
		* All vals should be cast to u64, and string vals are just pointers
		* to strings, cast to u64. Strings will be copied into space
		* reserved in the event for the string, using these pointers.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_trace_array(struct trace_event_file file, u64 vals,
		unsigned int n_vals)
		{
		struct trace_event_buffer fbuffer;
		struct synth_trace_event *entry;
		struct trace_buffer *buffer;
		struct synth_event *event;
		unsigned int i, n_u64;
		int fields_size = 0;
		int ret = 0;

		/*
		* Normal event generation doesn't get called at all unless
		* the ENABLED bit is set (which attaches the probe thus
		* allowing this code to be called, etc). Because this is
		* called directly by the user, we don't have that but we
		* still need to honor not logging when disabled.
		*/
		if (!(file->flags & EVENT_FILE_FL_ENABLED))
		return 0;

		event = file->event_call->data;

		if (n_vals != event->n_fields)
		return -EINVAL;

		if (trace_trigger_soft_disabled(file))
		return -EINVAL;

		fields_size = event->n_u64 * sizeof(u64);

		/*
		* Avoid ring buffer recursion detection, as this event
		* is being performed within another event.
		*/
		buffer = file->tr->array_buffer.buffer;
		ring_buffer_nest_start(buffer);

		entry = trace_event_buffer_reserve(&fbuffer, file,
		sizeof(*entry) + fields_size);
		if (!entry) {
		ret = -EINVAL;
		goto out;
		}

		for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
		if (event->fields[i]->is_string) {
		char str_val = (char )(long)vals[i];
		char str_field = (char )&entry->fields[n_u64];

		strscpy(str_field, str_val, STR_VAR_LEN_MAX);
		n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
		} else {
		entry->fields[n_u64] = vals[i];
		n_u64++;
		}
		}

		trace_event_buffer_commit(&fbuffer);
		out:
		ring_buffer_nest_end(buffer);

		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_trace_array);

		/**
		* synth_event_trace_start - Start piecewise synthetic event trace
		* @file: The trace_event_file representing the synthetic event
		* @trace_state: A pointer to object tracking the piecewise trace state
		*
		* Start the trace of a synthetic event field-by-field rather than all
		* at once.
		*
		* This function 'opens' an event trace, which means space is reserved
		* for the event in the trace buffer, after which the event's
		* individual field values can be set through either
		* synth_event_add_next_val() or synth_event_add_val().
		*
		* A pointer to a trace_state object is passed in, which will keep
		* track of the current event trace state until the event trace is
		* closed (and the event finally traced) using
		* synth_event_trace_end().
		*
		* Note that synth_event_trace_end() must be called after all values
		* have been added for each event trace, regardless of whether adding
		* all field values succeeded or not.
		*
		* Note also that for a given event trace, all fields must be added
		* using either synth_event_add_next_val() or synth_event_add_val()
		* but not both together or interleaved.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_trace_start(struct trace_event_file *file,
		struct synth_event_trace_state *trace_state)
		{
		struct synth_trace_event *entry;
		int fields_size = 0;
		int ret = 0;

		if (!trace_state) {
		ret = -EINVAL;
		goto out;
		}

		memset(trace_state, '\0', sizeof(*trace_state));

		/*
		* Normal event tracing doesn't get called at all unless the
		* ENABLED bit is set (which attaches the probe thus allowing
		* this code to be called, etc). Because this is called
		* directly by the user, we don't have that but we still need
		* to honor not logging when disabled. For the the iterated
		* trace case, we save the enabed state upon start and just
		* ignore the following data calls.
		*/
		if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
		trace_state->enabled = false;
		goto out;
		}

		trace_state->enabled = true;

		trace_state->event = file->event_call->data;

		if (trace_trigger_soft_disabled(file)) {
		ret = -EINVAL;
		goto out;
		}

		fields_size = trace_state->event->n_u64 * sizeof(u64);

		/*
		* Avoid ring buffer recursion detection, as this event
		* is being performed within another event.
		*/
		trace_state->buffer = file->tr->array_buffer.buffer;
		ring_buffer_nest_start(trace_state->buffer);

		entry = trace_event_buffer_reserve(&trace_state->fbuffer, file,
		sizeof(*entry) + fields_size);
		if (!entry) {
		ret = -EINVAL;
		goto out;
		}

		trace_state->entry = entry;
		out:
		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_trace_start);

		static int save_synth_val(struct synth_field *field, u64 val,
		struct synth_event_trace_state *trace_state)
		{
		struct synth_trace_event *entry = trace_state->entry;

		if (field->is_string) {
		char str_val = (char )(long)val;
		char *str_field;

		if (!str_val)
		return -EINVAL;

		str_field = (char *)&entry->fields[field->offset];
		strscpy(str_field, str_val, STR_VAR_LEN_MAX);
		} else
		entry->fields[field->offset] = val;

		return 0;
		}

		/**
		* synth_event_add_next_val - Add the next field's value to an open synth trace
		* @val: The value to set the next field to
		* @trace_state: A pointer to object tracking the piecewise trace state
		*
		* Set the value of the next field in an event that's been opened by
		* synth_event_trace_start().
		*
		* The val param should be the value cast to u64. If the value points
		* to a string, the val param should be a char * cast to u64.
		*
		* This function assumes all the fields in an event are to be set one
		* after another - successive calls to this function are made, one for
		* each field, in the order of the fields in the event, until all
		* fields have been set. If you'd rather set each field individually
		* without regard to ordering, synth_event_add_val() can be used
		* instead.
		*
		* Note however that synth_event_add_next_val() and
		* synth_event_add_val() can't be intermixed for a given event trace -
		* one or the other but not both can be used at the same time.
		*
		* Note also that synth_event_trace_end() must be called after all
		* values have been added for each event trace, regardless of whether
		* adding all field values succeeded or not.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_add_next_val(u64 val,
		struct synth_event_trace_state *trace_state)
		{
		struct synth_field *field;
		struct synth_event *event;
		int ret = 0;

		if (!trace_state) {
		ret = -EINVAL;
		goto out;
		}

		/* can't mix add_next_synth_val() with add_synth_val() */
		if (trace_state->add_name) {
		ret = -EINVAL;
		goto out;
		}
		trace_state->add_next = true;

		if (!trace_state->enabled)
		goto out;

		event = trace_state->event;

		if (trace_state->cur_field >= event->n_fields) {
		ret = -EINVAL;
		goto out;
		}

		field = event->fields[trace_state->cur_field++];
		ret = save_synth_val(field, val, trace_state);
		out:
		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_add_next_val);

		static struct synth_field find_synth_field(struct synth_event event,
		const char *field_name)
		{
		struct synth_field *field = NULL;
		unsigned int i;

		for (i = 0; i < event->n_fields; i++) {
		field = event->fields[i];
		if (strcmp(field->name, field_name) == 0)
		return field;
		}

		return NULL;
		}

		/**
		* synth_event_add_val - Add a named field's value to an open synth trace
		* @field_name: The name of the synthetic event field value to set
		* @val: The value to set the next field to
		* @trace_state: A pointer to object tracking the piecewise trace state
		*
		* Set the value of the named field in an event that's been opened by
		* synth_event_trace_start().
		*
		* The val param should be the value cast to u64. If the value points
		* to a string, the val param should be a char * cast to u64.
		*
		* This function looks up the field name, and if found, sets the field
		* to the specified value. This lookup makes this function more
		* expensive than synth_event_add_next_val(), so use that or the
		* none-piecewise synth_event_trace() instead if efficiency is more
		* important.
		*
		* Note however that synth_event_add_next_val() and
		* synth_event_add_val() can't be intermixed for a given event trace -
		* one or the other but not both can be used at the same time.
		*
		* Note also that synth_event_trace_end() must be called after all
		* values have been added for each event trace, regardless of whether
		* adding all field values succeeded or not.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_add_val(const char *field_name, u64 val,
		struct synth_event_trace_state *trace_state)
		{
		struct synth_trace_event *entry;
		struct synth_event *event;
		struct synth_field *field;
		int ret = 0;

		if (!trace_state) {
		ret = -EINVAL;
		goto out;
		}

		/* can't mix add_next_synth_val() with add_synth_val() */
		if (trace_state->add_next) {
		ret = -EINVAL;
		goto out;
		}
		trace_state->add_name = true;

		if (!trace_state->enabled)
		goto out;

		event = trace_state->event;
		entry = trace_state->entry;

		field = find_synth_field(event, field_name);
		if (!field) {
		ret = -EINVAL;
		goto out;
		}

		ret = save_synth_val(field, val, trace_state);
		out:
		return ret;
		}
		EXPORT_SYMBOL_GPL(synth_event_add_val);

		/**
		* synth_event_trace_end - End piecewise synthetic event trace
		* @trace_state: A pointer to object tracking the piecewise trace state
		*
		* End the trace of a synthetic event opened by
		* synth_event_trace__start().
		*
		* This function 'closes' an event trace, which basically means that
		* it commits the reserved event and cleans up other loose ends.
		*
		* A pointer to a trace_state object is passed in, which will keep
		* track of the current event trace state opened with
		* synth_event_trace_start().
		*
		* Note that this function must be called after all values have been
		* added for each event trace, regardless of whether adding all field
		* values succeeded or not.
		*
		* Return: 0 on success, err otherwise.
		*/
		int synth_event_trace_end(struct synth_event_trace_state *trace_state)
		{
		if (!trace_state)
		return -EINVAL;

		trace_event_buffer_commit(&trace_state->fbuffer);

		ring_buffer_nest_end(trace_state->buffer);

		return 0;
		}
		EXPORT_SYMBOL_GPL(synth_event_trace_end);

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

Admin message