1
2
3
4
5
6
7
8#include <linux/module.h>
9#include <linux/ctype.h>
10#include <linux/mutex.h>
11#include <linux/perf_event.h>
12#include <linux/slab.h>
13
14#include "trace.h"
15#include "trace_output.h"
16
17#define DEFAULT_SYS_FILTER_MESSAGE \
18 "### global filter ###\n" \
19 "# Use this to set filters for multiple events.\n" \
20 "# Only events with the given fields will be affected.\n" \
21 "# If no events are modified, an error message will be displayed here"
22
23
24#define OPS \
25 C( OP_GLOB, "~" ), \
26 C( OP_NE, "!=" ), \
27 C( OP_EQ, "==" ), \
28 C( OP_LE, "<=" ), \
29 C( OP_LT, "<" ), \
30 C( OP_GE, ">=" ), \
31 C( OP_GT, ">" ), \
32 C( OP_BAND, "&" ), \
33 C( OP_MAX, NULL )
34
35#undef C
36#define C(a, b) a
37
38enum filter_op_ids { OPS };
39
40#undef C
41#define C(a, b) b
42
43static const char * ops[] = { OPS };
44
45
46
47
48
49#define PRED_FUNC_START OP_LE
50#define PRED_FUNC_MAX (OP_BAND - PRED_FUNC_START)
51
52#define ERRORS \
53 C(NONE, "No error"), \
54 C(INVALID_OP, "Invalid operator"), \
55 C(TOO_MANY_OPEN, "Too many '('"), \
56 C(TOO_MANY_CLOSE, "Too few '('"), \
57 C(MISSING_QUOTE, "Missing matching quote"), \
58 C(OPERAND_TOO_LONG, "Operand too long"), \
59 C(EXPECT_STRING, "Expecting string field"), \
60 C(EXPECT_DIGIT, "Expecting numeric field"), \
61 C(ILLEGAL_FIELD_OP, "Illegal operation for field type"), \
62 C(FIELD_NOT_FOUND, "Field not found"), \
63 C(ILLEGAL_INTVAL, "Illegal integer value"), \
64 C(BAD_SUBSYS_FILTER, "Couldn't find or set field in one of a subsystem's events"), \
65 C(TOO_MANY_PREDS, "Too many terms in predicate expression"), \
66 C(INVALID_FILTER, "Meaningless filter expression"), \
67 C(IP_FIELD_ONLY, "Only 'ip' field is supported for function trace"), \
68 C(INVALID_VALUE, "Invalid value (did you forget quotes)?"), \
69 C(ERRNO, "Error"), \
70 C(NO_FILTER, "No filter found")
71
72#undef C
73#define C(a, b) FILT_ERR_##a
74
75enum { ERRORS };
76
77#undef C
78#define C(a, b) b
79
80static const char *err_text[] = { ERRORS };
81
82
83static bool is_not(const char *str)
84{
85 switch (str[1]) {
86 case '=':
87 case '~':
88 return false;
89 }
90 return true;
91}
92
93
94
95
96
97
98
99struct prog_entry {
100 int target;
101 int when_to_branch;
102 struct filter_pred *pred;
103};
104
105
106
107
108
109
110
111
112
113
114
115
116
117static void update_preds(struct prog_entry *prog, int N, int invert)
118{
119 int t, s;
120
121 t = prog[N].target;
122 s = prog[t].target;
123 prog[t].when_to_branch = invert;
124 prog[t].target = N;
125 prog[N].target = s;
126}
127
128struct filter_parse_error {
129 int lasterr;
130 int lasterr_pos;
131};
132
133static void parse_error(struct filter_parse_error *pe, int err, int pos)
134{
135 pe->lasterr = err;
136 pe->lasterr_pos = pos;
137}
138
139typedef int (*parse_pred_fn)(const char *str, void *data, int pos,
140 struct filter_parse_error *pe,
141 struct filter_pred **pred);
142
143enum {
144 INVERT = 1,
145 PROCESS_AND = 2,
146 PROCESS_OR = 4,
147};
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409static struct prog_entry *
410predicate_parse(const char *str, int nr_parens, int nr_preds,
411 parse_pred_fn parse_pred, void *data,
412 struct filter_parse_error *pe)
413{
414 struct prog_entry *prog_stack;
415 struct prog_entry *prog;
416 const char *ptr = str;
417 char *inverts = NULL;
418 int *op_stack;
419 int *top;
420 int invert = 0;
421 int ret = -ENOMEM;
422 int len;
423 int N = 0;
424 int i;
425
426 nr_preds += 2;
427
428 op_stack = kmalloc_array(nr_parens, sizeof(*op_stack), GFP_KERNEL);
429 if (!op_stack)
430 return ERR_PTR(-ENOMEM);
431 prog_stack = kcalloc(nr_preds, sizeof(*prog_stack), GFP_KERNEL);
432 if (!prog_stack) {
433 parse_error(pe, -ENOMEM, 0);
434 goto out_free;
435 }
436 inverts = kmalloc_array(nr_preds, sizeof(*inverts), GFP_KERNEL);
437 if (!inverts) {
438 parse_error(pe, -ENOMEM, 0);
439 goto out_free;
440 }
441
442 top = op_stack;
443 prog = prog_stack;
444 *top = 0;
445
446
447 while (*ptr) {
448 const char *next = ptr++;
449
450 if (isspace(*next))
451 continue;
452
453 switch (*next) {
454 case '(':
455 if (top - op_stack > nr_parens) {
456 ret = -EINVAL;
457 goto out_free;
458 }
459 *(++top) = invert;
460 continue;
461 case '!':
462 if (!is_not(next))
463 break;
464 invert = !invert;
465 continue;
466 }
467
468 if (N >= nr_preds) {
469 parse_error(pe, FILT_ERR_TOO_MANY_PREDS, next - str);
470 goto out_free;
471 }
472
473 inverts[N] = invert;
474 prog[N].target = N-1;
475
476 len = parse_pred(next, data, ptr - str, pe, &prog[N].pred);
477 if (len < 0) {
478 ret = len;
479 goto out_free;
480 }
481 ptr = next + len;
482
483 N++;
484
485 ret = -1;
486 while (1) {
487 next = ptr++;
488 if (isspace(*next))
489 continue;
490
491 switch (*next) {
492 case ')':
493 case '\0':
494 break;
495 case '&':
496 case '|':
497
498 if (next[1] == next[0]) {
499 ptr++;
500 break;
501 }
502 fallthrough;
503 default:
504 parse_error(pe, FILT_ERR_TOO_MANY_PREDS,
505 next - str);
506 goto out_free;
507 }
508
509 invert = *top & INVERT;
510
511 if (*top & PROCESS_AND) {
512 update_preds(prog, N - 1, invert);
513 *top &= ~PROCESS_AND;
514 }
515 if (*next == '&') {
516 *top |= PROCESS_AND;
517 break;
518 }
519 if (*top & PROCESS_OR) {
520 update_preds(prog, N - 1, !invert);
521 *top &= ~PROCESS_OR;
522 }
523 if (*next == '|') {
524 *top |= PROCESS_OR;
525 break;
526 }
527 if (!*next)
528 goto out;
529
530 if (top == op_stack) {
531 ret = -1;
532
533 parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, ptr - str);
534 goto out_free;
535 }
536 top--;
537 }
538 }
539 out:
540 if (top != op_stack) {
541
542 parse_error(pe, FILT_ERR_TOO_MANY_OPEN, ptr - str);
543 goto out_free;
544 }
545
546 if (!N) {
547
548 ret = -EINVAL;
549 parse_error(pe, FILT_ERR_NO_FILTER, ptr - str);
550 goto out_free;
551 }
552
553 prog[N].pred = NULL;
554 prog[N].target = 1;
555 prog[N+1].pred = NULL;
556 prog[N+1].target = 0;
557 prog[N-1].target = N;
558 prog[N-1].when_to_branch = false;
559
560
561 for (i = N-1 ; i--; ) {
562 int target = prog[i].target;
563 if (prog[i].when_to_branch == prog[target].when_to_branch)
564 prog[i].target = prog[target].target;
565 }
566
567
568 for (i = 0; i < N; i++) {
569 invert = inverts[i] ^ prog[i].when_to_branch;
570 prog[i].when_to_branch = invert;
571
572 if (WARN_ON(prog[i].target <= i)) {
573 ret = -EINVAL;
574 goto out_free;
575 }
576 }
577
578 kfree(op_stack);
579 kfree(inverts);
580 return prog;
581out_free:
582 kfree(op_stack);
583 kfree(inverts);
584 if (prog_stack) {
585 for (i = 0; prog_stack[i].pred; i++)
586 kfree(prog_stack[i].pred);
587 kfree(prog_stack);
588 }
589 return ERR_PTR(ret);
590}
591
592#define DEFINE_COMPARISON_PRED(type) \
593static int filter_pred_LT_##type(struct filter_pred *pred, void *event) \
594{ \
595 type *addr = (type *)(event + pred->offset); \
596 type val = (type)pred->val; \
597 return *addr < val; \
598} \
599static int filter_pred_LE_##type(struct filter_pred *pred, void *event) \
600{ \
601 type *addr = (type *)(event + pred->offset); \
602 type val = (type)pred->val; \
603 return *addr <= val; \
604} \
605static int filter_pred_GT_##type(struct filter_pred *pred, void *event) \
606{ \
607 type *addr = (type *)(event + pred->offset); \
608 type val = (type)pred->val; \
609 return *addr > val; \
610} \
611static int filter_pred_GE_##type(struct filter_pred *pred, void *event) \
612{ \
613 type *addr = (type *)(event + pred->offset); \
614 type val = (type)pred->val; \
615 return *addr >= val; \
616} \
617static int filter_pred_BAND_##type(struct filter_pred *pred, void *event) \
618{ \
619 type *addr = (type *)(event + pred->offset); \
620 type val = (type)pred->val; \
621 return !!(*addr & val); \
622} \
623static const filter_pred_fn_t pred_funcs_##type[] = { \
624 filter_pred_LE_##type, \
625 filter_pred_LT_##type, \
626 filter_pred_GE_##type, \
627 filter_pred_GT_##type, \
628 filter_pred_BAND_##type, \
629};
630
631#define DEFINE_EQUALITY_PRED(size) \
632static int filter_pred_##size(struct filter_pred *pred, void *event) \
633{ \
634 u##size *addr = (u##size *)(event + pred->offset); \
635 u##size val = (u##size)pred->val; \
636 int match; \
637 \
638 match = (val == *addr) ^ pred->not; \
639 \
640 return match; \
641}
642
643DEFINE_COMPARISON_PRED(s64);
644DEFINE_COMPARISON_PRED(u64);
645DEFINE_COMPARISON_PRED(s32);
646DEFINE_COMPARISON_PRED(u32);
647DEFINE_COMPARISON_PRED(s16);
648DEFINE_COMPARISON_PRED(u16);
649DEFINE_COMPARISON_PRED(s8);
650DEFINE_COMPARISON_PRED(u8);
651
652DEFINE_EQUALITY_PRED(64);
653DEFINE_EQUALITY_PRED(32);
654DEFINE_EQUALITY_PRED(16);
655DEFINE_EQUALITY_PRED(8);
656
657
658static int filter_pred_string(struct filter_pred *pred, void *event)
659{
660 char *addr = (char *)(event + pred->offset);
661 int cmp, match;
662
663 cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
664
665 match = cmp ^ pred->not;
666
667 return match;
668}
669
670
671static int filter_pred_pchar(struct filter_pred *pred, void *event)
672{
673 char **addr = (char **)(event + pred->offset);
674 int cmp, match;
675 int len = strlen(*addr) + 1;
676
677 cmp = pred->regex.match(*addr, &pred->regex, len);
678
679 match = cmp ^ pred->not;
680
681 return match;
682}
683
684
685
686
687
688
689
690
691
692
693
694static int filter_pred_strloc(struct filter_pred *pred, void *event)
695{
696 u32 str_item = *(u32 *)(event + pred->offset);
697 int str_loc = str_item & 0xffff;
698 int str_len = str_item >> 16;
699 char *addr = (char *)(event + str_loc);
700 int cmp, match;
701
702 cmp = pred->regex.match(addr, &pred->regex, str_len);
703
704 match = cmp ^ pred->not;
705
706 return match;
707}
708
709
710static int filter_pred_cpu(struct filter_pred *pred, void *event)
711{
712 int cpu, cmp;
713
714 cpu = raw_smp_processor_id();
715 cmp = pred->val;
716
717 switch (pred->op) {
718 case OP_EQ:
719 return cpu == cmp;
720 case OP_NE:
721 return cpu != cmp;
722 case OP_LT:
723 return cpu < cmp;
724 case OP_LE:
725 return cpu <= cmp;
726 case OP_GT:
727 return cpu > cmp;
728 case OP_GE:
729 return cpu >= cmp;
730 default:
731 return 0;
732 }
733}
734
735
736static int filter_pred_comm(struct filter_pred *pred, void *event)
737{
738 int cmp;
739
740 cmp = pred->regex.match(current->comm, &pred->regex,
741 TASK_COMM_LEN);
742 return cmp ^ pred->not;
743}
744
745static int filter_pred_none(struct filter_pred *pred, void *event)
746{
747 return 0;
748}
749
750
751
752
753
754
755
756
757
758
759
760
761
762static int regex_match_full(char *str, struct regex *r, int len)
763{
764
765 if (!len)
766 return strcmp(str, r->pattern) == 0;
767
768 return strncmp(str, r->pattern, len) == 0;
769}
770
771static int regex_match_front(char *str, struct regex *r, int len)
772{
773 if (len && len < r->len)
774 return 0;
775
776 return strncmp(str, r->pattern, r->len) == 0;
777}
778
779static int regex_match_middle(char *str, struct regex *r, int len)
780{
781 if (!len)
782 return strstr(str, r->pattern) != NULL;
783
784 return strnstr(str, r->pattern, len) != NULL;
785}
786
787static int regex_match_end(char *str, struct regex *r, int len)
788{
789 int strlen = len - 1;
790
791 if (strlen >= r->len &&
792 memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
793 return 1;
794 return 0;
795}
796
797static int regex_match_glob(char *str, struct regex *r, int len __maybe_unused)
798{
799 if (glob_match(r->pattern, str))
800 return 1;
801 return 0;
802}
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
822{
823 int type = MATCH_FULL;
824 int i;
825
826 if (buff[0] == '!') {
827 *not = 1;
828 buff++;
829 len--;
830 } else
831 *not = 0;
832
833 *search = buff;
834
835 if (isdigit(buff[0]))
836 return MATCH_INDEX;
837
838 for (i = 0; i < len; i++) {
839 if (buff[i] == '*') {
840 if (!i) {
841 type = MATCH_END_ONLY;
842 } else if (i == len - 1) {
843 if (type == MATCH_END_ONLY)
844 type = MATCH_MIDDLE_ONLY;
845 else
846 type = MATCH_FRONT_ONLY;
847 buff[i] = 0;
848 break;
849 } else {
850 return MATCH_GLOB;
851 }
852 } else if (strchr("[?\\", buff[i])) {
853 return MATCH_GLOB;
854 }
855 }
856 if (buff[0] == '*')
857 *search = buff + 1;
858
859 return type;
860}
861
862static void filter_build_regex(struct filter_pred *pred)
863{
864 struct regex *r = &pred->regex;
865 char *search;
866 enum regex_type type = MATCH_FULL;
867
868 if (pred->op == OP_GLOB) {
869 type = filter_parse_regex(r->pattern, r->len, &search, &pred->not);
870 r->len = strlen(search);
871 memmove(r->pattern, search, r->len+1);
872 }
873
874 switch (type) {
875
876 case MATCH_INDEX:
877 case MATCH_FULL:
878 r->match = regex_match_full;
879 break;
880 case MATCH_FRONT_ONLY:
881 r->match = regex_match_front;
882 break;
883 case MATCH_MIDDLE_ONLY:
884 r->match = regex_match_middle;
885 break;
886 case MATCH_END_ONLY:
887 r->match = regex_match_end;
888 break;
889 case MATCH_GLOB:
890 r->match = regex_match_glob;
891 break;
892 }
893}
894
895
896int filter_match_preds(struct event_filter *filter, void *rec)
897{
898 struct prog_entry *prog;
899 int i;
900
901
902 if (!filter)
903 return 1;
904
905
906 prog = rcu_dereference_raw(filter->prog);
907 if (!prog)
908 return 1;
909
910 for (i = 0; prog[i].pred; i++) {
911 struct filter_pred *pred = prog[i].pred;
912 int match = pred->fn(pred, rec);
913 if (match == prog[i].when_to_branch)
914 i = prog[i].target;
915 }
916 return prog[i].target;
917}
918EXPORT_SYMBOL_GPL(filter_match_preds);
919
920static void remove_filter_string(struct event_filter *filter)
921{
922 if (!filter)
923 return;
924
925 kfree(filter->filter_string);
926 filter->filter_string = NULL;
927}
928
929static void append_filter_err(struct trace_array *tr,
930 struct filter_parse_error *pe,
931 struct event_filter *filter)
932{
933 struct trace_seq *s;
934 int pos = pe->lasterr_pos;
935 char *buf;
936 int len;
937
938 if (WARN_ON(!filter->filter_string))
939 return;
940
941 s = kmalloc(sizeof(*s), GFP_KERNEL);
942 if (!s)
943 return;
944 trace_seq_init(s);
945
946 len = strlen(filter->filter_string);
947 if (pos > len)
948 pos = len;
949
950
951 if (pos)
952 pos++;
953
954 trace_seq_puts(s, filter->filter_string);
955 if (pe->lasterr > 0) {
956 trace_seq_printf(s, "\n%*s", pos, "^");
957 trace_seq_printf(s, "\nparse_error: %s\n", err_text[pe->lasterr]);
958 tracing_log_err(tr, "event filter parse error",
959 filter->filter_string, err_text,
960 pe->lasterr, pe->lasterr_pos);
961 } else {
962 trace_seq_printf(s, "\nError: (%d)\n", pe->lasterr);
963 tracing_log_err(tr, "event filter parse error",
964 filter->filter_string, err_text,
965 FILT_ERR_ERRNO, 0);
966 }
967 trace_seq_putc(s, 0);
968 buf = kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL);
969 if (buf) {
970 kfree(filter->filter_string);
971 filter->filter_string = buf;
972 }
973 kfree(s);
974}
975
976static inline struct event_filter *event_filter(struct trace_event_file *file)
977{
978 return file->filter;
979}
980
981
982void print_event_filter(struct trace_event_file *file, struct trace_seq *s)
983{
984 struct event_filter *filter = event_filter(file);
985
986 if (filter && filter->filter_string)
987 trace_seq_printf(s, "%s\n", filter->filter_string);
988 else
989 trace_seq_puts(s, "none\n");
990}
991
992void print_subsystem_event_filter(struct event_subsystem *system,
993 struct trace_seq *s)
994{
995 struct event_filter *filter;
996
997 mutex_lock(&event_mutex);
998 filter = system->filter;
999 if (filter && filter->filter_string)
1000 trace_seq_printf(s, "%s\n", filter->filter_string);
1001 else
1002 trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
1003 mutex_unlock(&event_mutex);
1004}
1005
1006static void free_prog(struct event_filter *filter)
1007{
1008 struct prog_entry *prog;
1009 int i;
1010
1011 prog = rcu_access_pointer(filter->prog);
1012 if (!prog)
1013 return;
1014
1015 for (i = 0; prog[i].pred; i++)
1016 kfree(prog[i].pred);
1017 kfree(prog);
1018}
1019
1020static void filter_disable(struct trace_event_file *file)
1021{
1022 unsigned long old_flags = file->flags;
1023
1024 file->flags &= ~EVENT_FILE_FL_FILTERED;
1025
1026 if (old_flags != file->flags)
1027 trace_buffered_event_disable();
1028}
1029
1030static void __free_filter(struct event_filter *filter)
1031{
1032 if (!filter)
1033 return;
1034
1035 free_prog(filter);
1036 kfree(filter->filter_string);
1037 kfree(filter);
1038}
1039
1040void free_event_filter(struct event_filter *filter)
1041{
1042 __free_filter(filter);
1043}
1044
1045static inline void __remove_filter(struct trace_event_file *file)
1046{
1047 filter_disable(file);
1048 remove_filter_string(file->filter);
1049}
1050
1051static void filter_free_subsystem_preds(struct trace_subsystem_dir *dir,
1052 struct trace_array *tr)
1053{
1054 struct trace_event_file *file;
1055
1056 list_for_each_entry(file, &tr->events, list) {
1057 if (file->system != dir)
1058 continue;
1059 __remove_filter(file);
1060 }
1061}
1062
1063static inline void __free_subsystem_filter(struct trace_event_file *file)
1064{
1065 __free_filter(file->filter);
1066 file->filter = NULL;
1067}
1068
1069static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir,
1070 struct trace_array *tr)
1071{
1072 struct trace_event_file *file;
1073
1074 list_for_each_entry(file, &tr->events, list) {
1075 if (file->system != dir)
1076 continue;
1077 __free_subsystem_filter(file);
1078 }
1079}
1080
1081int filter_assign_type(const char *type)
1082{
1083 if (strstr(type, "__data_loc") && strstr(type, "char"))
1084 return FILTER_DYN_STRING;
1085
1086 if (strchr(type, '[') && strstr(type, "char"))
1087 return FILTER_STATIC_STRING;
1088
1089 if (strcmp(type, "char *") == 0 || strcmp(type, "const char *") == 0)
1090 return FILTER_PTR_STRING;
1091
1092 return FILTER_OTHER;
1093}
1094
1095static filter_pred_fn_t select_comparison_fn(enum filter_op_ids op,
1096 int field_size, int field_is_signed)
1097{
1098 filter_pred_fn_t fn = NULL;
1099 int pred_func_index = -1;
1100
1101 switch (op) {
1102 case OP_EQ:
1103 case OP_NE:
1104 break;
1105 default:
1106 if (WARN_ON_ONCE(op < PRED_FUNC_START))
1107 return NULL;
1108 pred_func_index = op - PRED_FUNC_START;
1109 if (WARN_ON_ONCE(pred_func_index > PRED_FUNC_MAX))
1110 return NULL;
1111 }
1112
1113 switch (field_size) {
1114 case 8:
1115 if (pred_func_index < 0)
1116 fn = filter_pred_64;
1117 else if (field_is_signed)
1118 fn = pred_funcs_s64[pred_func_index];
1119 else
1120 fn = pred_funcs_u64[pred_func_index];
1121 break;
1122 case 4:
1123 if (pred_func_index < 0)
1124 fn = filter_pred_32;
1125 else if (field_is_signed)
1126 fn = pred_funcs_s32[pred_func_index];
1127 else
1128 fn = pred_funcs_u32[pred_func_index];
1129 break;
1130 case 2:
1131 if (pred_func_index < 0)
1132 fn = filter_pred_16;
1133 else if (field_is_signed)
1134 fn = pred_funcs_s16[pred_func_index];
1135 else
1136 fn = pred_funcs_u16[pred_func_index];
1137 break;
1138 case 1:
1139 if (pred_func_index < 0)
1140 fn = filter_pred_8;
1141 else if (field_is_signed)
1142 fn = pred_funcs_s8[pred_func_index];
1143 else
1144 fn = pred_funcs_u8[pred_func_index];
1145 break;
1146 }
1147
1148 return fn;
1149}
1150
1151
1152static int parse_pred(const char *str, void *data,
1153 int pos, struct filter_parse_error *pe,
1154 struct filter_pred **pred_ptr)
1155{
1156 struct trace_event_call *call = data;
1157 struct ftrace_event_field *field;
1158 struct filter_pred *pred = NULL;
1159 char num_buf[24];
1160 char *field_name;
1161 char q;
1162 u64 val;
1163 int len;
1164 int ret;
1165 int op;
1166 int s;
1167 int i = 0;
1168
1169
1170 while (isspace(str[i]))
1171 i++;
1172 s = i;
1173
1174 while (isalnum(str[i]) || str[i] == '_')
1175 i++;
1176
1177 len = i - s;
1178
1179 if (!len)
1180 return -1;
1181
1182 field_name = kmemdup_nul(str + s, len, GFP_KERNEL);
1183 if (!field_name)
1184 return -ENOMEM;
1185
1186
1187
1188 field = trace_find_event_field(call, field_name);
1189 kfree(field_name);
1190 if (!field) {
1191 parse_error(pe, FILT_ERR_FIELD_NOT_FOUND, pos + i);
1192 return -EINVAL;
1193 }
1194
1195 while (isspace(str[i]))
1196 i++;
1197
1198
1199 for (op = 0; ops[op]; op++) {
1200
1201 if (strncmp(str + i, ops[op], strlen(ops[op])) == 0)
1202 break;
1203 }
1204
1205 if (!ops[op]) {
1206 parse_error(pe, FILT_ERR_INVALID_OP, pos + i);
1207 goto err_free;
1208 }
1209
1210 i += strlen(ops[op]);
1211
1212 while (isspace(str[i]))
1213 i++;
1214
1215 s = i;
1216
1217 pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1218 if (!pred)
1219 return -ENOMEM;
1220
1221 pred->field = field;
1222 pred->offset = field->offset;
1223 pred->op = op;
1224
1225 if (ftrace_event_is_function(call)) {
1226
1227
1228
1229
1230
1231
1232
1233 if (strcmp(field->name, "ip") != 0) {
1234 parse_error(pe, FILT_ERR_IP_FIELD_ONLY, pos + i);
1235 goto err_free;
1236 }
1237 pred->fn = filter_pred_none;
1238
1239
1240
1241
1242
1243 if (str[i] == '\'' || str[i] == '"')
1244 q = str[i];
1245 else
1246 q = 0;
1247
1248 for (i++; str[i]; i++) {
1249 if (q && str[i] == q)
1250 break;
1251 if (!q && (str[i] == ')' || str[i] == '&' ||
1252 str[i] == '|'))
1253 break;
1254 }
1255
1256 if (q)
1257 s++;
1258 len = i - s;
1259 if (len >= MAX_FILTER_STR_VAL) {
1260 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1261 goto err_free;
1262 }
1263
1264 pred->regex.len = len;
1265 strncpy(pred->regex.pattern, str + s, len);
1266 pred->regex.pattern[len] = 0;
1267
1268
1269 } else if (str[i] == '\'' || str[i] == '"') {
1270 char q = str[i];
1271
1272
1273 switch (op) {
1274 case OP_NE:
1275 pred->not = 1;
1276 fallthrough;
1277 case OP_GLOB:
1278 case OP_EQ:
1279 break;
1280 default:
1281 parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1282 goto err_free;
1283 }
1284
1285
1286 if (!is_string_field(field)) {
1287 parse_error(pe, FILT_ERR_EXPECT_DIGIT, pos + i);
1288 goto err_free;
1289 }
1290
1291 for (i++; str[i]; i++) {
1292 if (str[i] == q)
1293 break;
1294 }
1295 if (!str[i]) {
1296 parse_error(pe, FILT_ERR_MISSING_QUOTE, pos + i);
1297 goto err_free;
1298 }
1299
1300
1301 s++;
1302 len = i - s;
1303 if (len >= MAX_FILTER_STR_VAL) {
1304 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1305 goto err_free;
1306 }
1307
1308 pred->regex.len = len;
1309 strncpy(pred->regex.pattern, str + s, len);
1310 pred->regex.pattern[len] = 0;
1311
1312 filter_build_regex(pred);
1313
1314 if (field->filter_type == FILTER_COMM) {
1315 pred->fn = filter_pred_comm;
1316
1317 } else if (field->filter_type == FILTER_STATIC_STRING) {
1318 pred->fn = filter_pred_string;
1319 pred->regex.field_len = field->size;
1320
1321 } else if (field->filter_type == FILTER_DYN_STRING)
1322 pred->fn = filter_pred_strloc;
1323 else
1324 pred->fn = filter_pred_pchar;
1325
1326 i++;
1327
1328 } else if (isdigit(str[i]) || str[i] == '-') {
1329
1330
1331 if (is_string_field(field)) {
1332 parse_error(pe, FILT_ERR_EXPECT_STRING, pos + i);
1333 goto err_free;
1334 }
1335
1336 if (op == OP_GLOB) {
1337 parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1338 goto err_free;
1339 }
1340
1341 if (str[i] == '-')
1342 i++;
1343
1344
1345 while (isalnum(str[i]))
1346 i++;
1347
1348 len = i - s;
1349
1350 if (len >= sizeof(num_buf)) {
1351 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1352 goto err_free;
1353 }
1354
1355 strncpy(num_buf, str + s, len);
1356 num_buf[len] = 0;
1357
1358
1359 if (field->is_signed)
1360 ret = kstrtoll(num_buf, 0, &val);
1361 else
1362 ret = kstrtoull(num_buf, 0, &val);
1363 if (ret) {
1364 parse_error(pe, FILT_ERR_ILLEGAL_INTVAL, pos + s);
1365 goto err_free;
1366 }
1367
1368 pred->val = val;
1369
1370 if (field->filter_type == FILTER_CPU)
1371 pred->fn = filter_pred_cpu;
1372 else {
1373 pred->fn = select_comparison_fn(pred->op, field->size,
1374 field->is_signed);
1375 if (pred->op == OP_NE)
1376 pred->not = 1;
1377 }
1378
1379 } else {
1380 parse_error(pe, FILT_ERR_INVALID_VALUE, pos + i);
1381 goto err_free;
1382 }
1383
1384 *pred_ptr = pred;
1385 return i;
1386
1387err_free:
1388 kfree(pred);
1389 return -EINVAL;
1390}
1391
1392enum {
1393 TOO_MANY_CLOSE = -1,
1394 TOO_MANY_OPEN = -2,
1395 MISSING_QUOTE = -3,
1396};
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408static int calc_stack(const char *str, int *parens, int *preds, int *err)
1409{
1410 bool is_pred = false;
1411 int nr_preds = 0;
1412 int open = 1;
1413 int last_quote = 0;
1414 int max_open = 1;
1415 int quote = 0;
1416 int i;
1417
1418 *err = 0;
1419
1420 for (i = 0; str[i]; i++) {
1421 if (isspace(str[i]))
1422 continue;
1423 if (quote) {
1424 if (str[i] == quote)
1425 quote = 0;
1426 continue;
1427 }
1428
1429 switch (str[i]) {
1430 case '\'':
1431 case '"':
1432 quote = str[i];
1433 last_quote = i;
1434 break;
1435 case '|':
1436 case '&':
1437 if (str[i+1] != str[i])
1438 break;
1439 is_pred = false;
1440 continue;
1441 case '(':
1442 is_pred = false;
1443 open++;
1444 if (open > max_open)
1445 max_open = open;
1446 continue;
1447 case ')':
1448 is_pred = false;
1449 if (open == 1) {
1450 *err = i;
1451 return TOO_MANY_CLOSE;
1452 }
1453 open--;
1454 continue;
1455 }
1456 if (!is_pred) {
1457 nr_preds++;
1458 is_pred = true;
1459 }
1460 }
1461
1462 if (quote) {
1463 *err = last_quote;
1464 return MISSING_QUOTE;
1465 }
1466
1467 if (open != 1) {
1468 int level = open;
1469
1470
1471 for (i--; i; i--) {
1472 if (quote) {
1473 if (str[i] == quote)
1474 quote = 0;
1475 continue;
1476 }
1477 switch (str[i]) {
1478 case '(':
1479 if (level == open) {
1480 *err = i;
1481 return TOO_MANY_OPEN;
1482 }
1483 level--;
1484 break;
1485 case ')':
1486 level++;
1487 break;
1488 case '\'':
1489 case '"':
1490 quote = str[i];
1491 break;
1492 }
1493 }
1494
1495 *err = 0;
1496 return TOO_MANY_OPEN;
1497 }
1498
1499
1500 *parens = max_open;
1501 *preds = nr_preds;
1502 return 0;
1503}
1504
1505static int process_preds(struct trace_event_call *call,
1506 const char *filter_string,
1507 struct event_filter *filter,
1508 struct filter_parse_error *pe)
1509{
1510 struct prog_entry *prog;
1511 int nr_parens;
1512 int nr_preds;
1513 int index;
1514 int ret;
1515
1516 ret = calc_stack(filter_string, &nr_parens, &nr_preds, &index);
1517 if (ret < 0) {
1518 switch (ret) {
1519 case MISSING_QUOTE:
1520 parse_error(pe, FILT_ERR_MISSING_QUOTE, index);
1521 break;
1522 case TOO_MANY_OPEN:
1523 parse_error(pe, FILT_ERR_TOO_MANY_OPEN, index);
1524 break;
1525 default:
1526 parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, index);
1527 }
1528 return ret;
1529 }
1530
1531 if (!nr_preds)
1532 return -EINVAL;
1533
1534 prog = predicate_parse(filter_string, nr_parens, nr_preds,
1535 parse_pred, call, pe);
1536 if (IS_ERR(prog))
1537 return PTR_ERR(prog);
1538
1539 rcu_assign_pointer(filter->prog, prog);
1540 return 0;
1541}
1542
1543static inline void event_set_filtered_flag(struct trace_event_file *file)
1544{
1545 unsigned long old_flags = file->flags;
1546
1547 file->flags |= EVENT_FILE_FL_FILTERED;
1548
1549 if (old_flags != file->flags)
1550 trace_buffered_event_enable();
1551}
1552
1553static inline void event_set_filter(struct trace_event_file *file,
1554 struct event_filter *filter)
1555{
1556 rcu_assign_pointer(file->filter, filter);
1557}
1558
1559static inline void event_clear_filter(struct trace_event_file *file)
1560{
1561 RCU_INIT_POINTER(file->filter, NULL);
1562}
1563
1564struct filter_list {
1565 struct list_head list;
1566 struct event_filter *filter;
1567};
1568
1569static int process_system_preds(struct trace_subsystem_dir *dir,
1570 struct trace_array *tr,
1571 struct filter_parse_error *pe,
1572 char *filter_string)
1573{
1574 struct trace_event_file *file;
1575 struct filter_list *filter_item;
1576 struct event_filter *filter = NULL;
1577 struct filter_list *tmp;
1578 LIST_HEAD(filter_list);
1579 bool fail = true;
1580 int err;
1581
1582 list_for_each_entry(file, &tr->events, list) {
1583
1584 if (file->system != dir)
1585 continue;
1586
1587 filter = kzalloc(sizeof(*filter), GFP_KERNEL);
1588 if (!filter)
1589 goto fail_mem;
1590
1591 filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
1592 if (!filter->filter_string)
1593 goto fail_mem;
1594
1595 err = process_preds(file->event_call, filter_string, filter, pe);
1596 if (err) {
1597 filter_disable(file);
1598 parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1599 append_filter_err(tr, pe, filter);
1600 } else
1601 event_set_filtered_flag(file);
1602
1603
1604 filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL);
1605 if (!filter_item)
1606 goto fail_mem;
1607
1608 list_add_tail(&filter_item->list, &filter_list);
1609
1610
1611
1612
1613 filter_item->filter = event_filter(file);
1614 event_set_filter(file, filter);
1615 filter = NULL;
1616
1617 fail = false;
1618 }
1619
1620 if (fail)
1621 goto fail;
1622
1623
1624
1625
1626
1627
1628 tracepoint_synchronize_unregister();
1629 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1630 __free_filter(filter_item->filter);
1631 list_del(&filter_item->list);
1632 kfree(filter_item);
1633 }
1634 return 0;
1635 fail:
1636
1637 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1638 list_del(&filter_item->list);
1639 kfree(filter_item);
1640 }
1641 parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1642 return -EINVAL;
1643 fail_mem:
1644 __free_filter(filter);
1645
1646 if (!fail)
1647 tracepoint_synchronize_unregister();
1648 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1649 __free_filter(filter_item->filter);
1650 list_del(&filter_item->list);
1651 kfree(filter_item);
1652 }
1653 return -ENOMEM;
1654}
1655
1656static int create_filter_start(char *filter_string, bool set_str,
1657 struct filter_parse_error **pse,
1658 struct event_filter **filterp)
1659{
1660 struct event_filter *filter;
1661 struct filter_parse_error *pe = NULL;
1662 int err = 0;
1663
1664 if (WARN_ON_ONCE(*pse || *filterp))
1665 return -EINVAL;
1666
1667 filter = kzalloc(sizeof(*filter), GFP_KERNEL);
1668 if (filter && set_str) {
1669 filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
1670 if (!filter->filter_string)
1671 err = -ENOMEM;
1672 }
1673
1674 pe = kzalloc(sizeof(*pe), GFP_KERNEL);
1675
1676 if (!filter || !pe || err) {
1677 kfree(pe);
1678 __free_filter(filter);
1679 return -ENOMEM;
1680 }
1681
1682
1683 *filterp = filter;
1684 *pse = pe;
1685
1686 return 0;
1687}
1688
1689static void create_filter_finish(struct filter_parse_error *pe)
1690{
1691 kfree(pe);
1692}
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712static int create_filter(struct trace_array *tr,
1713 struct trace_event_call *call,
1714 char *filter_string, bool set_str,
1715 struct event_filter **filterp)
1716{
1717 struct filter_parse_error *pe = NULL;
1718 int err;
1719
1720
1721 if (WARN_ON(*filterp))
1722 *filterp = NULL;
1723
1724 err = create_filter_start(filter_string, set_str, &pe, filterp);
1725 if (err)
1726 return err;
1727
1728 err = process_preds(call, filter_string, *filterp, pe);
1729 if (err && set_str)
1730 append_filter_err(tr, pe, *filterp);
1731 create_filter_finish(pe);
1732
1733 return err;
1734}
1735
1736int create_event_filter(struct trace_array *tr,
1737 struct trace_event_call *call,
1738 char *filter_str, bool set_str,
1739 struct event_filter **filterp)
1740{
1741 return create_filter(tr, call, filter_str, set_str, filterp);
1742}
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753static int create_system_filter(struct trace_subsystem_dir *dir,
1754 char *filter_str, struct event_filter **filterp)
1755{
1756 struct filter_parse_error *pe = NULL;
1757 int err;
1758
1759 err = create_filter_start(filter_str, true, &pe, filterp);
1760 if (!err) {
1761 err = process_system_preds(dir, dir->tr, pe, filter_str);
1762 if (!err) {
1763
1764 kfree((*filterp)->filter_string);
1765 (*filterp)->filter_string = NULL;
1766 } else {
1767 append_filter_err(dir->tr, pe, *filterp);
1768 }
1769 }
1770 create_filter_finish(pe);
1771
1772 return err;
1773}
1774
1775
1776int apply_event_filter(struct trace_event_file *file, char *filter_string)
1777{
1778 struct trace_event_call *call = file->event_call;
1779 struct event_filter *filter = NULL;
1780 int err;
1781
1782 if (!strcmp(strstrip(filter_string), "0")) {
1783 filter_disable(file);
1784 filter = event_filter(file);
1785
1786 if (!filter)
1787 return 0;
1788
1789 event_clear_filter(file);
1790
1791
1792 tracepoint_synchronize_unregister();
1793 __free_filter(filter);
1794
1795 return 0;
1796 }
1797
1798 err = create_filter(file->tr, call, filter_string, true, &filter);
1799
1800
1801
1802
1803
1804
1805
1806 if (filter) {
1807 struct event_filter *tmp;
1808
1809 tmp = event_filter(file);
1810 if (!err)
1811 event_set_filtered_flag(file);
1812 else
1813 filter_disable(file);
1814
1815 event_set_filter(file, filter);
1816
1817 if (tmp) {
1818
1819 tracepoint_synchronize_unregister();
1820 __free_filter(tmp);
1821 }
1822 }
1823
1824 return err;
1825}
1826
1827int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
1828 char *filter_string)
1829{
1830 struct event_subsystem *system = dir->subsystem;
1831 struct trace_array *tr = dir->tr;
1832 struct event_filter *filter = NULL;
1833 int err = 0;
1834
1835 mutex_lock(&event_mutex);
1836
1837
1838 if (!dir->nr_events) {
1839 err = -ENODEV;
1840 goto out_unlock;
1841 }
1842
1843 if (!strcmp(strstrip(filter_string), "0")) {
1844 filter_free_subsystem_preds(dir, tr);
1845 remove_filter_string(system->filter);
1846 filter = system->filter;
1847 system->filter = NULL;
1848
1849 tracepoint_synchronize_unregister();
1850 filter_free_subsystem_filters(dir, tr);
1851 __free_filter(filter);
1852 goto out_unlock;
1853 }
1854
1855 err = create_system_filter(dir, filter_string, &filter);
1856 if (filter) {
1857
1858
1859
1860
1861 __free_filter(system->filter);
1862 system->filter = filter;
1863 }
1864out_unlock:
1865 mutex_unlock(&event_mutex);
1866
1867 return err;
1868}
1869
1870#ifdef CONFIG_PERF_EVENTS
1871
1872void ftrace_profile_free_filter(struct perf_event *event)
1873{
1874 struct event_filter *filter = event->filter;
1875
1876 event->filter = NULL;
1877 __free_filter(filter);
1878}
1879
1880struct function_filter_data {
1881 struct ftrace_ops *ops;
1882 int first_filter;
1883 int first_notrace;
1884};
1885
1886#ifdef CONFIG_FUNCTION_TRACER
1887static char **
1888ftrace_function_filter_re(char *buf, int len, int *count)
1889{
1890 char *str, **re;
1891
1892 str = kstrndup(buf, len, GFP_KERNEL);
1893 if (!str)
1894 return NULL;
1895
1896
1897
1898
1899
1900 strreplace(str, ',', ' ');
1901
1902 re = argv_split(GFP_KERNEL, str, count);
1903 kfree(str);
1904 return re;
1905}
1906
1907static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
1908 int reset, char *re, int len)
1909{
1910 int ret;
1911
1912 if (filter)
1913 ret = ftrace_set_filter(ops, re, len, reset);
1914 else
1915 ret = ftrace_set_notrace(ops, re, len, reset);
1916
1917 return ret;
1918}
1919
1920static int __ftrace_function_set_filter(int filter, char *buf, int len,
1921 struct function_filter_data *data)
1922{
1923 int i, re_cnt, ret = -EINVAL;
1924 int *reset;
1925 char **re;
1926
1927 reset = filter ? &data->first_filter : &data->first_notrace;
1928
1929
1930
1931
1932
1933
1934 re = ftrace_function_filter_re(buf, len, &re_cnt);
1935 if (!re)
1936 return -EINVAL;
1937
1938 for (i = 0; i < re_cnt; i++) {
1939 ret = ftrace_function_set_regexp(data->ops, filter, *reset,
1940 re[i], strlen(re[i]));
1941 if (ret)
1942 break;
1943
1944 if (*reset)
1945 *reset = 0;
1946 }
1947
1948 argv_free(re);
1949 return ret;
1950}
1951
1952static int ftrace_function_check_pred(struct filter_pred *pred)
1953{
1954 struct ftrace_event_field *field = pred->field;
1955
1956
1957
1958
1959
1960
1961 if ((pred->op != OP_EQ) && (pred->op != OP_NE))
1962 return -EINVAL;
1963
1964 if (strcmp(field->name, "ip"))
1965 return -EINVAL;
1966
1967 return 0;
1968}
1969
1970static int ftrace_function_set_filter_pred(struct filter_pred *pred,
1971 struct function_filter_data *data)
1972{
1973 int ret;
1974
1975
1976 ret = ftrace_function_check_pred(pred);
1977 if (ret)
1978 return ret;
1979
1980 return __ftrace_function_set_filter(pred->op == OP_EQ,
1981 pred->regex.pattern,
1982 pred->regex.len,
1983 data);
1984}
1985
1986static bool is_or(struct prog_entry *prog, int i)
1987{
1988 int target;
1989
1990
1991
1992
1993
1994
1995 target = prog[i].target + 1;
1996
1997 if (prog[target].pred)
1998 return false;
1999
2000
2001 return prog[i].when_to_branch == prog[target].target;
2002}
2003
2004static int ftrace_function_set_filter(struct perf_event *event,
2005 struct event_filter *filter)
2006{
2007 struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2008 lockdep_is_held(&event_mutex));
2009 struct function_filter_data data = {
2010 .first_filter = 1,
2011 .first_notrace = 1,
2012 .ops = &event->ftrace_ops,
2013 };
2014 int i;
2015
2016 for (i = 0; prog[i].pred; i++) {
2017 struct filter_pred *pred = prog[i].pred;
2018
2019 if (!is_or(prog, i))
2020 return -EINVAL;
2021
2022 if (ftrace_function_set_filter_pred(pred, &data) < 0)
2023 return -EINVAL;
2024 }
2025 return 0;
2026}
2027#else
2028static int ftrace_function_set_filter(struct perf_event *event,
2029 struct event_filter *filter)
2030{
2031 return -ENODEV;
2032}
2033#endif
2034
2035int ftrace_profile_set_filter(struct perf_event *event, int event_id,
2036 char *filter_str)
2037{
2038 int err;
2039 struct event_filter *filter = NULL;
2040 struct trace_event_call *call;
2041
2042 mutex_lock(&event_mutex);
2043
2044 call = event->tp_event;
2045
2046 err = -EINVAL;
2047 if (!call)
2048 goto out_unlock;
2049
2050 err = -EEXIST;
2051 if (event->filter)
2052 goto out_unlock;
2053
2054 err = create_filter(NULL, call, filter_str, false, &filter);
2055 if (err)
2056 goto free_filter;
2057
2058 if (ftrace_event_is_function(call))
2059 err = ftrace_function_set_filter(event, filter);
2060 else
2061 event->filter = filter;
2062
2063free_filter:
2064 if (err || ftrace_event_is_function(call))
2065 __free_filter(filter);
2066
2067out_unlock:
2068 mutex_unlock(&event_mutex);
2069
2070 return err;
2071}
2072
2073#endif
2074
2075#ifdef CONFIG_FTRACE_STARTUP_TEST
2076
2077#include <linux/types.h>
2078#include <linux/tracepoint.h>
2079
2080#define CREATE_TRACE_POINTS
2081#include "trace_events_filter_test.h"
2082
2083#define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
2084{ \
2085 .filter = FILTER, \
2086 .rec = { .a = va, .b = vb, .c = vc, .d = vd, \
2087 .e = ve, .f = vf, .g = vg, .h = vh }, \
2088 .match = m, \
2089 .not_visited = nvisit, \
2090}
2091#define YES 1
2092#define NO 0
2093
2094static struct test_filter_data_t {
2095 char *filter;
2096 struct trace_event_raw_ftrace_test_filter rec;
2097 int match;
2098 char *not_visited;
2099} test_filter_data[] = {
2100#define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
2101 "e == 1 && f == 1 && g == 1 && h == 1"
2102 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
2103 DATA_REC(NO, 0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
2104 DATA_REC(NO, 1, 1, 1, 1, 1, 1, 1, 0, ""),
2105#undef FILTER
2106#define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
2107 "e == 1 || f == 1 || g == 1 || h == 1"
2108 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
2109 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2110 DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
2111#undef FILTER
2112#define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
2113 "(e == 1 || f == 1) && (g == 1 || h == 1)"
2114 DATA_REC(NO, 0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
2115 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2116 DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
2117 DATA_REC(NO, 1, 0, 1, 0, 0, 1, 0, 0, "bd"),
2118#undef FILTER
2119#define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
2120 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2121 DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
2122 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
2123 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2124#undef FILTER
2125#define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
2126 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2127 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
2128 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2129 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
2130#undef FILTER
2131#define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
2132 "(e == 1 || f == 1)) && (g == 1 || h == 1)"
2133 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
2134 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
2135 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
2136#undef FILTER
2137#define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
2138 "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
2139 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
2140 DATA_REC(NO, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2141 DATA_REC(NO, 1, 0, 1, 0, 1, 0, 1, 0, ""),
2142#undef FILTER
2143#define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
2144 "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
2145 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
2146 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2147 DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
2148};
2149
2150#undef DATA_REC
2151#undef FILTER
2152#undef YES
2153#undef NO
2154
2155#define DATA_CNT ARRAY_SIZE(test_filter_data)
2156
2157static int test_pred_visited;
2158
2159static int test_pred_visited_fn(struct filter_pred *pred, void *event)
2160{
2161 struct ftrace_event_field *field = pred->field;
2162
2163 test_pred_visited = 1;
2164 printk(KERN_INFO "\npred visited %s\n", field->name);
2165 return 1;
2166}
2167
2168static void update_pred_fn(struct event_filter *filter, char *fields)
2169{
2170 struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2171 lockdep_is_held(&event_mutex));
2172 int i;
2173
2174 for (i = 0; prog[i].pred; i++) {
2175 struct filter_pred *pred = prog[i].pred;
2176 struct ftrace_event_field *field = pred->field;
2177
2178 WARN_ON_ONCE(!pred->fn);
2179
2180 if (!field) {
2181 WARN_ONCE(1, "all leafs should have field defined %d", i);
2182 continue;
2183 }
2184
2185 if (!strchr(fields, *field->name))
2186 continue;
2187
2188 pred->fn = test_pred_visited_fn;
2189 }
2190}
2191
2192static __init int ftrace_test_event_filter(void)
2193{
2194 int i;
2195
2196 printk(KERN_INFO "Testing ftrace filter: ");
2197
2198 for (i = 0; i < DATA_CNT; i++) {
2199 struct event_filter *filter = NULL;
2200 struct test_filter_data_t *d = &test_filter_data[i];
2201 int err;
2202
2203 err = create_filter(NULL, &event_ftrace_test_filter,
2204 d->filter, false, &filter);
2205 if (err) {
2206 printk(KERN_INFO
2207 "Failed to get filter for '%s', err %d\n",
2208 d->filter, err);
2209 __free_filter(filter);
2210 break;
2211 }
2212
2213
2214 mutex_lock(&event_mutex);
2215
2216
2217
2218
2219 preempt_disable();
2220 if (*d->not_visited)
2221 update_pred_fn(filter, d->not_visited);
2222
2223 test_pred_visited = 0;
2224 err = filter_match_preds(filter, &d->rec);
2225 preempt_enable();
2226
2227 mutex_unlock(&event_mutex);
2228
2229 __free_filter(filter);
2230
2231 if (test_pred_visited) {
2232 printk(KERN_INFO
2233 "Failed, unwanted pred visited for filter %s\n",
2234 d->filter);
2235 break;
2236 }
2237
2238 if (err != d->match) {
2239 printk(KERN_INFO
2240 "Failed to match filter '%s', expected %d\n",
2241 d->filter, d->match);
2242 break;
2243 }
2244 }
2245
2246 if (i == DATA_CNT)
2247 printk(KERN_CONT "OK\n");
2248
2249 return 0;
2250}
2251
2252late_initcall(ftrace_test_event_filter);
2253
2254#endif
2255