Commit e906bb78 authored by Tzvetomir Stoyanov (VMware)'s avatar Tzvetomir Stoyanov (VMware) Committed by Arnaldo Carvalho de Melo
Browse files

tools lib traceevent: Add prefix tep_ to enums filter_{boolean,op,cmp}_type 



In order to make libtraceevent into a proper library, variables, data
structures and functions require a unique prefix to prevent name space
conflicts. That prefix will be "tep_". This adds prefix tep_ to enums
filter_boolean_type, filter_op_type, filter_cmp_type and all enum's members

Signed-off-by: default avatarTzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
Cc: linux-trace-devel@vger.kernel.org
Link: http://lkml.kernel.org/r/20180919185723.680572508@goodmis.org


Signed-off-by: default avatarSteven Rostedt (VMware) <rostedt@goodmis.org>
Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 1e97216f

tools/lib/traceevent/event-parse.h

+23 −23
Original line number Diff line number Diff line
@@ -768,29 +768,29 @@ void tep_print_printk(struct tep_handle *pevent); 


/* ----------------------- filtering ----------------------- */



enum filter_boolean_type {

	FILTER_FALSE,

	FILTER_TRUE,

enum tep_filter_boolean_type {

	TEP_FILTER_FALSE,

	TEP_FILTER_TRUE,

};



enum filter_op_type {

	FILTER_OP_AND = 1,

	FILTER_OP_OR,

	FILTER_OP_NOT,

enum tep_filter_op_type {

	TEP_FILTER_OP_AND = 1,

	TEP_FILTER_OP_OR,

	TEP_FILTER_OP_NOT,

};



enum filter_cmp_type {

	FILTER_CMP_NONE,

	FILTER_CMP_EQ,

	FILTER_CMP_NE,

	FILTER_CMP_GT,

	FILTER_CMP_LT,

	FILTER_CMP_GE,

	FILTER_CMP_LE,

	FILTER_CMP_MATCH,

	FILTER_CMP_NOT_MATCH,

	FILTER_CMP_REGEX,

	FILTER_CMP_NOT_REGEX,

enum tep_filter_cmp_type {

	TEP_FILTER_CMP_NONE,

	TEP_FILTER_CMP_EQ,

	TEP_FILTER_CMP_NE,

	TEP_FILTER_CMP_GT,

	TEP_FILTER_CMP_LT,

	TEP_FILTER_CMP_GE,

	TEP_FILTER_CMP_LE,

	TEP_FILTER_CMP_MATCH,

	TEP_FILTER_CMP_NOT_MATCH,

	TEP_FILTER_CMP_REGEX,

	TEP_FILTER_CMP_NOT_REGEX,

};



enum filter_exp_type {
@@ -828,7 +828,7 @@ enum filter_value_type { 
struct fliter_arg;



struct filter_arg_boolean {

	enum filter_boolean_type	value;

	enum tep_filter_boolean_type	value;

};



struct filter_arg_field {
@@ -844,7 +844,7 @@ struct filter_arg_value { 
};



struct filter_arg_op {

	enum filter_op_type	type;

	enum tep_filter_op_type	type;

	struct filter_arg	*left;

	struct filter_arg	*right;

};
@@ -856,13 +856,13 @@ struct filter_arg_exp { 
};



struct filter_arg_num {

	enum filter_cmp_type	type;

	enum tep_filter_cmp_type	type;

	struct filter_arg	*left;

	struct filter_arg	*right;

};



struct filter_arg_str {

	enum filter_cmp_type	type;

	enum tep_filter_cmp_type	type;

	struct tep_format_field	*field;

	char			*val;

	char			*buffer;

tools/lib/traceevent/parse-filter.c

+72 −72
Original line number Diff line number Diff line
@@ -378,7 +378,7 @@ create_arg_item(struct tep_event_format *event, const char *token, 
			} else {

				/* not a field, Make it false */

				arg->type = FILTER_ARG_BOOLEAN;

				arg->boolean.value = FILTER_FALSE;

				arg->boolean.value = TEP_FILTER_FALSE;

				break;

			}

		}
@@ -395,7 +395,7 @@ create_arg_item(struct tep_event_format *event, const char *token, 
}



static struct filter_arg *

create_arg_op(enum filter_op_type btype)

create_arg_op(enum tep_filter_op_type btype)

{

	struct filter_arg *arg;
@@ -425,7 +425,7 @@ create_arg_exp(enum filter_exp_type etype) 
}



static struct filter_arg *

create_arg_cmp(enum filter_cmp_type ctype)

create_arg_cmp(enum tep_filter_cmp_type ctype)

{

	struct filter_arg *arg;
@@ -488,8 +488,8 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str) 
			 * is not a REGEX.

			 */

			if (strlen(arg->value.str) == 1 &&

			    op->num.type != FILTER_CMP_REGEX &&

			    op->num.type != FILTER_CMP_NOT_REGEX) {

			    op->num.type != TEP_FILTER_CMP_REGEX &&

			    op->num.type != TEP_FILTER_CMP_NOT_REGEX) {

				arg->value.type = FILTER_NUMBER;

				goto do_int;

			}
@@ -512,7 +512,7 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str) 
				free_arg(left);

				free_arg(arg);

				op->type = FILTER_ARG_BOOLEAN;

				op->boolean.value = FILTER_FALSE;

				op->boolean.value = TEP_FILTER_FALSE;

				break;

			}
@@ -525,15 +525,15 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str) 


			/* Make sure this is a valid string compare */

			switch (op_type) {

			case FILTER_CMP_EQ:

				op_type = FILTER_CMP_MATCH;

			case TEP_FILTER_CMP_EQ:

				op_type = TEP_FILTER_CMP_MATCH;

				break;

			case FILTER_CMP_NE:

				op_type = FILTER_CMP_NOT_MATCH;

			case TEP_FILTER_CMP_NE:

				op_type = TEP_FILTER_CMP_NOT_MATCH;

				break;



			case FILTER_CMP_REGEX:

			case FILTER_CMP_NOT_REGEX:

			case TEP_FILTER_CMP_REGEX:

			case TEP_FILTER_CMP_NOT_REGEX:

				ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);

				if (ret) {

					show_error(error_str,
@@ -577,8 +577,8 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str) 


 do_int:

			switch (op->num.type) {

			case FILTER_CMP_REGEX:

			case FILTER_CMP_NOT_REGEX:

			case TEP_FILTER_CMP_REGEX:

			case TEP_FILTER_CMP_NOT_REGEX:

				show_error(error_str,

					   "Op not allowed with integers");

				return TEP_ERRNO__ILLEGAL_INTEGER_CMP;
@@ -652,22 +652,22 @@ enum op_type { 
};



static enum op_type process_op(const char *token,

			       enum filter_op_type *btype,

			       enum filter_cmp_type *ctype,

			       enum tep_filter_op_type *btype,

			       enum tep_filter_cmp_type *ctype,

			       enum filter_exp_type *etype)

{

	*btype = FILTER_OP_NOT;

	*btype = TEP_FILTER_OP_NOT;

	*etype = FILTER_EXP_NONE;

	*ctype = FILTER_CMP_NONE;

	*ctype = TEP_FILTER_CMP_NONE;



	if (strcmp(token, "&&") == 0)

		*btype = FILTER_OP_AND;

		*btype = TEP_FILTER_OP_AND;

	else if (strcmp(token, "||") == 0)

		*btype = FILTER_OP_OR;

		*btype = TEP_FILTER_OP_OR;

	else if (strcmp(token, "!") == 0)

		return OP_NOT;



	if (*btype != FILTER_OP_NOT)

	if (*btype != TEP_FILTER_OP_NOT)

		return OP_BOOL;



	/* Check for value expressions */
@@ -699,21 +699,21 @@ static enum op_type process_op(const char *token, 


	/* Check for compares */

	if (strcmp(token, "==") == 0)

		*ctype = FILTER_CMP_EQ;

		*ctype = TEP_FILTER_CMP_EQ;

	else if (strcmp(token, "!=") == 0)

		*ctype = FILTER_CMP_NE;

		*ctype = TEP_FILTER_CMP_NE;

	else if (strcmp(token, "<") == 0)

		*ctype = FILTER_CMP_LT;

		*ctype = TEP_FILTER_CMP_LT;

	else if (strcmp(token, ">") == 0)

		*ctype = FILTER_CMP_GT;

		*ctype = TEP_FILTER_CMP_GT;

	else if (strcmp(token, "<=") == 0)

		*ctype = FILTER_CMP_LE;

		*ctype = TEP_FILTER_CMP_LE;

	else if (strcmp(token, ">=") == 0)

		*ctype = FILTER_CMP_GE;

		*ctype = TEP_FILTER_CMP_GE;

	else if (strcmp(token, "=~") == 0)

		*ctype = FILTER_CMP_REGEX;

		*ctype = TEP_FILTER_CMP_REGEX;

	else if (strcmp(token, "!~") == 0)

		*ctype = FILTER_CMP_NOT_REGEX;

		*ctype = TEP_FILTER_CMP_NOT_REGEX;

	else

		return OP_NONE;
@@ -840,13 +840,13 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg, 
		return FILTER_VAL_NORM;



	case FILTER_ARG_OP:

		if (arg->op.type != FILTER_OP_NOT) {

		if (arg->op.type != TEP_FILTER_OP_NOT) {

			lval = test_arg(arg, arg->op.left, error_str);

			switch (lval) {

			case FILTER_VAL_NORM:

				break;

			case FILTER_VAL_TRUE:

				if (arg->op.type == FILTER_OP_OR)

				if (arg->op.type == TEP_FILTER_OP_OR)

					return FILTER_VAL_TRUE;

				rval = test_arg(arg, arg->op.right, error_str);

				if (rval != FILTER_VAL_NORM)
@@ -856,7 +856,7 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg, 
						       error_str);



			case FILTER_VAL_FALSE:

				if (arg->op.type == FILTER_OP_AND)

				if (arg->op.type == TEP_FILTER_OP_AND)

					return FILTER_VAL_FALSE;

				rval = test_arg(arg, arg->op.right, error_str);

				if (rval != FILTER_VAL_NORM)
@@ -877,18 +877,18 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg, 
			break;



		case FILTER_VAL_TRUE:

			if (arg->op.type == FILTER_OP_OR)

			if (arg->op.type == TEP_FILTER_OP_OR)

				return FILTER_VAL_TRUE;

			if (arg->op.type == FILTER_OP_NOT)

			if (arg->op.type == TEP_FILTER_OP_NOT)

				return FILTER_VAL_FALSE;



			return reparent_op_arg(parent, arg, arg->op.left,

					       error_str);



		case FILTER_VAL_FALSE:

			if (arg->op.type == FILTER_OP_AND)

			if (arg->op.type == TEP_FILTER_OP_AND)

				return FILTER_VAL_FALSE;

			if (arg->op.type == FILTER_OP_NOT)

			if (arg->op.type == TEP_FILTER_OP_NOT)

				return FILTER_VAL_TRUE;



			return reparent_op_arg(parent, arg, arg->op.left,
@@ -949,9 +949,9 @@ process_filter(struct tep_event_format *event, struct filter_arg **parg, 
	struct filter_arg *left_item = NULL;

	struct filter_arg *arg = NULL;

	enum op_type op_type;

	enum filter_op_type btype;

	enum tep_filter_op_type btype;

	enum filter_exp_type etype;

	enum filter_cmp_type ctype;

	enum tep_filter_cmp_type ctype;

	enum tep_errno ret;



	*parg = NULL;
@@ -1197,7 +1197,7 @@ process_event(struct tep_event_format *event, const char *filter_str, 
			return TEP_ERRNO__MEM_ALLOC_FAILED;



		(*parg)->type = FILTER_ARG_BOOLEAN;

		(*parg)->boolean.value = FILTER_FALSE;

		(*parg)->boolean.value = TEP_FILTER_FALSE;

	}



	return 0;
@@ -1223,7 +1223,7 @@ filter_event(struct event_filter *filter, struct tep_event_format *event, 
			return TEP_ERRNO__MEM_ALLOC_FAILED;



		arg->type = FILTER_ARG_BOOLEAN;

		arg->boolean.value = FILTER_TRUE;

		arg->boolean.value = TEP_FILTER_TRUE;

	}



	filter_type = add_filter_type(filter, event->id);
@@ -1832,22 +1832,22 @@ static int test_num(struct tep_event_format *event, struct filter_arg *arg, 
	}



	switch (arg->num.type) {

	case FILTER_CMP_EQ:

	case TEP_FILTER_CMP_EQ:

		return lval == rval;



	case FILTER_CMP_NE:

	case TEP_FILTER_CMP_NE:

		return lval != rval;



	case FILTER_CMP_GT:

	case TEP_FILTER_CMP_GT:

		return lval > rval;



	case FILTER_CMP_LT:

	case TEP_FILTER_CMP_LT:

		return lval < rval;



	case FILTER_CMP_GE:

	case TEP_FILTER_CMP_GE:

		return lval >= rval;



	case FILTER_CMP_LE:

	case TEP_FILTER_CMP_LE:

		return lval <= rval;



	default:
@@ -1918,17 +1918,17 @@ static int test_str(struct tep_event_format *event, struct filter_arg *arg, 
		val = get_field_str(arg, record);



	switch (arg->str.type) {

	case FILTER_CMP_MATCH:

	case TEP_FILTER_CMP_MATCH:

		return strcmp(val, arg->str.val) == 0;



	case FILTER_CMP_NOT_MATCH:

	case TEP_FILTER_CMP_NOT_MATCH:

		return strcmp(val, arg->str.val) != 0;



	case FILTER_CMP_REGEX:

	case TEP_FILTER_CMP_REGEX:

		/* Returns zero on match */

		return !regexec(&arg->str.reg, val, 0, NULL, 0);



	case FILTER_CMP_NOT_REGEX:

	case TEP_FILTER_CMP_NOT_REGEX:

		return regexec(&arg->str.reg, val, 0, NULL, 0);



	default:
@@ -1942,15 +1942,15 @@ static int test_op(struct tep_event_format *event, struct filter_arg *arg, 
		   struct tep_record *record, enum tep_errno *err)

{

	switch (arg->op.type) {

	case FILTER_OP_AND:

	case TEP_FILTER_OP_AND:

		return test_filter(event, arg->op.left, record, err) &&

			test_filter(event, arg->op.right, record, err);



	case FILTER_OP_OR:

	case TEP_FILTER_OP_OR:

		return test_filter(event, arg->op.left, record, err) ||

			test_filter(event, arg->op.right, record, err);



	case FILTER_OP_NOT:

	case TEP_FILTER_OP_NOT:

		return !test_filter(event, arg->op.right, record, err);



	default:
@@ -2070,10 +2070,10 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg) 
	int val;



	switch (arg->op.type) {

	case FILTER_OP_AND:

	case TEP_FILTER_OP_AND:

		op = "&&";

		/* fall through */

	case FILTER_OP_OR:

	case TEP_FILTER_OP_OR:

		if (!op)

			op = "||";
@@ -2094,8 +2094,8 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg) 
			right_val = 0;



		if (left_val >= 0) {

			if ((arg->op.type == FILTER_OP_AND && !left_val) ||

			    (arg->op.type == FILTER_OP_OR && left_val)) {

			if ((arg->op.type == TEP_FILTER_OP_AND && !left_val) ||

			    (arg->op.type == TEP_FILTER_OP_OR && left_val)) {

				/* Just return left value */

				str = left;

				left = NULL;
@@ -2105,10 +2105,10 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg) 
				/* just evaluate this. */

				val = 0;

				switch (arg->op.type) {

				case FILTER_OP_AND:

				case TEP_FILTER_OP_AND:

					val = left_val && right_val;

					break;

				case FILTER_OP_OR:

				case TEP_FILTER_OP_OR:

					val = left_val || right_val;

					break;

				default:
@@ -2119,8 +2119,8 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg) 
			}

		}

		if (right_val >= 0) {

			if ((arg->op.type == FILTER_OP_AND && !right_val) ||

			    (arg->op.type == FILTER_OP_OR && right_val)) {

			if ((arg->op.type == TEP_FILTER_OP_AND && !right_val) ||

			    (arg->op.type == TEP_FILTER_OP_OR && right_val)) {

				/* Just return right value */

				str = right;

				right = NULL;
@@ -2135,7 +2135,7 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg) 
		asprintf(&str, "(%s) %s (%s)", left, op, right);

		break;



	case FILTER_OP_NOT:

	case TEP_FILTER_OP_NOT:

		op = "!";

		right = arg_to_str(filter, arg->op.right);

		if (!right)
@@ -2246,26 +2246,26 @@ static char *num_to_str(struct event_filter *filter, struct filter_arg *arg) 
		goto out;



	switch (arg->num.type) {

	case FILTER_CMP_EQ:

	case TEP_FILTER_CMP_EQ:

		op = "==";

		/* fall through */

	case FILTER_CMP_NE:

	case TEP_FILTER_CMP_NE:

		if (!op)

			op = "!=";

		/* fall through */

	case FILTER_CMP_GT:

	case TEP_FILTER_CMP_GT:

		if (!op)

			op = ">";

		/* fall through */

	case FILTER_CMP_LT:

	case TEP_FILTER_CMP_LT:

		if (!op)

			op = "<";

		/* fall through */

	case FILTER_CMP_GE:

	case TEP_FILTER_CMP_GE:

		if (!op)

			op = ">=";

		/* fall through */

	case FILTER_CMP_LE:

	case TEP_FILTER_CMP_LE:

		if (!op)

			op = "<=";
@@ -2289,18 +2289,18 @@ static char *str_to_str(struct event_filter *filter, struct filter_arg *arg) 
	char *op = NULL;



	switch (arg->str.type) {

	case FILTER_CMP_MATCH:

	case TEP_FILTER_CMP_MATCH:

		op = "==";

		/* fall through */

	case FILTER_CMP_NOT_MATCH:

	case TEP_FILTER_CMP_NOT_MATCH:

		if (!op)

			op = "!=";

		/* fall through */

	case FILTER_CMP_REGEX:

	case TEP_FILTER_CMP_REGEX:

		if (!op)

			op = "=~";

		/* fall through */

	case FILTER_CMP_NOT_REGEX:

	case TEP_FILTER_CMP_NOT_REGEX:

		if (!op)

			op = "!~";

CRA Git | Maintained and supported by SUSTech CRA and CCSE