Merge tag 'perf-core-for-mingo' of... (baa5a7bc) · Commits · 戴 / test

tools/lib/traceevent/event-parse.c

+233 −34

Original line number	Diff line number	Diff line
		@@ -304,7 +304,10 @@ int pevent_register_comm(struct pevent pevent, const char comm, int pid)
		if (!item)
		return -1;

		if (comm)
		item->comm = strdup(comm);
		else
		item->comm = strdup("<...>");
		if (!item->comm) {
		free(item);
		return -1;
		@@ -318,9 +321,14 @@ int pevent_register_comm(struct pevent pevent, const char comm, int pid)
		return 0;
		}

		void pevent_register_trace_clock(struct pevent pevent, char trace_clock)
		int pevent_register_trace_clock(struct pevent pevent, const char trace_clock)
		{
		pevent->trace_clock = trace_clock;
		pevent->trace_clock = strdup(trace_clock);
		if (!pevent->trace_clock) {
		errno = ENOMEM;
		return -1;
		}
		return 0;
		}

		struct func_map {
		@@ -758,6 +766,11 @@ static void free_arg(struct print_arg *arg)
		free_arg(arg->hex.field);
		free_arg(arg->hex.size);
		break;
		case PRINT_INT_ARRAY:
		free_arg(arg->int_array.field);
		free_arg(arg->int_array.count);
		free_arg(arg->int_array.el_size);
		break;
		case PRINT_TYPE:
		free(arg->typecast.type);
		free_arg(arg->typecast.item);
		@@ -2014,6 +2027,38 @@ process_entry(struct event_format event __maybe_unused, struct print_arg arg,
		return EVENT_ERROR;
		}

		static int alloc_and_process_delim(struct event_format event, char next_token,
		struct print_arg **print_arg)
		{
		struct print_arg *field;
		enum event_type type;
		char *token;
		int ret = 0;

		field = alloc_arg();
		if (!field) {
		do_warning_event(event, "%s: not enough memory!", __func__);
		errno = ENOMEM;
		return -1;
		}

		type = process_arg(event, field, &token);

		if (test_type_token(type, token, EVENT_DELIM, next_token)) {
		errno = EINVAL;
		ret = -1;
		free_arg(field);
		goto out_free_token;
		}

		*print_arg = field;

		out_free_token:
		free_token(token);

		return ret;
		}

		static char arg_eval (struct print_arg arg);

		static unsigned long long
		@@ -2486,49 +2531,46 @@ out_free:
		static enum event_type
		process_hex(struct event_format event, struct print_arg arg, char **tok)
		{
		struct print_arg *field;
		enum event_type type;
		char *token = NULL;

		memset(arg, 0, sizeof(*arg));
		arg->type = PRINT_HEX;

		field = alloc_arg();
		if (!field) {
		do_warning_event(event, "%s: not enough memory!", __func__);
		goto out_free;
		}

		type = process_arg(event, field, &token);

		if (test_type_token(type, token, EVENT_DELIM, ","))
		goto out_free;
		if (alloc_and_process_delim(event, ",", &arg->hex.field))
		goto out;

		arg->hex.field = field;
		if (alloc_and_process_delim(event, ")", &arg->hex.size))
		goto free_field;

		free_token(token);
		return read_token_item(tok);

		field = alloc_arg();
		if (!field) {
		do_warning_event(event, "%s: not enough memory!", __func__);
		free_field:
		free_arg(arg->hex.field);
		out:
		*tok = NULL;
		return EVENT_ERROR;
		}

		type = process_arg(event, field, &token);
		static enum event_type
		process_int_array(struct event_format event, struct print_arg arg, char **tok)
		{
		memset(arg, 0, sizeof(*arg));
		arg->type = PRINT_INT_ARRAY;

		if (test_type_token(type, token, EVENT_DELIM, ")"))
		goto out_free;
		if (alloc_and_process_delim(event, ",", &arg->int_array.field))
		goto out;

		arg->hex.size = field;
		if (alloc_and_process_delim(event, ",", &arg->int_array.count))
		goto free_field;

		free_token(token);
		type = read_token_item(tok);
		return type;
		if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
		goto free_size;

		out_free:
		free_arg(field);
		free_token(token);
		return read_token_item(tok);

		free_size:
		free_arg(arg->int_array.count);
		free_field:
		free_arg(arg->int_array.field);
		out:
		*tok = NULL;
		return EVENT_ERROR;
		}
		@@ -2828,6 +2870,10 @@ process_function(struct event_format event, struct print_arg arg,
		free_token(token);
		return process_hex(event, arg, tok);
		}
		if (strcmp(token, "__print_array") == 0) {
		free_token(token);
		return process_int_array(event, arg, tok);
		}
		if (strcmp(token, "__get_str") == 0) {
		free_token(token);
		return process_str(event, arg, tok);
		@@ -3356,6 +3402,7 @@ eval_num_arg(void data, int size, struct event_format event, struct print_arg
		break;
		case PRINT_FLAGS:
		case PRINT_SYMBOL:
		case PRINT_INT_ARRAY:
		case PRINT_HEX:
		break;
		case PRINT_TYPE:
		@@ -3766,6 +3813,54 @@ static void print_str_arg(struct trace_seq s, void data, int size,
		}
		break;

		case PRINT_INT_ARRAY: {
		void *num;
		int el_size;

		if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
		unsigned long offset;
		struct format_field *field =
		arg->int_array.field->dynarray.field;
		offset = pevent_read_number(pevent,
		data + field->offset,
		field->size);
		num = data + (offset & 0xffff);
		} else {
		field = arg->int_array.field->field.field;
		if (!field) {
		str = arg->int_array.field->field.name;
		field = pevent_find_any_field(event, str);
		if (!field)
		goto out_warning_field;
		arg->int_array.field->field.field = field;
		}
		num = data + field->offset;
		}
		len = eval_num_arg(data, size, event, arg->int_array.count);
		el_size = eval_num_arg(data, size, event,
		arg->int_array.el_size);
		for (i = 0; i < len; i++) {
		if (i)
		trace_seq_putc(s, ' ');

		if (el_size == 1) {
		trace_seq_printf(s, "%u", (uint8_t )num);
		} else if (el_size == 2) {
		trace_seq_printf(s, "%u", (uint16_t )num);
		} else if (el_size == 4) {
		trace_seq_printf(s, "%u", (uint32_t )num);
		} else if (el_size == 8) {
		trace_seq_printf(s, "%lu", (uint64_t )num);
		} else {
		trace_seq_printf(s, "BAD SIZE:%d 0x%x",
		el_size, (uint8_t )num);
		el_size = 1;
		}

		num += el_size;
		}
		break;
		}
		case PRINT_TYPE:
		break;
		case PRINT_STRING: {
		@@ -3997,6 +4092,10 @@ static struct print_arg make_bprint_args(char fmt, void *data, int size, struc
		goto process_again;
		case '.':
		goto process_again;
		case 'z':
		case 'Z':
		ls = 1;
		goto process_again;
		case 'p':
		ls = 1;
		/* fall through */
		@@ -4939,6 +5038,96 @@ const char pevent_data_comm_from_pid(struct pevent pevent, int pid)
		return comm;
		}

		static struct cmdline *
		pid_from_cmdlist(struct pevent pevent, const char comm, struct cmdline *next)
		{
		struct cmdline_list cmdlist = (struct cmdline_list )next;

		if (cmdlist)
		cmdlist = cmdlist->next;
		else
		cmdlist = pevent->cmdlist;

		while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
		cmdlist = cmdlist->next;

		return (struct cmdline *)cmdlist;
		}

		/**
		* pevent_data_pid_from_comm - return the pid from a given comm
		* @pevent: a handle to the pevent
		* @comm: the cmdline to find the pid from
		* @next: the cmdline structure to find the next comm
		*
		* This returns the cmdline structure that holds a pid for a given
		* comm, or NULL if none found. As there may be more than one pid for
		* a given comm, the result of this call can be passed back into
		* a recurring call in the @next paramater, and then it will find the
		* next pid.
		* Also, it does a linear seach, so it may be slow.
		*/
		struct cmdline pevent_data_pid_from_comm(struct pevent pevent, const char *comm,
		struct cmdline *next)
		{
		struct cmdline *cmdline;

		/*
		* If the cmdlines have not been converted yet, then use
		* the list.
		*/
		if (!pevent->cmdlines)
		return pid_from_cmdlist(pevent, comm, next);

		if (next) {
		/*
		* The next pointer could have been still from
		* a previous call before cmdlines were created
		*/
		if (next < pevent->cmdlines \|\|
		next >= pevent->cmdlines + pevent->cmdline_count)
		next = NULL;
		else
		cmdline = next++;
		}

		if (!next)
		cmdline = pevent->cmdlines;

		while (cmdline < pevent->cmdlines + pevent->cmdline_count) {
		if (strcmp(cmdline->comm, comm) == 0)
		return cmdline;
		cmdline++;
		}
		return NULL;
		}

		/**
		* pevent_cmdline_pid - return the pid associated to a given cmdline
		* @cmdline: The cmdline structure to get the pid from
		*
		* Returns the pid for a give cmdline. If @cmdline is NULL, then
		* -1 is returned.
		*/
		int pevent_cmdline_pid(struct pevent pevent, struct cmdline cmdline)
		{
		struct cmdline_list cmdlist = (struct cmdline_list )cmdline;

		if (!cmdline)
		return -1;

		/*
		* If cmdlines have not been created yet, or cmdline is
		* not part of the array, then treat it as a cmdlist instead.
		*/
		if (!pevent->cmdlines \|\|
		cmdline < pevent->cmdlines \|\|
		cmdline >= pevent->cmdlines + pevent->cmdline_count)
		return cmdlist->pid;

		return cmdline->pid;
		}

		/**
		* pevent_data_comm_from_pid - parse the data into the print format
		* @s: the trace_seq to write to
		@@ -5256,6 +5445,15 @@ static void print_args(struct print_arg *args)
		print_args(args->hex.size);
		printf(")");
		break;
		case PRINT_INT_ARRAY:
		printf("__print_array(");
		print_args(args->int_array.field);
		printf(", ");
		print_args(args->int_array.count);
		printf(", ");
		print_args(args->int_array.el_size);
		printf(")");
		break;
		case PRINT_STRING:
		case PRINT_BSTRING:
		printf("__get_str(%s)", args->string.string);
		@@ -6346,6 +6544,7 @@ void pevent_free(struct pevent *pevent)
		free_handler(handle);
		}

		free(pevent->trace_clock);
		free(pevent->events);
		free(pevent->sort_events);

tools/lib/traceevent/event-parse.h

+19 −2

Original line number	Diff line number	Diff line
		@@ -116,7 +116,7 @@ struct pevent_plugin_option {
		char *name;
		char *plugin_alias;
		char *description;
		char *value;
		const char *value;
		void *priv;
		int set;
		};
		@@ -154,6 +154,10 @@ struct pevent_plugin_option {
		* .plugin_alias is used to give a shorter name to access
		* the vairable. Useful if a plugin handles more than one event.
		*
		* If .value is not set, then it is considered a boolean and only
		* .set will be processed. If .value is defined, then it is considered
		* a string option and .set will be ignored.
		*
		* PEVENT_PLUGIN_ALIAS: (optional)
		* The name to use for finding options (uses filename if not defined)
		*/
		@@ -247,6 +251,12 @@ struct print_arg_hex {
		struct print_arg *size;
		};

		struct print_arg_int_array {
		struct print_arg *field;
		struct print_arg *count;
		struct print_arg *el_size;
		};

		struct print_arg_dynarray {
		struct format_field *field;
		struct print_arg *index;
		@@ -275,6 +285,7 @@ enum print_arg_type {
		PRINT_FLAGS,
		PRINT_SYMBOL,
		PRINT_HEX,
		PRINT_INT_ARRAY,
		PRINT_TYPE,
		PRINT_STRING,
		PRINT_BSTRING,
		@@ -294,6 +305,7 @@ struct print_arg {
		struct print_arg_flags flags;
		struct print_arg_symbol symbol;
		struct print_arg_hex hex;
		struct print_arg_int_array int_array;
		struct print_arg_func func;
		struct print_arg_string string;
		struct print_arg_bitmask bitmask;
		@@ -599,7 +611,7 @@ enum trace_flag_type {
		};

		int pevent_register_comm(struct pevent pevent, const char comm, int pid);
		void pevent_register_trace_clock(struct pevent pevent, char trace_clock);
		int pevent_register_trace_clock(struct pevent pevent, const char trace_clock);
		int pevent_register_function(struct pevent pevent, char name,
		unsigned long long addr, char *mod);
		int pevent_register_print_string(struct pevent pevent, const char fmt,
		@@ -678,6 +690,11 @@ int pevent_data_type(struct pevent pevent, struct pevent_record rec);
		struct event_format pevent_data_event_from_type(struct pevent pevent, int type);
		int pevent_data_pid(struct pevent pevent, struct pevent_record rec);
		const char pevent_data_comm_from_pid(struct pevent pevent, int pid);
		struct cmdline;
		struct cmdline pevent_data_pid_from_comm(struct pevent pevent, const char *comm,
		struct cmdline *next);
		int pevent_cmdline_pid(struct pevent pevent, struct cmdline cmdline);

		void pevent_event_info(struct trace_seq s, struct event_format event,
		struct pevent_record *record);
		int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum,

tools/lib/traceevent/event-plugin.c

+54 −6

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		*/

		#include <ctype.h>
		#include <stdio.h>
		#include <string.h>
		#include <dlfcn.h>
		@@ -49,6 +50,52 @@ struct plugin_list {
		void *handle;
		};

		static void lower_case(char *str)
		{
		if (!str)
		return;
		for (; *str; str++)
		str = tolower(str);
		}

		static int update_option_value(struct pevent_plugin_option op, const char val)
		{
		char *op_val;

		if (!val) {
		/* toggle, only if option is boolean */
		if (op->value)
		/* Warn? */
		return 0;
		op->set ^= 1;
		return 0;
		}

		/*
		* If the option has a value then it takes a string
		* otherwise the option is a boolean.
		*/
		if (op->value) {
		op->value = val;
		return 0;
		}

		/* Option is boolean, must be either "1", "0", "true" or "false" */

		op_val = strdup(val);
		if (!op_val)
		return -1;
		lower_case(op_val);

		if (strcmp(val, "1") == 0 \|\| strcmp(val, "true") == 0)
		op->set = 1;
		else if (strcmp(val, "0") == 0 \|\| strcmp(val, "false") == 0)
		op->set = 0;
		free(op_val);

		return 0;
		}

		/**
		* traceevent_plugin_list_options - get list of plugin options
		*
		@@ -120,6 +167,7 @@ update_option(const char file, struct pevent_plugin_option option)
		{
		struct trace_plugin_options *op;
		char *plugin;
		int ret = 0;

		if (option->plugin_alias) {
		plugin = strdup(option->plugin_alias);
		@@ -144,9 +192,10 @@ update_option(const char file, struct pevent_plugin_option option)
		if (strcmp(op->option, option->name) != 0)
		continue;

		option->value = op->value;
		option->set ^= 1;
		ret = update_option_value(option, op->value);
		if (ret)
		goto out;
		break;
		}

		/* first look for unnamed options */
		@@ -156,14 +205,13 @@ update_option(const char file, struct pevent_plugin_option option)
		if (strcmp(op->option, option->name) != 0)
		continue;

		option->value = op->value;
		option->set ^= 1;
		ret = update_option_value(option, op->value);
		break;
		}

		out:
		free(plugin);
		return 0;
		return ret;
		}

		/**

tools/lib/traceevent/kbuffer-parse.c

+11 −1

Original line number	Diff line number	Diff line
		@@ -372,7 +372,6 @@ translate_data(struct kbuffer kbuf, void data, void **rptr,
		switch (type_len) {
		case KBUFFER_TYPE_PADDING:
		*length = read_4(kbuf, data);
		data += *length;
		break;

		case KBUFFER_TYPE_TIME_EXTEND:
		@@ -730,3 +729,14 @@ void kbuffer_set_old_format(struct kbuffer *kbuf)

		kbuf->next_event = __old_next_event;
		}

		/**
		* kbuffer_start_of_data - return offset of where data starts on subbuffer
		* @kbuf: The kbuffer
		*
		* Returns the location on the subbuffer where the data starts.
		*/
		int kbuffer_start_of_data(struct kbuffer *kbuf)
		{
		return kbuf->start;
		}

tools/lib/traceevent/kbuffer.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -63,5 +63,6 @@ int kbuffer_missed_events(struct kbuffer *kbuf);
		int kbuffer_subbuffer_size(struct kbuffer *kbuf);

		void kbuffer_set_old_format(struct kbuffer *kbuf);
		int kbuffer_start_of_data(struct kbuffer *kbuf);

		#endif /* _K_BUFFER_H */

Admin message