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