tools/lib/traceevent/parse-filter.c

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