projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'pm-cpufreq-fixes'
[deliverable/linux.git] / kernel / trace / trace_events_filter.c
1 /*
2 * trace_events_filter - generic event filtering
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 *
18 * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
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
30 #define DEFAULT_SYS_FILTER_MESSAGE \
31 "### global filter ###\n" \
32 "# Use this to set filters for multiple events.\n" \
33 "# Only events with the given fields will be affected.\n" \
34 "# If no events are modified, an error message will be displayed here"
35
36 enum filter_op_ids
37 {
38 OP_OR,
39 OP_AND,
40 OP_GLOB,
41 OP_NE,
42 OP_EQ,
43 OP_LT,
44 OP_LE,
45 OP_GT,
46 OP_GE,
47 OP_BAND,
48 OP_NOT,
49 OP_NONE,
50 OP_OPEN_PAREN,
51 };
52
53 struct filter_op {
54 int id;
55 char *string;
56 int precedence;
57 };
58
59 /* Order must be the same as enum filter_op_ids above */
60 static struct filter_op filter_ops[] = {
61 { OP_OR, "||", 1 },
62 { OP_AND, "&&", 2 },
63 { OP_GLOB, "~", 4 },
64 { OP_NE, "!=", 4 },
65 { OP_EQ, "==", 4 },
66 { OP_LT, "<", 5 },
67 { OP_LE, "<=", 5 },
68 { OP_GT, ">", 5 },
69 { OP_GE, ">=", 5 },
70 { OP_BAND, "&", 6 },
71 { OP_NOT, "!", 6 },
72 { OP_NONE, "OP_NONE", 0 },
73 { OP_OPEN_PAREN, "(", 0 },
74 };
75
76 enum {
77 FILT_ERR_NONE,
78 FILT_ERR_INVALID_OP,
79 FILT_ERR_UNBALANCED_PAREN,
80 FILT_ERR_TOO_MANY_OPERANDS,
81 FILT_ERR_OPERAND_TOO_LONG,
82 FILT_ERR_FIELD_NOT_FOUND,
83 FILT_ERR_ILLEGAL_FIELD_OP,
84 FILT_ERR_ILLEGAL_INTVAL,
85 FILT_ERR_BAD_SUBSYS_FILTER,
86 FILT_ERR_TOO_MANY_PREDS,
87 FILT_ERR_MISSING_FIELD,
88 FILT_ERR_INVALID_FILTER,
89 FILT_ERR_IP_FIELD_ONLY,
90 FILT_ERR_ILLEGAL_NOT_OP,
91 };
92
93 static char *err_text[] = {
94 "No error",
95 "Invalid operator",
96 "Unbalanced parens",
97 "Too many operands",
98 "Operand too long",
99 "Field not found",
100 "Illegal operation for field type",
101 "Illegal integer value",
102 "Couldn't find or set field in one of a subsystem's events",
103 "Too many terms in predicate expression",
104 "Missing field name and/or value",
105 "Meaningless filter expression",
106 "Only 'ip' field is supported for function trace",
107 "Illegal use of '!'",
108 };
109
110 struct opstack_op {
111 int op;
112 struct list_head list;
113 };
114
115 struct postfix_elt {
116 int op;
117 char *operand;
118 struct list_head list;
119 };
120
121 struct filter_parse_state {
122 struct filter_op *ops;
123 struct list_head opstack;
124 struct list_head postfix;
125 int lasterr;
126 int lasterr_pos;
127
128 struct {
129 char *string;
130 unsigned int cnt;
131 unsigned int tail;
132 } infix;
133
134 struct {
135 char string[MAX_FILTER_STR_VAL];
136 int pos;
137 unsigned int tail;
138 } operand;
139 };
140
141 struct pred_stack {
142 struct filter_pred **preds;
143 int index;
144 };
145
146 /* If not of not match is equal to not of not, then it is a match */
147 #define DEFINE_COMPARISON_PRED(type) \
148 static int filter_pred_##type(struct filter_pred *pred, void *event) \
149 { \
150 type *addr = (type *)(event + pred->offset); \
151 type val = (type)pred->val; \
152 int match = 0; \
153 \
154 switch (pred->op) { \
155 case OP_LT: \
156 match = (*addr < val); \
157 break; \
158 case OP_LE: \
159 match = (*addr <= val); \
160 break; \
161 case OP_GT: \
162 match = (*addr > val); \
163 break; \
164 case OP_GE: \
165 match = (*addr >= val); \
166 break; \
167 case OP_BAND: \
168 match = (*addr & val); \
169 break; \
170 default: \
171 break; \
172 } \
173 \
174 return !!match == !pred->not; \
175 }
176
177 #define DEFINE_EQUALITY_PRED(size) \
178 static int filter_pred_##size(struct filter_pred *pred, void *event) \
179 { \
180 u##size *addr = (u##size *)(event + pred->offset); \
181 u##size val = (u##size)pred->val; \
182 int match; \
183 \
184 match = (val == *addr) ^ pred->not; \
185 \
186 return match; \
187 }
188
189 DEFINE_COMPARISON_PRED(s64);
190 DEFINE_COMPARISON_PRED(u64);
191 DEFINE_COMPARISON_PRED(s32);
192 DEFINE_COMPARISON_PRED(u32);
193 DEFINE_COMPARISON_PRED(s16);
194 DEFINE_COMPARISON_PRED(u16);
195 DEFINE_COMPARISON_PRED(s8);
196 DEFINE_COMPARISON_PRED(u8);
197
198 DEFINE_EQUALITY_PRED(64);
199 DEFINE_EQUALITY_PRED(32);
200 DEFINE_EQUALITY_PRED(16);
201 DEFINE_EQUALITY_PRED(8);
202
203 /* Filter predicate for fixed sized arrays of characters */
204 static int filter_pred_string(struct filter_pred *pred, void *event)
205 {
206 char *addr = (char *)(event + pred->offset);
207 int cmp, match;
208
209 cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
210
211 match = cmp ^ pred->not;
212
213 return match;
214 }
215
216 /* Filter predicate for char * pointers */
217 static int filter_pred_pchar(struct filter_pred *pred, void *event)
218 {
219 char **addr = (char **)(event + pred->offset);
220 int cmp, match;
221 int len = strlen(*addr) + 1; /* including tailing '\0' */
222
223 cmp = pred->regex.match(*addr, &pred->regex, len);
224
225 match = cmp ^ pred->not;
226
227 return match;
228 }
229
230 /*
231 * Filter predicate for dynamic sized arrays of characters.
232 * These are implemented through a list of strings at the end
233 * of the entry.
234 * Also each of these strings have a field in the entry which
235 * contains its offset from the beginning of the entry.
236 * We have then first to get this field, dereference it
237 * and add it to the address of the entry, and at last we have
238 * the address of the string.
239 */
240 static int filter_pred_strloc(struct filter_pred *pred, void *event)
241 {
242 u32 str_item = *(u32 *)(event + pred->offset);
243 int str_loc = str_item & 0xffff;
244 int str_len = str_item >> 16;
245 char *addr = (char *)(event + str_loc);
246 int cmp, match;
247
248 cmp = pred->regex.match(addr, &pred->regex, str_len);
249
250 match = cmp ^ pred->not;
251
252 return match;
253 }
254
255 /* Filter predicate for CPUs. */
256 static int filter_pred_cpu(struct filter_pred *pred, void *event)
257 {
258 int cpu, cmp;
259 int match = 0;
260
261 cpu = raw_smp_processor_id();
262 cmp = pred->val;
263
264 switch (pred->op) {
265 case OP_EQ:
266 match = cpu == cmp;
267 break;
268 case OP_LT:
269 match = cpu < cmp;
270 break;
271 case OP_LE:
272 match = cpu <= cmp;
273 break;
274 case OP_GT:
275 match = cpu > cmp;
276 break;
277 case OP_GE:
278 match = cpu >= cmp;
279 break;
280 default:
281 break;
282 }
283
284 return !!match == !pred->not;
285 }
286
287 /* Filter predicate for COMM. */
288 static int filter_pred_comm(struct filter_pred *pred, void *event)
289 {
290 int cmp, match;
291
292 cmp = pred->regex.match(current->comm, &pred->regex,
293 pred->regex.field_len);
294 match = cmp ^ pred->not;
295
296 return match;
297 }
298
299 static int filter_pred_none(struct filter_pred *pred, void *event)
300 {
301 return 0;
302 }
303
304 /*
305 * regex_match_foo - Basic regex callbacks
306 *
307 * @str: the string to be searched
308 * @r: the regex structure containing the pattern string
309 * @len: the length of the string to be searched (including '\0')
310 *
311 * Note:
312 * - @str might not be NULL-terminated if it's of type DYN_STRING
313 * or STATIC_STRING
314 */
315
316 static int regex_match_full(char *str, struct regex *r, int len)
317 {
318 if (strncmp(str, r->pattern, len) == 0)
319 return 1;
320 return 0;
321 }
322
323 static int regex_match_front(char *str, struct regex *r, int len)
324 {
325 if (strncmp(str, r->pattern, r->len) == 0)
326 return 1;
327 return 0;
328 }
329
330 static int regex_match_middle(char *str, struct regex *r, int len)
331 {
332 if (strnstr(str, r->pattern, len))
333 return 1;
334 return 0;
335 }
336
337 static int regex_match_end(char *str, struct regex *r, int len)
338 {
339 int strlen = len - 1;
340
341 if (strlen >= r->len &&
342 memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
343 return 1;
344 return 0;
345 }
346
347 /**
348 * filter_parse_regex - parse a basic regex
349 * @buff: the raw regex
350 * @len: length of the regex
351 * @search: will point to the beginning of the string to compare
352 * @not: tell whether the match will have to be inverted
353 *
354 * This passes in a buffer containing a regex and this function will
355 * set search to point to the search part of the buffer and
356 * return the type of search it is (see enum above).
357 * This does modify buff.
358 *
359 * Returns enum type.
360 * search returns the pointer to use for comparison.
361 * not returns 1 if buff started with a '!'
362 * 0 otherwise.
363 */
364 enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
365 {
366 int type = MATCH_FULL;
367 int i;
368
369 if (buff[0] == '!') {
370 *not = 1;
371 buff++;
372 len--;
373 } else
374 *not = 0;
375
376 *search = buff;
377
378 for (i = 0; i < len; i++) {
379 if (buff[i] == '*') {
380 if (!i) {
381 *search = buff + 1;
382 type = MATCH_END_ONLY;
383 } else {
384 if (type == MATCH_END_ONLY)
385 type = MATCH_MIDDLE_ONLY;
386 else
387 type = MATCH_FRONT_ONLY;
388 buff[i] = 0;
389 break;
390 }
391 }
392 }
393
394 return type;
395 }
396
397 static void filter_build_regex(struct filter_pred *pred)
398 {
399 struct regex *r = &pred->regex;
400 char *search;
401 enum regex_type type = MATCH_FULL;
402 int not = 0;
403
404 if (pred->op == OP_GLOB) {
405 type = filter_parse_regex(r->pattern, r->len, &search, &not);
406 r->len = strlen(search);
407 memmove(r->pattern, search, r->len+1);
408 }
409
410 switch (type) {
411 case MATCH_FULL:
412 r->match = regex_match_full;
413 break;
414 case MATCH_FRONT_ONLY:
415 r->match = regex_match_front;
416 break;
417 case MATCH_MIDDLE_ONLY:
418 r->match = regex_match_middle;
419 break;
420 case MATCH_END_ONLY:
421 r->match = regex_match_end;
422 break;
423 }
424
425 pred->not ^= not;
426 }
427
428 enum move_type {
429 MOVE_DOWN,
430 MOVE_UP_FROM_LEFT,
431 MOVE_UP_FROM_RIGHT
432 };
433
434 static struct filter_pred *
435 get_pred_parent(struct filter_pred *pred, struct filter_pred *preds,
436 int index, enum move_type *move)
437 {
438 if (pred->parent & FILTER_PRED_IS_RIGHT)
439 *move = MOVE_UP_FROM_RIGHT;
440 else
441 *move = MOVE_UP_FROM_LEFT;
442 pred = &preds[pred->parent & ~FILTER_PRED_IS_RIGHT];
443
444 return pred;
445 }
446
447 enum walk_return {
448 WALK_PRED_ABORT,
449 WALK_PRED_PARENT,
450 WALK_PRED_DEFAULT,
451 };
452
453 typedef int (*filter_pred_walkcb_t) (enum move_type move,
454 struct filter_pred *pred,
455 int *err, void *data);
456
457 static int walk_pred_tree(struct filter_pred *preds,
458 struct filter_pred *root,
459 filter_pred_walkcb_t cb, void *data)
460 {
461 struct filter_pred *pred = root;
462 enum move_type move = MOVE_DOWN;
463 int done = 0;
464
465 if (!preds)
466 return -EINVAL;
467
468 do {
469 int err = 0, ret;
470
471 ret = cb(move, pred, &err, data);
472 if (ret == WALK_PRED_ABORT)
473 return err;
474 if (ret == WALK_PRED_PARENT)
475 goto get_parent;
476
477 switch (move) {
478 case MOVE_DOWN:
479 if (pred->left != FILTER_PRED_INVALID) {
480 pred = &preds[pred->left];
481 continue;
482 }
483 goto get_parent;
484 case MOVE_UP_FROM_LEFT:
485 pred = &preds[pred->right];
486 move = MOVE_DOWN;
487 continue;
488 case MOVE_UP_FROM_RIGHT:
489 get_parent:
490 if (pred == root)
491 break;
492 pred = get_pred_parent(pred, preds,
493 pred->parent,
494 &move);
495 continue;
496 }
497 done = 1;
498 } while (!done);
499
500 /* We are fine. */
501 return 0;
502 }
503
504 /*
505 * A series of AND or ORs where found together. Instead of
506 * climbing up and down the tree branches, an array of the
507 * ops were made in order of checks. We can just move across
508 * the array and short circuit if needed.
509 */
510 static int process_ops(struct filter_pred *preds,
511 struct filter_pred *op, void *rec)
512 {
513 struct filter_pred *pred;
514 int match = 0;
515 int type;
516 int i;
517
518 /*
519 * Micro-optimization: We set type to true if op
520 * is an OR and false otherwise (AND). Then we
521 * just need to test if the match is equal to
522 * the type, and if it is, we can short circuit the
523 * rest of the checks:
524 *
525 * if ((match && op->op == OP_OR) ||
526 * (!match && op->op == OP_AND))
527 * return match;
528 */
529 type = op->op == OP_OR;
530
531 for (i = 0; i < op->val; i++) {
532 pred = &preds[op->ops[i]];
533 if (!WARN_ON_ONCE(!pred->fn))
534 match = pred->fn(pred, rec);
535 if (!!match == type)
536 break;
537 }
538 /* If not of not match is equal to not of not, then it is a match */
539 return !!match == !op->not;
540 }
541
542 struct filter_match_preds_data {
543 struct filter_pred *preds;
544 int match;
545 void *rec;
546 };
547
548 static int filter_match_preds_cb(enum move_type move, struct filter_pred *pred,
549 int *err, void *data)
550 {
551 struct filter_match_preds_data *d = data;
552
553 *err = 0;
554 switch (move) {
555 case MOVE_DOWN:
556 /* only AND and OR have children */
557 if (pred->left != FILTER_PRED_INVALID) {
558 /* If ops is set, then it was folded. */
559 if (!pred->ops)
560 return WALK_PRED_DEFAULT;
561 /* We can treat folded ops as a leaf node */
562 d->match = process_ops(d->preds, pred, d->rec);
563 } else {
564 if (!WARN_ON_ONCE(!pred->fn))
565 d->match = pred->fn(pred, d->rec);
566 }
567
568 return WALK_PRED_PARENT;
569 case MOVE_UP_FROM_LEFT:
570 /*
571 * Check for short circuits.
572 *
573 * Optimization: !!match == (pred->op == OP_OR)
574 * is the same as:
575 * if ((match && pred->op == OP_OR) ||
576 * (!match && pred->op == OP_AND))
577 */
578 if (!!d->match == (pred->op == OP_OR))
579 return WALK_PRED_PARENT;
580 break;
581 case MOVE_UP_FROM_RIGHT:
582 break;
583 }
584
585 return WALK_PRED_DEFAULT;
586 }
587
588 /* return 1 if event matches, 0 otherwise (discard) */
589 int filter_match_preds(struct event_filter *filter, void *rec)
590 {
591 struct filter_pred *preds;
592 struct filter_pred *root;
593 struct filter_match_preds_data data = {
594 /* match is currently meaningless */
595 .match = -1,
596 .rec = rec,
597 };
598 int n_preds, ret;
599
600 /* no filter is considered a match */
601 if (!filter)
602 return 1;
603
604 n_preds = filter->n_preds;
605 if (!n_preds)
606 return 1;
607
608 /*
609 * n_preds, root and filter->preds are protect with preemption disabled.
610 */
611 root = rcu_dereference_sched(filter->root);
612 if (!root)
613 return 1;
614
615 data.preds = preds = rcu_dereference_sched(filter->preds);
616 ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data);
617 WARN_ON(ret);
618 return data.match;
619 }
620 EXPORT_SYMBOL_GPL(filter_match_preds);
621
622 static void parse_error(struct filter_parse_state *ps, int err, int pos)
623 {
624 ps->lasterr = err;
625 ps->lasterr_pos = pos;
626 }
627
628 static void remove_filter_string(struct event_filter *filter)
629 {
630 if (!filter)
631 return;
632
633 kfree(filter->filter_string);
634 filter->filter_string = NULL;
635 }
636
637 static int replace_filter_string(struct event_filter *filter,
638 char *filter_string)
639 {
640 kfree(filter->filter_string);
641 filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
642 if (!filter->filter_string)
643 return -ENOMEM;
644
645 return 0;
646 }
647
648 static int append_filter_string(struct event_filter *filter,
649 char *string)
650 {
651 int newlen;
652 char *new_filter_string;
653
654 BUG_ON(!filter->filter_string);
655 newlen = strlen(filter->filter_string) + strlen(string) + 1;
656 new_filter_string = kmalloc(newlen, GFP_KERNEL);
657 if (!new_filter_string)
658 return -ENOMEM;
659
660 strcpy(new_filter_string, filter->filter_string);
661 strcat(new_filter_string, string);
662 kfree(filter->filter_string);
663 filter->filter_string = new_filter_string;
664
665 return 0;
666 }
667
668 static void append_filter_err(struct filter_parse_state *ps,
669 struct event_filter *filter)
670 {
671 int pos = ps->lasterr_pos;
672 char *buf, *pbuf;
673
674 buf = (char *)__get_free_page(GFP_TEMPORARY);
675 if (!buf)
676 return;
677
678 append_filter_string(filter, "\n");
679 memset(buf, ' ', PAGE_SIZE);
680 if (pos > PAGE_SIZE - 128)
681 pos = 0;
682 buf[pos] = '^';
683 pbuf = &buf[pos] + 1;
684
685 sprintf(pbuf, "\nparse_error: %s\n", err_text[ps->lasterr]);
686 append_filter_string(filter, buf);
687 free_page((unsigned long) buf);
688 }
689
690 static inline struct event_filter *event_filter(struct trace_event_file *file)
691 {
692 return file->filter;
693 }
694
695 /* caller must hold event_mutex */
696 void print_event_filter(struct trace_event_file *file, struct trace_seq *s)
697 {
698 struct event_filter *filter = event_filter(file);
699
700 if (filter && filter->filter_string)
701 trace_seq_printf(s, "%s\n", filter->filter_string);
702 else
703 trace_seq_puts(s, "none\n");
704 }
705
706 void print_subsystem_event_filter(struct event_subsystem *system,
707 struct trace_seq *s)
708 {
709 struct event_filter *filter;
710
711 mutex_lock(&event_mutex);
712 filter = system->filter;
713 if (filter && filter->filter_string)
714 trace_seq_printf(s, "%s\n", filter->filter_string);
715 else
716 trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
717 mutex_unlock(&event_mutex);
718 }
719
720 static int __alloc_pred_stack(struct pred_stack *stack, int n_preds)
721 {
722 stack->preds = kcalloc(n_preds + 1, sizeof(*stack->preds), GFP_KERNEL);
723 if (!stack->preds)
724 return -ENOMEM;
725 stack->index = n_preds;
726 return 0;
727 }
728
729 static void __free_pred_stack(struct pred_stack *stack)
730 {
731 kfree(stack->preds);
732 stack->index = 0;
733 }
734
735 static int __push_pred_stack(struct pred_stack *stack,
736 struct filter_pred *pred)
737 {
738 int index = stack->index;
739
740 if (WARN_ON(index == 0))
741 return -ENOSPC;
742
743 stack->preds[--index] = pred;
744 stack->index = index;
745 return 0;
746 }
747
748 static struct filter_pred *
749 __pop_pred_stack(struct pred_stack *stack)
750 {
751 struct filter_pred *pred;
752 int index = stack->index;
753
754 pred = stack->preds[index++];
755 if (!pred)
756 return NULL;
757
758 stack->index = index;
759 return pred;
760 }
761
762 static int filter_set_pred(struct event_filter *filter,
763 int idx,
764 struct pred_stack *stack,
765 struct filter_pred *src)
766 {
767 struct filter_pred *dest = &filter->preds[idx];
768 struct filter_pred *left;
769 struct filter_pred *right;
770
771 *dest = *src;
772 dest->index = idx;
773
774 if (dest->op == OP_OR || dest->op == OP_AND) {
775 right = __pop_pred_stack(stack);
776 left = __pop_pred_stack(stack);
777 if (!left || !right)
778 return -EINVAL;
779 /*
780 * If both children can be folded
781 * and they are the same op as this op or a leaf,
782 * then this op can be folded.
783 */
784 if (left->index & FILTER_PRED_FOLD &&
785 ((left->op == dest->op && !left->not) ||
786 left->left == FILTER_PRED_INVALID) &&
787 right->index & FILTER_PRED_FOLD &&
788 ((right->op == dest->op && !right->not) ||
789 right->left == FILTER_PRED_INVALID))
790 dest->index |= FILTER_PRED_FOLD;
791
792 dest->left = left->index & ~FILTER_PRED_FOLD;
793 dest->right = right->index & ~FILTER_PRED_FOLD;
794 left->parent = dest->index & ~FILTER_PRED_FOLD;
795 right->parent = dest->index | FILTER_PRED_IS_RIGHT;
796 } else {
797 /*
798 * Make dest->left invalid to be used as a quick
799 * way to know this is a leaf node.
800 */
801 dest->left = FILTER_PRED_INVALID;
802
803 /* All leafs allow folding the parent ops. */
804 dest->index |= FILTER_PRED_FOLD;
805 }
806
807 return __push_pred_stack(stack, dest);
808 }
809
810 static void __free_preds(struct event_filter *filter)
811 {
812 int i;
813
814 if (filter->preds) {
815 for (i = 0; i < filter->n_preds; i++)
816 kfree(filter->preds[i].ops);
817 kfree(filter->preds);
818 filter->preds = NULL;
819 }
820 filter->a_preds = 0;
821 filter->n_preds = 0;
822 }
823
824 static void filter_disable(struct trace_event_file *file)
825 {
826 unsigned long old_flags = file->flags;
827
828 file->flags &= ~EVENT_FILE_FL_FILTERED;
829
830 if (old_flags != file->flags)
831 trace_buffered_event_disable();
832 }
833
834 static void __free_filter(struct event_filter *filter)
835 {
836 if (!filter)
837 return;
838
839 __free_preds(filter);
840 kfree(filter->filter_string);
841 kfree(filter);
842 }
843
844 void free_event_filter(struct event_filter *filter)
845 {
846 __free_filter(filter);
847 }
848
849 static struct event_filter *__alloc_filter(void)
850 {
851 struct event_filter *filter;
852
853 filter = kzalloc(sizeof(*filter), GFP_KERNEL);
854 return filter;
855 }
856
857 static int __alloc_preds(struct event_filter *filter, int n_preds)
858 {
859 struct filter_pred *pred;
860 int i;
861
862 if (filter->preds)
863 __free_preds(filter);
864
865 filter->preds = kcalloc(n_preds, sizeof(*filter->preds), GFP_KERNEL);
866
867 if (!filter->preds)
868 return -ENOMEM;
869
870 filter->a_preds = n_preds;
871 filter->n_preds = 0;
872
873 for (i = 0; i < n_preds; i++) {
874 pred = &filter->preds[i];
875 pred->fn = filter_pred_none;
876 }
877
878 return 0;
879 }
880
881 static inline void __remove_filter(struct trace_event_file *file)
882 {
883 filter_disable(file);
884 remove_filter_string(file->filter);
885 }
886
887 static void filter_free_subsystem_preds(struct trace_subsystem_dir *dir,
888 struct trace_array *tr)
889 {
890 struct trace_event_file *file;
891
892 list_for_each_entry(file, &tr->events, list) {
893 if (file->system != dir)
894 continue;
895 __remove_filter(file);
896 }
897 }
898
899 static inline void __free_subsystem_filter(struct trace_event_file *file)
900 {
901 __free_filter(file->filter);
902 file->filter = NULL;
903 }
904
905 static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir,
906 struct trace_array *tr)
907 {
908 struct trace_event_file *file;
909
910 list_for_each_entry(file, &tr->events, list) {
911 if (file->system != dir)
912 continue;
913 __free_subsystem_filter(file);
914 }
915 }
916
917 static int filter_add_pred(struct filter_parse_state *ps,
918 struct event_filter *filter,
919 struct filter_pred *pred,
920 struct pred_stack *stack)
921 {
922 int err;
923
924 if (WARN_ON(filter->n_preds == filter->a_preds)) {
925 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
926 return -ENOSPC;
927 }
928
929 err = filter_set_pred(filter, filter->n_preds, stack, pred);
930 if (err)
931 return err;
932
933 filter->n_preds++;
934
935 return 0;
936 }
937
938 int filter_assign_type(const char *type)
939 {
940 if (strstr(type, "__data_loc") && strstr(type, "char"))
941 return FILTER_DYN_STRING;
942
943 if (strchr(type, '[') && strstr(type, "char"))
944 return FILTER_STATIC_STRING;
945
946 return FILTER_OTHER;
947 }
948
949 static bool is_legal_op(struct ftrace_event_field *field, int op)
950 {
951 if (is_string_field(field) &&
952 (op != OP_EQ && op != OP_NE && op != OP_GLOB))
953 return false;
954 if (!is_string_field(field) && op == OP_GLOB)
955 return false;
956
957 return true;
958 }
959
960 static filter_pred_fn_t select_comparison_fn(int op, int field_size,
961 int field_is_signed)
962 {
963 filter_pred_fn_t fn = NULL;
964
965 switch (field_size) {
966 case 8:
967 if (op == OP_EQ || op == OP_NE)
968 fn = filter_pred_64;
969 else if (field_is_signed)
970 fn = filter_pred_s64;
971 else
972 fn = filter_pred_u64;
973 break;
974 case 4:
975 if (op == OP_EQ || op == OP_NE)
976 fn = filter_pred_32;
977 else if (field_is_signed)
978 fn = filter_pred_s32;
979 else
980 fn = filter_pred_u32;
981 break;
982 case 2:
983 if (op == OP_EQ || op == OP_NE)
984 fn = filter_pred_16;
985 else if (field_is_signed)
986 fn = filter_pred_s16;
987 else
988 fn = filter_pred_u16;
989 break;
990 case 1:
991 if (op == OP_EQ || op == OP_NE)
992 fn = filter_pred_8;
993 else if (field_is_signed)
994 fn = filter_pred_s8;
995 else
996 fn = filter_pred_u8;
997 break;
998 }
999
1000 return fn;
1001 }
1002
1003 static int init_pred(struct filter_parse_state *ps,
1004 struct ftrace_event_field *field,
1005 struct filter_pred *pred)
1006
1007 {
1008 filter_pred_fn_t fn = filter_pred_none;
1009 unsigned long long val;
1010 int ret;
1011
1012 pred->offset = field->offset;
1013
1014 if (!is_legal_op(field, pred->op)) {
1015 parse_error(ps, FILT_ERR_ILLEGAL_FIELD_OP, 0);
1016 return -EINVAL;
1017 }
1018
1019 if (field->filter_type == FILTER_COMM) {
1020 filter_build_regex(pred);
1021 fn = filter_pred_comm;
1022 pred->regex.field_len = TASK_COMM_LEN;
1023 } else if (is_string_field(field)) {
1024 filter_build_regex(pred);
1025
1026 if (field->filter_type == FILTER_STATIC_STRING) {
1027 fn = filter_pred_string;
1028 pred->regex.field_len = field->size;
1029 } else if (field->filter_type == FILTER_DYN_STRING)
1030 fn = filter_pred_strloc;
1031 else
1032 fn = filter_pred_pchar;
1033 } else if (is_function_field(field)) {
1034 if (strcmp(field->name, "ip")) {
1035 parse_error(ps, FILT_ERR_IP_FIELD_ONLY, 0);
1036 return -EINVAL;
1037 }
1038 } else {
1039 if (field->is_signed)
1040 ret = kstrtoll(pred->regex.pattern, 0, &val);
1041 else
1042 ret = kstrtoull(pred->regex.pattern, 0, &val);
1043 if (ret) {
1044 parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0);
1045 return -EINVAL;
1046 }
1047 pred->val = val;
1048
1049 if (field->filter_type == FILTER_CPU)
1050 fn = filter_pred_cpu;
1051 else
1052 fn = select_comparison_fn(pred->op, field->size,
1053 field->is_signed);
1054 if (!fn) {
1055 parse_error(ps, FILT_ERR_INVALID_OP, 0);
1056 return -EINVAL;
1057 }
1058 }
1059
1060 if (pred->op == OP_NE)
1061 pred->not ^= 1;
1062
1063 pred->fn = fn;
1064 return 0;
1065 }
1066
1067 static void parse_init(struct filter_parse_state *ps,
1068 struct filter_op *ops,
1069 char *infix_string)
1070 {
1071 memset(ps, '\0', sizeof(*ps));
1072
1073 ps->infix.string = infix_string;
1074 ps->infix.cnt = strlen(infix_string);
1075 ps->ops = ops;
1076
1077 INIT_LIST_HEAD(&ps->opstack);
1078 INIT_LIST_HEAD(&ps->postfix);
1079 }
1080
1081 static char infix_next(struct filter_parse_state *ps)
1082 {
1083 if (!ps->infix.cnt)
1084 return 0;
1085
1086 ps->infix.cnt--;
1087
1088 return ps->infix.string[ps->infix.tail++];
1089 }
1090
1091 static char infix_peek(struct filter_parse_state *ps)
1092 {
1093 if (ps->infix.tail == strlen(ps->infix.string))
1094 return 0;
1095
1096 return ps->infix.string[ps->infix.tail];
1097 }
1098
1099 static void infix_advance(struct filter_parse_state *ps)
1100 {
1101 if (!ps->infix.cnt)
1102 return;
1103
1104 ps->infix.cnt--;
1105 ps->infix.tail++;
1106 }
1107
1108 static inline int is_precedence_lower(struct filter_parse_state *ps,
1109 int a, int b)
1110 {
1111 return ps->ops[a].precedence < ps->ops[b].precedence;
1112 }
1113
1114 static inline int is_op_char(struct filter_parse_state *ps, char c)
1115 {
1116 int i;
1117
1118 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
1119 if (ps->ops[i].string[0] == c)
1120 return 1;
1121 }
1122
1123 return 0;
1124 }
1125
1126 static int infix_get_op(struct filter_parse_state *ps, char firstc)
1127 {
1128 char nextc = infix_peek(ps);
1129 char opstr[3];
1130 int i;
1131
1132 opstr[0] = firstc;
1133 opstr[1] = nextc;
1134 opstr[2] = '\0';
1135
1136 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
1137 if (!strcmp(opstr, ps->ops[i].string)) {
1138 infix_advance(ps);
1139 return ps->ops[i].id;
1140 }
1141 }
1142
1143 opstr[1] = '\0';
1144
1145 for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
1146 if (!strcmp(opstr, ps->ops[i].string))
1147 return ps->ops[i].id;
1148 }
1149
1150 return OP_NONE;
1151 }
1152
1153 static inline void clear_operand_string(struct filter_parse_state *ps)
1154 {
1155 memset(ps->operand.string, '\0', MAX_FILTER_STR_VAL);
1156 ps->operand.tail = 0;
1157 }
1158
1159 static inline int append_operand_char(struct filter_parse_state *ps, char c)
1160 {
1161 if (ps->operand.tail == MAX_FILTER_STR_VAL - 1)
1162 return -EINVAL;
1163
1164 ps->operand.string[ps->operand.tail++] = c;
1165
1166 return 0;
1167 }
1168
1169 static int filter_opstack_push(struct filter_parse_state *ps, int op)
1170 {
1171 struct opstack_op *opstack_op;
1172
1173 opstack_op = kmalloc(sizeof(*opstack_op), GFP_KERNEL);
1174 if (!opstack_op)
1175 return -ENOMEM;
1176
1177 opstack_op->op = op;
1178 list_add(&opstack_op->list, &ps->opstack);
1179
1180 return 0;
1181 }
1182
1183 static int filter_opstack_empty(struct filter_parse_state *ps)
1184 {
1185 return list_empty(&ps->opstack);
1186 }
1187
1188 static int filter_opstack_top(struct filter_parse_state *ps)
1189 {
1190 struct opstack_op *opstack_op;
1191
1192 if (filter_opstack_empty(ps))
1193 return OP_NONE;
1194
1195 opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
1196
1197 return opstack_op->op;
1198 }
1199
1200 static int filter_opstack_pop(struct filter_parse_state *ps)
1201 {
1202 struct opstack_op *opstack_op;
1203 int op;
1204
1205 if (filter_opstack_empty(ps))
1206 return OP_NONE;
1207
1208 opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
1209 op = opstack_op->op;
1210 list_del(&opstack_op->list);
1211
1212 kfree(opstack_op);
1213
1214 return op;
1215 }
1216
1217 static void filter_opstack_clear(struct filter_parse_state *ps)
1218 {
1219 while (!filter_opstack_empty(ps))
1220 filter_opstack_pop(ps);
1221 }
1222
1223 static char *curr_operand(struct filter_parse_state *ps)
1224 {
1225 return ps->operand.string;
1226 }
1227
1228 static int postfix_append_operand(struct filter_parse_state *ps, char *operand)
1229 {
1230 struct postfix_elt *elt;
1231
1232 elt = kmalloc(sizeof(*elt), GFP_KERNEL);
1233 if (!elt)
1234 return -ENOMEM;
1235
1236 elt->op = OP_NONE;
1237 elt->operand = kstrdup(operand, GFP_KERNEL);
1238 if (!elt->operand) {
1239 kfree(elt);
1240 return -ENOMEM;
1241 }
1242
1243 list_add_tail(&elt->list, &ps->postfix);
1244
1245 return 0;
1246 }
1247
1248 static int postfix_append_op(struct filter_parse_state *ps, int op)
1249 {
1250 struct postfix_elt *elt;
1251
1252 elt = kmalloc(sizeof(*elt), GFP_KERNEL);
1253 if (!elt)
1254 return -ENOMEM;
1255
1256 elt->op = op;
1257 elt->operand = NULL;
1258
1259 list_add_tail(&elt->list, &ps->postfix);
1260
1261 return 0;
1262 }
1263
1264 static void postfix_clear(struct filter_parse_state *ps)
1265 {
1266 struct postfix_elt *elt;
1267
1268 while (!list_empty(&ps->postfix)) {
1269 elt = list_first_entry(&ps->postfix, struct postfix_elt, list);
1270 list_del(&elt->list);
1271 kfree(elt->operand);
1272 kfree(elt);
1273 }
1274 }
1275
1276 static int filter_parse(struct filter_parse_state *ps)
1277 {
1278 int in_string = 0;
1279 int op, top_op;
1280 char ch;
1281
1282 while ((ch = infix_next(ps))) {
1283 if (ch == '"') {
1284 in_string ^= 1;
1285 continue;
1286 }
1287
1288 if (in_string)
1289 goto parse_operand;
1290
1291 if (isspace(ch))
1292 continue;
1293
1294 if (is_op_char(ps, ch)) {
1295 op = infix_get_op(ps, ch);
1296 if (op == OP_NONE) {
1297 parse_error(ps, FILT_ERR_INVALID_OP, 0);
1298 return -EINVAL;
1299 }
1300
1301 if (strlen(curr_operand(ps))) {
1302 postfix_append_operand(ps, curr_operand(ps));
1303 clear_operand_string(ps);
1304 }
1305
1306 while (!filter_opstack_empty(ps)) {
1307 top_op = filter_opstack_top(ps);
1308 if (!is_precedence_lower(ps, top_op, op)) {
1309 top_op = filter_opstack_pop(ps);
1310 postfix_append_op(ps, top_op);
1311 continue;
1312 }
1313 break;
1314 }
1315
1316 filter_opstack_push(ps, op);
1317 continue;
1318 }
1319
1320 if (ch == '(') {
1321 filter_opstack_push(ps, OP_OPEN_PAREN);
1322 continue;
1323 }
1324
1325 if (ch == ')') {
1326 if (strlen(curr_operand(ps))) {
1327 postfix_append_operand(ps, curr_operand(ps));
1328 clear_operand_string(ps);
1329 }
1330
1331 top_op = filter_opstack_pop(ps);
1332 while (top_op != OP_NONE) {
1333 if (top_op == OP_OPEN_PAREN)
1334 break;
1335 postfix_append_op(ps, top_op);
1336 top_op = filter_opstack_pop(ps);
1337 }
1338 if (top_op == OP_NONE) {
1339 parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1340 return -EINVAL;
1341 }
1342 continue;
1343 }
1344 parse_operand:
1345 if (append_operand_char(ps, ch)) {
1346 parse_error(ps, FILT_ERR_OPERAND_TOO_LONG, 0);
1347 return -EINVAL;
1348 }
1349 }
1350
1351 if (strlen(curr_operand(ps)))
1352 postfix_append_operand(ps, curr_operand(ps));
1353
1354 while (!filter_opstack_empty(ps)) {
1355 top_op = filter_opstack_pop(ps);
1356 if (top_op == OP_NONE)
1357 break;
1358 if (top_op == OP_OPEN_PAREN) {
1359 parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1360 return -EINVAL;
1361 }
1362 postfix_append_op(ps, top_op);
1363 }
1364
1365 return 0;
1366 }
1367
1368 static struct filter_pred *create_pred(struct filter_parse_state *ps,
1369 struct trace_event_call *call,
1370 int op, char *operand1, char *operand2)
1371 {
1372 struct ftrace_event_field *field;
1373 static struct filter_pred pred;
1374
1375 memset(&pred, 0, sizeof(pred));
1376 pred.op = op;
1377
1378 if (op == OP_AND || op == OP_OR)
1379 return &pred;
1380
1381 if (!operand1 || !operand2) {
1382 parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
1383 return NULL;
1384 }
1385
1386 field = trace_find_event_field(call, operand1);
1387 if (!field) {
1388 parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
1389 return NULL;
1390 }
1391
1392 strcpy(pred.regex.pattern, operand2);
1393 pred.regex.len = strlen(pred.regex.pattern);
1394 pred.field = field;
1395 return init_pred(ps, field, &pred) ? NULL : &pred;
1396 }
1397
1398 static int check_preds(struct filter_parse_state *ps)
1399 {
1400 int n_normal_preds = 0, n_logical_preds = 0;
1401 struct postfix_elt *elt;
1402 int cnt = 0;
1403
1404 list_for_each_entry(elt, &ps->postfix, list) {
1405 if (elt->op == OP_NONE) {
1406 cnt++;
1407 continue;
1408 }
1409
1410 if (elt->op == OP_AND || elt->op == OP_OR) {
1411 n_logical_preds++;
1412 cnt--;
1413 continue;
1414 }
1415 if (elt->op != OP_NOT)
1416 cnt--;
1417 n_normal_preds++;
1418 /* all ops should have operands */
1419 if (cnt < 0)
1420 break;
1421 }
1422
1423 if (cnt != 1 || !n_normal_preds || n_logical_preds >= n_normal_preds) {
1424 parse_error(ps, FILT_ERR_INVALID_FILTER, 0);
1425 return -EINVAL;
1426 }
1427
1428 return 0;
1429 }
1430
1431 static int count_preds(struct filter_parse_state *ps)
1432 {
1433 struct postfix_elt *elt;
1434 int n_preds = 0;
1435
1436 list_for_each_entry(elt, &ps->postfix, list) {
1437 if (elt->op == OP_NONE)
1438 continue;
1439 n_preds++;
1440 }
1441
1442 return n_preds;
1443 }
1444
1445 struct check_pred_data {
1446 int count;
1447 int max;
1448 };
1449
1450 static int check_pred_tree_cb(enum move_type move, struct filter_pred *pred,
1451 int *err, void *data)
1452 {
1453 struct check_pred_data *d = data;
1454
1455 if (WARN_ON(d->count++ > d->max)) {
1456 *err = -EINVAL;
1457 return WALK_PRED_ABORT;
1458 }
1459 return WALK_PRED_DEFAULT;
1460 }
1461
1462 /*
1463 * The tree is walked at filtering of an event. If the tree is not correctly
1464 * built, it may cause an infinite loop. Check here that the tree does
1465 * indeed terminate.
1466 */
1467 static int check_pred_tree(struct event_filter *filter,
1468 struct filter_pred *root)
1469 {
1470 struct check_pred_data data = {
1471 /*
1472 * The max that we can hit a node is three times.
1473 * Once going down, once coming up from left, and
1474 * once coming up from right. This is more than enough
1475 * since leafs are only hit a single time.
1476 */
1477 .max = 3 * filter->n_preds,
1478 .count = 0,
1479 };
1480
1481 return walk_pred_tree(filter->preds, root,
1482 check_pred_tree_cb, &data);
1483 }
1484
1485 static int count_leafs_cb(enum move_type move, struct filter_pred *pred,
1486 int *err, void *data)
1487 {
1488 int *count = data;
1489
1490 if ((move == MOVE_DOWN) &&
1491 (pred->left == FILTER_PRED_INVALID))
1492 (*count)++;
1493
1494 return WALK_PRED_DEFAULT;
1495 }
1496
1497 static int count_leafs(struct filter_pred *preds, struct filter_pred *root)
1498 {
1499 int count = 0, ret;
1500
1501 ret = walk_pred_tree(preds, root, count_leafs_cb, &count);
1502 WARN_ON(ret);
1503 return count;
1504 }
1505
1506 struct fold_pred_data {
1507 struct filter_pred *root;
1508 int count;
1509 int children;
1510 };
1511
1512 static int fold_pred_cb(enum move_type move, struct filter_pred *pred,
1513 int *err, void *data)
1514 {
1515 struct fold_pred_data *d = data;
1516 struct filter_pred *root = d->root;
1517
1518 if (move != MOVE_DOWN)
1519 return WALK_PRED_DEFAULT;
1520 if (pred->left != FILTER_PRED_INVALID)
1521 return WALK_PRED_DEFAULT;
1522
1523 if (WARN_ON(d->count == d->children)) {
1524 *err = -EINVAL;
1525 return WALK_PRED_ABORT;
1526 }
1527
1528 pred->index &= ~FILTER_PRED_FOLD;
1529 root->ops[d->count++] = pred->index;
1530 return WALK_PRED_DEFAULT;
1531 }
1532
1533 static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
1534 {
1535 struct fold_pred_data data = {
1536 .root = root,
1537 .count = 0,
1538 };
1539 int children;
1540
1541 /* No need to keep the fold flag */
1542 root->index &= ~FILTER_PRED_FOLD;
1543
1544 /* If the root is a leaf then do nothing */
1545 if (root->left == FILTER_PRED_INVALID)
1546 return 0;
1547
1548 /* count the children */
1549 children = count_leafs(preds, &preds[root->left]);
1550 children += count_leafs(preds, &preds[root->right]);
1551
1552 root->ops = kcalloc(children, sizeof(*root->ops), GFP_KERNEL);
1553 if (!root->ops)
1554 return -ENOMEM;
1555
1556 root->val = children;
1557 data.children = children;
1558 return walk_pred_tree(preds, root, fold_pred_cb, &data);
1559 }
1560
1561 static int fold_pred_tree_cb(enum move_type move, struct filter_pred *pred,
1562 int *err, void *data)
1563 {
1564 struct filter_pred *preds = data;
1565
1566 if (move != MOVE_DOWN)
1567 return WALK_PRED_DEFAULT;
1568 if (!(pred->index & FILTER_PRED_FOLD))
1569 return WALK_PRED_DEFAULT;
1570
1571 *err = fold_pred(preds, pred);
1572 if (*err)
1573 return WALK_PRED_ABORT;
1574
1575 /* eveyrhing below is folded, continue with parent */
1576 return WALK_PRED_PARENT;
1577 }
1578
1579 /*
1580 * To optimize the processing of the ops, if we have several "ors" or
1581 * "ands" together, we can put them in an array and process them all
1582 * together speeding up the filter logic.
1583 */
1584 static int fold_pred_tree(struct event_filter *filter,
1585 struct filter_pred *root)
1586 {
1587 return walk_pred_tree(filter->preds, root, fold_pred_tree_cb,
1588 filter->preds);
1589 }
1590
1591 static int replace_preds(struct trace_event_call *call,
1592 struct event_filter *filter,
1593 struct filter_parse_state *ps,
1594 bool dry_run)
1595 {
1596 char *operand1 = NULL, *operand2 = NULL;
1597 struct filter_pred *pred;
1598 struct filter_pred *root;
1599 struct postfix_elt *elt;
1600 struct pred_stack stack = { }; /* init to NULL */
1601 int err;
1602 int n_preds = 0;
1603
1604 n_preds = count_preds(ps);
1605 if (n_preds >= MAX_FILTER_PRED) {
1606 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
1607 return -ENOSPC;
1608 }
1609
1610 err = check_preds(ps);
1611 if (err)
1612 return err;
1613
1614 if (!dry_run) {
1615 err = __alloc_pred_stack(&stack, n_preds);
1616 if (err)
1617 return err;
1618 err = __alloc_preds(filter, n_preds);
1619 if (err)
1620 goto fail;
1621 }
1622
1623 n_preds = 0;
1624 list_for_each_entry(elt, &ps->postfix, list) {
1625 if (elt->op == OP_NONE) {
1626 if (!operand1)
1627 operand1 = elt->operand;
1628 else if (!operand2)
1629 operand2 = elt->operand;
1630 else {
1631 parse_error(ps, FILT_ERR_TOO_MANY_OPERANDS, 0);
1632 err = -EINVAL;
1633 goto fail;
1634 }
1635 continue;
1636 }
1637
1638 if (elt->op == OP_NOT) {
1639 if (!n_preds || operand1 || operand2) {
1640 parse_error(ps, FILT_ERR_ILLEGAL_NOT_OP, 0);
1641 err = -EINVAL;
1642 goto fail;
1643 }
1644 if (!dry_run)
1645 filter->preds[n_preds - 1].not ^= 1;
1646 continue;
1647 }
1648
1649 if (WARN_ON(n_preds++ == MAX_FILTER_PRED)) {
1650 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
1651 err = -ENOSPC;
1652 goto fail;
1653 }
1654
1655 pred = create_pred(ps, call, elt->op, operand1, operand2);
1656 if (!pred) {
1657 err = -EINVAL;
1658 goto fail;
1659 }
1660
1661 if (!dry_run) {
1662 err = filter_add_pred(ps, filter, pred, &stack);
1663 if (err)
1664 goto fail;
1665 }
1666
1667 operand1 = operand2 = NULL;
1668 }
1669
1670 if (!dry_run) {
1671 /* We should have one item left on the stack */
1672 pred = __pop_pred_stack(&stack);
1673 if (!pred)
1674 return -EINVAL;
1675 /* This item is where we start from in matching */
1676 root = pred;
1677 /* Make sure the stack is empty */
1678 pred = __pop_pred_stack(&stack);
1679 if (WARN_ON(pred)) {
1680 err = -EINVAL;
1681 filter->root = NULL;
1682 goto fail;
1683 }
1684 err = check_pred_tree(filter, root);
1685 if (err)
1686 goto fail;
1687
1688 /* Optimize the tree */
1689 err = fold_pred_tree(filter, root);
1690 if (err)
1691 goto fail;
1692
1693 /* We don't set root until we know it works */
1694 barrier();
1695 filter->root = root;
1696 }
1697
1698 err = 0;
1699 fail:
1700 __free_pred_stack(&stack);
1701 return err;
1702 }
1703
1704 static inline void event_set_filtered_flag(struct trace_event_file *file)
1705 {
1706 unsigned long old_flags = file->flags;
1707
1708 file->flags |= EVENT_FILE_FL_FILTERED;
1709
1710 if (old_flags != file->flags)
1711 trace_buffered_event_enable();
1712 }
1713
1714 static inline void event_set_filter(struct trace_event_file *file,
1715 struct event_filter *filter)
1716 {
1717 rcu_assign_pointer(file->filter, filter);
1718 }
1719
1720 static inline void event_clear_filter(struct trace_event_file *file)
1721 {
1722 RCU_INIT_POINTER(file->filter, NULL);
1723 }
1724
1725 static inline void
1726 event_set_no_set_filter_flag(struct trace_event_file *file)
1727 {
1728 file->flags |= EVENT_FILE_FL_NO_SET_FILTER;
1729 }
1730
1731 static inline void
1732 event_clear_no_set_filter_flag(struct trace_event_file *file)
1733 {
1734 file->flags &= ~EVENT_FILE_FL_NO_SET_FILTER;
1735 }
1736
1737 static inline bool
1738 event_no_set_filter_flag(struct trace_event_file *file)
1739 {
1740 if (file->flags & EVENT_FILE_FL_NO_SET_FILTER)
1741 return true;
1742
1743 return false;
1744 }
1745
1746 struct filter_list {
1747 struct list_head list;
1748 struct event_filter *filter;
1749 };
1750
1751 static int replace_system_preds(struct trace_subsystem_dir *dir,
1752 struct trace_array *tr,
1753 struct filter_parse_state *ps,
1754 char *filter_string)
1755 {
1756 struct trace_event_file *file;
1757 struct filter_list *filter_item;
1758 struct filter_list *tmp;
1759 LIST_HEAD(filter_list);
1760 bool fail = true;
1761 int err;
1762
1763 list_for_each_entry(file, &tr->events, list) {
1764 if (file->system != dir)
1765 continue;
1766
1767 /*
1768 * Try to see if the filter can be applied
1769 * (filter arg is ignored on dry_run)
1770 */
1771 err = replace_preds(file->event_call, NULL, ps, true);
1772 if (err)
1773 event_set_no_set_filter_flag(file);
1774 else
1775 event_clear_no_set_filter_flag(file);
1776 }
1777
1778 list_for_each_entry(file, &tr->events, list) {
1779 struct event_filter *filter;
1780
1781 if (file->system != dir)
1782 continue;
1783
1784 if (event_no_set_filter_flag(file))
1785 continue;
1786
1787 filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL);
1788 if (!filter_item)
1789 goto fail_mem;
1790
1791 list_add_tail(&filter_item->list, &filter_list);
1792
1793 filter_item->filter = __alloc_filter();
1794 if (!filter_item->filter)
1795 goto fail_mem;
1796 filter = filter_item->filter;
1797
1798 /* Can only fail on no memory */
1799 err = replace_filter_string(filter, filter_string);
1800 if (err)
1801 goto fail_mem;
1802
1803 err = replace_preds(file->event_call, filter, ps, false);
1804 if (err) {
1805 filter_disable(file);
1806 parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1807 append_filter_err(ps, filter);
1808 } else
1809 event_set_filtered_flag(file);
1810 /*
1811 * Regardless of if this returned an error, we still
1812 * replace the filter for the call.
1813 */
1814 filter = event_filter(file);
1815 event_set_filter(file, filter_item->filter);
1816 filter_item->filter = filter;
1817
1818 fail = false;
1819 }
1820
1821 if (fail)
1822 goto fail;
1823
1824 /*
1825 * The calls can still be using the old filters.
1826 * Do a synchronize_sched() to ensure all calls are
1827 * done with them before we free them.
1828 */
1829 synchronize_sched();
1830 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1831 __free_filter(filter_item->filter);
1832 list_del(&filter_item->list);
1833 kfree(filter_item);
1834 }
1835 return 0;
1836 fail:
1837 /* No call succeeded */
1838 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1839 list_del(&filter_item->list);
1840 kfree(filter_item);
1841 }
1842 parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1843 return -EINVAL;
1844 fail_mem:
1845 /* If any call succeeded, we still need to sync */
1846 if (!fail)
1847 synchronize_sched();
1848 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
1849 __free_filter(filter_item->filter);
1850 list_del(&filter_item->list);
1851 kfree(filter_item);
1852 }
1853 return -ENOMEM;
1854 }
1855
1856 static int create_filter_start(char *filter_str, bool set_str,
1857 struct filter_parse_state **psp,
1858 struct event_filter **filterp)
1859 {
1860 struct event_filter *filter;
1861 struct filter_parse_state *ps = NULL;
1862 int err = 0;
1863
1864 WARN_ON_ONCE(*psp || *filterp);
1865
1866 /* allocate everything, and if any fails, free all and fail */
1867 filter = __alloc_filter();
1868 if (filter && set_str)
1869 err = replace_filter_string(filter, filter_str);
1870
1871 ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1872
1873 if (!filter || !ps || err) {
1874 kfree(ps);
1875 __free_filter(filter);
1876 return -ENOMEM;
1877 }
1878
1879 /* we're committed to creating a new filter */
1880 *filterp = filter;
1881 *psp = ps;
1882
1883 parse_init(ps, filter_ops, filter_str);
1884 err = filter_parse(ps);
1885 if (err && set_str)
1886 append_filter_err(ps, filter);
1887 return err;
1888 }
1889
1890 static void create_filter_finish(struct filter_parse_state *ps)
1891 {
1892 if (ps) {
1893 filter_opstack_clear(ps);
1894 postfix_clear(ps);
1895 kfree(ps);
1896 }
1897 }
1898
1899 /**
1900 * create_filter - create a filter for a trace_event_call
1901 * @call: trace_event_call to create a filter for
1902 * @filter_str: filter string
1903 * @set_str: remember @filter_str and enable detailed error in filter
1904 * @filterp: out param for created filter (always updated on return)
1905 *
1906 * Creates a filter for @call with @filter_str. If @set_str is %true,
1907 * @filter_str is copied and recorded in the new filter.
1908 *
1909 * On success, returns 0 and *@filterp points to the new filter. On
1910 * failure, returns -errno and *@filterp may point to %NULL or to a new
1911 * filter. In the latter case, the returned filter contains error
1912 * information if @set_str is %true and the caller is responsible for
1913 * freeing it.
1914 */
1915 static int create_filter(struct trace_event_call *call,
1916 char *filter_str, bool set_str,
1917 struct event_filter **filterp)
1918 {
1919 struct event_filter *filter = NULL;
1920 struct filter_parse_state *ps = NULL;
1921 int err;
1922
1923 err = create_filter_start(filter_str, set_str, &ps, &filter);
1924 if (!err) {
1925 err = replace_preds(call, filter, ps, false);
1926 if (err && set_str)
1927 append_filter_err(ps, filter);
1928 }
1929 create_filter_finish(ps);
1930
1931 *filterp = filter;
1932 return err;
1933 }
1934
1935 int create_event_filter(struct trace_event_call *call,
1936 char *filter_str, bool set_str,
1937 struct event_filter **filterp)
1938 {
1939 return create_filter(call, filter_str, set_str, filterp);
1940 }
1941
1942 /**
1943 * create_system_filter - create a filter for an event_subsystem
1944 * @system: event_subsystem to create a filter for
1945 * @filter_str: filter string
1946 * @filterp: out param for created filter (always updated on return)
1947 *
1948 * Identical to create_filter() except that it creates a subsystem filter
1949 * and always remembers @filter_str.
1950 */
1951 static int create_system_filter(struct trace_subsystem_dir *dir,
1952 struct trace_array *tr,
1953 char *filter_str, struct event_filter **filterp)
1954 {
1955 struct event_filter *filter = NULL;
1956 struct filter_parse_state *ps = NULL;
1957 int err;
1958
1959 err = create_filter_start(filter_str, true, &ps, &filter);
1960 if (!err) {
1961 err = replace_system_preds(dir, tr, ps, filter_str);
1962 if (!err) {
1963 /* System filters just show a default message */
1964 kfree(filter->filter_string);
1965 filter->filter_string = NULL;
1966 } else {
1967 append_filter_err(ps, filter);
1968 }
1969 }
1970 create_filter_finish(ps);
1971
1972 *filterp = filter;
1973 return err;
1974 }
1975
1976 /* caller must hold event_mutex */
1977 int apply_event_filter(struct trace_event_file *file, char *filter_string)
1978 {
1979 struct trace_event_call *call = file->event_call;
1980 struct event_filter *filter;
1981 int err;
1982
1983 if (!strcmp(strstrip(filter_string), "0")) {
1984 filter_disable(file);
1985 filter = event_filter(file);
1986
1987 if (!filter)
1988 return 0;
1989
1990 event_clear_filter(file);
1991
1992 /* Make sure the filter is not being used */
1993 synchronize_sched();
1994 __free_filter(filter);
1995
1996 return 0;
1997 }
1998
1999 err = create_filter(call, filter_string, true, &filter);
2000
2001 /*
2002 * Always swap the call filter with the new filter
2003 * even if there was an error. If there was an error
2004 * in the filter, we disable the filter and show the error
2005 * string
2006 */
2007 if (filter) {
2008 struct event_filter *tmp;
2009
2010 tmp = event_filter(file);
2011 if (!err)
2012 event_set_filtered_flag(file);
2013 else
2014 filter_disable(file);
2015
2016 event_set_filter(file, filter);
2017
2018 if (tmp) {
2019 /* Make sure the call is done with the filter */
2020 synchronize_sched();
2021 __free_filter(tmp);
2022 }
2023 }
2024
2025 return err;
2026 }
2027
2028 int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
2029 char *filter_string)
2030 {
2031 struct event_subsystem *system = dir->subsystem;
2032 struct trace_array *tr = dir->tr;
2033 struct event_filter *filter;
2034 int err = 0;
2035
2036 mutex_lock(&event_mutex);
2037
2038 /* Make sure the system still has events */
2039 if (!dir->nr_events) {
2040 err = -ENODEV;
2041 goto out_unlock;
2042 }
2043
2044 if (!strcmp(strstrip(filter_string), "0")) {
2045 filter_free_subsystem_preds(dir, tr);
2046 remove_filter_string(system->filter);
2047 filter = system->filter;
2048 system->filter = NULL;
2049 /* Ensure all filters are no longer used */
2050 synchronize_sched();
2051 filter_free_subsystem_filters(dir, tr);
2052 __free_filter(filter);
2053 goto out_unlock;
2054 }
2055
2056 err = create_system_filter(dir, tr, filter_string, &filter);
2057 if (filter) {
2058 /*
2059 * No event actually uses the system filter
2060 * we can free it without synchronize_sched().
2061 */
2062 __free_filter(system->filter);
2063 system->filter = filter;
2064 }
2065 out_unlock:
2066 mutex_unlock(&event_mutex);
2067
2068 return err;
2069 }
2070
2071 #ifdef CONFIG_PERF_EVENTS
2072
2073 void ftrace_profile_free_filter(struct perf_event *event)
2074 {
2075 struct event_filter *filter = event->filter;
2076
2077 event->filter = NULL;
2078 __free_filter(filter);
2079 }
2080
2081 struct function_filter_data {
2082 struct ftrace_ops *ops;
2083 int first_filter;
2084 int first_notrace;
2085 };
2086
2087 #ifdef CONFIG_FUNCTION_TRACER
2088 static char **
2089 ftrace_function_filter_re(char *buf, int len, int *count)
2090 {
2091 char *str, **re;
2092
2093 str = kstrndup(buf, len, GFP_KERNEL);
2094 if (!str)
2095 return NULL;
2096
2097 /*
2098 * The argv_split function takes white space
2099 * as a separator, so convert ',' into spaces.
2100 */
2101 strreplace(str, ',', ' ');
2102
2103 re = argv_split(GFP_KERNEL, str, count);
2104 kfree(str);
2105 return re;
2106 }
2107
2108 static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
2109 int reset, char *re, int len)
2110 {
2111 int ret;
2112
2113 if (filter)
2114 ret = ftrace_set_filter(ops, re, len, reset);
2115 else
2116 ret = ftrace_set_notrace(ops, re, len, reset);
2117
2118 return ret;
2119 }
2120
2121 static int __ftrace_function_set_filter(int filter, char *buf, int len,
2122 struct function_filter_data *data)
2123 {
2124 int i, re_cnt, ret = -EINVAL;
2125 int *reset;
2126 char **re;
2127
2128 reset = filter ? &data->first_filter : &data->first_notrace;
2129
2130 /*
2131 * The 'ip' field could have multiple filters set, separated
2132 * either by space or comma. We first cut the filter and apply
2133 * all pieces separatelly.
2134 */
2135 re = ftrace_function_filter_re(buf, len, &re_cnt);
2136 if (!re)
2137 return -EINVAL;
2138
2139 for (i = 0; i < re_cnt; i++) {
2140 ret = ftrace_function_set_regexp(data->ops, filter, *reset,
2141 re[i], strlen(re[i]));
2142 if (ret)
2143 break;
2144
2145 if (*reset)
2146 *reset = 0;
2147 }
2148
2149 argv_free(re);
2150 return ret;
2151 }
2152
2153 static int ftrace_function_check_pred(struct filter_pred *pred, int leaf)
2154 {
2155 struct ftrace_event_field *field = pred->field;
2156
2157 if (leaf) {
2158 /*
2159 * Check the leaf predicate for function trace, verify:
2160 * - only '==' and '!=' is used
2161 * - the 'ip' field is used
2162 */
2163 if ((pred->op != OP_EQ) && (pred->op != OP_NE))
2164 return -EINVAL;
2165
2166 if (strcmp(field->name, "ip"))
2167 return -EINVAL;
2168 } else {
2169 /*
2170 * Check the non leaf predicate for function trace, verify:
2171 * - only '||' is used
2172 */
2173 if (pred->op != OP_OR)
2174 return -EINVAL;
2175 }
2176
2177 return 0;
2178 }
2179
2180 static int ftrace_function_set_filter_cb(enum move_type move,
2181 struct filter_pred *pred,
2182 int *err, void *data)
2183 {
2184 /* Checking the node is valid for function trace. */
2185 if ((move != MOVE_DOWN) ||
2186 (pred->left != FILTER_PRED_INVALID)) {
2187 *err = ftrace_function_check_pred(pred, 0);
2188 } else {
2189 *err = ftrace_function_check_pred(pred, 1);
2190 if (*err)
2191 return WALK_PRED_ABORT;
2192
2193 *err = __ftrace_function_set_filter(pred->op == OP_EQ,
2194 pred->regex.pattern,
2195 pred->regex.len,
2196 data);
2197 }
2198
2199 return (*err) ? WALK_PRED_ABORT : WALK_PRED_DEFAULT;
2200 }
2201
2202 static int ftrace_function_set_filter(struct perf_event *event,
2203 struct event_filter *filter)
2204 {
2205 struct function_filter_data data = {
2206 .first_filter = 1,
2207 .first_notrace = 1,
2208 .ops = &event->ftrace_ops,
2209 };
2210
2211 return walk_pred_tree(filter->preds, filter->root,
2212 ftrace_function_set_filter_cb, &data);
2213 }
2214 #else
2215 static int ftrace_function_set_filter(struct perf_event *event,
2216 struct event_filter *filter)
2217 {
2218 return -ENODEV;
2219 }
2220 #endif /* CONFIG_FUNCTION_TRACER */
2221
2222 int ftrace_profile_set_filter(struct perf_event *event, int event_id,
2223 char *filter_str)
2224 {
2225 int err;
2226 struct event_filter *filter;
2227 struct trace_event_call *call;
2228
2229 mutex_lock(&event_mutex);
2230
2231 call = event->tp_event;
2232
2233 err = -EINVAL;
2234 if (!call)
2235 goto out_unlock;
2236
2237 err = -EEXIST;
2238 if (event->filter)
2239 goto out_unlock;
2240
2241 err = create_filter(call, filter_str, false, &filter);
2242 if (err)
2243 goto free_filter;
2244
2245 if (ftrace_event_is_function(call))
2246 err = ftrace_function_set_filter(event, filter);
2247 else
2248 event->filter = filter;
2249
2250 free_filter:
2251 if (err || ftrace_event_is_function(call))
2252 __free_filter(filter);
2253
2254 out_unlock:
2255 mutex_unlock(&event_mutex);
2256
2257 return err;
2258 }
2259
2260 #endif /* CONFIG_PERF_EVENTS */
2261
2262 #ifdef CONFIG_FTRACE_STARTUP_TEST
2263
2264 #include <linux/types.h>
2265 #include <linux/tracepoint.h>
2266
2267 #define CREATE_TRACE_POINTS
2268 #include "trace_events_filter_test.h"
2269
2270 #define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
2271 { \
2272 .filter = FILTER, \
2273 .rec = { .a = va, .b = vb, .c = vc, .d = vd, \
2274 .e = ve, .f = vf, .g = vg, .h = vh }, \
2275 .match = m, \
2276 .not_visited = nvisit, \
2277 }
2278 #define YES 1
2279 #define NO 0
2280
2281 static struct test_filter_data_t {
2282 char *filter;
2283 struct trace_event_raw_ftrace_test_filter rec;
2284 int match;
2285 char *not_visited;
2286 } test_filter_data[] = {
2287 #define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
2288 "e == 1 && f == 1 && g == 1 && h == 1"
2289 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
2290 DATA_REC(NO, 0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
2291 DATA_REC(NO, 1, 1, 1, 1, 1, 1, 1, 0, ""),
2292 #undef FILTER
2293 #define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
2294 "e == 1 || f == 1 || g == 1 || h == 1"
2295 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
2296 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2297 DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
2298 #undef FILTER
2299 #define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
2300 "(e == 1 || f == 1) && (g == 1 || h == 1)"
2301 DATA_REC(NO, 0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
2302 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2303 DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
2304 DATA_REC(NO, 1, 0, 1, 0, 0, 1, 0, 0, "bd"),
2305 #undef FILTER
2306 #define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
2307 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2308 DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
2309 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
2310 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2311 #undef FILTER
2312 #define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
2313 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2314 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
2315 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2316 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
2317 #undef FILTER
2318 #define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
2319 "(e == 1 || f == 1)) && (g == 1 || h == 1)"
2320 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
2321 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
2322 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
2323 #undef FILTER
2324 #define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
2325 "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
2326 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
2327 DATA_REC(NO, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2328 DATA_REC(NO, 1, 0, 1, 0, 1, 0, 1, 0, ""),
2329 #undef FILTER
2330 #define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
2331 "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
2332 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
2333 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2334 DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
2335 };
2336
2337 #undef DATA_REC
2338 #undef FILTER
2339 #undef YES
2340 #undef NO
2341
2342 #define DATA_CNT (sizeof(test_filter_data)/sizeof(struct test_filter_data_t))
2343
2344 static int test_pred_visited;
2345
2346 static int test_pred_visited_fn(struct filter_pred *pred, void *event)
2347 {
2348 struct ftrace_event_field *field = pred->field;
2349
2350 test_pred_visited = 1;
2351 printk(KERN_INFO "\npred visited %s\n", field->name);
2352 return 1;
2353 }
2354
2355 static int test_walk_pred_cb(enum move_type move, struct filter_pred *pred,
2356 int *err, void *data)
2357 {
2358 char *fields = data;
2359
2360 if ((move == MOVE_DOWN) &&
2361 (pred->left == FILTER_PRED_INVALID)) {
2362 struct ftrace_event_field *field = pred->field;
2363
2364 if (!field) {
2365 WARN(1, "all leafs should have field defined");
2366 return WALK_PRED_DEFAULT;
2367 }
2368 if (!strchr(fields, *field->name))
2369 return WALK_PRED_DEFAULT;
2370
2371 WARN_ON(!pred->fn);
2372 pred->fn = test_pred_visited_fn;
2373 }
2374 return WALK_PRED_DEFAULT;
2375 }
2376
2377 static __init int ftrace_test_event_filter(void)
2378 {
2379 int i;
2380
2381 printk(KERN_INFO "Testing ftrace filter: ");
2382
2383 for (i = 0; i < DATA_CNT; i++) {
2384 struct event_filter *filter = NULL;
2385 struct test_filter_data_t *d = &test_filter_data[i];
2386 int err;
2387
2388 err = create_filter(&event_ftrace_test_filter, d->filter,
2389 false, &filter);
2390 if (err) {
2391 printk(KERN_INFO
2392 "Failed to get filter for '%s', err %d\n",
2393 d->filter, err);
2394 __free_filter(filter);
2395 break;
2396 }
2397
2398 /*
2399 * The preemption disabling is not really needed for self
2400 * tests, but the rcu dereference will complain without it.
2401 */
2402 preempt_disable();
2403 if (*d->not_visited)
2404 walk_pred_tree(filter->preds, filter->root,
2405 test_walk_pred_cb,
2406 d->not_visited);
2407
2408 test_pred_visited = 0;
2409 err = filter_match_preds(filter, &d->rec);
2410 preempt_enable();
2411
2412 __free_filter(filter);
2413
2414 if (test_pred_visited) {
2415 printk(KERN_INFO
2416 "Failed, unwanted pred visited for filter %s\n",
2417 d->filter);
2418 break;
2419 }
2420
2421 if (err != d->match) {
2422 printk(KERN_INFO
2423 "Failed to match filter '%s', expected %d\n",
2424 d->filter, d->match);
2425 break;
2426 }
2427 }
2428
2429 if (i == DATA_CNT)
2430 printk(KERN_CONT "OK\n");
2431
2432 return 0;
2433 }
2434
2435 late_initcall(ftrace_test_event_filter);
2436
2437 #endif /* CONFIG_FTRACE_STARTUP_TEST */
Linux kernel - Deliverables
This page took 0.077087 seconds and 6 git commands to generate.