Commit 689fd8b6 authored by jolsa@redhat.com's avatar jolsa@redhat.com Committed by Steven Rostedt
Browse files

tracing: trace parser support for function and graph 



Convert the writing to 'set_graph_function', 'set_ftrace_filter'
and 'set_ftrace_notrace' to use the generic trace_parser
'trace_get_user' function.

Removed FTRACE_ITER_CONT flag, since it's not needed after this change.

Minor fix in set_graph_function display - g_show function.

Signed-off-by: default avatarJiri Olsa <jolsa@redhat.com>
LKML-Reference: <1252682969-3366-4-git-send-email-jolsa@redhat.com>
Signed-off-by: default avatarSteven Rostedt <rostedt@goodmis.org>
parent 48966364

kernel/trace/ftrace.c

+40 −110
Original line number Diff line number Diff line
@@ -1323,11 +1323,10 @@ static int __init ftrace_dyn_table_alloc(unsigned long num_to_init) 


enum {

	FTRACE_ITER_FILTER	= (1 << 0),

	FTRACE_ITER_CONT	= (1 << 1),

	FTRACE_ITER_NOTRACE	= (1 << 2),

	FTRACE_ITER_FAILURES	= (1 << 3),

	FTRACE_ITER_PRINTALL	= (1 << 4),

	FTRACE_ITER_HASH	= (1 << 5),

	FTRACE_ITER_NOTRACE	= (1 << 1),

	FTRACE_ITER_FAILURES	= (1 << 2),

	FTRACE_ITER_PRINTALL	= (1 << 3),

	FTRACE_ITER_HASH	= (1 << 4),

};



#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
@@ -1337,8 +1336,7 @@ struct ftrace_iterator { 
	int			hidx;

	int			idx;

	unsigned		flags;

	unsigned char		buffer[FTRACE_BUFF_MAX+1];

	unsigned		buffer_idx;

	struct trace_parser	parser;

};



static void *
@@ -1604,6 +1602,11 @@ ftrace_regex_open(struct inode *inode, struct file *file, int enable) 
	if (!iter)

		return -ENOMEM;



	if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {

		kfree(iter);

		return -ENOMEM;

	}



	mutex_lock(&ftrace_regex_lock);

	if ((file->f_mode & FMODE_WRITE) &&

	    (file->f_flags & O_TRUNC))
@@ -2196,9 +2199,8 @@ ftrace_regex_write(struct file *file, const char __user *ubuf, 
		   size_t cnt, loff_t *ppos, int enable)

{

	struct ftrace_iterator *iter;

	char ch;

	size_t read = 0;

	ssize_t ret;

	struct trace_parser *parser;

	ssize_t ret, read;



	if (!cnt || cnt < 0)

		return 0;
@@ -2211,72 +2213,23 @@ ftrace_regex_write(struct file *file, const char __user *ubuf, 
	} else

		iter = file->private_data;



	if (!*ppos) {

		iter->flags &= ~FTRACE_ITER_CONT;

		iter->buffer_idx = 0;

	}

	parser = &iter->parser;

	read = trace_get_user(parser, ubuf, cnt, ppos);



	ret = get_user(ch, ubuf++);

	if (trace_parser_loaded(parser) &&

	    !trace_parser_cont(parser)) {

		ret = ftrace_process_regex(parser->buffer,

					   parser->idx, enable);

		if (ret)

			goto out;

	read++;

	cnt--;



	/*

	 * If the parser haven't finished with the last write,

	 * continue reading the user input without skipping spaces.

	 */

	if (!(iter->flags & FTRACE_ITER_CONT)) {

		/* skip white space */

		while (cnt && isspace(ch)) {

			ret = get_user(ch, ubuf++);

			if (ret)

				goto out;

			read++;

			cnt--;

		trace_parser_clear(parser);

	}



		/* only spaces were written */

		if (isspace(ch)) {

			*ppos += read;

	ret = read;

			goto out;

		}



		iter->buffer_idx = 0;

	}



	while (cnt && !isspace(ch)) {

		if (iter->buffer_idx < FTRACE_BUFF_MAX)

			iter->buffer[iter->buffer_idx++] = ch;

		else {

			ret = -EINVAL;

			goto out;

		}

		ret = get_user(ch, ubuf++);

		if (ret)

			goto out;

		read++;

		cnt--;

	}



	if (isspace(ch)) {

		iter->buffer[iter->buffer_idx] = 0;

		ret = ftrace_process_regex(iter->buffer,

					   iter->buffer_idx, enable);

		if (ret)

			goto out;

		iter->buffer_idx = 0;

	} else {

		iter->flags |= FTRACE_ITER_CONT;

		iter->buffer[iter->buffer_idx++] = ch;

	}



	*ppos += read;

	ret = read;

 out:

	mutex_unlock(&ftrace_regex_lock);



out:

	return ret;

}
@@ -2381,6 +2334,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable) 
{

	struct seq_file *m = (struct seq_file *)file->private_data;

	struct ftrace_iterator *iter;

	struct trace_parser *parser;



	mutex_lock(&ftrace_regex_lock);

	if (file->f_mode & FMODE_READ) {
@@ -2390,9 +2344,10 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable) 
	} else

		iter = file->private_data;



	if (iter->buffer_idx) {

		iter->buffer[iter->buffer_idx] = 0;

		ftrace_match_records(iter->buffer, iter->buffer_idx, enable);

	parser = &iter->parser;

	if (trace_parser_loaded(parser)) {

		parser->buffer[parser->idx] = 0;

		ftrace_match_records(parser->buffer, parser->idx, enable);

	}



	mutex_lock(&ftrace_lock);
@@ -2400,7 +2355,9 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable) 
		ftrace_run_update_code(FTRACE_ENABLE_CALLS);

	mutex_unlock(&ftrace_lock);



	trace_parser_put(parser);

	kfree(iter);



	mutex_unlock(&ftrace_regex_lock);

	return 0;

}
@@ -2499,7 +2456,7 @@ static int g_show(struct seq_file *m, void *v) 
		return 0;

	}



	seq_printf(m, "%pf\n", v);

	seq_printf(m, "%pf\n", (void *)*ptr);



	return 0;

}
@@ -2602,12 +2559,10 @@ static ssize_t 
ftrace_graph_write(struct file *file, const char __user *ubuf,

		   size_t cnt, loff_t *ppos)

{

	unsigned char buffer[FTRACE_BUFF_MAX+1];

	struct trace_parser parser;

	unsigned long *array;

	size_t read = 0;

	ssize_t ret;

	int index = 0;

	char ch;



	if (!cnt || cnt < 0)

		return 0;
@@ -2625,51 +2580,26 @@ ftrace_graph_write(struct file *file, const char __user *ubuf, 
	} else

		array = file->private_data;



	ret = get_user(ch, ubuf++);

	if (ret)

		goto out;

	read++;

	cnt--;



	/* skip white space */

	while (cnt && isspace(ch)) {

		ret = get_user(ch, ubuf++);

		if (ret)

	if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX)) {

		ret = -ENOMEM;

		goto out;

		read++;

		cnt--;

	}



	if (isspace(ch)) {

		*ppos += read;

		ret = read;

		goto out;

	}

	read = trace_get_user(&parser, ubuf, cnt, ppos);



	while (cnt && !isspace(ch)) {

		if (index < FTRACE_BUFF_MAX)

			buffer[index++] = ch;

		else {

			ret = -EINVAL;

			goto out;

		}

		ret = get_user(ch, ubuf++);

		if (ret)

			goto out;

		read++;

		cnt--;

	}

	buffer[index] = 0;

	if (trace_parser_loaded((&parser))) {

		parser.buffer[parser.idx] = 0;



		/* we allow only one expression at a time */

	ret = ftrace_set_func(array, &ftrace_graph_count, buffer);

		ret = ftrace_set_func(array, &ftrace_graph_count,

					parser.buffer);

		if (ret)

			goto out;



	file->f_pos += read;

	}



	ret = read;

 out:

	trace_parser_put(&parser);

	mutex_unlock(&graph_lock);



	return ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE