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