tools/lib/traceevent/parse-filter.c

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