1// SPDX-License-Identifier: LGPL-2.1
   2/*
   3 * Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   4 *
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   5 */
   6#include <stdio.h>
   7#include <stdlib.h>
   8#include <string.h>
   9#include <stdarg.h>
  10#include <errno.h>
  11#include <sys/types.h>
  12
  13#include "event-parse.h"
  14#include "event-parse-local.h"
  15#include "event-utils.h"
  16
  17#define COMM "COMM"
  18#define CPU "CPU"
  19
  20static struct tep_format_field comm = {
  21	.name = "COMM",
  22};
  23
  24static struct tep_format_field cpu = {
  25	.name = "CPU",
  26};
  27
  28struct event_list {
  29	struct event_list	*next;
  30	struct tep_event	*event;
  31};
  32
  33static void show_error(char *error_buf, const char *fmt, ...)
  34{
  35	unsigned long long index;
  36	const char *input;
  37	va_list ap;
  38	int len;
  39	int i;
  40
  41	input = tep_get_input_buf();
  42	index = tep_get_input_buf_ptr();
  43	len = input ? strlen(input) : 0;
  44
  45	if (len) {
  46		strcpy(error_buf, input);
  47		error_buf[len] = '\n';
  48		for (i = 1; i < len && i < index; i++)
  49			error_buf[len+i] = ' ';
  50		error_buf[len + i] = '^';
  51		error_buf[len + i + 1] = '\n';
  52		len += i+2;
  53	}
  54
  55	va_start(ap, fmt);
  56	vsnprintf(error_buf + len, TEP_FILTER_ERROR_BUFSZ - len, fmt, ap);
  57	va_end(ap);
  58}
  59
  60static void free_token(char *token)
  61{
  62	tep_free_token(token);
  63}
  64
  65static enum tep_event_type read_token(char **tok)
  66{
  67	enum tep_event_type type;
  68	char *token = NULL;
  69
  70	do {
  71		free_token(token);
  72		type = tep_read_token(&token);
  73	} while (type == TEP_EVENT_NEWLINE || type == TEP_EVENT_SPACE);
  74
  75	/* If token is = or ! check to see if the next char is ~ */
  76	if (token &&
  77	    (strcmp(token, "=") == 0 || strcmp(token, "!") == 0) &&
  78	    tep_peek_char() == '~') {
  79		/* append it */
  80		*tok = malloc(3);
  81		if (*tok == NULL) {
  82			free_token(token);
  83			return TEP_EVENT_ERROR;
  84		}
  85		sprintf(*tok, "%c%c", *token, '~');
  86		free_token(token);
  87		/* Now remove the '~' from the buffer */
  88		tep_read_token(&token);
  89		free_token(token);
  90	} else
  91		*tok = token;
  92
  93	return type;
  94}
  95
  96static int filter_cmp(const void *a, const void *b)
  97{
  98	const struct tep_filter_type *ea = a;
  99	const struct tep_filter_type *eb = b;
 100
 101	if (ea->event_id < eb->event_id)
 102		return -1;
 103
 104	if (ea->event_id > eb->event_id)
 105		return 1;
 106
 107	return 0;
 108}
 109
 110static struct tep_filter_type *
 111find_filter_type(struct tep_event_filter *filter, int id)
 112{
 113	struct tep_filter_type *filter_type;
 114	struct tep_filter_type key;
 115
 116	key.event_id = id;
 117
 118	filter_type = bsearch(&key, filter->event_filters,
 119			      filter->filters,
 120			      sizeof(*filter->event_filters),
 121			      filter_cmp);
 122
 123	return filter_type;
 124}
 125
 126static struct tep_filter_type *
 127add_filter_type(struct tep_event_filter *filter, int id)
 128{
 129	struct tep_filter_type *filter_type;
 130	int i;
 131
 132	filter_type = find_filter_type(filter, id);
 133	if (filter_type)
 134		return filter_type;
 135
 136	filter_type = realloc(filter->event_filters,
 137			      sizeof(*filter->event_filters) *
 138			      (filter->filters + 1));
 139	if (!filter_type)
 140		return NULL;
 141
 142	filter->event_filters = filter_type;
 143
 144	for (i = 0; i < filter->filters; i++) {
 145		if (filter->event_filters[i].event_id > id)
 146			break;
 147	}
 148
 149	if (i < filter->filters)
 150		memmove(&filter->event_filters[i+1],
 151			&filter->event_filters[i],
 152			sizeof(*filter->event_filters) *
 153			(filter->filters - i));
 154
 155	filter_type = &filter->event_filters[i];
 156	filter_type->event_id = id;
 157	filter_type->event = tep_find_event(filter->tep, id);
 158	filter_type->filter = NULL;
 159
 160	filter->filters++;
 161
 162	return filter_type;
 163}
 164
 165/**
 166 * tep_filter_alloc - create a new event filter
 167 * @tep: The tep that this filter is associated with
 168 */
 169struct tep_event_filter *tep_filter_alloc(struct tep_handle *tep)
 170{
 171	struct tep_event_filter *filter;
 172
 173	filter = malloc(sizeof(*filter));
 174	if (filter == NULL)
 175		return NULL;
 176
 177	memset(filter, 0, sizeof(*filter));
 178	filter->tep = tep;
 179	tep_ref(tep);
 180
 181	return filter;
 182}
 183
 184static struct tep_filter_arg *allocate_arg(void)
 185{
 186	return calloc(1, sizeof(struct tep_filter_arg));
 187}
 188
 189static void free_arg(struct tep_filter_arg *arg)
 190{
 191	if (!arg)
 192		return;
 193
 194	switch (arg->type) {
 195	case TEP_FILTER_ARG_NONE:
 196	case TEP_FILTER_ARG_BOOLEAN:
 197		break;
 198
 199	case TEP_FILTER_ARG_NUM:
 200		free_arg(arg->num.left);
 201		free_arg(arg->num.right);
 202		break;
 203
 204	case TEP_FILTER_ARG_EXP:
 205		free_arg(arg->exp.left);
 206		free_arg(arg->exp.right);
 207		break;
 208
 209	case TEP_FILTER_ARG_STR:
 210		free(arg->str.val);
 211		regfree(&arg->str.reg);
 212		free(arg->str.buffer);
 213		break;
 214
 215	case TEP_FILTER_ARG_VALUE:
 216		if (arg->value.type == TEP_FILTER_STRING ||
 217		    arg->value.type == TEP_FILTER_CHAR)
 218			free(arg->value.str);
 219		break;
 220
 221	case TEP_FILTER_ARG_OP:
 222		free_arg(arg->op.left);
 223		free_arg(arg->op.right);
 224	default:
 225		break;
 226	}
 227
 228	free(arg);
 229}
 230
 231static int add_event(struct event_list **events,
 232		     struct tep_event *event)
 233{
 234	struct event_list *list;
 235
 236	list = malloc(sizeof(*list));
 237	if (list == NULL)
 238		return -1;
 239
 240	list->next = *events;
 241	*events = list;
 242	list->event = event;
 243	return 0;
 244}
 245
 246static int event_match(struct tep_event *event,
 247		       regex_t *sreg, regex_t *ereg)
 248{
 249	if (sreg) {
 250		return !regexec(sreg, event->system, 0, NULL, 0) &&
 251			!regexec(ereg, event->name, 0, NULL, 0);
 252	}
 253
 254	return !regexec(ereg, event->system, 0, NULL, 0) ||
 255		!regexec(ereg, event->name, 0, NULL, 0);
 256}
 257
 258static enum tep_errno
 259find_event(struct tep_handle *tep, struct event_list **events,
 260	   char *sys_name, char *event_name)
 261{
 262	struct tep_event *event;
 263	regex_t ereg;
 264	regex_t sreg;
 265	int match = 0;
 266	int fail = 0;
 267	char *reg;
 268	int ret;
 269	int i;
 270
 271	if (!event_name) {
 272		/* if no name is given, then swap sys and name */
 273		event_name = sys_name;
 274		sys_name = NULL;
 275	}
 276
 277	ret = asprintf(&reg, "^%s$", event_name);
 278	if (ret < 0)
 279		return TEP_ERRNO__MEM_ALLOC_FAILED;
 
 
 280
 281	ret = regcomp(&ereg, reg, REG_ICASE|REG_NOSUB);
 282	free(reg);
 283
 284	if (ret)
 285		return TEP_ERRNO__INVALID_EVENT_NAME;
 286
 287	if (sys_name) {
 288		ret = asprintf(&reg, "^%s$", sys_name);
 289		if (ret < 0) {
 290			regfree(&ereg);
 291			return TEP_ERRNO__MEM_ALLOC_FAILED;
 292		}
 293
 
 294		ret = regcomp(&sreg, reg, REG_ICASE|REG_NOSUB);
 295		free(reg);
 296		if (ret) {
 297			regfree(&ereg);
 298			return TEP_ERRNO__INVALID_EVENT_NAME;
 299		}
 300	}
 301
 302	for (i = 0; i < tep->nr_events; i++) {
 303		event = tep->events[i];
 304		if (event_match(event, sys_name ? &sreg : NULL, &ereg)) {
 305			match = 1;
 306			if (add_event(events, event) < 0) {
 307				fail = 1;
 308				break;
 309			}
 310		}
 311	}
 312
 313	regfree(&ereg);
 314	if (sys_name)
 315		regfree(&sreg);
 316
 317	if (!match)
 318		return TEP_ERRNO__EVENT_NOT_FOUND;
 319	if (fail)
 320		return TEP_ERRNO__MEM_ALLOC_FAILED;
 321
 322	return 0;
 323}
 324
 325static void free_events(struct event_list *events)
 326{
 327	struct event_list *event;
 328
 329	while (events) {
 330		event = events;
 331		events = events->next;
 332		free(event);
 333	}
 334}
 335
 336static enum tep_errno
 337create_arg_item(struct tep_event *event, const char *token,
 338		enum tep_event_type type, struct tep_filter_arg **parg, char *error_str)
 339{
 340	struct tep_format_field *field;
 341	struct tep_filter_arg *arg;
 342
 343	arg = allocate_arg();
 344	if (arg == NULL) {
 345		show_error(error_str, "failed to allocate filter arg");
 346		return TEP_ERRNO__MEM_ALLOC_FAILED;
 347	}
 348
 349	switch (type) {
 350
 351	case TEP_EVENT_SQUOTE:
 352	case TEP_EVENT_DQUOTE:
 353		arg->type = TEP_FILTER_ARG_VALUE;
 354		arg->value.type =
 355			type == TEP_EVENT_DQUOTE ? TEP_FILTER_STRING : TEP_FILTER_CHAR;
 356		arg->value.str = strdup(token);
 357		if (!arg->value.str) {
 358			free_arg(arg);
 359			show_error(error_str, "failed to allocate string filter arg");
 360			return TEP_ERRNO__MEM_ALLOC_FAILED;
 361		}
 362		break;
 363	case TEP_EVENT_ITEM:
 364		/* if it is a number, then convert it */
 365		if (isdigit(token[0])) {
 366			arg->type = TEP_FILTER_ARG_VALUE;
 367			arg->value.type = TEP_FILTER_NUMBER;
 368			arg->value.val = strtoull(token, NULL, 0);
 369			break;
 370		}
 371		/* Consider this a field */
 372		field = tep_find_any_field(event, token);
 373		if (!field) {
 374			/* If token is 'COMM' or 'CPU' then it is special */
 375			if (strcmp(token, COMM) == 0) {
 376				field = &comm;
 377			} else if (strcmp(token, CPU) == 0) {
 378				field = &cpu;
 379			} else {
 380				/* not a field, Make it false */
 381				arg->type = TEP_FILTER_ARG_BOOLEAN;
 382				arg->boolean.value = TEP_FILTER_FALSE;
 383				break;
 384			}
 385		}
 386		arg->type = TEP_FILTER_ARG_FIELD;
 387		arg->field.field = field;
 388		break;
 389	default:
 390		free_arg(arg);
 391		show_error(error_str, "expected a value but found %s", token);
 392		return TEP_ERRNO__UNEXPECTED_TYPE;
 393	}
 394	*parg = arg;
 395	return 0;
 396}
 397
 398static struct tep_filter_arg *
 399create_arg_op(enum tep_filter_op_type btype)
 400{
 401	struct tep_filter_arg *arg;
 402
 403	arg = allocate_arg();
 404	if (!arg)
 405		return NULL;
 406
 407	arg->type = TEP_FILTER_ARG_OP;
 408	arg->op.type = btype;
 409
 410	return arg;
 411}
 412
 413static struct tep_filter_arg *
 414create_arg_exp(enum tep_filter_exp_type etype)
 415{
 416	struct tep_filter_arg *arg;
 417
 418	arg = allocate_arg();
 419	if (!arg)
 420		return NULL;
 421
 422	arg->type = TEP_FILTER_ARG_EXP;
 423	arg->exp.type = etype;
 424
 425	return arg;
 426}
 427
 428static struct tep_filter_arg *
 429create_arg_cmp(enum tep_filter_cmp_type ctype)
 430{
 431	struct tep_filter_arg *arg;
 432
 433	arg = allocate_arg();
 434	if (!arg)
 435		return NULL;
 436
 437	/* Use NUM and change if necessary */
 438	arg->type = TEP_FILTER_ARG_NUM;
 439	arg->num.type = ctype;
 440
 441	return arg;
 442}
 443
 444static enum tep_errno
 445add_right(struct tep_filter_arg *op, struct tep_filter_arg *arg, char *error_str)
 446{
 447	struct tep_filter_arg *left;
 448	char *str;
 449	int op_type;
 450	int ret;
 451
 452	switch (op->type) {
 453	case TEP_FILTER_ARG_EXP:
 454		if (op->exp.right)
 455			goto out_fail;
 456		op->exp.right = arg;
 457		break;
 458
 459	case TEP_FILTER_ARG_OP:
 460		if (op->op.right)
 461			goto out_fail;
 462		op->op.right = arg;
 463		break;
 464
 465	case TEP_FILTER_ARG_NUM:
 466		if (op->op.right)
 467			goto out_fail;
 468		/*
 469		 * The arg must be num, str, or field
 470		 */
 471		switch (arg->type) {
 472		case TEP_FILTER_ARG_VALUE:
 473		case TEP_FILTER_ARG_FIELD:
 474			break;
 475		default:
 476			show_error(error_str, "Illegal rvalue");
 477			return TEP_ERRNO__ILLEGAL_RVALUE;
 478		}
 479
 480		/*
 481		 * Depending on the type, we may need to
 482		 * convert this to a string or regex.
 483		 */
 484		switch (arg->value.type) {
 485		case TEP_FILTER_CHAR:
 486			/*
 487			 * A char should be converted to number if
 488			 * the string is 1 byte, and the compare
 489			 * is not a REGEX.
 490			 */
 491			if (strlen(arg->value.str) == 1 &&
 492			    op->num.type != TEP_FILTER_CMP_REGEX &&
 493			    op->num.type != TEP_FILTER_CMP_NOT_REGEX) {
 494				arg->value.type = TEP_FILTER_NUMBER;
 495				goto do_int;
 496			}
 497			/* fall through */
 498		case TEP_FILTER_STRING:
 499
 500			/* convert op to a string arg */
 501			op_type = op->num.type;
 502			left = op->num.left;
 503			str = arg->value.str;
 504
 505			/* reset the op for the new field */
 506			memset(op, 0, sizeof(*op));
 507
 508			/*
 509			 * If left arg was a field not found then
 510			 * NULL the entire op.
 511			 */
 512			if (left->type == TEP_FILTER_ARG_BOOLEAN) {
 513				free_arg(left);
 514				free_arg(arg);
 515				op->type = TEP_FILTER_ARG_BOOLEAN;
 516				op->boolean.value = TEP_FILTER_FALSE;
 517				break;
 518			}
 519
 520			/* Left arg must be a field */
 521			if (left->type != TEP_FILTER_ARG_FIELD) {
 522				show_error(error_str,
 523					   "Illegal lvalue for string comparison");
 524				return TEP_ERRNO__ILLEGAL_LVALUE;
 525			}
 526
 527			/* Make sure this is a valid string compare */
 528			switch (op_type) {
 529			case TEP_FILTER_CMP_EQ:
 530				op_type = TEP_FILTER_CMP_MATCH;
 531				break;
 532			case TEP_FILTER_CMP_NE:
 533				op_type = TEP_FILTER_CMP_NOT_MATCH;
 534				break;
 535
 536			case TEP_FILTER_CMP_REGEX:
 537			case TEP_FILTER_CMP_NOT_REGEX:
 538				ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);
 539				if (ret) {
 540					show_error(error_str,
 541						   "RegEx '%s' did not compute",
 542						   str);
 543					return TEP_ERRNO__INVALID_REGEX;
 544				}
 545				break;
 546			default:
 547				show_error(error_str,
 548					   "Illegal comparison for string");
 549				return TEP_ERRNO__ILLEGAL_STRING_CMP;
 550			}
 551
 552			op->type = TEP_FILTER_ARG_STR;
 553			op->str.type = op_type;
 554			op->str.field = left->field.field;
 555			op->str.val = strdup(str);
 556			if (!op->str.val) {
 557				show_error(error_str, "Failed to allocate string filter");
 558				return TEP_ERRNO__MEM_ALLOC_FAILED;
 559			}
 560			/*
 561			 * Need a buffer to copy data for tests
 562			 */
 563			op->str.buffer = malloc(op->str.field->size + 1);
 564			if (!op->str.buffer) {
 565				show_error(error_str, "Failed to allocate string filter");
 566				return TEP_ERRNO__MEM_ALLOC_FAILED;
 567			}
 568			/* Null terminate this buffer */
 569			op->str.buffer[op->str.field->size] = 0;
 570
 571			/* We no longer have left or right args */
 572			free_arg(arg);
 573			free_arg(left);
 574
 575			break;
 576
 577		case TEP_FILTER_NUMBER:
 578
 579 do_int:
 580			switch (op->num.type) {
 581			case TEP_FILTER_CMP_REGEX:
 582			case TEP_FILTER_CMP_NOT_REGEX:
 583				show_error(error_str,
 584					   "Op not allowed with integers");
 585				return TEP_ERRNO__ILLEGAL_INTEGER_CMP;
 586
 587			default:
 588				break;
 589			}
 590
 591			/* numeric compare */
 592			op->num.right = arg;
 593			break;
 594		default:
 595			goto out_fail;
 596		}
 597		break;
 598	default:
 599		goto out_fail;
 600	}
 601
 602	return 0;
 603
 604 out_fail:
 605	show_error(error_str, "Syntax error");
 606	return TEP_ERRNO__SYNTAX_ERROR;
 607}
 608
 609static struct tep_filter_arg *
 610rotate_op_right(struct tep_filter_arg *a, struct tep_filter_arg *b)
 611{
 612	struct tep_filter_arg *arg;
 613
 614	arg = a->op.right;
 615	a->op.right = b;
 616	return arg;
 617}
 618
 619static enum tep_errno add_left(struct tep_filter_arg *op, struct tep_filter_arg *arg)
 620{
 621	switch (op->type) {
 622	case TEP_FILTER_ARG_EXP:
 623		if (arg->type == TEP_FILTER_ARG_OP)
 624			arg = rotate_op_right(arg, op);
 625		op->exp.left = arg;
 626		break;
 627
 628	case TEP_FILTER_ARG_OP:
 629		op->op.left = arg;
 630		break;
 631	case TEP_FILTER_ARG_NUM:
 632		if (arg->type == TEP_FILTER_ARG_OP)
 633			arg = rotate_op_right(arg, op);
 634
 635		/* left arg of compares must be a field */
 636		if (arg->type != TEP_FILTER_ARG_FIELD &&
 637		    arg->type != TEP_FILTER_ARG_BOOLEAN)
 638			return TEP_ERRNO__INVALID_ARG_TYPE;
 639		op->num.left = arg;
 640		break;
 641	default:
 642		return TEP_ERRNO__INVALID_ARG_TYPE;
 643	}
 644	return 0;
 645}
 646
 647enum op_type {
 648	OP_NONE,
 649	OP_BOOL,
 650	OP_NOT,
 651	OP_EXP,
 652	OP_CMP,
 653};
 654
 655static enum op_type process_op(const char *token,
 656			       enum tep_filter_op_type *btype,
 657			       enum tep_filter_cmp_type *ctype,
 658			       enum tep_filter_exp_type *etype)
 659{
 660	*btype = TEP_FILTER_OP_NOT;
 661	*etype = TEP_FILTER_EXP_NONE;
 662	*ctype = TEP_FILTER_CMP_NONE;
 663
 664	if (strcmp(token, "&&") == 0)
 665		*btype = TEP_FILTER_OP_AND;
 666	else if (strcmp(token, "||") == 0)
 667		*btype = TEP_FILTER_OP_OR;
 668	else if (strcmp(token, "!") == 0)
 669		return OP_NOT;
 670
 671	if (*btype != TEP_FILTER_OP_NOT)
 672		return OP_BOOL;
 673
 674	/* Check for value expressions */
 675	if (strcmp(token, "+") == 0) {
 676		*etype = TEP_FILTER_EXP_ADD;
 677	} else if (strcmp(token, "-") == 0) {
 678		*etype = TEP_FILTER_EXP_SUB;
 679	} else if (strcmp(token, "*") == 0) {
 680		*etype = TEP_FILTER_EXP_MUL;
 681	} else if (strcmp(token, "/") == 0) {
 682		*etype = TEP_FILTER_EXP_DIV;
 683	} else if (strcmp(token, "%") == 0) {
 684		*etype = TEP_FILTER_EXP_MOD;
 685	} else if (strcmp(token, ">>") == 0) {
 686		*etype = TEP_FILTER_EXP_RSHIFT;
 687	} else if (strcmp(token, "<<") == 0) {
 688		*etype = TEP_FILTER_EXP_LSHIFT;
 689	} else if (strcmp(token, "&") == 0) {
 690		*etype = TEP_FILTER_EXP_AND;
 691	} else if (strcmp(token, "|") == 0) {
 692		*etype = TEP_FILTER_EXP_OR;
 693	} else if (strcmp(token, "^") == 0) {
 694		*etype = TEP_FILTER_EXP_XOR;
 695	} else if (strcmp(token, "~") == 0)
 696		*etype = TEP_FILTER_EXP_NOT;
 697
 698	if (*etype != TEP_FILTER_EXP_NONE)
 699		return OP_EXP;
 700
 701	/* Check for compares */
 702	if (strcmp(token, "==") == 0)
 703		*ctype = TEP_FILTER_CMP_EQ;
 704	else if (strcmp(token, "!=") == 0)
 705		*ctype = TEP_FILTER_CMP_NE;
 706	else if (strcmp(token, "<") == 0)
 707		*ctype = TEP_FILTER_CMP_LT;
 708	else if (strcmp(token, ">") == 0)
 709		*ctype = TEP_FILTER_CMP_GT;
 710	else if (strcmp(token, "<=") == 0)
 711		*ctype = TEP_FILTER_CMP_LE;
 712	else if (strcmp(token, ">=") == 0)
 713		*ctype = TEP_FILTER_CMP_GE;
 714	else if (strcmp(token, "=~") == 0)
 715		*ctype = TEP_FILTER_CMP_REGEX;
 716	else if (strcmp(token, "!~") == 0)
 717		*ctype = TEP_FILTER_CMP_NOT_REGEX;
 718	else
 719		return OP_NONE;
 720
 721	return OP_CMP;
 722}
 723
 724static int check_op_done(struct tep_filter_arg *arg)
 725{
 726	switch (arg->type) {
 727	case TEP_FILTER_ARG_EXP:
 728		return arg->exp.right != NULL;
 729
 730	case TEP_FILTER_ARG_OP:
 731		return arg->op.right != NULL;
 732
 733	case TEP_FILTER_ARG_NUM:
 734		return arg->num.right != NULL;
 735
 736	case TEP_FILTER_ARG_STR:
 737		/* A string conversion is always done */
 738		return 1;
 739
 740	case TEP_FILTER_ARG_BOOLEAN:
 741		/* field not found, is ok */
 742		return 1;
 743
 744	default:
 745		return 0;
 746	}
 747}
 748
 749enum filter_vals {
 750	FILTER_VAL_NORM,
 751	FILTER_VAL_FALSE,
 752	FILTER_VAL_TRUE,
 753};
 754
 755static enum tep_errno
 756reparent_op_arg(struct tep_filter_arg *parent, struct tep_filter_arg *old_child,
 757		struct tep_filter_arg *arg, char *error_str)
 758{
 759	struct tep_filter_arg *other_child;
 760	struct tep_filter_arg **ptr;
 761
 762	if (parent->type != TEP_FILTER_ARG_OP &&
 763	    arg->type != TEP_FILTER_ARG_OP) {
 764		show_error(error_str, "can not reparent other than OP");
 765		return TEP_ERRNO__REPARENT_NOT_OP;
 766	}
 767
 768	/* Get the sibling */
 769	if (old_child->op.right == arg) {
 770		ptr = &old_child->op.right;
 771		other_child = old_child->op.left;
 772	} else if (old_child->op.left == arg) {
 773		ptr = &old_child->op.left;
 774		other_child = old_child->op.right;
 775	} else {
 776		show_error(error_str, "Error in reparent op, find other child");
 777		return TEP_ERRNO__REPARENT_FAILED;
 778	}
 779
 780	/* Detach arg from old_child */
 781	*ptr = NULL;
 782
 783	/* Check for root */
 784	if (parent == old_child) {
 785		free_arg(other_child);
 786		*parent = *arg;
 787		/* Free arg without recussion */
 788		free(arg);
 789		return 0;
 790	}
 791
 792	if (parent->op.right == old_child)
 793		ptr = &parent->op.right;
 794	else if (parent->op.left == old_child)
 795		ptr = &parent->op.left;
 796	else {
 797		show_error(error_str, "Error in reparent op");
 798		return TEP_ERRNO__REPARENT_FAILED;
 799	}
 800
 801	*ptr = arg;
 802
 803	free_arg(old_child);
 804	return 0;
 805}
 806
 807/* Returns either filter_vals (success) or tep_errno (failfure) */
 808static int test_arg(struct tep_filter_arg *parent, struct tep_filter_arg *arg,
 809		    char *error_str)
 810{
 811	int lval, rval;
 812
 813	switch (arg->type) {
 814
 815		/* bad case */
 816	case TEP_FILTER_ARG_BOOLEAN:
 817		return FILTER_VAL_FALSE + arg->boolean.value;
 818
 819		/* good cases: */
 820	case TEP_FILTER_ARG_STR:
 821	case TEP_FILTER_ARG_VALUE:
 822	case TEP_FILTER_ARG_FIELD:
 823		return FILTER_VAL_NORM;
 824
 825	case TEP_FILTER_ARG_EXP:
 826		lval = test_arg(arg, arg->exp.left, error_str);
 827		if (lval != FILTER_VAL_NORM)
 828			return lval;
 829		rval = test_arg(arg, arg->exp.right, error_str);
 830		if (rval != FILTER_VAL_NORM)
 831			return rval;
 832		return FILTER_VAL_NORM;
 833
 834	case TEP_FILTER_ARG_NUM:
 835		lval = test_arg(arg, arg->num.left, error_str);
 836		if (lval != FILTER_VAL_NORM)
 837			return lval;
 838		rval = test_arg(arg, arg->num.right, error_str);
 839		if (rval != FILTER_VAL_NORM)
 840			return rval;
 841		return FILTER_VAL_NORM;
 842
 843	case TEP_FILTER_ARG_OP:
 844		if (arg->op.type != TEP_FILTER_OP_NOT) {
 845			lval = test_arg(arg, arg->op.left, error_str);
 846			switch (lval) {
 847			case FILTER_VAL_NORM:
 848				break;
 849			case FILTER_VAL_TRUE:
 850				if (arg->op.type == TEP_FILTER_OP_OR)
 851					return FILTER_VAL_TRUE;
 852				rval = test_arg(arg, arg->op.right, error_str);
 853				if (rval != FILTER_VAL_NORM)
 854					return rval;
 855
 856				return reparent_op_arg(parent, arg, arg->op.right,
 857						       error_str);
 858
 859			case FILTER_VAL_FALSE:
 860				if (arg->op.type == TEP_FILTER_OP_AND)
 861					return FILTER_VAL_FALSE;
 862				rval = test_arg(arg, arg->op.right, error_str);
 863				if (rval != FILTER_VAL_NORM)
 864					return rval;
 865
 866				return reparent_op_arg(parent, arg, arg->op.right,
 867						       error_str);
 868
 869			default:
 870				return lval;
 871			}
 872		}
 873
 874		rval = test_arg(arg, arg->op.right, error_str);
 875		switch (rval) {
 876		case FILTER_VAL_NORM:
 877		default:
 878			break;
 879
 880		case FILTER_VAL_TRUE:
 881			if (arg->op.type == TEP_FILTER_OP_OR)
 882				return FILTER_VAL_TRUE;
 883			if (arg->op.type == TEP_FILTER_OP_NOT)
 884				return FILTER_VAL_FALSE;
 885
 886			return reparent_op_arg(parent, arg, arg->op.left,
 887					       error_str);
 888
 889		case FILTER_VAL_FALSE:
 890			if (arg->op.type == TEP_FILTER_OP_AND)
 891				return FILTER_VAL_FALSE;
 892			if (arg->op.type == TEP_FILTER_OP_NOT)
 893				return FILTER_VAL_TRUE;
 894
 895			return reparent_op_arg(parent, arg, arg->op.left,
 896					       error_str);
 897		}
 898
 899		return rval;
 900	default:
 901		show_error(error_str, "bad arg in filter tree");
 902		return TEP_ERRNO__BAD_FILTER_ARG;
 903	}
 904	return FILTER_VAL_NORM;
 905}
 906
 907/* Remove any unknown event fields */
 908static int collapse_tree(struct tep_filter_arg *arg,
 909			 struct tep_filter_arg **arg_collapsed, char *error_str)
 910{
 911	int ret;
 912
 913	ret = test_arg(arg, arg, error_str);
 914	switch (ret) {
 915	case FILTER_VAL_NORM:
 916		break;
 917
 918	case FILTER_VAL_TRUE:
 919	case FILTER_VAL_FALSE:
 920		free_arg(arg);
 921		arg = allocate_arg();
 922		if (arg) {
 923			arg->type = TEP_FILTER_ARG_BOOLEAN;
 924			arg->boolean.value = ret == FILTER_VAL_TRUE;
 925		} else {
 926			show_error(error_str, "Failed to allocate filter arg");
 927			ret = TEP_ERRNO__MEM_ALLOC_FAILED;
 928		}
 929		break;
 930
 931	default:
 932		/* test_arg() already set the error_str */
 933		free_arg(arg);
 934		arg = NULL;
 935		break;
 936	}
 937
 938	*arg_collapsed = arg;
 939	return ret;
 940}
 941
 942static enum tep_errno
 943process_filter(struct tep_event *event, struct tep_filter_arg **parg,
 944	       char *error_str, int not)
 945{
 946	enum tep_event_type type;
 947	char *token = NULL;
 948	struct tep_filter_arg *current_op = NULL;
 949	struct tep_filter_arg *current_exp = NULL;
 950	struct tep_filter_arg *left_item = NULL;
 951	struct tep_filter_arg *arg = NULL;
 952	enum op_type op_type;
 953	enum tep_filter_op_type btype;
 954	enum tep_filter_exp_type etype;
 955	enum tep_filter_cmp_type ctype;
 956	enum tep_errno ret;
 957
 958	*parg = NULL;
 959
 960	do {
 961		free(token);
 962		type = read_token(&token);
 963		switch (type) {
 964		case TEP_EVENT_SQUOTE:
 965		case TEP_EVENT_DQUOTE:
 966		case TEP_EVENT_ITEM:
 967			ret = create_arg_item(event, token, type, &arg, error_str);
 968			if (ret < 0)
 969				goto fail;
 970			if (!left_item)
 971				left_item = arg;
 972			else if (current_exp) {
 973				ret = add_right(current_exp, arg, error_str);
 974				if (ret < 0)
 975					goto fail;
 976				left_item = NULL;
 977				/* Not's only one one expression */
 978				if (not) {
 979					arg = NULL;
 980					if (current_op)
 981						goto fail_syntax;
 982					free(token);
 983					*parg = current_exp;
 984					return 0;
 985				}
 986			} else
 987				goto fail_syntax;
 988			arg = NULL;
 989			break;
 990
 991		case TEP_EVENT_DELIM:
 992			if (*token == ',') {
 993				show_error(error_str, "Illegal token ','");
 994				ret = TEP_ERRNO__ILLEGAL_TOKEN;
 995				goto fail;
 996			}
 997
 998			if (*token == '(') {
 999				if (left_item) {
1000					show_error(error_str,
1001						   "Open paren can not come after item");
1002					ret = TEP_ERRNO__INVALID_PAREN;
1003					goto fail;
1004				}
1005				if (current_exp) {
1006					show_error(error_str,
1007						   "Open paren can not come after expression");
1008					ret = TEP_ERRNO__INVALID_PAREN;
1009					goto fail;
1010				}
1011
1012				ret = process_filter(event, &arg, error_str, 0);
1013				if (ret != TEP_ERRNO__UNBALANCED_PAREN) {
1014					if (ret == 0) {
1015						show_error(error_str,
1016							   "Unbalanced number of '('");
1017						ret = TEP_ERRNO__UNBALANCED_PAREN;
1018					}
1019					goto fail;
1020				}
1021				ret = 0;
1022
1023				/* A not wants just one expression */
1024				if (not) {
1025					if (current_op)
1026						goto fail_syntax;
1027					*parg = arg;
1028					return 0;
1029				}
1030
1031				if (current_op)
1032					ret = add_right(current_op, arg, error_str);
1033				else
1034					current_exp = arg;
1035
1036				if (ret < 0)
1037					goto fail;
1038
1039			} else { /* ')' */
1040				if (!current_op && !current_exp)
1041					goto fail_syntax;
1042
1043				/* Make sure everything is finished at this level */
1044				if (current_exp && !check_op_done(current_exp))
1045					goto fail_syntax;
1046				if (current_op && !check_op_done(current_op))
1047					goto fail_syntax;
1048
1049				if (current_op)
1050					*parg = current_op;
1051				else
1052					*parg = current_exp;
1053				free(token);
1054				return TEP_ERRNO__UNBALANCED_PAREN;
1055			}
1056			break;
1057
1058		case TEP_EVENT_OP:
1059			op_type = process_op(token, &btype, &ctype, &etype);
1060
1061			/* All expect a left arg except for NOT */
1062			switch (op_type) {
1063			case OP_BOOL:
1064				/* Logic ops need a left expression */
1065				if (!current_exp && !current_op)
1066					goto fail_syntax;
1067				/* fall through */
1068			case OP_NOT:
1069				/* logic only processes ops and exp */
1070				if (left_item)
1071					goto fail_syntax;
1072				break;
1073			case OP_EXP:
1074			case OP_CMP:
1075				if (!left_item)
1076					goto fail_syntax;
1077				break;
1078			case OP_NONE:
1079				show_error(error_str,
1080					   "Unknown op token %s", token);
1081				ret = TEP_ERRNO__UNKNOWN_TOKEN;
1082				goto fail;
1083			}
1084
1085			ret = 0;
1086			switch (op_type) {
1087			case OP_BOOL:
1088				arg = create_arg_op(btype);
1089				if (arg == NULL)
1090					goto fail_alloc;
1091				if (current_op)
1092					ret = add_left(arg, current_op);
1093				else
1094					ret = add_left(arg, current_exp);
1095				current_op = arg;
1096				current_exp = NULL;
1097				break;
1098
1099			case OP_NOT:
1100				arg = create_arg_op(btype);
1101				if (arg == NULL)
1102					goto fail_alloc;
1103				if (current_op)
1104					ret = add_right(current_op, arg, error_str);
1105				if (ret < 0)
1106					goto fail;
1107				current_exp = arg;
1108				ret = process_filter(event, &arg, error_str, 1);
1109				if (ret < 0)
1110					goto fail;
1111				ret = add_right(current_exp, arg, error_str);
1112				if (ret < 0)
1113					goto fail;
1114				break;
1115
1116			case OP_EXP:
1117			case OP_CMP:
1118				if (op_type == OP_EXP)
1119					arg = create_arg_exp(etype);
1120				else
1121					arg = create_arg_cmp(ctype);
1122				if (arg == NULL)
1123					goto fail_alloc;
1124
1125				if (current_op)
1126					ret = add_right(current_op, arg, error_str);
1127				if (ret < 0)
1128					goto fail;
1129				ret = add_left(arg, left_item);
1130				if (ret < 0) {
1131					arg = NULL;
1132					goto fail_syntax;
1133				}
1134				current_exp = arg;
1135				break;
1136			default:
1137				break;
1138			}
1139			arg = NULL;
1140			if (ret < 0)
1141				goto fail_syntax;
1142			break;
1143		case TEP_EVENT_NONE:
1144			break;
1145		case TEP_EVENT_ERROR:
1146			goto fail_alloc;
1147		default:
1148			goto fail_syntax;
1149		}
1150	} while (type != TEP_EVENT_NONE);
1151
1152	if (!current_op && !current_exp)
1153		goto fail_syntax;
1154
1155	if (!current_op)
1156		current_op = current_exp;
1157
1158	ret = collapse_tree(current_op, parg, error_str);
1159	/* collapse_tree() may free current_op, and updates parg accordingly */
1160	current_op = NULL;
1161	if (ret < 0)
1162		goto fail;
1163
1164	free(token);
1165	return 0;
1166
1167 fail_alloc:
1168	show_error(error_str, "failed to allocate filter arg");
1169	ret = TEP_ERRNO__MEM_ALLOC_FAILED;
1170	goto fail;
1171 fail_syntax:
1172	show_error(error_str, "Syntax error");
1173	ret = TEP_ERRNO__SYNTAX_ERROR;
1174 fail:
1175	free_arg(current_op);
1176	free_arg(current_exp);
1177	free_arg(arg);
1178	free(token);
1179	return ret;
1180}
1181
1182static enum tep_errno
1183process_event(struct tep_event *event, const char *filter_str,
1184	      struct tep_filter_arg **parg, char *error_str)
1185{
1186	int ret;
1187
1188	tep_buffer_init(filter_str, strlen(filter_str));
1189
1190	ret = process_filter(event, parg, error_str, 0);
1191	if (ret < 0)
1192		return ret;
1193
1194	/* If parg is NULL, then make it into FALSE */
1195	if (!*parg) {
1196		*parg = allocate_arg();
1197		if (*parg == NULL)
1198			return TEP_ERRNO__MEM_ALLOC_FAILED;
1199
1200		(*parg)->type = TEP_FILTER_ARG_BOOLEAN;
1201		(*parg)->boolean.value = TEP_FILTER_FALSE;
1202	}
1203
1204	return 0;
1205}
1206
1207static enum tep_errno
1208filter_event(struct tep_event_filter *filter, struct tep_event *event,
1209	     const char *filter_str, char *error_str)
1210{
1211	struct tep_filter_type *filter_type;
1212	struct tep_filter_arg *arg;
1213	enum tep_errno ret;
1214
1215	if (filter_str) {
1216		ret = process_event(event, filter_str, &arg, error_str);
1217		if (ret < 0)
1218			return ret;
1219
1220	} else {
1221		/* just add a TRUE arg */
1222		arg = allocate_arg();
1223		if (arg == NULL)
1224			return TEP_ERRNO__MEM_ALLOC_FAILED;
1225
1226		arg->type = TEP_FILTER_ARG_BOOLEAN;
1227		arg->boolean.value = TEP_FILTER_TRUE;
1228	}
1229
1230	filter_type = add_filter_type(filter, event->id);
1231	if (filter_type == NULL) {
1232		free_arg(arg);
1233		return TEP_ERRNO__MEM_ALLOC_FAILED;
1234	}
1235
1236	if (filter_type->filter)
1237		free_arg(filter_type->filter);
1238	filter_type->filter = arg;
1239
1240	return 0;
1241}
1242
1243static void filter_init_error_buf(struct tep_event_filter *filter)
1244{
1245	/* clear buffer to reset show error */
1246	tep_buffer_init("", 0);
1247	filter->error_buffer[0] = '\0';
1248}
1249
1250/**
1251 * tep_filter_add_filter_str - add a new filter
1252 * @filter: the event filter to add to
1253 * @filter_str: the filter string that contains the filter
1254 *
1255 * Returns 0 if the filter was successfully added or a
1256 * negative error code.  Use tep_filter_strerror() to see
1257 * actual error message in case of error.
1258 */
1259enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter,
1260					 const char *filter_str)
1261{
1262	struct tep_handle *tep = filter->tep;
1263	struct event_list *event;
1264	struct event_list *events = NULL;
1265	const char *filter_start;
1266	const char *next_event;
1267	char *this_event;
1268	char *event_name = NULL;
1269	char *sys_name = NULL;
1270	char *sp;
1271	enum tep_errno rtn = 0; /* TEP_ERRNO__SUCCESS */
1272	int len;
1273	int ret;
1274
1275	filter_init_error_buf(filter);
1276
1277	filter_start = strchr(filter_str, ':');
1278	if (filter_start)
1279		len = filter_start - filter_str;
1280	else
1281		len = strlen(filter_str);
1282
1283	do {
1284		next_event = strchr(filter_str, ',');
1285		if (next_event &&
1286		    (!filter_start || next_event < filter_start))
1287			len = next_event - filter_str;
1288		else if (filter_start)
1289			len = filter_start - filter_str;
1290		else
1291			len = strlen(filter_str);
1292
1293		this_event = malloc(len + 1);
1294		if (this_event == NULL) {
1295			/* This can only happen when events is NULL, but still */
1296			free_events(events);
1297			return TEP_ERRNO__MEM_ALLOC_FAILED;
1298		}
1299		memcpy(this_event, filter_str, len);
1300		this_event[len] = 0;
1301
1302		if (next_event)
1303			next_event++;
1304
1305		filter_str = next_event;
1306
1307		sys_name = strtok_r(this_event, "/", &sp);
1308		event_name = strtok_r(NULL, "/", &sp);
1309
1310		if (!sys_name) {
1311			/* This can only happen when events is NULL, but still */
1312			free_events(events);
1313			free(this_event);
1314			return TEP_ERRNO__FILTER_NOT_FOUND;
1315		}
1316
1317		/* Find this event */
1318		ret = find_event(tep, &events, strim(sys_name), strim(event_name));
1319		if (ret < 0) {
1320			free_events(events);
1321			free(this_event);
1322			return ret;
1323		}
1324		free(this_event);
1325	} while (filter_str);
1326
1327	/* Skip the ':' */
1328	if (filter_start)
1329		filter_start++;
1330
1331	/* filter starts here */
1332	for (event = events; event; event = event->next) {
1333		ret = filter_event(filter, event->event, filter_start,
1334				   filter->error_buffer);
1335		/* Failures are returned if a parse error happened */
1336		if (ret < 0)
1337			rtn = ret;
1338
1339		if (ret >= 0 && tep->test_filters) {
1340			char *test;
1341			test = tep_filter_make_string(filter, event->event->id);
1342			if (test) {
1343				printf(" '%s: %s'\n", event->event->name, test);
1344				free(test);
1345			}
1346		}
1347	}
1348
1349	free_events(events);
1350
 
 
 
1351	return rtn;
1352}
1353
1354static void free_filter_type(struct tep_filter_type *filter_type)
1355{
1356	free_arg(filter_type->filter);
1357}
1358
1359/**
1360 * tep_filter_strerror - fill error message in a buffer
1361 * @filter: the event filter contains error
1362 * @err: the error code
1363 * @buf: the buffer to be filled in
1364 * @buflen: the size of the buffer
1365 *
1366 * Returns 0 if message was filled successfully, -1 if error
1367 */
1368int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err,
1369			char *buf, size_t buflen)
1370{
1371	if (err <= __TEP_ERRNO__START || err >= __TEP_ERRNO__END)
1372		return -1;
1373
1374	if (strlen(filter->error_buffer) > 0) {
1375		size_t len = snprintf(buf, buflen, "%s", filter->error_buffer);
1376
1377		if (len > buflen)
1378			return -1;
1379		return 0;
1380	}
1381
1382	return tep_strerror(filter->tep, err, buf, buflen);
1383}
1384
1385/**
1386 * tep_filter_remove_event - remove a filter for an event
1387 * @filter: the event filter to remove from
1388 * @event_id: the event to remove a filter for
1389 *
1390 * Removes the filter saved for an event defined by @event_id
1391 * from the @filter.
1392 *
1393 * Returns 1: if an event was removed
1394 *   0: if the event was not found
1395 */
1396int tep_filter_remove_event(struct tep_event_filter *filter,
1397			    int event_id)
1398{
1399	struct tep_filter_type *filter_type;
1400	unsigned long len;
1401
1402	if (!filter->filters)
1403		return 0;
1404
1405	filter_type = find_filter_type(filter, event_id);
1406
1407	if (!filter_type)
1408		return 0;
1409
1410	free_filter_type(filter_type);
1411
1412	/* The filter_type points into the event_filters array */
1413	len = (unsigned long)(filter->event_filters + filter->filters) -
1414		(unsigned long)(filter_type + 1);
1415
1416	memmove(filter_type, filter_type + 1, len);
1417	filter->filters--;
1418
1419	memset(&filter->event_filters[filter->filters], 0,
1420	       sizeof(*filter_type));
1421
1422	return 1;
1423}
1424
1425/**
1426 * tep_filter_reset - clear all filters in a filter
1427 * @filter: the event filter to reset
1428 *
1429 * Removes all filters from a filter and resets it.
1430 */
1431void tep_filter_reset(struct tep_event_filter *filter)
1432{
1433	int i;
1434
1435	for (i = 0; i < filter->filters; i++)
1436		free_filter_type(&filter->event_filters[i]);
1437
1438	free(filter->event_filters);
1439	filter->filters = 0;
1440	filter->event_filters = NULL;
1441}
1442
1443void tep_filter_free(struct tep_event_filter *filter)
1444{
1445	tep_unref(filter->tep);
1446
1447	tep_filter_reset(filter);
1448
1449	free(filter);
1450}
1451
1452static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg);
1453
1454static int copy_filter_type(struct tep_event_filter *filter,
1455			    struct tep_event_filter *source,
1456			    struct tep_filter_type *filter_type)
1457{
1458	struct tep_filter_arg *arg;
1459	struct tep_event *event;
1460	const char *sys;
1461	const char *name;
1462	char *str;
1463
1464	/* Can't assume that the tep's are the same */
1465	sys = filter_type->event->system;
1466	name = filter_type->event->name;
1467	event = tep_find_event_by_name(filter->tep, sys, name);
1468	if (!event)
1469		return -1;
1470
1471	str = arg_to_str(source, filter_type->filter);
1472	if (!str)
1473		return -1;
1474
1475	if (strcmp(str, "TRUE") == 0 || strcmp(str, "FALSE") == 0) {
1476		/* Add trivial event */
1477		arg = allocate_arg();
1478		if (arg == NULL) {
1479			free(str);
1480			return -1;
1481		}
1482
1483		arg->type = TEP_FILTER_ARG_BOOLEAN;
1484		if (strcmp(str, "TRUE") == 0)
1485			arg->boolean.value = 1;
1486		else
1487			arg->boolean.value = 0;
1488
1489		filter_type = add_filter_type(filter, event->id);
1490		if (filter_type == NULL) {
1491			free(str);
1492			free_arg(arg);
1493			return -1;
1494		}
1495
1496		filter_type->filter = arg;
1497
1498		free(str);
1499		return 0;
1500	}
1501
1502	filter_event(filter, event, str, NULL);
1503	free(str);
1504
1505	return 0;
1506}
1507
1508/**
1509 * tep_filter_copy - copy a filter using another filter
1510 * @dest - the filter to copy to
1511 * @source - the filter to copy from
1512 *
1513 * Returns 0 on success and -1 if not all filters were copied
1514 */
1515int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source)
1516{
1517	int ret = 0;
1518	int i;
1519
1520	tep_filter_reset(dest);
1521
1522	for (i = 0; i < source->filters; i++) {
1523		if (copy_filter_type(dest, source, &source->event_filters[i]))
1524			ret = -1;
1525	}
1526	return ret;
1527}
1528
1529static int test_filter(struct tep_event *event, struct tep_filter_arg *arg,
1530		       struct tep_record *record, enum tep_errno *err);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1531
1532static const char *
1533get_comm(struct tep_event *event, struct tep_record *record)
1534{
1535	const char *comm;
1536	int pid;
1537
1538	pid = tep_data_pid(event->tep, record);
1539	comm = tep_data_comm_from_pid(event->tep, pid);
1540	return comm;
1541}
1542
1543static unsigned long long
1544get_value(struct tep_event *event,
1545	  struct tep_format_field *field, struct tep_record *record)
1546{
1547	unsigned long long val;
1548
1549	/* Handle our dummy "comm" field */
1550	if (field == &comm) {
1551		const char *name;
1552
1553		name = get_comm(event, record);
1554		return (unsigned long)name;
1555	}
1556
1557	/* Handle our dummy "cpu" field */
1558	if (field == &cpu)
1559		return record->cpu;
1560
1561	tep_read_number_field(field, record->data, &val);
1562
1563	if (!(field->flags & TEP_FIELD_IS_SIGNED))
1564		return val;
1565
1566	switch (field->size) {
1567	case 1:
1568		return (char)val;
1569	case 2:
1570		return (short)val;
1571	case 4:
1572		return (int)val;
1573	case 8:
1574		return (long long)val;
1575	}
1576	return val;
1577}
1578
1579static unsigned long long
1580get_arg_value(struct tep_event *event, struct tep_filter_arg *arg,
1581	      struct tep_record *record, enum tep_errno *err);
1582
1583static unsigned long long
1584get_exp_value(struct tep_event *event, struct tep_filter_arg *arg,
1585	      struct tep_record *record, enum tep_errno *err)
1586{
1587	unsigned long long lval, rval;
1588
1589	lval = get_arg_value(event, arg->exp.left, record, err);
1590	rval = get_arg_value(event, arg->exp.right, record, err);
1591
1592	if (*err) {
1593		/*
1594		 * There was an error, no need to process anymore.
1595		 */
1596		return 0;
1597	}
1598
1599	switch (arg->exp.type) {
1600	case TEP_FILTER_EXP_ADD:
1601		return lval + rval;
1602
1603	case TEP_FILTER_EXP_SUB:
1604		return lval - rval;
1605
1606	case TEP_FILTER_EXP_MUL:
1607		return lval * rval;
1608
1609	case TEP_FILTER_EXP_DIV:
1610		return lval / rval;
1611
1612	case TEP_FILTER_EXP_MOD:
1613		return lval % rval;
1614
1615	case TEP_FILTER_EXP_RSHIFT:
1616		return lval >> rval;
1617
1618	case TEP_FILTER_EXP_LSHIFT:
1619		return lval << rval;
1620
1621	case TEP_FILTER_EXP_AND:
1622		return lval & rval;
1623
1624	case TEP_FILTER_EXP_OR:
1625		return lval | rval;
1626
1627	case TEP_FILTER_EXP_XOR:
1628		return lval ^ rval;
1629
1630	case TEP_FILTER_EXP_NOT:
1631	default:
1632		if (!*err)
1633			*err = TEP_ERRNO__INVALID_EXP_TYPE;
1634	}
1635	return 0;
1636}
1637
1638static unsigned long long
1639get_arg_value(struct tep_event *event, struct tep_filter_arg *arg,
1640	      struct tep_record *record, enum tep_errno *err)
1641{
1642	switch (arg->type) {
1643	case TEP_FILTER_ARG_FIELD:
1644		return get_value(event, arg->field.field, record);
1645
1646	case TEP_FILTER_ARG_VALUE:
1647		if (arg->value.type != TEP_FILTER_NUMBER) {
1648			if (!*err)
1649				*err = TEP_ERRNO__NOT_A_NUMBER;
1650		}
1651		return arg->value.val;
1652
1653	case TEP_FILTER_ARG_EXP:
1654		return get_exp_value(event, arg, record, err);
1655
1656	default:
1657		if (!*err)
1658			*err = TEP_ERRNO__INVALID_ARG_TYPE;
1659	}
1660	return 0;
1661}
1662
1663static int test_num(struct tep_event *event, struct tep_filter_arg *arg,
1664		    struct tep_record *record, enum tep_errno *err)
1665{
1666	unsigned long long lval, rval;
1667
1668	lval = get_arg_value(event, arg->num.left, record, err);
1669	rval = get_arg_value(event, arg->num.right, record, err);
1670
1671	if (*err) {
1672		/*
1673		 * There was an error, no need to process anymore.
1674		 */
1675		return 0;
1676	}
1677
1678	switch (arg->num.type) {
1679	case TEP_FILTER_CMP_EQ:
1680		return lval == rval;
1681
1682	case TEP_FILTER_CMP_NE:
1683		return lval != rval;
1684
1685	case TEP_FILTER_CMP_GT:
1686		return lval > rval;
1687
1688	case TEP_FILTER_CMP_LT:
1689		return lval < rval;
1690
1691	case TEP_FILTER_CMP_GE:
1692		return lval >= rval;
1693
1694	case TEP_FILTER_CMP_LE:
1695		return lval <= rval;
1696
1697	default:
1698		if (!*err)
1699			*err = TEP_ERRNO__ILLEGAL_INTEGER_CMP;
1700		return 0;
1701	}
1702}
1703
1704static const char *get_field_str(struct tep_filter_arg *arg, struct tep_record *record)
1705{
1706	struct tep_event *event;
1707	struct tep_handle *tep;
1708	unsigned long long addr;
1709	const char *val = NULL;
1710	unsigned int size;
1711	char hex[64];
1712
1713	/* If the field is not a string convert it */
1714	if (arg->str.field->flags & TEP_FIELD_IS_STRING) {
1715		val = record->data + arg->str.field->offset;
1716		size = arg->str.field->size;
1717
1718		if (arg->str.field->flags & TEP_FIELD_IS_DYNAMIC) {
1719			addr = *(unsigned int *)val;
1720			val = record->data + (addr & 0xffff);
1721			size = addr >> 16;
1722		}
1723
1724		/*
1725		 * We need to copy the data since we can't be sure the field
1726		 * is null terminated.
1727		 */
1728		if (*(val + size - 1)) {
1729			/* copy it */
1730			memcpy(arg->str.buffer, val, arg->str.field->size);
1731			/* the buffer is already NULL terminated */
1732			val = arg->str.buffer;
1733		}
1734
1735	} else {
1736		event = arg->str.field->event;
1737		tep = event->tep;
1738		addr = get_value(event, arg->str.field, record);
1739
1740		if (arg->str.field->flags & (TEP_FIELD_IS_POINTER | TEP_FIELD_IS_LONG))
1741			/* convert to a kernel symbol */
1742			val = tep_find_function(tep, addr);
1743
1744		if (val == NULL) {
1745			/* just use the hex of the string name */
1746			snprintf(hex, 64, "0x%llx", addr);
1747			val = hex;
1748		}
1749	}
1750
1751	return val;
1752}
1753
1754static int test_str(struct tep_event *event, struct tep_filter_arg *arg,
1755		    struct tep_record *record, enum tep_errno *err)
1756{
1757	const char *val;
1758
1759	if (arg->str.field == &comm)
1760		val = get_comm(event, record);
1761	else
1762		val = get_field_str(arg, record);
1763
1764	switch (arg->str.type) {
1765	case TEP_FILTER_CMP_MATCH:
1766		return strcmp(val, arg->str.val) == 0;
1767
1768	case TEP_FILTER_CMP_NOT_MATCH:
1769		return strcmp(val, arg->str.val) != 0;
1770
1771	case TEP_FILTER_CMP_REGEX:
1772		/* Returns zero on match */
1773		return !regexec(&arg->str.reg, val, 0, NULL, 0);
1774
1775	case TEP_FILTER_CMP_NOT_REGEX:
1776		return regexec(&arg->str.reg, val, 0, NULL, 0);
1777
1778	default:
1779		if (!*err)
1780			*err = TEP_ERRNO__ILLEGAL_STRING_CMP;
1781		return 0;
1782	}
1783}
1784
1785static int test_op(struct tep_event *event, struct tep_filter_arg *arg,
1786		   struct tep_record *record, enum tep_errno *err)
1787{
1788	switch (arg->op.type) {
1789	case TEP_FILTER_OP_AND:
1790		return test_filter(event, arg->op.left, record, err) &&
1791			test_filter(event, arg->op.right, record, err);
1792
1793	case TEP_FILTER_OP_OR:
1794		return test_filter(event, arg->op.left, record, err) ||
1795			test_filter(event, arg->op.right, record, err);
1796
1797	case TEP_FILTER_OP_NOT:
1798		return !test_filter(event, arg->op.right, record, err);
1799
1800	default:
1801		if (!*err)
1802			*err = TEP_ERRNO__INVALID_OP_TYPE;
1803		return 0;
1804	}
1805}
1806
1807static int test_filter(struct tep_event *event, struct tep_filter_arg *arg,
1808		       struct tep_record *record, enum tep_errno *err)
1809{
1810	if (*err) {
1811		/*
1812		 * There was an error, no need to process anymore.
1813		 */
1814		return 0;
1815	}
1816
1817	switch (arg->type) {
1818	case TEP_FILTER_ARG_BOOLEAN:
1819		/* easy case */
1820		return arg->boolean.value;
1821
1822	case TEP_FILTER_ARG_OP:
1823		return test_op(event, arg, record, err);
1824
1825	case TEP_FILTER_ARG_NUM:
1826		return test_num(event, arg, record, err);
1827
1828	case TEP_FILTER_ARG_STR:
1829		return test_str(event, arg, record, err);
1830
1831	case TEP_FILTER_ARG_EXP:
1832	case TEP_FILTER_ARG_VALUE:
1833	case TEP_FILTER_ARG_FIELD:
1834		/*
1835		 * Expressions, fields and values evaluate
1836		 * to true if they return non zero
1837		 */
1838		return !!get_arg_value(event, arg, record, err);
1839
1840	default:
1841		if (!*err)
1842			*err = TEP_ERRNO__INVALID_ARG_TYPE;
1843		return 0;
1844	}
1845}
1846
1847/**
1848 * tep_event_filtered - return true if event has filter
1849 * @filter: filter struct with filter information
1850 * @event_id: event id to test if filter exists
1851 *
1852 * Returns 1 if filter found for @event_id
1853 *   otherwise 0;
1854 */
1855int tep_event_filtered(struct tep_event_filter *filter, int event_id)
1856{
1857	struct tep_filter_type *filter_type;
1858
1859	if (!filter->filters)
1860		return 0;
1861
1862	filter_type = find_filter_type(filter, event_id);
1863
1864	return filter_type ? 1 : 0;
1865}
1866
1867/**
1868 * tep_filter_match - test if a record matches a filter
1869 * @filter: filter struct with filter information
1870 * @record: the record to test against the filter
1871 *
1872 * Returns: match result or error code (prefixed with TEP_ERRNO__)
1873 * FILTER_MATCH - filter found for event and @record matches
1874 * FILTER_MISS  - filter found for event and @record does not match
1875 * FILTER_NOT_FOUND - no filter found for @record's event
1876 * NO_FILTER - if no filters exist
1877 * otherwise - error occurred during test
1878 */
1879enum tep_errno tep_filter_match(struct tep_event_filter *filter,
1880				struct tep_record *record)
1881{
1882	struct tep_handle *tep = filter->tep;
1883	struct tep_filter_type *filter_type;
1884	int event_id;
1885	int ret;
1886	enum tep_errno err = 0;
1887
1888	filter_init_error_buf(filter);
1889
1890	if (!filter->filters)
1891		return TEP_ERRNO__NO_FILTER;
1892
1893	event_id = tep_data_type(tep, record);
1894
1895	filter_type = find_filter_type(filter, event_id);
1896	if (!filter_type)
1897		return TEP_ERRNO__FILTER_NOT_FOUND;
1898
1899	ret = test_filter(filter_type->event, filter_type->filter, record, &err);
1900	if (err)
1901		return err;
1902
1903	return ret ? TEP_ERRNO__FILTER_MATCH : TEP_ERRNO__FILTER_MISS;
1904}
1905
1906static char *op_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
1907{
1908	char *str = NULL;
1909	char *left = NULL;
1910	char *right = NULL;
1911	char *op = NULL;
1912	int left_val = -1;
1913	int right_val = -1;
1914	int val;
1915
1916	switch (arg->op.type) {
1917	case TEP_FILTER_OP_AND:
1918		op = "&&";
1919		/* fall through */
1920	case TEP_FILTER_OP_OR:
1921		if (!op)
1922			op = "||";
1923
1924		left = arg_to_str(filter, arg->op.left);
1925		right = arg_to_str(filter, arg->op.right);
1926		if (!left || !right)
1927			break;
1928
1929		/* Try to consolidate boolean values */
1930		if (strcmp(left, "TRUE") == 0)
1931			left_val = 1;
1932		else if (strcmp(left, "FALSE") == 0)
1933			left_val = 0;
1934
1935		if (strcmp(right, "TRUE") == 0)
1936			right_val = 1;
1937		else if (strcmp(right, "FALSE") == 0)
1938			right_val = 0;
1939
1940		if (left_val >= 0) {
1941			if ((arg->op.type == TEP_FILTER_OP_AND && !left_val) ||
1942			    (arg->op.type == TEP_FILTER_OP_OR && left_val)) {
1943				/* Just return left value */
1944				str = left;
1945				left = NULL;
1946				break;
1947			}
1948			if (right_val >= 0) {
1949				/* just evaluate this. */
1950				val = 0;
1951				switch (arg->op.type) {
1952				case TEP_FILTER_OP_AND:
1953					val = left_val && right_val;
1954					break;
1955				case TEP_FILTER_OP_OR:
1956					val = left_val || right_val;
1957					break;
1958				default:
1959					break;
1960				}
1961				if (asprintf(&str, val ? "TRUE" : "FALSE") < 0)
1962					str = NULL;
1963				break;
1964			}
1965		}
1966		if (right_val >= 0) {
1967			if ((arg->op.type == TEP_FILTER_OP_AND && !right_val) ||
1968			    (arg->op.type == TEP_FILTER_OP_OR && right_val)) {
1969				/* Just return right value */
1970				str = right;
1971				right = NULL;
1972				break;
1973			}
1974			/* The right value is meaningless */
1975			str = left;
1976			left = NULL;
1977			break;
1978		}
1979
1980		if (asprintf(&str, "(%s) %s (%s)", left, op, right) < 0)
1981			str = NULL;
1982		break;
1983
1984	case TEP_FILTER_OP_NOT:
1985		op = "!";
1986		right = arg_to_str(filter, arg->op.right);
1987		if (!right)
1988			break;
1989
1990		/* See if we can consolidate */
1991		if (strcmp(right, "TRUE") == 0)
1992			right_val = 1;
1993		else if (strcmp(right, "FALSE") == 0)
1994			right_val = 0;
1995		if (right_val >= 0) {
1996			/* just return the opposite */
1997			if (asprintf(&str, right_val ? "FALSE" : "TRUE") < 0)
1998				str = NULL;
1999			break;
2000		}
2001		if (asprintf(&str, "%s(%s)", op, right) < 0)
2002			str = NULL;
2003		break;
2004
2005	default:
2006		/* ?? */
2007		break;
2008	}
2009	free(left);
2010	free(right);
2011	return str;
2012}
2013
2014static char *val_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2015{
2016	char *str = NULL;
2017
2018	if (asprintf(&str, "%lld", arg->value.val) < 0)
2019		str = NULL;
2020
2021	return str;
2022}
2023
2024static char *field_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2025{
2026	return strdup(arg->field.field->name);
2027}
2028
2029static char *exp_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2030{
2031	char *lstr;
2032	char *rstr;
2033	char *op;
2034	char *str = NULL;
2035
2036	lstr = arg_to_str(filter, arg->exp.left);
2037	rstr = arg_to_str(filter, arg->exp.right);
2038	if (!lstr || !rstr)
2039		goto out;
2040
2041	switch (arg->exp.type) {
2042	case TEP_FILTER_EXP_ADD:
2043		op = "+";
2044		break;
2045	case TEP_FILTER_EXP_SUB:
2046		op = "-";
2047		break;
2048	case TEP_FILTER_EXP_MUL:
2049		op = "*";
2050		break;
2051	case TEP_FILTER_EXP_DIV:
2052		op = "/";
2053		break;
2054	case TEP_FILTER_EXP_MOD:
2055		op = "%";
2056		break;
2057	case TEP_FILTER_EXP_RSHIFT:
2058		op = ">>";
2059		break;
2060	case TEP_FILTER_EXP_LSHIFT:
2061		op = "<<";
2062		break;
2063	case TEP_FILTER_EXP_AND:
2064		op = "&";
2065		break;
2066	case TEP_FILTER_EXP_OR:
2067		op = "|";
2068		break;
2069	case TEP_FILTER_EXP_XOR:
2070		op = "^";
2071		break;
2072	default:
2073		op = "[ERROR IN EXPRESSION TYPE]";
2074		break;
2075	}
2076
2077	if (asprintf(&str, "%s %s %s", lstr, op, rstr) < 0)
2078		str = NULL;
2079out:
2080	free(lstr);
2081	free(rstr);
2082
2083	return str;
2084}
2085
2086static char *num_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2087{
2088	char *lstr;
2089	char *rstr;
2090	char *str = NULL;
2091	char *op = NULL;
2092
2093	lstr = arg_to_str(filter, arg->num.left);
2094	rstr = arg_to_str(filter, arg->num.right);
2095	if (!lstr || !rstr)
2096		goto out;
2097
2098	switch (arg->num.type) {
2099	case TEP_FILTER_CMP_EQ:
2100		op = "==";
2101		/* fall through */
2102	case TEP_FILTER_CMP_NE:
2103		if (!op)
2104			op = "!=";
2105		/* fall through */
2106	case TEP_FILTER_CMP_GT:
2107		if (!op)
2108			op = ">";
2109		/* fall through */
2110	case TEP_FILTER_CMP_LT:
2111		if (!op)
2112			op = "<";
2113		/* fall through */
2114	case TEP_FILTER_CMP_GE:
2115		if (!op)
2116			op = ">=";
2117		/* fall through */
2118	case TEP_FILTER_CMP_LE:
2119		if (!op)
2120			op = "<=";
2121
2122		if (asprintf(&str, "%s %s %s", lstr, op, rstr) < 0)
2123			str = NULL;
2124		break;
2125
2126	default:
2127		/* ?? */
2128		break;
2129	}
2130
2131out:
2132	free(lstr);
2133	free(rstr);
2134	return str;
2135}
2136
2137static char *str_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2138{
2139	char *str = NULL;
2140	char *op = NULL;
2141
2142	switch (arg->str.type) {
2143	case TEP_FILTER_CMP_MATCH:
2144		op = "==";
2145		/* fall through */
2146	case TEP_FILTER_CMP_NOT_MATCH:
2147		if (!op)
2148			op = "!=";
2149		/* fall through */
2150	case TEP_FILTER_CMP_REGEX:
2151		if (!op)
2152			op = "=~";
2153		/* fall through */
2154	case TEP_FILTER_CMP_NOT_REGEX:
2155		if (!op)
2156			op = "!~";
2157
2158		if (asprintf(&str, "%s %s \"%s\"",
2159			 arg->str.field->name, op, arg->str.val) < 0)
2160			str = NULL;
2161		break;
2162
2163	default:
2164		/* ?? */
2165		break;
2166	}
2167	return str;
2168}
2169
2170static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2171{
2172	char *str = NULL;
2173
2174	switch (arg->type) {
2175	case TEP_FILTER_ARG_BOOLEAN:
2176		if (asprintf(&str, arg->boolean.value ? "TRUE" : "FALSE") < 0)
2177			str = NULL;
2178		return str;
2179
2180	case TEP_FILTER_ARG_OP:
2181		return op_to_str(filter, arg);
2182
2183	case TEP_FILTER_ARG_NUM:
2184		return num_to_str(filter, arg);
2185
2186	case TEP_FILTER_ARG_STR:
2187		return str_to_str(filter, arg);
2188
2189	case TEP_FILTER_ARG_VALUE:
2190		return val_to_str(filter, arg);
2191
2192	case TEP_FILTER_ARG_FIELD:
2193		return field_to_str(filter, arg);
2194
2195	case TEP_FILTER_ARG_EXP:
2196		return exp_to_str(filter, arg);
2197
2198	default:
2199		/* ?? */
2200		return NULL;
2201	}
2202
2203}
2204
2205/**
2206 * tep_filter_make_string - return a string showing the filter
2207 * @filter: filter struct with filter information
2208 * @event_id: the event id to return the filter string with
2209 *
2210 * Returns a string that displays the filter contents.
2211 *  This string must be freed with free(str).
2212 *  NULL is returned if no filter is found or allocation failed.
2213 */
2214char *
2215tep_filter_make_string(struct tep_event_filter *filter, int event_id)
2216{
2217	struct tep_filter_type *filter_type;
2218
2219	if (!filter->filters)
2220		return NULL;
2221
2222	filter_type = find_filter_type(filter, event_id);
2223
2224	if (!filter_type)
2225		return NULL;
2226
2227	return arg_to_str(filter, filter_type->filter);
2228}
2229
2230/**
2231 * tep_filter_compare - compare two filters and return if they are the same
2232 * @filter1: Filter to compare with @filter2
2233 * @filter2: Filter to compare with @filter1
2234 *
2235 * Returns:
2236 *  1 if the two filters hold the same content.
2237 *  0 if they do not.
2238 */
2239int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2)
2240{
2241	struct tep_filter_type *filter_type1;
2242	struct tep_filter_type *filter_type2;
2243	char *str1, *str2;
2244	int result;
2245	int i;
2246
2247	/* Do the easy checks first */
2248	if (filter1->filters != filter2->filters)
2249		return 0;
2250	if (!filter1->filters && !filter2->filters)
2251		return 1;
2252
2253	/*
2254	 * Now take a look at each of the events to see if they have the same
2255	 * filters to them.
2256	 */
2257	for (i = 0; i < filter1->filters; i++) {
2258		filter_type1 = &filter1->event_filters[i];
2259		filter_type2 = find_filter_type(filter2, filter_type1->event_id);
2260		if (!filter_type2)
2261			break;
2262		if (filter_type1->filter->type != filter_type2->filter->type)
2263			break;
 
 
 
 
 
 
 
 
2264		/* The best way to compare complex filters is with strings */
2265		str1 = arg_to_str(filter1, filter_type1->filter);
2266		str2 = arg_to_str(filter2, filter_type2->filter);
2267		if (str1 && str2)
2268			result = strcmp(str1, str2) != 0;
2269		else
2270			/* bail out if allocation fails */
2271			result = 1;
2272
2273		free(str1);
2274		free(str2);
2275		if (result)
2276			break;
2277	}
2278
2279	if (i < filter1->filters)
2280		return 0;
2281	return 1;
2282}
2283