1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/module.h>
22#include <linux/ctype.h>
23#include <linux/mutex.h>
24#include <linux/perf_event.h>
25#include <linux/slab.h>
26
27#include "trace.h"
28#include "trace_output.h"
29
30enum filter_op_ids
31{
32 OP_OR,
33 OP_AND,
34 OP_GLOB,
35 OP_NE,
36 OP_EQ,
37 OP_LT,
38 OP_LE,
39 OP_GT,
40 OP_GE,
41 OP_NONE,
42 OP_OPEN_PAREN,
43};
44
45struct filter_op {
46 int id;
47 char *string;
48 int precedence;
49};
50
51static struct filter_op filter_ops[] = {
52 { OP_OR, "||", 1 },
53 { OP_AND, "&&", 2 },
54 { OP_GLOB, "~", 4 },
55 { OP_NE, "!=", 4 },
56 { OP_EQ, "==", 4 },
57 { OP_LT, "<", 5 },
58 { OP_LE, "<=", 5 },
59 { OP_GT, ">", 5 },
60 { OP_GE, ">=", 5 },
61 { OP_NONE, "OP_NONE", 0 },
62 { OP_OPEN_PAREN, "(", 0 },
63};
64
65enum {
66 FILT_ERR_NONE,
67 FILT_ERR_INVALID_OP,
68 FILT_ERR_UNBALANCED_PAREN,
69 FILT_ERR_TOO_MANY_OPERANDS,
70 FILT_ERR_OPERAND_TOO_LONG,
71 FILT_ERR_FIELD_NOT_FOUND,
72 FILT_ERR_ILLEGAL_FIELD_OP,
73 FILT_ERR_ILLEGAL_INTVAL,
74 FILT_ERR_BAD_SUBSYS_FILTER,
75 FILT_ERR_TOO_MANY_PREDS,
76 FILT_ERR_MISSING_FIELD,
77 FILT_ERR_INVALID_FILTER,
78};
79
80static char *err_text[] = {
81 "No error",
82 "Invalid operator",
83 "Unbalanced parens",
84 "Too many operands",
85 "Operand too long",
86 "Field not found",
87 "Illegal operation for field type",
88 "Illegal integer value",
89 "Couldn't find or set field in one of a subsystem's events",
90 "Too many terms in predicate expression",
91 "Missing field name and/or value",
92 "Meaningless filter expression",
93};
94
95struct opstack_op {
96 int op;
97 struct list_head list;
98};
99
100struct postfix_elt {
101 int op;
102 char *operand;
103 struct list_head list;
104};
105
106struct filter_parse_state {
107 struct filter_op *ops;
108 struct list_head opstack;
109 struct list_head postfix;
110 int lasterr;
111 int lasterr_pos;
112
113 struct {
114 char *string;
115 unsigned int cnt;
116 unsigned int tail;
117 } infix;
118
119 struct {
120 char string[MAX_FILTER_STR_VAL];
121 int pos;
122 unsigned int tail;
123 } operand;
124};
125
126#define DEFINE_COMPARISON_PRED(type) \
127static int filter_pred_##type(struct filter_pred *pred, void *event, \
128 int val1, int val2) \
129{ \
130 type *addr = (type *)(event + pred->offset); \
131 type val = (type)pred->val; \
132 int match = 0; \
133 \
134 switch (pred->op) { \
135 case OP_LT: \
136 match = (*addr < val); \
137 break; \
138 case OP_LE: \
139 match = (*addr <= val); \
140 break; \
141 case OP_GT: \
142 match = (*addr > val); \
143 break; \
144 case OP_GE: \
145 match = (*addr >= val); \
146 break; \
147 default: \
148 break; \
149 } \
150 \
151 return match; \
152}
153
154#define DEFINE_EQUALITY_PRED(size) \
155static int filter_pred_##size(struct filter_pred *pred, void *event, \
156 int val1, int val2) \
157{ \
158 u##size *addr = (u##size *)(event + pred->offset); \
159 u##size val = (u##size)pred->val; \
160 int match; \
161 \
162 match = (val == *addr) ^ pred->not; \
163 \
164 return match; \
165}
166
167DEFINE_COMPARISON_PRED(s64);
168DEFINE_COMPARISON_PRED(u64);
169DEFINE_COMPARISON_PRED(s32);
170DEFINE_COMPARISON_PRED(u32);
171DEFINE_COMPARISON_PRED(s16);
172DEFINE_COMPARISON_PRED(u16);
173DEFINE_COMPARISON_PRED(s8);
174DEFINE_COMPARISON_PRED(u8);
175
176DEFINE_EQUALITY_PRED(64);
177DEFINE_EQUALITY_PRED(32);
178DEFINE_EQUALITY_PRED(16);
179DEFINE_EQUALITY_PRED(8);
180
181static int filter_pred_and(struct filter_pred *pred __attribute((unused)),
182 void *event __attribute((unused)),
183 int val1, int val2)
184{
185 return val1 && val2;
186}
187
188static int filter_pred_or(struct filter_pred *pred __attribute((unused)),
189 void *event __attribute((unused)),
190 int val1, int val2)
191{
192 return val1 || val2;
193}
194
195
196static int filter_pred_string(struct filter_pred *pred, void *event,
197 int val1, int val2)
198{
199 char *addr = (char *)(event + pred->offset);
200 int cmp, match;
201
202 cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
203
204 match = cmp ^ pred->not;
205
206 return match;
207}
208
209
210static int filter_pred_pchar(struct filter_pred *pred, void *event,
211 int val1, int val2)
212{
213 char **addr = (char **)(event + pred->offset);
214 int cmp, match;
215 int len = strlen(*addr) + 1;
216
217 cmp = pred->regex.match(*addr, &pred->regex, len);
218
219 match = cmp ^ pred->not;
220
221 return match;
222}
223
224
225
226
227
228
229
230
231
232
233
234static int filter_pred_strloc(struct filter_pred *pred, void *event,
235 int val1, int val2)
236{
237 u32 str_item = *(u32 *)(event + pred->offset);
238 int str_loc = str_item & 0xffff;
239 int str_len = str_item >> 16;
240 char *addr = (char *)(event + str_loc);
241 int cmp, match;
242
243 cmp = pred->regex.match(addr, &pred->regex, str_len);
244
245 match = cmp ^ pred->not;
246
247 return match;
248}
249
250static int filter_pred_none(struct filter_pred *pred, void *event,
251 int val1, int val2)
252{
253 return 0;
254}
255
256
257
258
259
260
261
262
263
264
265
266
267
268static int regex_match_full(char *str, struct regex *r, int len)
269{
270 if (strncmp(str, r->pattern, len) == 0)
271 return 1;
272 return 0;
273}
274
275static int regex_match_front(char *str, struct regex *r, int len)
276{
277 if (strncmp(str, r->pattern, r->len) == 0)
278 return 1;
279 return 0;
280}
281
282static int regex_match_middle(char *str, struct regex *r, int len)
283{
284 if (strnstr(str, r->pattern, len))
285 return 1;
286 return 0;
287}
288
289static int regex_match_end(char *str, struct regex *r, int len)
290{
291 int strlen = len - 1;
292
293 if (strlen >= r->len &&
294 memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
295 return 1;
296 return 0;
297}
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
317{
318 int type = MATCH_FULL;
319 int i;
320
321 if (buff[0] == '!') {
322 *not = 1;
323 buff++;
324 len--;
325 } else
326 *not = 0;
327
328 *search = buff;
329
330 for (i = 0; i < len; i++) {
331 if (buff[i] == '*') {
332 if (!i) {
333 *search = buff + 1;
334 type = MATCH_END_ONLY;
335 } else {
336 if (type == MATCH_END_ONLY)
337 type = MATCH_MIDDLE_ONLY;
338 else
339 type = MATCH_FRONT_ONLY;
340 buff[i] = 0;
341 break;
342 }
343 }
344 }
345
346 return type;
347}
348
349static void filter_build_regex(struct filter_pred *pred)
350{
351 struct regex *r = &pred->regex;
352 char *search;
353 enum regex_type type = MATCH_FULL;
354 int not = 0;
355
356 if (pred->op == OP_GLOB) {
357 type = filter_parse_regex(r->pattern, r->len, &search, ¬);
358 r->len = strlen(search);
359 memmove(r->pattern, search, r->len+1);
360 }
361
362 switch (type) {
363 case MATCH_FULL:
364 r->match = regex_match_full;
365 break;
366 case MATCH_FRONT_ONLY:
367 r->match = regex_match_front;
368 break;
369 case MATCH_MIDDLE_ONLY:
370 r->match = regex_match_middle;
371 break;
372 case MATCH_END_ONLY:
373 r->match = regex_match_end;
374 break;
375 }
376
377 pred->not ^= not;
378}
379
380
381int filter_match_preds(struct event_filter *filter, void *rec)
382{
383 int match, top = 0, val1 = 0, val2 = 0;
384 int stack[MAX_FILTER_PRED];
385 struct filter_pred *pred;
386 int i;
387
388 for (i = 0; i < filter->n_preds; i++) {
389 pred = filter->preds[i];
390 if (!pred->pop_n) {
391 match = pred->fn(pred, rec, val1, val2);
392 stack[top++] = match;
393 continue;
394 }
395 if (pred->pop_n > top) {
396 WARN_ON_ONCE(1);
397 return 0;
398 }
399 val1 = stack[--top];
400 val2 = stack[--top];
401 match = pred->fn(pred, rec, val1, val2);
402 stack[top++] = match;
403 }
404
405 return stack[--top];
406}
407EXPORT_SYMBOL_GPL(filter_match_preds);
408
409static void parse_error(struct filter_parse_state *ps, int err, int pos)
410{
411 ps->lasterr = err;
412 ps->lasterr_pos = pos;
413}
414
415static void remove_filter_string(struct event_filter *filter)
416{
417 kfree(filter->filter_string);
418 filter->filter_string = NULL;
419}
420
421static int replace_filter_string(struct event_filter *filter,
422 char *filter_string)
423{
424 kfree(filter->filter_string);
425 filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
426 if (!filter->filter_string)
427 return -ENOMEM;
428
429 return 0;
430}
431
432static int append_filter_string(struct event_filter *filter,
433 char *string)
434{
435 int newlen;
436 char *new_filter_string;
437
438 BUG_ON(!filter->filter_string);
439 newlen = strlen(filter->filter_string) + strlen(string) + 1;
440 new_filter_string = kmalloc(newlen, GFP_KERNEL);
441 if (!new_filter_string)
442 return -ENOMEM;
443
444 strcpy(new_filter_string, filter->filter_string);
445 strcat(new_filter_string, string);
446 kfree(filter->filter_string);
447 filter->filter_string = new_filter_string;
448
449 return 0;
450}
451
452static void append_filter_err(struct filter_parse_state *ps,
453 struct event_filter *filter)
454{
455 int pos = ps->lasterr_pos;
456 char *buf, *pbuf;
457
458 buf = (char *)__get_free_page(GFP_TEMPORARY);
459 if (!buf)
460 return;
461
462 append_filter_string(filter, "\n");
463 memset(buf, ' ', PAGE_SIZE);
464 if (pos > PAGE_SIZE - 128)
465 pos = 0;
466 buf[pos] = '^';
467 pbuf = &buf[pos] + 1;
468
469 sprintf(pbuf, "\nparse_error: %s\n", err_text[ps->lasterr]);
470 append_filter_string(filter, buf);
471 free_page((unsigned long) buf);
472}
473
474void print_event_filter(struct ftrace_event_call *call, struct trace_seq *s)
475{
476 struct event_filter *filter = call->filter;
477
478 mutex_lock(&event_mutex);
479 if (filter && filter->filter_string)
480 trace_seq_printf(s, "%s\n", filter->filter_string);
481 else
482 trace_seq_printf(s, "none\n");
483 mutex_unlock(&event_mutex);
484}
485
486void print_subsystem_event_filter(struct event_subsystem *system,
487 struct trace_seq *s)
488{
489 struct event_filter *filter = system->filter;
490
491 mutex_lock(&event_mutex);
492 if (filter && filter->filter_string)
493 trace_seq_printf(s, "%s\n", filter->filter_string);
494 else
495 trace_seq_printf(s, "none\n");
496 mutex_unlock(&event_mutex);
497}
498
499static struct ftrace_event_field *
500__find_event_field(struct list_head *head, char *name)
501{
502 struct ftrace_event_field *field;
503
504 list_for_each_entry(field, head, link) {
505 if (!strcmp(field->name, name))
506 return field;
507 }
508
509 return NULL;
510}
511
512static struct ftrace_event_field *
513find_event_field(struct ftrace_event_call *call, char *name)
514{
515 struct ftrace_event_field *field;
516 struct list_head *head;
517
518 field = __find_event_field(&ftrace_common_fields, name);
519 if (field)
520 return field;
521
522 head = trace_get_fields(call);
523 return __find_event_field(head, name);
524}
525
526static void filter_free_pred(struct filter_pred *pred)
527{
528 if (!pred)
529 return;
530
531 kfree(pred->field_name);
532 kfree(pred);
533}
534
535static void filter_clear_pred(struct filter_pred *pred)
536{
537 kfree(pred->field_name);
538 pred->field_name = NULL;
539 pred->regex.len = 0;
540}
541
542static int filter_set_pred(struct filter_pred *dest,
543 struct filter_pred *src,
544 filter_pred_fn_t fn)
545{
546 *dest = *src;
547 if (src->field_name) {
548 dest->field_name = kstrdup(src->field_name, GFP_KERNEL);
549 if (!dest->field_name)
550 return -ENOMEM;
551 }
552 dest->fn = fn;
553
554 return 0;
555}
556
557static void filter_disable_preds(struct ftrace_event_call *call)
558{
559 struct event_filter *filter = call->filter;
560 int i;
561
562 call->flags &= ~TRACE_EVENT_FL_FILTERED;
563 filter->n_preds = 0;
564
565 for (i = 0; i < MAX_FILTER_PRED; i++)
566 filter->preds[i]->fn = filter_pred_none;
567}
568
569static void __free_preds(struct event_filter *filter)
570{
571 int i;
572
573 if (!filter)
574 return;
575
576 for (i = 0; i < MAX_FILTER_PRED; i++) {
577 if (filter->preds[i])
578 filter_free_pred(filter->preds[i]);
579 }
580 kfree(filter->preds);
581 kfree(filter->filter_string);
582 kfree(filter);
583}
584
585void destroy_preds(struct ftrace_event_call *call)
586{
587 __free_preds(call->filter);
588 call->filter = NULL;
589 call->flags &= ~TRACE_EVENT_FL_FILTERED;
590}
591
592static struct event_filter *__alloc_preds(void)
593{
594 struct event_filter *filter;
595 struct filter_pred *pred;
596 int i;
597
598 filter = kzalloc(sizeof(*filter), GFP_KERNEL);
599 if (!filter)
600 return ERR_PTR(-ENOMEM);
601
602 filter->n_preds = 0;
603
604 filter->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred), GFP_KERNEL);
605 if (!filter->preds)
606 goto oom;
607
608 for (i = 0; i < MAX_FILTER_PRED; i++) {
609 pred = kzalloc(sizeof(*pred), GFP_KERNEL);
610 if (!pred)
611 goto oom;
612 pred->fn = filter_pred_none;
613 filter->preds[i] = pred;
614 }
615
616 return filter;
617
618oom:
619 __free_preds(filter);
620 return ERR_PTR(-ENOMEM);
621}
622
623static int init_preds(struct ftrace_event_call *call)
624{
625 if (call->filter)
626 return 0;
627
628 call->flags &= ~TRACE_EVENT_FL_FILTERED;
629 call->filter = __alloc_preds();
630 if (IS_ERR(call->filter))
631 return PTR_ERR(call->filter);
632
633 return 0;
634}
635
636static int init_subsystem_preds(struct event_subsystem *system)
637{
638 struct ftrace_event_call *call;
639 int err;
640
641 list_for_each_entry(call, &ftrace_events, list) {
642 if (strcmp(call->class->system, system->name) != 0)
643 continue;
644
645 err = init_preds(call);
646 if (err)
647 return err;
648 }
649
650 return 0;
651}
652
653static void filter_free_subsystem_preds(struct event_subsystem *system)
654{
655 struct ftrace_event_call *call;
656
657 list_for_each_entry(call, &ftrace_events, list) {
658 if (strcmp(call->class->system, system->name) != 0)
659 continue;
660
661 filter_disable_preds(call);
662 remove_filter_string(call->filter);
663 }
664}
665
666static int filter_add_pred_fn(struct filter_parse_state *ps,
667 struct ftrace_event_call *call,
668 struct event_filter *filter,
669 struct filter_pred *pred,
670 filter_pred_fn_t fn)
671{
672 int idx, err;
673
674 if (filter->n_preds == MAX_FILTER_PRED) {
675 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
676 return -ENOSPC;
677 }
678
679 idx = filter->n_preds;
680 filter_clear_pred(filter->preds[idx]);
681 err = filter_set_pred(filter->preds[idx], pred, fn);
682 if (err)
683 return err;
684
685 filter->n_preds++;
686
687 return 0;
688}
689
690int filter_assign_type(const char *type)
691{
692 if (strstr(type, "__data_loc") && strstr(type, "char"))
693 return FILTER_DYN_STRING;
694
695 if (strchr(type, '[') && strstr(type, "char"))
696 return FILTER_STATIC_STRING;
697
698 return FILTER_OTHER;
699}
700
701static bool is_string_field(struct ftrace_event_field *field)
702{
703 return field->filter_type == FILTER_DYN_STRING ||
704 field->filter_type == FILTER_STATIC_STRING ||
705 field->filter_type == FILTER_PTR_STRING;
706}
707
708static int is_legal_op(struct ftrace_event_field *field, int op)
709{
710 if (is_string_field(field) &&
711 (op != OP_EQ && op != OP_NE && op != OP_GLOB))
712 return 0;
713 if (!is_string_field(field) && op == OP_GLOB)
714 return 0;
715
716 return 1;
717}
718
719static filter_pred_fn_t select_comparison_fn(int op, int field_size,
720 int field_is_signed)
721{
722 filter_pred_fn_t fn = NULL;
723
724 switch (field_size) {
725 case 8:
726 if (op == OP_EQ || op == OP_NE)
727 fn = filter_pred_64;
728 else if (field_is_signed)
729 fn = filter_pred_s64;
730 else
731 fn = filter_pred_u64;
732 break;
733 case 4:
734 if (op == OP_EQ || op == OP_NE)
735 fn = filter_pred_32;
736 else if (field_is_signed)
737 fn = filter_pred_s32;
738 else
739 fn = filter_pred_u32;
740 break;
741 case 2:
742 if (op == OP_EQ || op == OP_NE)
743 fn = filter_pred_16;
744 else if (field_is_signed)
745 fn = filter_pred_s16;
746 else
747 fn = filter_pred_u16;
748 break;
749 case 1:
750 if (op == OP_EQ || op == OP_NE)
751 fn = filter_pred_8;
752 else if (field_is_signed)
753 fn = filter_pred_s8;
754 else
755 fn = filter_pred_u8;
756 break;
757 }
758
759 return fn;
760}
761
762static int filter_add_pred(struct filter_parse_state *ps,
763 struct ftrace_event_call *call,
764 struct event_filter *filter,
765 struct filter_pred *pred,
766 bool dry_run)
767{
768 struct ftrace_event_field *field;
769 filter_pred_fn_t fn;
770 unsigned long long val;
771 int ret;
772
773 pred->fn = filter_pred_none;
774
775 if (pred->op == OP_AND) {
776 pred->pop_n = 2;
777 fn = filter_pred_and;
778 goto add_pred_fn;
779 } else if (pred->op == OP_OR) {
780 pred->pop_n = 2;
781 fn = filter_pred_or;
782 goto add_pred_fn;
783 }
784
785 field = find_event_field(call, pred->field_name);
786 if (!field) {
787 parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
788 return -EINVAL;
789 }
790
791 pred->offset = field->offset;
792
793 if (!is_legal_op(field, pred->op)) {
794 parse_error(ps, FILT_ERR_ILLEGAL_FIELD_OP, 0);
795 return -EINVAL;
796 }
797
798 if (is_string_field(field)) {
799 filter_build_regex(pred);
800
801 if (field->filter_type == FILTER_STATIC_STRING) {
802 fn = filter_pred_string;
803 pred->regex.field_len = field->size;
804 } else if (field->filter_type == FILTER_DYN_STRING)
805 fn = filter_pred_strloc;
806 else
807 fn = filter_pred_pchar;
808 } else {
809 if (field->is_signed)
810 ret = strict_strtoll(pred->regex.pattern, 0, &val);
811 else
812 ret = strict_strtoull(pred->regex.pattern, 0, &val);
813 if (ret) {
814 parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0);
815 return -EINVAL;
816 }
817 pred->val = val;
818
819 fn = select_comparison_fn(pred->op, field->size,
820 field->is_signed);
821 if (!fn) {
822 parse_error(ps, FILT_ERR_INVALID_OP, 0);
823 return -EINVAL;
824 }
825 }
826
827 if (pred->op == OP_NE)
828 pred->not = 1;
829
830add_pred_fn:
831 if (!dry_run)
832 return filter_add_pred_fn(ps, call, filter, pred, fn);
833 return 0;
834}
835
836static void parse_init(struct filter_parse_state *ps,
837 struct filter_op *ops,
838 char *infix_string)
839{
840 memset(ps, '\0', sizeof(*ps));
841
842 ps->infix.string = infix_string;
843 ps->infix.cnt = strlen(infix_string);
844 ps->ops = ops;
845
846 INIT_LIST_HEAD(&ps->opstack);
847 INIT_LIST_HEAD(&ps->postfix);
848}
849
850static char infix_next(struct filter_parse_state *ps)
851{
852 ps->infix.cnt--;
853
854 return ps->infix.string[ps->infix.tail++];
855}
856
857static char infix_peek(struct filter_parse_state *ps)
858{
859 if (ps->infix.tail == strlen(ps->infix.string))
860 return 0;
861
862 return ps->infix.string[ps->infix.tail];
863}
864
865static void infix_advance(struct filter_parse_state *ps)
866{
867 ps->infix.cnt--;
868 ps->infix.tail++;
869}
870
871static inline int is_precedence_lower(struct filter_parse_state *ps,
872 int a, int b)
873{
874 return ps->ops[a].precedence < ps->ops[b].precedence;
875}
876
877static inline int is_op_char(struct filter_parse_state *ps, char c)
878{
879 int i;
880
881 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
882 if (ps->ops[i].string[0] == c)
883 return 1;
884 }
885
886 return 0;
887}
888
889static int infix_get_op(struct filter_parse_state *ps, char firstc)
890{
891 char nextc = infix_peek(ps);
892 char opstr[3];
893 int i;
894
895 opstr[0] = firstc;
896 opstr[1] = nextc;
897 opstr[2] = '\0';
898
899 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
900 if (!strcmp(opstr, ps->ops[i].string)) {
901 infix_advance(ps);
902 return ps->ops[i].id;
903 }
904 }
905
906 opstr[1] = '\0';
907
908 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
909 if (!strcmp(opstr, ps->ops[i].string))
910 return ps->ops[i].id;
911 }
912
913 return OP_NONE;
914}
915
916static inline void clear_operand_string(struct filter_parse_state *ps)
917{
918 memset(ps->operand.string, '\0', MAX_FILTER_STR_VAL);
919 ps->operand.tail = 0;
920}
921
922static inline int append_operand_char(struct filter_parse_state *ps, char c)
923{
924 if (ps->operand.tail == MAX_FILTER_STR_VAL - 1)
925 return -EINVAL;
926
927 ps->operand.string[ps->operand.tail++] = c;
928
929 return 0;
930}
931
932static int filter_opstack_push(struct filter_parse_state *ps, int op)
933{
934 struct opstack_op *opstack_op;
935
936 opstack_op = kmalloc(sizeof(*opstack_op), GFP_KERNEL);
937 if (!opstack_op)
938 return -ENOMEM;
939
940 opstack_op->op = op;
941 list_add(&opstack_op->list, &ps->opstack);
942
943 return 0;
944}
945
946static int filter_opstack_empty(struct filter_parse_state *ps)
947{
948 return list_empty(&ps->opstack);
949}
950
951static int filter_opstack_top(struct filter_parse_state *ps)
952{
953 struct opstack_op *opstack_op;
954
955 if (filter_opstack_empty(ps))
956 return OP_NONE;
957
958 opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
959
960 return opstack_op->op;
961}
962
963static int filter_opstack_pop(struct filter_parse_state *ps)
964{
965 struct opstack_op *opstack_op;
966 int op;
967
968 if (filter_opstack_empty(ps))
969 return OP_NONE;
970
971 opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
972 op = opstack_op->op;
973 list_del(&opstack_op->list);
974
975 kfree(opstack_op);
976
977 return op;
978}
979
980static void filter_opstack_clear(struct filter_parse_state *ps)
981{
982 while (!filter_opstack_empty(ps))
983 filter_opstack_pop(ps);
984}
985
986static char *curr_operand(struct filter_parse_state *ps)
987{
988 return ps->operand.string;
989}
990
991static int postfix_append_operand(struct filter_parse_state *ps, char *operand)
992{
993 struct postfix_elt *elt;
994
995 elt = kmalloc(sizeof(*elt), GFP_KERNEL);
996 if (!elt)
997 return -ENOMEM;
998
999 elt->op = OP_NONE;
1000 elt->operand = kstrdup(operand, GFP_KERNEL);
1001 if (!elt->operand) {
1002 kfree(elt);
1003 return -ENOMEM;
1004 }
1005
1006 list_add_tail(&elt->list, &ps->postfix);
1007
1008 return 0;
1009}
1010
1011static int postfix_append_op(struct filter_parse_state *ps, int op)
1012{
1013 struct postfix_elt *elt;
1014
1015 elt = kmalloc(sizeof(*elt), GFP_KERNEL);
1016 if (!elt)
1017 return -ENOMEM;
1018
1019 elt->op = op;
1020 elt->operand = NULL;
1021
1022 list_add_tail(&elt->list, &ps->postfix);
1023
1024 return 0;
1025}
1026
1027static void postfix_clear(struct filter_parse_state *ps)
1028{
1029 struct postfix_elt *elt;
1030
1031 while (!list_empty(&ps->postfix)) {
1032 elt = list_first_entry(&ps->postfix, struct postfix_elt, list);
1033 list_del(&elt->list);
1034 kfree(elt->operand);
1035 kfree(elt);
1036 }
1037}
1038
1039static int filter_parse(struct filter_parse_state *ps)
1040{
1041 int in_string = 0;
1042 int op, top_op;
1043 char ch;
1044
1045 while ((ch = infix_next(ps))) {
1046 if (ch == '"') {
1047 in_string ^= 1;
1048 continue;
1049 }
1050
1051 if (in_string)
1052 goto parse_operand;
1053
1054 if (isspace(ch))
1055 continue;
1056
1057 if (is_op_char(ps, ch)) {
1058 op = infix_get_op(ps, ch);
1059 if (op == OP_NONE) {
1060 parse_error(ps, FILT_ERR_INVALID_OP, 0);
1061 return -EINVAL;
1062 }
1063
1064 if (strlen(curr_operand(ps))) {
1065 postfix_append_operand(ps, curr_operand(ps));
1066 clear_operand_string(ps);
1067 }
1068
1069 while (!filter_opstack_empty(ps)) {
1070 top_op = filter_opstack_top(ps);
1071 if (!is_precedence_lower(ps, top_op, op)) {
1072 top_op = filter_opstack_pop(ps);
1073 postfix_append_op(ps, top_op);
1074 continue;
1075 }
1076 break;
1077 }
1078
1079 filter_opstack_push(ps, op);
1080 continue;
1081 }
1082
1083 if (ch == '(') {
1084 filter_opstack_push(ps, OP_OPEN_PAREN);
1085 continue;
1086 }
1087
1088 if (ch == ')') {
1089 if (strlen(curr_operand(ps))) {
1090 postfix_append_operand(ps, curr_operand(ps));
1091 clear_operand_string(ps);
1092 }
1093
1094 top_op = filter_opstack_pop(ps);
1095 while (top_op != OP_NONE) {
1096 if (top_op == OP_OPEN_PAREN)
1097 break;
1098 postfix_append_op(ps, top_op);
1099 top_op = filter_opstack_pop(ps);
1100 }
1101 if (top_op == OP_NONE) {
1102 parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1103 return -EINVAL;
1104 }
1105 continue;
1106 }
1107parse_operand:
1108 if (append_operand_char(ps, ch)) {
1109 parse_error(ps, FILT_ERR_OPERAND_TOO_LONG, 0);
1110 return -EINVAL;
1111 }
1112 }
1113
1114 if (strlen(curr_operand(ps)))
1115 postfix_append_operand(ps, curr_operand(ps));
1116
1117 while (!filter_opstack_empty(ps)) {
1118 top_op = filter_opstack_pop(ps);
1119 if (top_op == OP_NONE)
1120 break;
1121 if (top_op == OP_OPEN_PAREN) {
1122 parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1123 return -EINVAL;
1124 }
1125 postfix_append_op(ps, top_op);
1126 }
1127
1128 return 0;
1129}
1130
1131static struct filter_pred *create_pred(int op, char *operand1, char *operand2)
1132{
1133 struct filter_pred *pred;
1134
1135 pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1136 if (!pred)
1137 return NULL;
1138
1139 pred->field_name = kstrdup(operand1, GFP_KERNEL);
1140 if (!pred->field_name) {
1141 kfree(pred);
1142 return NULL;
1143 }
1144
1145 strcpy(pred->regex.pattern, operand2);
1146 pred->regex.len = strlen(pred->regex.pattern);
1147
1148 pred->op = op;
1149
1150 return pred;
1151}
1152
1153static struct filter_pred *create_logical_pred(int op)
1154{
1155 struct filter_pred *pred;
1156
1157 pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1158 if (!pred)
1159 return NULL;
1160
1161 pred->op = op;
1162
1163 return pred;
1164}
1165
1166static int check_preds(struct filter_parse_state *ps)
1167{
1168 int n_normal_preds = 0, n_logical_preds = 0;
1169 struct postfix_elt *elt;
1170
1171 list_for_each_entry(elt, &ps->postfix, list) {
1172 if (elt->op == OP_NONE)
1173 continue;
1174
1175 if (elt->op == OP_AND || elt->op == OP_OR) {
1176 n_logical_preds++;
1177 continue;
1178 }
1179 n_normal_preds++;
1180 }
1181
1182 if (!n_normal_preds || n_logical_preds >= n_normal_preds) {
1183 parse_error(ps, FILT_ERR_INVALID_FILTER, 0);
1184 return -EINVAL;
1185 }
1186
1187 return 0;
1188}
1189
1190static int replace_preds(struct ftrace_event_call *call,
1191 struct event_filter *filter,
1192 struct filter_parse_state *ps,
1193 char *filter_string,
1194 bool dry_run)
1195{
1196 char *operand1 = NULL, *operand2 = NULL;
1197 struct filter_pred *pred;
1198 struct postfix_elt *elt;
1199 int err;
1200 int n_preds = 0;
1201
1202 err = check_preds(ps);
1203 if (err)
1204 return err;
1205
1206 list_for_each_entry(elt, &ps->postfix, list) {
1207 if (elt->op == OP_NONE) {
1208 if (!operand1)
1209 operand1 = elt->operand;
1210 else if (!operand2)
1211 operand2 = elt->operand;
1212 else {
1213 parse_error(ps, FILT_ERR_TOO_MANY_OPERANDS, 0);
1214 return -EINVAL;
1215 }
1216 continue;
1217 }
1218
1219 if (n_preds++ == MAX_FILTER_PRED) {
1220 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
1221 return -ENOSPC;
1222 }
1223
1224 if (elt->op == OP_AND || elt->op == OP_OR) {
1225 pred = create_logical_pred(elt->op);
1226 goto add_pred;
1227 }
1228
1229 if (!operand1 || !operand2) {
1230 parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
1231 return -EINVAL;
1232 }
1233
1234 pred = create_pred(elt->op, operand1, operand2);
1235add_pred:
1236 if (!pred)
1237 return -ENOMEM;
1238 err = filter_add_pred(ps, call, filter, pred, dry_run);
1239 filter_free_pred(pred);
1240 if (err)
1241 return err;
1242
1243 operand1 = operand2 = NULL;
1244 }
1245
1246 return 0;
1247}
1248
1249static int replace_system_preds(struct event_subsystem *system,
1250 struct filter_parse_state *ps,
1251 char *filter_string)
1252{
1253 struct ftrace_event_call *call;
1254 bool fail = true;
1255 int err;
1256
1257 list_for_each_entry(call, &ftrace_events, list) {
1258 struct event_filter *filter = call->filter;
1259
1260 if (strcmp(call->class->system, system->name) != 0)
1261 continue;
1262
1263
1264 err = replace_preds(call, filter, ps, filter_string, true);
1265 if (err)
1266 continue;
1267
1268
1269 filter_disable_preds(call);
1270 err = replace_preds(call, filter, ps, filter_string, false);
1271 if (err)
1272 filter_disable_preds(call);
1273 else {
1274 call->flags |= TRACE_EVENT_FL_FILTERED;
1275 replace_filter_string(filter, filter_string);
1276 }
1277 fail = false;
1278 }
1279
1280 if (fail) {
1281 parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1282 return -EINVAL;
1283 }
1284 return 0;
1285}
1286
1287int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
1288{
1289 int err;
1290 struct filter_parse_state *ps;
1291
1292 mutex_lock(&event_mutex);
1293
1294 err = init_preds(call);
1295 if (err)
1296 goto out_unlock;
1297
1298 if (!strcmp(strstrip(filter_string), "0")) {
1299 filter_disable_preds(call);
1300 remove_filter_string(call->filter);
1301 goto out_unlock;
1302 }
1303
1304 err = -ENOMEM;
1305 ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1306 if (!ps)
1307 goto out_unlock;
1308
1309 filter_disable_preds(call);
1310 replace_filter_string(call->filter, filter_string);
1311
1312 parse_init(ps, filter_ops, filter_string);
1313 err = filter_parse(ps);
1314 if (err) {
1315 append_filter_err(ps, call->filter);
1316 goto out;
1317 }
1318
1319 err = replace_preds(call, call->filter, ps, filter_string, false);
1320 if (err)
1321 append_filter_err(ps, call->filter);
1322 else
1323 call->flags |= TRACE_EVENT_FL_FILTERED;
1324out:
1325 filter_opstack_clear(ps);
1326 postfix_clear(ps);
1327 kfree(ps);
1328out_unlock:
1329 mutex_unlock(&event_mutex);
1330
1331 return err;
1332}
1333
1334int apply_subsystem_event_filter(struct event_subsystem *system,
1335 char *filter_string)
1336{
1337 int err;
1338 struct filter_parse_state *ps;
1339
1340 mutex_lock(&event_mutex);
1341
1342 err = init_subsystem_preds(system);
1343 if (err)
1344 goto out_unlock;
1345
1346 if (!strcmp(strstrip(filter_string), "0")) {
1347 filter_free_subsystem_preds(system);
1348 remove_filter_string(system->filter);
1349 goto out_unlock;
1350 }
1351
1352 err = -ENOMEM;
1353 ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1354 if (!ps)
1355 goto out_unlock;
1356
1357 replace_filter_string(system->filter, filter_string);
1358
1359 parse_init(ps, filter_ops, filter_string);
1360 err = filter_parse(ps);
1361 if (err) {
1362 append_filter_err(ps, system->filter);
1363 goto out;
1364 }
1365
1366 err = replace_system_preds(system, ps, filter_string);
1367 if (err)
1368 append_filter_err(ps, system->filter);
1369
1370out:
1371 filter_opstack_clear(ps);
1372 postfix_clear(ps);
1373 kfree(ps);
1374out_unlock:
1375 mutex_unlock(&event_mutex);
1376
1377 return err;
1378}
1379
1380#ifdef CONFIG_PERF_EVENTS
1381
1382void ftrace_profile_free_filter(struct perf_event *event)
1383{
1384 struct event_filter *filter = event->filter;
1385
1386 event->filter = NULL;
1387 __free_preds(filter);
1388}
1389
1390int ftrace_profile_set_filter(struct perf_event *event, int event_id,
1391 char *filter_str)
1392{
1393 int err;
1394 struct event_filter *filter;
1395 struct filter_parse_state *ps;
1396 struct ftrace_event_call *call = NULL;
1397
1398 mutex_lock(&event_mutex);
1399
1400 list_for_each_entry(call, &ftrace_events, list) {
1401 if (call->event.type == event_id)
1402 break;
1403 }
1404
1405 err = -EINVAL;
1406 if (&call->list == &ftrace_events)
1407 goto out_unlock;
1408
1409 err = -EEXIST;
1410 if (event->filter)
1411 goto out_unlock;
1412
1413 filter = __alloc_preds();
1414 if (IS_ERR(filter)) {
1415 err = PTR_ERR(filter);
1416 goto out_unlock;
1417 }
1418
1419 err = -ENOMEM;
1420 ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1421 if (!ps)
1422 goto free_preds;
1423
1424 parse_init(ps, filter_ops, filter_str);
1425 err = filter_parse(ps);
1426 if (err)
1427 goto free_ps;
1428
1429 err = replace_preds(call, filter, ps, filter_str, false);
1430 if (!err)
1431 event->filter = filter;
1432
1433free_ps:
1434 filter_opstack_clear(ps);
1435 postfix_clear(ps);
1436 kfree(ps);
1437
1438free_preds:
1439 if (err)
1440 __free_preds(filter);
1441
1442out_unlock:
1443 mutex_unlock(&event_mutex);
1444
1445 return err;
1446}
1447
1448#endif
1449
1450