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