1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * trace_events_filter - generic event filtering
4  *
5  * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
6  */
7 
8 #include <linux/uaccess.h>
9 #include <linux/module.h>
10 #include <linux/ctype.h>
11 #include <linux/mutex.h>
12 #include <linux/perf_event.h>
13 #include <linux/slab.h>
14 
15 #include "trace.h"
16 #include "trace_output.h"
17 
18 #define DEFAULT_SYS_FILTER_MESSAGE					\
19 	"### global filter ###\n"					\
20 	"# Use this to set filters for multiple events.\n"		\
21 	"# Only events with the given fields will be affected.\n"	\
22 	"# If no events are modified, an error message will be displayed here"
23 
24 /* Due to token parsing '<=' must be before '<' and '>=' must be before '>' */
25 #define OPS					\
26 	C( OP_GLOB,	"~"  ),			\
27 	C( OP_NE,	"!=" ),			\
28 	C( OP_EQ,	"==" ),			\
29 	C( OP_LE,	"<=" ),			\
30 	C( OP_LT,	"<"  ),			\
31 	C( OP_GE,	">=" ),			\
32 	C( OP_GT,	">"  ),			\
33 	C( OP_BAND,	"&"  ),			\
34 	C( OP_MAX,	NULL )
35 
36 #undef C
37 #define C(a, b)	a
38 
39 enum filter_op_ids { OPS };
40 
41 #undef C
42 #define C(a, b)	b
43 
44 static const char * ops[] = { OPS };
45 
46 enum filter_pred_fn {
47 	FILTER_PRED_FN_NOP,
48 	FILTER_PRED_FN_64,
49 	FILTER_PRED_FN_64_CPUMASK,
50 	FILTER_PRED_FN_S64,
51 	FILTER_PRED_FN_U64,
52 	FILTER_PRED_FN_32,
53 	FILTER_PRED_FN_32_CPUMASK,
54 	FILTER_PRED_FN_S32,
55 	FILTER_PRED_FN_U32,
56 	FILTER_PRED_FN_16,
57 	FILTER_PRED_FN_16_CPUMASK,
58 	FILTER_PRED_FN_S16,
59 	FILTER_PRED_FN_U16,
60 	FILTER_PRED_FN_8,
61 	FILTER_PRED_FN_8_CPUMASK,
62 	FILTER_PRED_FN_S8,
63 	FILTER_PRED_FN_U8,
64 	FILTER_PRED_FN_COMM,
65 	FILTER_PRED_FN_STRING,
66 	FILTER_PRED_FN_STRLOC,
67 	FILTER_PRED_FN_STRRELLOC,
68 	FILTER_PRED_FN_PCHAR_USER,
69 	FILTER_PRED_FN_PCHAR,
70 	FILTER_PRED_FN_CPU,
71 	FILTER_PRED_FN_CPU_CPUMASK,
72 	FILTER_PRED_FN_CPUMASK,
73 	FILTER_PRED_FN_CPUMASK_CPU,
74 	FILTER_PRED_FN_FUNCTION,
75 	FILTER_PRED_FN_,
76 	FILTER_PRED_TEST_VISITED,
77 };
78 
79 struct filter_pred {
80 	struct regex		*regex;
81 	struct cpumask          *mask;
82 	unsigned short		*ops;
83 	struct ftrace_event_field *field;
84 	u64			val;
85 	u64			val2;
86 	enum filter_pred_fn	fn_num;
87 	int			offset;
88 	int			not;
89 	int			op;
90 };
91 
92 /*
93  * pred functions are OP_LE, OP_LT, OP_GE, OP_GT, and OP_BAND
94  * pred_funcs_##type below must match the order of them above.
95  */
96 #define PRED_FUNC_START			OP_LE
97 #define PRED_FUNC_MAX			(OP_BAND - PRED_FUNC_START)
98 
99 #define ERRORS								\
100 	C(NONE,			"No error"),				\
101 	C(INVALID_OP,		"Invalid operator"),			\
102 	C(TOO_MANY_OPEN,	"Too many '('"),			\
103 	C(TOO_MANY_CLOSE,	"Too few '('"),				\
104 	C(MISSING_QUOTE,	"Missing matching quote"),		\
105 	C(MISSING_BRACE_OPEN,   "Missing '{'"),				\
106 	C(MISSING_BRACE_CLOSE,  "Missing '}'"),				\
107 	C(OPERAND_TOO_LONG,	"Operand too long"),			\
108 	C(EXPECT_STRING,	"Expecting string field"),		\
109 	C(EXPECT_DIGIT,		"Expecting numeric field"),		\
110 	C(ILLEGAL_FIELD_OP,	"Illegal operation for field type"),	\
111 	C(FIELD_NOT_FOUND,	"Field not found"),			\
112 	C(ILLEGAL_INTVAL,	"Illegal integer value"),		\
113 	C(BAD_SUBSYS_FILTER,	"Couldn't find or set field in one of a subsystem's events"), \
114 	C(TOO_MANY_PREDS,	"Too many terms in predicate expression"), \
115 	C(INVALID_FILTER,	"Meaningless filter expression"),	\
116 	C(INVALID_CPULIST,	"Invalid cpulist"),	\
117 	C(IP_FIELD_ONLY,	"Only 'ip' field is supported for function trace"), \
118 	C(INVALID_VALUE,	"Invalid value (did you forget quotes)?"), \
119 	C(NO_FUNCTION,		"Function not found"),			\
120 	C(ERRNO,		"Error"),				\
121 	C(NO_FILTER,		"No filter found")
122 
123 #undef C
124 #define C(a, b)		FILT_ERR_##a
125 
126 enum { ERRORS };
127 
128 #undef C
129 #define C(a, b)		b
130 
131 static const char *err_text[] = { ERRORS };
132 
133 /* Called after a '!' character but "!=" and "!~" are not "not"s */
is_not(const char * str)134 static bool is_not(const char *str)
135 {
136 	switch (str[1]) {
137 	case '=':
138 	case '~':
139 		return false;
140 	}
141 	return true;
142 }
143 
144 /**
145  * struct prog_entry - a singe entry in the filter program
146  * @target:	     Index to jump to on a branch (actually one minus the index)
147  * @when_to_branch:  The value of the result of the predicate to do a branch
148  * @pred:	     The predicate to execute.
149  */
150 struct prog_entry {
151 	int			target;
152 	int			when_to_branch;
153 	struct filter_pred	*pred;
154 };
155 
156 /**
157  * update_preds - assign a program entry a label target
158  * @prog: The program array
159  * @N: The index of the current entry in @prog
160  * @invert: What to assign a program entry for its branch condition
161  *
162  * The program entry at @N has a target that points to the index of a program
163  * entry that can have its target and when_to_branch fields updated.
164  * Update the current program entry denoted by index @N target field to be
165  * that of the updated entry. This will denote the entry to update if
166  * we are processing an "||" after an "&&".
167  */
update_preds(struct prog_entry * prog,int N,int invert)168 static void update_preds(struct prog_entry *prog, int N, int invert)
169 {
170 	int t, s;
171 
172 	t = prog[N].target;
173 	s = prog[t].target;
174 	prog[t].when_to_branch = invert;
175 	prog[t].target = N;
176 	prog[N].target = s;
177 }
178 
179 struct filter_parse_error {
180 	int lasterr;
181 	int lasterr_pos;
182 };
183 
parse_error(struct filter_parse_error * pe,int err,int pos)184 static void parse_error(struct filter_parse_error *pe, int err, int pos)
185 {
186 	pe->lasterr = err;
187 	pe->lasterr_pos = pos;
188 }
189 
190 typedef int (*parse_pred_fn)(const char *str, void *data, int pos,
191 			     struct filter_parse_error *pe,
192 			     struct filter_pred **pred);
193 
194 enum {
195 	INVERT		= 1,
196 	PROCESS_AND	= 2,
197 	PROCESS_OR	= 4,
198 };
199 
free_predicate(struct filter_pred * pred)200 static void free_predicate(struct filter_pred *pred)
201 {
202 	if (pred) {
203 		kfree(pred->regex);
204 		kfree(pred->mask);
205 		kfree(pred);
206 	}
207 }
208 
209 /*
210  * Without going into a formal proof, this explains the method that is used in
211  * parsing the logical expressions.
212  *
213  * For example, if we have: "a && !(!b || (c && g)) || d || e && !f"
214  * The first pass will convert it into the following program:
215  *
216  * n1: r=a;       l1: if (!r) goto l4;
217  * n2: r=b;       l2: if (!r) goto l4;
218  * n3: r=c; r=!r; l3: if (r) goto l4;
219  * n4: r=g; r=!r; l4: if (r) goto l5;
220  * n5: r=d;       l5: if (r) goto T
221  * n6: r=e;       l6: if (!r) goto l7;
222  * n7: r=f; r=!r; l7: if (!r) goto F
223  * T: return TRUE
224  * F: return FALSE
225  *
226  * To do this, we use a data structure to represent each of the above
227  * predicate and conditions that has:
228  *
229  *  predicate, when_to_branch, invert, target
230  *
231  * The "predicate" will hold the function to determine the result "r".
232  * The "when_to_branch" denotes what "r" should be if a branch is to be taken
233  * "&&" would contain "!r" or (0) and "||" would contain "r" or (1).
234  * The "invert" holds whether the value should be reversed before testing.
235  * The "target" contains the label "l#" to jump to.
236  *
237  * A stack is created to hold values when parentheses are used.
238  *
239  * To simplify the logic, the labels will start at 0 and not 1.
240  *
241  * The possible invert values are 1 and 0. The number of "!"s that are in scope
242  * before the predicate determines the invert value, if the number is odd then
243  * the invert value is 1 and 0 otherwise. This means the invert value only
244  * needs to be toggled when a new "!" is introduced compared to what is stored
245  * on the stack, where parentheses were used.
246  *
247  * The top of the stack and "invert" are initialized to zero.
248  *
249  * ** FIRST PASS **
250  *
251  * #1 A loop through all the tokens is done:
252  *
253  * #2 If the token is an "(", the stack is push, and the current stack value
254  *    gets the current invert value, and the loop continues to the next token.
255  *    The top of the stack saves the "invert" value to keep track of what
256  *    the current inversion is. As "!(a && !b || c)" would require all
257  *    predicates being affected separately by the "!" before the parentheses.
258  *    And that would end up being equivalent to "(!a || b) && !c"
259  *
260  * #3 If the token is an "!", the current "invert" value gets inverted, and
261  *    the loop continues. Note, if the next token is a predicate, then
262  *    this "invert" value is only valid for the current program entry,
263  *    and does not affect other predicates later on.
264  *
265  * The only other acceptable token is the predicate string.
266  *
267  * #4 A new entry into the program is added saving: the predicate and the
268  *    current value of "invert". The target is currently assigned to the
269  *    previous program index (this will not be its final value).
270  *
271  * #5 We now enter another loop and look at the next token. The only valid
272  *    tokens are ")", "&&", "||" or end of the input string "\0".
273  *
274  * #6 The invert variable is reset to the current value saved on the top of
275  *    the stack.
276  *
277  * #7 The top of the stack holds not only the current invert value, but also
278  *    if a "&&" or "||" needs to be processed. Note, the "&&" takes higher
279  *    precedence than "||". That is "a && b || c && d" is equivalent to
280  *    "(a && b) || (c && d)". Thus the first thing to do is to see if "&&" needs
281  *    to be processed. This is the case if an "&&" was the last token. If it was
282  *    then we call update_preds(). This takes the program, the current index in
283  *    the program, and the current value of "invert".  More will be described
284  *    below about this function.
285  *
286  * #8 If the next token is "&&" then we set a flag in the top of the stack
287  *    that denotes that "&&" needs to be processed, break out of this loop
288  *    and continue with the outer loop.
289  *
290  * #9 Otherwise, if a "||" needs to be processed then update_preds() is called.
291  *    This is called with the program, the current index in the program, but
292  *    this time with an inverted value of "invert" (that is !invert). This is
293  *    because the value taken will become the "when_to_branch" value of the
294  *    program.
295  *    Note, this is called when the next token is not an "&&". As stated before,
296  *    "&&" takes higher precedence, and "||" should not be processed yet if the
297  *    next logical operation is "&&".
298  *
299  * #10 If the next token is "||" then we set a flag in the top of the stack
300  *     that denotes that "||" needs to be processed, break out of this loop
301  *     and continue with the outer loop.
302  *
303  * #11 If this is the end of the input string "\0" then we break out of both
304  *     loops.
305  *
306  * #12 Otherwise, the next token is ")", where we pop the stack and continue
307  *     this inner loop.
308  *
309  * Now to discuss the update_pred() function, as that is key to the setting up
310  * of the program. Remember the "target" of the program is initialized to the
311  * previous index and not the "l" label. The target holds the index into the
312  * program that gets affected by the operand. Thus if we have something like
313  *  "a || b && c", when we process "a" the target will be "-1" (undefined).
314  * When we process "b", its target is "0", which is the index of "a", as that's
315  * the predicate that is affected by "||". But because the next token after "b"
316  * is "&&" we don't call update_preds(). Instead continue to "c". As the
317  * next token after "c" is not "&&" but the end of input, we first process the
318  * "&&" by calling update_preds() for the "&&" then we process the "||" by
319  * calling updates_preds() with the values for processing "||".
320  *
321  * What does that mean? What update_preds() does is to first save the "target"
322  * of the program entry indexed by the current program entry's "target"
323  * (remember the "target" is initialized to previous program entry), and then
324  * sets that "target" to the current index which represents the label "l#".
325  * That entry's "when_to_branch" is set to the value passed in (the "invert"
326  * or "!invert"). Then it sets the current program entry's target to the saved
327  * "target" value (the old value of the program that had its "target" updated
328  * to the label).
329  *
330  * Looking back at "a || b && c", we have the following steps:
331  *  "a"  - prog[0] = { "a", X, -1 } // pred, when_to_branch, target
332  *  "||" - flag that we need to process "||"; continue outer loop
333  *  "b"  - prog[1] = { "b", X, 0 }
334  *  "&&" - flag that we need to process "&&"; continue outer loop
335  * (Notice we did not process "||")
336  *  "c"  - prog[2] = { "c", X, 1 }
337  *  update_preds(prog, 2, 0); // invert = 0 as we are processing "&&"
338  *    t = prog[2].target; // t = 1
339  *    s = prog[t].target; // s = 0
340  *    prog[t].target = 2; // Set target to "l2"
341  *    prog[t].when_to_branch = 0;
342  *    prog[2].target = s;
343  * update_preds(prog, 2, 1); // invert = 1 as we are now processing "||"
344  *    t = prog[2].target; // t = 0
345  *    s = prog[t].target; // s = -1
346  *    prog[t].target = 2; // Set target to "l2"
347  *    prog[t].when_to_branch = 1;
348  *    prog[2].target = s;
349  *
350  * #13 Which brings us to the final step of the first pass, which is to set
351  *     the last program entry's when_to_branch and target, which will be
352  *     when_to_branch = 0; target = N; ( the label after the program entry after
353  *     the last program entry processed above).
354  *
355  * If we denote "TRUE" to be the entry after the last program entry processed,
356  * and "FALSE" the program entry after that, we are now done with the first
357  * pass.
358  *
359  * Making the above "a || b && c" have a program of:
360  *  prog[0] = { "a", 1, 2 }
361  *  prog[1] = { "b", 0, 2 }
362  *  prog[2] = { "c", 0, 3 }
363  *
364  * Which translates into:
365  * n0: r = a; l0: if (r) goto l2;
366  * n1: r = b; l1: if (!r) goto l2;
367  * n2: r = c; l2: if (!r) goto l3;  // Which is the same as "goto F;"
368  * T: return TRUE; l3:
369  * F: return FALSE
370  *
371  * Although, after the first pass, the program is correct, it is
372  * inefficient. The simple sample of "a || b && c" could be easily been
373  * converted into:
374  * n0: r = a; if (r) goto T
375  * n1: r = b; if (!r) goto F
376  * n2: r = c; if (!r) goto F
377  * T: return TRUE;
378  * F: return FALSE;
379  *
380  * The First Pass is over the input string. The next too passes are over
381  * the program itself.
382  *
383  * ** SECOND PASS **
384  *
385  * Which brings us to the second pass. If a jump to a label has the
386  * same condition as that label, it can instead jump to its target.
387  * The original example of "a && !(!b || (c && g)) || d || e && !f"
388  * where the first pass gives us:
389  *
390  * n1: r=a;       l1: if (!r) goto l4;
391  * n2: r=b;       l2: if (!r) goto l4;
392  * n3: r=c; r=!r; l3: if (r) goto l4;
393  * n4: r=g; r=!r; l4: if (r) goto l5;
394  * n5: r=d;       l5: if (r) goto T
395  * n6: r=e;       l6: if (!r) goto l7;
396  * n7: r=f; r=!r; l7: if (!r) goto F:
397  * T: return TRUE;
398  * F: return FALSE
399  *
400  * We can see that "l3: if (r) goto l4;" and at l4, we have "if (r) goto l5;".
401  * And "l5: if (r) goto T", we could optimize this by converting l3 and l4
402  * to go directly to T. To accomplish this, we start from the last
403  * entry in the program and work our way back. If the target of the entry
404  * has the same "when_to_branch" then we could use that entry's target.
405  * Doing this, the above would end up as:
406  *
407  * n1: r=a;       l1: if (!r) goto l4;
408  * n2: r=b;       l2: if (!r) goto l4;
409  * n3: r=c; r=!r; l3: if (r) goto T;
410  * n4: r=g; r=!r; l4: if (r) goto T;
411  * n5: r=d;       l5: if (r) goto T;
412  * n6: r=e;       l6: if (!r) goto F;
413  * n7: r=f; r=!r; l7: if (!r) goto F;
414  * T: return TRUE
415  * F: return FALSE
416  *
417  * In that same pass, if the "when_to_branch" doesn't match, we can simply
418  * go to the program entry after the label. That is, "l2: if (!r) goto l4;"
419  * where "l4: if (r) goto T;", then we can convert l2 to be:
420  * "l2: if (!r) goto n5;".
421  *
422  * This will have the second pass give us:
423  * n1: r=a;       l1: if (!r) goto n5;
424  * n2: r=b;       l2: if (!r) goto n5;
425  * n3: r=c; r=!r; l3: if (r) goto T;
426  * n4: r=g; r=!r; l4: if (r) goto T;
427  * n5: r=d;       l5: if (r) goto T
428  * n6: r=e;       l6: if (!r) goto F;
429  * n7: r=f; r=!r; l7: if (!r) goto F
430  * T: return TRUE
431  * F: return FALSE
432  *
433  * Notice, all the "l#" labels are no longer used, and they can now
434  * be discarded.
435  *
436  * ** THIRD PASS **
437  *
438  * For the third pass we deal with the inverts. As they simply just
439  * make the "when_to_branch" get inverted, a simple loop over the
440  * program to that does: "when_to_branch ^= invert;" will do the
441  * job, leaving us with:
442  * n1: r=a; if (!r) goto n5;
443  * n2: r=b; if (!r) goto n5;
444  * n3: r=c: if (!r) goto T;
445  * n4: r=g; if (!r) goto T;
446  * n5: r=d; if (r) goto T
447  * n6: r=e; if (!r) goto F;
448  * n7: r=f; if (r) goto F
449  * T: return TRUE
450  * F: return FALSE
451  *
452  * As "r = a; if (!r) goto n5;" is obviously the same as
453  * "if (!a) goto n5;" without doing anything we can interpret the
454  * program as:
455  * n1: if (!a) goto n5;
456  * n2: if (!b) goto n5;
457  * n3: if (!c) goto T;
458  * n4: if (!g) goto T;
459  * n5: if (d) goto T
460  * n6: if (!e) goto F;
461  * n7: if (f) goto F
462  * T: return TRUE
463  * F: return FALSE
464  *
465  * Since the inverts are discarded at the end, there's no reason to store
466  * them in the program array (and waste memory). A separate array to hold
467  * the inverts is used and freed at the end.
468  */
469 static struct prog_entry *
predicate_parse(const char * str,int nr_parens,int nr_preds,parse_pred_fn parse_pred,void * data,struct filter_parse_error * pe)470 predicate_parse(const char *str, int nr_parens, int nr_preds,
471 		parse_pred_fn parse_pred, void *data,
472 		struct filter_parse_error *pe)
473 {
474 	struct prog_entry *prog_stack;
475 	struct prog_entry *prog;
476 	const char *ptr = str;
477 	char *inverts = NULL;
478 	int *op_stack;
479 	int *top;
480 	int invert = 0;
481 	int ret = -ENOMEM;
482 	int len;
483 	int N = 0;
484 	int i;
485 
486 	nr_preds += 2; /* For TRUE and FALSE */
487 
488 	op_stack = kmalloc_array(nr_parens, sizeof(*op_stack), GFP_KERNEL);
489 	if (!op_stack)
490 		return ERR_PTR(-ENOMEM);
491 	prog_stack = kcalloc(nr_preds, sizeof(*prog_stack), GFP_KERNEL);
492 	if (!prog_stack) {
493 		parse_error(pe, -ENOMEM, 0);
494 		goto out_free;
495 	}
496 	inverts = kmalloc_array(nr_preds, sizeof(*inverts), GFP_KERNEL);
497 	if (!inverts) {
498 		parse_error(pe, -ENOMEM, 0);
499 		goto out_free;
500 	}
501 
502 	top = op_stack;
503 	prog = prog_stack;
504 	*top = 0;
505 
506 	/* First pass */
507 	while (*ptr) {						/* #1 */
508 		const char *next = ptr++;
509 
510 		if (isspace(*next))
511 			continue;
512 
513 		switch (*next) {
514 		case '(':					/* #2 */
515 			if (top - op_stack > nr_parens) {
516 				ret = -EINVAL;
517 				goto out_free;
518 			}
519 			*(++top) = invert;
520 			continue;
521 		case '!':					/* #3 */
522 			if (!is_not(next))
523 				break;
524 			invert = !invert;
525 			continue;
526 		}
527 
528 		if (N >= nr_preds) {
529 			parse_error(pe, FILT_ERR_TOO_MANY_PREDS, next - str);
530 			goto out_free;
531 		}
532 
533 		inverts[N] = invert;				/* #4 */
534 		prog[N].target = N-1;
535 
536 		len = parse_pred(next, data, ptr - str, pe, &prog[N].pred);
537 		if (len < 0) {
538 			ret = len;
539 			goto out_free;
540 		}
541 		ptr = next + len;
542 
543 		N++;
544 
545 		ret = -1;
546 		while (1) {					/* #5 */
547 			next = ptr++;
548 			if (isspace(*next))
549 				continue;
550 
551 			switch (*next) {
552 			case ')':
553 			case '\0':
554 				break;
555 			case '&':
556 			case '|':
557 				/* accepting only "&&" or "||" */
558 				if (next[1] == next[0]) {
559 					ptr++;
560 					break;
561 				}
562 				fallthrough;
563 			default:
564 				parse_error(pe, FILT_ERR_TOO_MANY_PREDS,
565 					    next - str);
566 				goto out_free;
567 			}
568 
569 			invert = *top & INVERT;
570 
571 			if (*top & PROCESS_AND) {		/* #7 */
572 				update_preds(prog, N - 1, invert);
573 				*top &= ~PROCESS_AND;
574 			}
575 			if (*next == '&') {			/* #8 */
576 				*top |= PROCESS_AND;
577 				break;
578 			}
579 			if (*top & PROCESS_OR) {		/* #9 */
580 				update_preds(prog, N - 1, !invert);
581 				*top &= ~PROCESS_OR;
582 			}
583 			if (*next == '|') {			/* #10 */
584 				*top |= PROCESS_OR;
585 				break;
586 			}
587 			if (!*next)				/* #11 */
588 				goto out;
589 
590 			if (top == op_stack) {
591 				ret = -1;
592 				/* Too few '(' */
593 				parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, ptr - str);
594 				goto out_free;
595 			}
596 			top--;					/* #12 */
597 		}
598 	}
599  out:
600 	if (top != op_stack) {
601 		/* Too many '(' */
602 		parse_error(pe, FILT_ERR_TOO_MANY_OPEN, ptr - str);
603 		goto out_free;
604 	}
605 
606 	if (!N) {
607 		/* No program? */
608 		ret = -EINVAL;
609 		parse_error(pe, FILT_ERR_NO_FILTER, ptr - str);
610 		goto out_free;
611 	}
612 
613 	prog[N].pred = NULL;					/* #13 */
614 	prog[N].target = 1;		/* TRUE */
615 	prog[N+1].pred = NULL;
616 	prog[N+1].target = 0;		/* FALSE */
617 	prog[N-1].target = N;
618 	prog[N-1].when_to_branch = false;
619 
620 	/* Second Pass */
621 	for (i = N-1 ; i--; ) {
622 		int target = prog[i].target;
623 		if (prog[i].when_to_branch == prog[target].when_to_branch)
624 			prog[i].target = prog[target].target;
625 	}
626 
627 	/* Third Pass */
628 	for (i = 0; i < N; i++) {
629 		invert = inverts[i] ^ prog[i].when_to_branch;
630 		prog[i].when_to_branch = invert;
631 		/* Make sure the program always moves forward */
632 		if (WARN_ON(prog[i].target <= i)) {
633 			ret = -EINVAL;
634 			goto out_free;
635 		}
636 	}
637 
638 	kfree(op_stack);
639 	kfree(inverts);
640 	return prog;
641 out_free:
642 	kfree(op_stack);
643 	kfree(inverts);
644 	if (prog_stack) {
645 		for (i = 0; prog_stack[i].pred; i++)
646 			free_predicate(prog_stack[i].pred);
647 		kfree(prog_stack);
648 	}
649 	return ERR_PTR(ret);
650 }
651 
652 static inline int
do_filter_cpumask(int op,const struct cpumask * mask,const struct cpumask * cmp)653 do_filter_cpumask(int op, const struct cpumask *mask, const struct cpumask *cmp)
654 {
655 	switch (op) {
656 	case OP_EQ:
657 		return cpumask_equal(mask, cmp);
658 	case OP_NE:
659 		return !cpumask_equal(mask, cmp);
660 	case OP_BAND:
661 		return cpumask_intersects(mask, cmp);
662 	default:
663 		return 0;
664 	}
665 }
666 
667 /* Optimisation of do_filter_cpumask() for scalar fields */
668 static inline int
do_filter_scalar_cpumask(int op,unsigned int cpu,const struct cpumask * mask)669 do_filter_scalar_cpumask(int op, unsigned int cpu, const struct cpumask *mask)
670 {
671 	/*
672 	 * Per the weight-of-one cpumask optimisations, the mask passed in this
673 	 * function has a weight >= 2, so it is never equal to a single scalar.
674 	 */
675 	switch (op) {
676 	case OP_EQ:
677 		return false;
678 	case OP_NE:
679 		return true;
680 	case OP_BAND:
681 		return cpumask_test_cpu(cpu, mask);
682 	default:
683 		return 0;
684 	}
685 }
686 
687 static inline int
do_filter_cpumask_scalar(int op,const struct cpumask * mask,unsigned int cpu)688 do_filter_cpumask_scalar(int op, const struct cpumask *mask, unsigned int cpu)
689 {
690 	switch (op) {
691 	case OP_EQ:
692 		return cpumask_test_cpu(cpu, mask) &&
693 			cpumask_nth(1, mask) >= nr_cpu_ids;
694 	case OP_NE:
695 		return !cpumask_test_cpu(cpu, mask) ||
696 			cpumask_nth(1, mask) < nr_cpu_ids;
697 	case OP_BAND:
698 		return cpumask_test_cpu(cpu, mask);
699 	default:
700 		return 0;
701 	}
702 }
703 
704 enum pred_cmp_types {
705 	PRED_CMP_TYPE_NOP,
706 	PRED_CMP_TYPE_LT,
707 	PRED_CMP_TYPE_LE,
708 	PRED_CMP_TYPE_GT,
709 	PRED_CMP_TYPE_GE,
710 	PRED_CMP_TYPE_BAND,
711 };
712 
713 #define DEFINE_COMPARISON_PRED(type)					\
714 static int filter_pred_##type(struct filter_pred *pred, void *event)	\
715 {									\
716 	switch (pred->op) {						\
717 	case OP_LT: {							\
718 		type *addr = (type *)(event + pred->offset);		\
719 		type val = (type)pred->val;				\
720 		return *addr < val;					\
721 	}								\
722 	case OP_LE: {					\
723 		type *addr = (type *)(event + pred->offset);		\
724 		type val = (type)pred->val;				\
725 		return *addr <= val;					\
726 	}								\
727 	case OP_GT: {					\
728 		type *addr = (type *)(event + pred->offset);		\
729 		type val = (type)pred->val;				\
730 		return *addr > val;					\
731 	}								\
732 	case OP_GE: {					\
733 		type *addr = (type *)(event + pred->offset);		\
734 		type val = (type)pred->val;				\
735 		return *addr >= val;					\
736 	}								\
737 	case OP_BAND: {					\
738 		type *addr = (type *)(event + pred->offset);		\
739 		type val = (type)pred->val;				\
740 		return !!(*addr & val);					\
741 	}								\
742 	default:							\
743 		return 0;						\
744 	}								\
745 }
746 
747 #define DEFINE_CPUMASK_COMPARISON_PRED(size)					\
748 static int filter_pred_##size##_cpumask(struct filter_pred *pred, void *event)	\
749 {										\
750 	u##size *addr = (u##size *)(event + pred->offset);			\
751 	unsigned int cpu = *addr;						\
752 										\
753 	if (cpu >= nr_cpu_ids)							\
754 		return 0;							\
755 										\
756 	return do_filter_scalar_cpumask(pred->op, cpu, pred->mask);		\
757 }
758 
759 #define DEFINE_EQUALITY_PRED(size)					\
760 static int filter_pred_##size(struct filter_pred *pred, void *event)	\
761 {									\
762 	u##size *addr = (u##size *)(event + pred->offset);		\
763 	u##size val = (u##size)pred->val;				\
764 	int match;							\
765 									\
766 	match = (val == *addr) ^ pred->not;				\
767 									\
768 	return match;							\
769 }
770 
771 DEFINE_COMPARISON_PRED(s64);
772 DEFINE_COMPARISON_PRED(u64);
773 DEFINE_COMPARISON_PRED(s32);
774 DEFINE_COMPARISON_PRED(u32);
775 DEFINE_COMPARISON_PRED(s16);
776 DEFINE_COMPARISON_PRED(u16);
777 DEFINE_COMPARISON_PRED(s8);
778 DEFINE_COMPARISON_PRED(u8);
779 
780 DEFINE_CPUMASK_COMPARISON_PRED(64);
781 DEFINE_CPUMASK_COMPARISON_PRED(32);
782 DEFINE_CPUMASK_COMPARISON_PRED(16);
783 DEFINE_CPUMASK_COMPARISON_PRED(8);
784 
785 DEFINE_EQUALITY_PRED(64);
786 DEFINE_EQUALITY_PRED(32);
787 DEFINE_EQUALITY_PRED(16);
788 DEFINE_EQUALITY_PRED(8);
789 
790 /* user space strings temp buffer */
791 #define USTRING_BUF_SIZE	1024
792 
793 struct ustring_buffer {
794 	char		buffer[USTRING_BUF_SIZE];
795 };
796 
797 static __percpu struct ustring_buffer *ustring_per_cpu;
798 
test_string(char * str)799 static __always_inline char *test_string(char *str)
800 {
801 	struct ustring_buffer *ubuf;
802 	char *kstr;
803 
804 	if (!ustring_per_cpu)
805 		return NULL;
806 
807 	ubuf = this_cpu_ptr(ustring_per_cpu);
808 	kstr = ubuf->buffer;
809 
810 	/* For safety, do not trust the string pointer */
811 	if (!strncpy_from_kernel_nofault(kstr, str, USTRING_BUF_SIZE))
812 		return NULL;
813 	return kstr;
814 }
815 
test_ustring(char * str)816 static __always_inline char *test_ustring(char *str)
817 {
818 	struct ustring_buffer *ubuf;
819 	char __user *ustr;
820 	char *kstr;
821 
822 	if (!ustring_per_cpu)
823 		return NULL;
824 
825 	ubuf = this_cpu_ptr(ustring_per_cpu);
826 	kstr = ubuf->buffer;
827 
828 	/* user space address? */
829 	ustr = (char __user *)str;
830 	if (!strncpy_from_user_nofault(kstr, ustr, USTRING_BUF_SIZE))
831 		return NULL;
832 
833 	return kstr;
834 }
835 
836 /* Filter predicate for fixed sized arrays of characters */
filter_pred_string(struct filter_pred * pred,void * event)837 static int filter_pred_string(struct filter_pred *pred, void *event)
838 {
839 	char *addr = (char *)(event + pred->offset);
840 	int cmp, match;
841 
842 	cmp = pred->regex->match(addr, pred->regex, pred->regex->field_len);
843 
844 	match = cmp ^ pred->not;
845 
846 	return match;
847 }
848 
filter_pchar(struct filter_pred * pred,char * str)849 static __always_inline int filter_pchar(struct filter_pred *pred, char *str)
850 {
851 	int cmp, match;
852 	int len;
853 
854 	len = strlen(str) + 1;	/* including tailing '\0' */
855 	cmp = pred->regex->match(str, pred->regex, len);
856 
857 	match = cmp ^ pred->not;
858 
859 	return match;
860 }
861 /* Filter predicate for char * pointers */
filter_pred_pchar(struct filter_pred * pred,void * event)862 static int filter_pred_pchar(struct filter_pred *pred, void *event)
863 {
864 	char **addr = (char **)(event + pred->offset);
865 	char *str;
866 
867 	str = test_string(*addr);
868 	if (!str)
869 		return 0;
870 
871 	return filter_pchar(pred, str);
872 }
873 
874 /* Filter predicate for char * pointers in user space*/
filter_pred_pchar_user(struct filter_pred * pred,void * event)875 static int filter_pred_pchar_user(struct filter_pred *pred, void *event)
876 {
877 	char **addr = (char **)(event + pred->offset);
878 	char *str;
879 
880 	str = test_ustring(*addr);
881 	if (!str)
882 		return 0;
883 
884 	return filter_pchar(pred, str);
885 }
886 
887 /*
888  * Filter predicate for dynamic sized arrays of characters.
889  * These are implemented through a list of strings at the end
890  * of the entry.
891  * Also each of these strings have a field in the entry which
892  * contains its offset from the beginning of the entry.
893  * We have then first to get this field, dereference it
894  * and add it to the address of the entry, and at last we have
895  * the address of the string.
896  */
filter_pred_strloc(struct filter_pred * pred,void * event)897 static int filter_pred_strloc(struct filter_pred *pred, void *event)
898 {
899 	u32 str_item = *(u32 *)(event + pred->offset);
900 	int str_loc = str_item & 0xffff;
901 	int str_len = str_item >> 16;
902 	char *addr = (char *)(event + str_loc);
903 	int cmp, match;
904 
905 	cmp = pred->regex->match(addr, pred->regex, str_len);
906 
907 	match = cmp ^ pred->not;
908 
909 	return match;
910 }
911 
912 /*
913  * Filter predicate for relative dynamic sized arrays of characters.
914  * These are implemented through a list of strings at the end
915  * of the entry as same as dynamic string.
916  * The difference is that the relative one records the location offset
917  * from the field itself, not the event entry.
918  */
filter_pred_strrelloc(struct filter_pred * pred,void * event)919 static int filter_pred_strrelloc(struct filter_pred *pred, void *event)
920 {
921 	u32 *item = (u32 *)(event + pred->offset);
922 	u32 str_item = *item;
923 	int str_loc = str_item & 0xffff;
924 	int str_len = str_item >> 16;
925 	char *addr = (char *)(&item[1]) + str_loc;
926 	int cmp, match;
927 
928 	cmp = pred->regex->match(addr, pred->regex, str_len);
929 
930 	match = cmp ^ pred->not;
931 
932 	return match;
933 }
934 
935 /* Filter predicate for CPUs. */
filter_pred_cpu(struct filter_pred * pred,void * event)936 static int filter_pred_cpu(struct filter_pred *pred, void *event)
937 {
938 	int cpu, cmp;
939 
940 	cpu = raw_smp_processor_id();
941 	cmp = pred->val;
942 
943 	switch (pred->op) {
944 	case OP_EQ:
945 		return cpu == cmp;
946 	case OP_NE:
947 		return cpu != cmp;
948 	case OP_LT:
949 		return cpu < cmp;
950 	case OP_LE:
951 		return cpu <= cmp;
952 	case OP_GT:
953 		return cpu > cmp;
954 	case OP_GE:
955 		return cpu >= cmp;
956 	default:
957 		return 0;
958 	}
959 }
960 
961 /* Filter predicate for current CPU vs user-provided cpumask */
filter_pred_cpu_cpumask(struct filter_pred * pred,void * event)962 static int filter_pred_cpu_cpumask(struct filter_pred *pred, void *event)
963 {
964 	int cpu = raw_smp_processor_id();
965 
966 	return do_filter_scalar_cpumask(pred->op, cpu, pred->mask);
967 }
968 
969 /* Filter predicate for cpumask field vs user-provided cpumask */
filter_pred_cpumask(struct filter_pred * pred,void * event)970 static int filter_pred_cpumask(struct filter_pred *pred, void *event)
971 {
972 	u32 item = *(u32 *)(event + pred->offset);
973 	int loc = item & 0xffff;
974 	const struct cpumask *mask = (event + loc);
975 	const struct cpumask *cmp = pred->mask;
976 
977 	return do_filter_cpumask(pred->op, mask, cmp);
978 }
979 
980 /* Filter predicate for cpumask field vs user-provided scalar  */
filter_pred_cpumask_cpu(struct filter_pred * pred,void * event)981 static int filter_pred_cpumask_cpu(struct filter_pred *pred, void *event)
982 {
983 	u32 item = *(u32 *)(event + pred->offset);
984 	int loc = item & 0xffff;
985 	const struct cpumask *mask = (event + loc);
986 	unsigned int cpu = pred->val;
987 
988 	return do_filter_cpumask_scalar(pred->op, mask, cpu);
989 }
990 
991 /* Filter predicate for COMM. */
filter_pred_comm(struct filter_pred * pred,void * event)992 static int filter_pred_comm(struct filter_pred *pred, void *event)
993 {
994 	int cmp;
995 
996 	cmp = pred->regex->match(current->comm, pred->regex,
997 				TASK_COMM_LEN);
998 	return cmp ^ pred->not;
999 }
1000 
1001 /* Filter predicate for functions. */
filter_pred_function(struct filter_pred * pred,void * event)1002 static int filter_pred_function(struct filter_pred *pred, void *event)
1003 {
1004 	unsigned long *addr = (unsigned long *)(event + pred->offset);
1005 	unsigned long start = (unsigned long)pred->val;
1006 	unsigned long end = (unsigned long)pred->val2;
1007 	int ret = *addr >= start && *addr < end;
1008 
1009 	return pred->op == OP_EQ ? ret : !ret;
1010 }
1011 
1012 /*
1013  * regex_match_foo - Basic regex callbacks
1014  *
1015  * @str: the string to be searched
1016  * @r:   the regex structure containing the pattern string
1017  * @len: the length of the string to be searched (including '\0')
1018  *
1019  * Note:
1020  * - @str might not be NULL-terminated if it's of type DYN_STRING
1021  *   RDYN_STRING, or STATIC_STRING, unless @len is zero.
1022  */
1023 
regex_match_full(char * str,struct regex * r,int len)1024 static int regex_match_full(char *str, struct regex *r, int len)
1025 {
1026 	/* len of zero means str is dynamic and ends with '\0' */
1027 	if (!len)
1028 		return strcmp(str, r->pattern) == 0;
1029 
1030 	return strncmp(str, r->pattern, len) == 0;
1031 }
1032 
regex_match_front(char * str,struct regex * r,int len)1033 static int regex_match_front(char *str, struct regex *r, int len)
1034 {
1035 	if (len && len < r->len)
1036 		return 0;
1037 
1038 	return strncmp(str, r->pattern, r->len) == 0;
1039 }
1040 
regex_match_middle(char * str,struct regex * r,int len)1041 static int regex_match_middle(char *str, struct regex *r, int len)
1042 {
1043 	if (!len)
1044 		return strstr(str, r->pattern) != NULL;
1045 
1046 	return strnstr(str, r->pattern, len) != NULL;
1047 }
1048 
regex_match_end(char * str,struct regex * r,int len)1049 static int regex_match_end(char *str, struct regex *r, int len)
1050 {
1051 	int strlen = len - 1;
1052 
1053 	if (strlen >= r->len &&
1054 	    memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
1055 		return 1;
1056 	return 0;
1057 }
1058 
regex_match_glob(char * str,struct regex * r,int len __maybe_unused)1059 static int regex_match_glob(char *str, struct regex *r, int len __maybe_unused)
1060 {
1061 	if (glob_match(r->pattern, str))
1062 		return 1;
1063 	return 0;
1064 }
1065 
1066 /**
1067  * filter_parse_regex - parse a basic regex
1068  * @buff:   the raw regex
1069  * @len:    length of the regex
1070  * @search: will point to the beginning of the string to compare
1071  * @not:    tell whether the match will have to be inverted
1072  *
1073  * This passes in a buffer containing a regex and this function will
1074  * set search to point to the search part of the buffer and
1075  * return the type of search it is (see enum above).
1076  * This does modify buff.
1077  *
1078  * Returns enum type.
1079  *  search returns the pointer to use for comparison.
1080  *  not returns 1 if buff started with a '!'
1081  *     0 otherwise.
1082  */
filter_parse_regex(char * buff,int len,char ** search,int * not)1083 enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
1084 {
1085 	int type = MATCH_FULL;
1086 	int i;
1087 
1088 	if (buff[0] == '!') {
1089 		*not = 1;
1090 		buff++;
1091 		len--;
1092 	} else
1093 		*not = 0;
1094 
1095 	*search = buff;
1096 
1097 	if (isdigit(buff[0]))
1098 		return MATCH_INDEX;
1099 
1100 	for (i = 0; i < len; i++) {
1101 		if (buff[i] == '*') {
1102 			if (!i) {
1103 				type = MATCH_END_ONLY;
1104 			} else if (i == len - 1) {
1105 				if (type == MATCH_END_ONLY)
1106 					type = MATCH_MIDDLE_ONLY;
1107 				else
1108 					type = MATCH_FRONT_ONLY;
1109 				buff[i] = 0;
1110 				break;
1111 			} else {	/* pattern continues, use full glob */
1112 				return MATCH_GLOB;
1113 			}
1114 		} else if (strchr("[?\\", buff[i])) {
1115 			return MATCH_GLOB;
1116 		}
1117 	}
1118 	if (buff[0] == '*')
1119 		*search = buff + 1;
1120 
1121 	return type;
1122 }
1123 
filter_build_regex(struct filter_pred * pred)1124 static void filter_build_regex(struct filter_pred *pred)
1125 {
1126 	struct regex *r = pred->regex;
1127 	char *search;
1128 	enum regex_type type = MATCH_FULL;
1129 
1130 	if (pred->op == OP_GLOB) {
1131 		type = filter_parse_regex(r->pattern, r->len, &search, &pred->not);
1132 		r->len = strlen(search);
1133 		memmove(r->pattern, search, r->len+1);
1134 	}
1135 
1136 	switch (type) {
1137 	/* MATCH_INDEX should not happen, but if it does, match full */
1138 	case MATCH_INDEX:
1139 	case MATCH_FULL:
1140 		r->match = regex_match_full;
1141 		break;
1142 	case MATCH_FRONT_ONLY:
1143 		r->match = regex_match_front;
1144 		break;
1145 	case MATCH_MIDDLE_ONLY:
1146 		r->match = regex_match_middle;
1147 		break;
1148 	case MATCH_END_ONLY:
1149 		r->match = regex_match_end;
1150 		break;
1151 	case MATCH_GLOB:
1152 		r->match = regex_match_glob;
1153 		break;
1154 	}
1155 }
1156 
1157 
1158 #ifdef CONFIG_FTRACE_STARTUP_TEST
1159 static int test_pred_visited_fn(struct filter_pred *pred, void *event);
1160 #else
test_pred_visited_fn(struct filter_pred * pred,void * event)1161 static int test_pred_visited_fn(struct filter_pred *pred, void *event)
1162 {
1163 	return 0;
1164 }
1165 #endif
1166 
1167 
1168 static int filter_pred_fn_call(struct filter_pred *pred, void *event);
1169 
1170 /* return 1 if event matches, 0 otherwise (discard) */
filter_match_preds(struct event_filter * filter,void * rec)1171 int filter_match_preds(struct event_filter *filter, void *rec)
1172 {
1173 	struct prog_entry *prog;
1174 	int i;
1175 
1176 	/* no filter is considered a match */
1177 	if (!filter)
1178 		return 1;
1179 
1180 	/* Protected by either SRCU(tracepoint_srcu) or preempt_disable */
1181 	prog = rcu_dereference_raw(filter->prog);
1182 	if (!prog)
1183 		return 1;
1184 
1185 	for (i = 0; prog[i].pred; i++) {
1186 		struct filter_pred *pred = prog[i].pred;
1187 		int match = filter_pred_fn_call(pred, rec);
1188 		if (match == prog[i].when_to_branch)
1189 			i = prog[i].target;
1190 	}
1191 	return prog[i].target;
1192 }
1193 EXPORT_SYMBOL_GPL(filter_match_preds);
1194 
remove_filter_string(struct event_filter * filter)1195 static void remove_filter_string(struct event_filter *filter)
1196 {
1197 	if (!filter)
1198 		return;
1199 
1200 	kfree(filter->filter_string);
1201 	filter->filter_string = NULL;
1202 }
1203 
append_filter_err(struct trace_array * tr,struct filter_parse_error * pe,struct event_filter * filter)1204 static void append_filter_err(struct trace_array *tr,
1205 			      struct filter_parse_error *pe,
1206 			      struct event_filter *filter)
1207 {
1208 	struct trace_seq *s;
1209 	int pos = pe->lasterr_pos;
1210 	char *buf;
1211 	int len;
1212 
1213 	if (WARN_ON(!filter->filter_string))
1214 		return;
1215 
1216 	s = kmalloc(sizeof(*s), GFP_KERNEL);
1217 	if (!s)
1218 		return;
1219 	trace_seq_init(s);
1220 
1221 	len = strlen(filter->filter_string);
1222 	if (pos > len)
1223 		pos = len;
1224 
1225 	/* indexing is off by one */
1226 	if (pos)
1227 		pos++;
1228 
1229 	trace_seq_puts(s, filter->filter_string);
1230 	if (pe->lasterr > 0) {
1231 		trace_seq_printf(s, "\n%*s", pos, "^");
1232 		trace_seq_printf(s, "\nparse_error: %s\n", err_text[pe->lasterr]);
1233 		tracing_log_err(tr, "event filter parse error",
1234 				filter->filter_string, err_text,
1235 				pe->lasterr, pe->lasterr_pos);
1236 	} else {
1237 		trace_seq_printf(s, "\nError: (%d)\n", pe->lasterr);
1238 		tracing_log_err(tr, "event filter parse error",
1239 				filter->filter_string, err_text,
1240 				FILT_ERR_ERRNO, 0);
1241 	}
1242 	trace_seq_putc(s, 0);
1243 	buf = kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL);
1244 	if (buf) {
1245 		kfree(filter->filter_string);
1246 		filter->filter_string = buf;
1247 	}
1248 	kfree(s);
1249 }
1250 
event_filter(struct trace_event_file * file)1251 static inline struct event_filter *event_filter(struct trace_event_file *file)
1252 {
1253 	return file->filter;
1254 }
1255 
1256 /* caller must hold event_mutex */
print_event_filter(struct trace_event_file * file,struct trace_seq * s)1257 void print_event_filter(struct trace_event_file *file, struct trace_seq *s)
1258 {
1259 	struct event_filter *filter = event_filter(file);
1260 
1261 	if (filter && filter->filter_string)
1262 		trace_seq_printf(s, "%s\n", filter->filter_string);
1263 	else
1264 		trace_seq_puts(s, "none\n");
1265 }
1266 
print_subsystem_event_filter(struct event_subsystem * system,struct trace_seq * s)1267 void print_subsystem_event_filter(struct event_subsystem *system,
1268 				  struct trace_seq *s)
1269 {
1270 	struct event_filter *filter;
1271 
1272 	mutex_lock(&event_mutex);
1273 	filter = system->filter;
1274 	if (filter && filter->filter_string)
1275 		trace_seq_printf(s, "%s\n", filter->filter_string);
1276 	else
1277 		trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
1278 	mutex_unlock(&event_mutex);
1279 }
1280 
free_prog(struct event_filter * filter)1281 static void free_prog(struct event_filter *filter)
1282 {
1283 	struct prog_entry *prog;
1284 	int i;
1285 
1286 	prog = rcu_access_pointer(filter->prog);
1287 	if (!prog)
1288 		return;
1289 
1290 	for (i = 0; prog[i].pred; i++)
1291 		free_predicate(prog[i].pred);
1292 	kfree(prog);
1293 }
1294 
filter_disable(struct trace_event_file * file)1295 static void filter_disable(struct trace_event_file *file)
1296 {
1297 	unsigned long old_flags = file->flags;
1298 
1299 	file->flags &= ~EVENT_FILE_FL_FILTERED;
1300 
1301 	if (old_flags != file->flags)
1302 		trace_buffered_event_disable();
1303 }
1304 
__free_filter(struct event_filter * filter)1305 static void __free_filter(struct event_filter *filter)
1306 {
1307 	if (!filter)
1308 		return;
1309 
1310 	free_prog(filter);
1311 	kfree(filter->filter_string);
1312 	kfree(filter);
1313 }
1314 
free_event_filter(struct event_filter * filter)1315 void free_event_filter(struct event_filter *filter)
1316 {
1317 	__free_filter(filter);
1318 }
1319 
__remove_filter(struct trace_event_file * file)1320 static inline void __remove_filter(struct trace_event_file *file)
1321 {
1322 	filter_disable(file);
1323 	remove_filter_string(file->filter);
1324 }
1325 
filter_free_subsystem_preds(struct trace_subsystem_dir * dir,struct trace_array * tr)1326 static void filter_free_subsystem_preds(struct trace_subsystem_dir *dir,
1327 					struct trace_array *tr)
1328 {
1329 	struct trace_event_file *file;
1330 
1331 	list_for_each_entry(file, &tr->events, list) {
1332 		if (file->system != dir)
1333 			continue;
1334 		__remove_filter(file);
1335 	}
1336 }
1337 
__free_subsystem_filter(struct trace_event_file * file)1338 static inline void __free_subsystem_filter(struct trace_event_file *file)
1339 {
1340 	__free_filter(file->filter);
1341 	file->filter = NULL;
1342 }
1343 
filter_free_subsystem_filters(struct trace_subsystem_dir * dir,struct trace_array * tr)1344 static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir,
1345 					  struct trace_array *tr)
1346 {
1347 	struct trace_event_file *file;
1348 
1349 	list_for_each_entry(file, &tr->events, list) {
1350 		if (file->system != dir)
1351 			continue;
1352 		__free_subsystem_filter(file);
1353 	}
1354 }
1355 
filter_assign_type(const char * type)1356 int filter_assign_type(const char *type)
1357 {
1358 	if (strstr(type, "__data_loc")) {
1359 		if (strstr(type, "char"))
1360 			return FILTER_DYN_STRING;
1361 		if (strstr(type, "cpumask_t"))
1362 			return FILTER_CPUMASK;
1363 	}
1364 
1365 	if (strstr(type, "__rel_loc") && strstr(type, "char"))
1366 		return FILTER_RDYN_STRING;
1367 
1368 	if (strchr(type, '[') && strstr(type, "char"))
1369 		return FILTER_STATIC_STRING;
1370 
1371 	if (strcmp(type, "char *") == 0 || strcmp(type, "const char *") == 0)
1372 		return FILTER_PTR_STRING;
1373 
1374 	return FILTER_OTHER;
1375 }
1376 
select_comparison_fn(enum filter_op_ids op,int field_size,int field_is_signed)1377 static enum filter_pred_fn select_comparison_fn(enum filter_op_ids op,
1378 						int field_size, int field_is_signed)
1379 {
1380 	enum filter_pred_fn fn = FILTER_PRED_FN_NOP;
1381 	int pred_func_index = -1;
1382 
1383 	switch (op) {
1384 	case OP_EQ:
1385 	case OP_NE:
1386 		break;
1387 	default:
1388 		if (WARN_ON_ONCE(op < PRED_FUNC_START))
1389 			return fn;
1390 		pred_func_index = op - PRED_FUNC_START;
1391 		if (WARN_ON_ONCE(pred_func_index > PRED_FUNC_MAX))
1392 			return fn;
1393 	}
1394 
1395 	switch (field_size) {
1396 	case 8:
1397 		if (pred_func_index < 0)
1398 			fn = FILTER_PRED_FN_64;
1399 		else if (field_is_signed)
1400 			fn = FILTER_PRED_FN_S64;
1401 		else
1402 			fn = FILTER_PRED_FN_U64;
1403 		break;
1404 	case 4:
1405 		if (pred_func_index < 0)
1406 			fn = FILTER_PRED_FN_32;
1407 		else if (field_is_signed)
1408 			fn = FILTER_PRED_FN_S32;
1409 		else
1410 			fn = FILTER_PRED_FN_U32;
1411 		break;
1412 	case 2:
1413 		if (pred_func_index < 0)
1414 			fn = FILTER_PRED_FN_16;
1415 		else if (field_is_signed)
1416 			fn = FILTER_PRED_FN_S16;
1417 		else
1418 			fn = FILTER_PRED_FN_U16;
1419 		break;
1420 	case 1:
1421 		if (pred_func_index < 0)
1422 			fn = FILTER_PRED_FN_8;
1423 		else if (field_is_signed)
1424 			fn = FILTER_PRED_FN_S8;
1425 		else
1426 			fn = FILTER_PRED_FN_U8;
1427 		break;
1428 	}
1429 
1430 	return fn;
1431 }
1432 
1433 
filter_pred_fn_call(struct filter_pred * pred,void * event)1434 static int filter_pred_fn_call(struct filter_pred *pred, void *event)
1435 {
1436 	switch (pred->fn_num) {
1437 	case FILTER_PRED_FN_64:
1438 		return filter_pred_64(pred, event);
1439 	case FILTER_PRED_FN_64_CPUMASK:
1440 		return filter_pred_64_cpumask(pred, event);
1441 	case FILTER_PRED_FN_S64:
1442 		return filter_pred_s64(pred, event);
1443 	case FILTER_PRED_FN_U64:
1444 		return filter_pred_u64(pred, event);
1445 	case FILTER_PRED_FN_32:
1446 		return filter_pred_32(pred, event);
1447 	case FILTER_PRED_FN_32_CPUMASK:
1448 		return filter_pred_32_cpumask(pred, event);
1449 	case FILTER_PRED_FN_S32:
1450 		return filter_pred_s32(pred, event);
1451 	case FILTER_PRED_FN_U32:
1452 		return filter_pred_u32(pred, event);
1453 	case FILTER_PRED_FN_16:
1454 		return filter_pred_16(pred, event);
1455 	case FILTER_PRED_FN_16_CPUMASK:
1456 		return filter_pred_16_cpumask(pred, event);
1457 	case FILTER_PRED_FN_S16:
1458 		return filter_pred_s16(pred, event);
1459 	case FILTER_PRED_FN_U16:
1460 		return filter_pred_u16(pred, event);
1461 	case FILTER_PRED_FN_8:
1462 		return filter_pred_8(pred, event);
1463 	case FILTER_PRED_FN_8_CPUMASK:
1464 		return filter_pred_8_cpumask(pred, event);
1465 	case FILTER_PRED_FN_S8:
1466 		return filter_pred_s8(pred, event);
1467 	case FILTER_PRED_FN_U8:
1468 		return filter_pred_u8(pred, event);
1469 	case FILTER_PRED_FN_COMM:
1470 		return filter_pred_comm(pred, event);
1471 	case FILTER_PRED_FN_STRING:
1472 		return filter_pred_string(pred, event);
1473 	case FILTER_PRED_FN_STRLOC:
1474 		return filter_pred_strloc(pred, event);
1475 	case FILTER_PRED_FN_STRRELLOC:
1476 		return filter_pred_strrelloc(pred, event);
1477 	case FILTER_PRED_FN_PCHAR_USER:
1478 		return filter_pred_pchar_user(pred, event);
1479 	case FILTER_PRED_FN_PCHAR:
1480 		return filter_pred_pchar(pred, event);
1481 	case FILTER_PRED_FN_CPU:
1482 		return filter_pred_cpu(pred, event);
1483 	case FILTER_PRED_FN_CPU_CPUMASK:
1484 		return filter_pred_cpu_cpumask(pred, event);
1485 	case FILTER_PRED_FN_CPUMASK:
1486 		return filter_pred_cpumask(pred, event);
1487 	case FILTER_PRED_FN_CPUMASK_CPU:
1488 		return filter_pred_cpumask_cpu(pred, event);
1489 	case FILTER_PRED_FN_FUNCTION:
1490 		return filter_pred_function(pred, event);
1491 	case FILTER_PRED_TEST_VISITED:
1492 		return test_pred_visited_fn(pred, event);
1493 	default:
1494 		return 0;
1495 	}
1496 }
1497 
1498 /* Called when a predicate is encountered by predicate_parse() */
parse_pred(const char * str,void * data,int pos,struct filter_parse_error * pe,struct filter_pred ** pred_ptr)1499 static int parse_pred(const char *str, void *data,
1500 		      int pos, struct filter_parse_error *pe,
1501 		      struct filter_pred **pred_ptr)
1502 {
1503 	struct trace_event_call *call = data;
1504 	struct ftrace_event_field *field;
1505 	struct filter_pred *pred = NULL;
1506 	unsigned long offset;
1507 	unsigned long size;
1508 	unsigned long ip;
1509 	char num_buf[24];	/* Big enough to hold an address */
1510 	char *field_name;
1511 	char *name;
1512 	bool function = false;
1513 	bool ustring = false;
1514 	char q;
1515 	u64 val;
1516 	int len;
1517 	int ret;
1518 	int op;
1519 	int s;
1520 	int i = 0;
1521 
1522 	/* First find the field to associate to */
1523 	while (isspace(str[i]))
1524 		i++;
1525 	s = i;
1526 
1527 	while (isalnum(str[i]) || str[i] == '_')
1528 		i++;
1529 
1530 	len = i - s;
1531 
1532 	if (!len)
1533 		return -1;
1534 
1535 	field_name = kmemdup_nul(str + s, len, GFP_KERNEL);
1536 	if (!field_name)
1537 		return -ENOMEM;
1538 
1539 	/* Make sure that the field exists */
1540 
1541 	field = trace_find_event_field(call, field_name);
1542 	kfree(field_name);
1543 	if (!field) {
1544 		parse_error(pe, FILT_ERR_FIELD_NOT_FOUND, pos + i);
1545 		return -EINVAL;
1546 	}
1547 
1548 	/* See if the field is a user space string */
1549 	if ((len = str_has_prefix(str + i, ".ustring"))) {
1550 		ustring = true;
1551 		i += len;
1552 	}
1553 
1554 	/* See if the field is a kernel function name */
1555 	if ((len = str_has_prefix(str + i, ".function"))) {
1556 		function = true;
1557 		i += len;
1558 	}
1559 
1560 	while (isspace(str[i]))
1561 		i++;
1562 
1563 	/* Make sure this op is supported */
1564 	for (op = 0; ops[op]; op++) {
1565 		/* This is why '<=' must come before '<' in ops[] */
1566 		if (strncmp(str + i, ops[op], strlen(ops[op])) == 0)
1567 			break;
1568 	}
1569 
1570 	if (!ops[op]) {
1571 		parse_error(pe, FILT_ERR_INVALID_OP, pos + i);
1572 		goto err_free;
1573 	}
1574 
1575 	i += strlen(ops[op]);
1576 
1577 	while (isspace(str[i]))
1578 		i++;
1579 
1580 	s = i;
1581 
1582 	pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1583 	if (!pred)
1584 		return -ENOMEM;
1585 
1586 	pred->field = field;
1587 	pred->offset = field->offset;
1588 	pred->op = op;
1589 
1590 	if (function) {
1591 		/* The field must be the same size as long */
1592 		if (field->size != sizeof(long)) {
1593 			parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1594 			goto err_free;
1595 		}
1596 
1597 		/* Function only works with '==' or '!=' and an unquoted string */
1598 		switch (op) {
1599 		case OP_NE:
1600 		case OP_EQ:
1601 			break;
1602 		default:
1603 			parse_error(pe, FILT_ERR_INVALID_OP, pos + i);
1604 			goto err_free;
1605 		}
1606 
1607 		if (isdigit(str[i])) {
1608 			/* We allow 0xDEADBEEF */
1609 			while (isalnum(str[i]))
1610 				i++;
1611 
1612 			len = i - s;
1613 			/* 0xfeedfacedeadbeef is 18 chars max */
1614 			if (len >= sizeof(num_buf)) {
1615 				parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1616 				goto err_free;
1617 			}
1618 
1619 			strncpy(num_buf, str + s, len);
1620 			num_buf[len] = 0;
1621 
1622 			ret = kstrtoul(num_buf, 0, &ip);
1623 			if (ret) {
1624 				parse_error(pe, FILT_ERR_INVALID_VALUE, pos + i);
1625 				goto err_free;
1626 			}
1627 		} else {
1628 			s = i;
1629 			for (; str[i] && !isspace(str[i]); i++)
1630 				;
1631 
1632 			len = i - s;
1633 			name = kmemdup_nul(str + s, len, GFP_KERNEL);
1634 			if (!name)
1635 				goto err_mem;
1636 			ip = kallsyms_lookup_name(name);
1637 			kfree(name);
1638 			if (!ip) {
1639 				parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
1640 				goto err_free;
1641 			}
1642 		}
1643 
1644 		/* Now find the function start and end address */
1645 		if (!kallsyms_lookup_size_offset(ip, &size, &offset)) {
1646 			parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
1647 			goto err_free;
1648 		}
1649 
1650 		pred->fn_num = FILTER_PRED_FN_FUNCTION;
1651 		pred->val = ip - offset;
1652 		pred->val2 = pred->val + size;
1653 
1654 	} else if (ftrace_event_is_function(call)) {
1655 		/*
1656 		 * Perf does things different with function events.
1657 		 * It only allows an "ip" field, and expects a string.
1658 		 * But the string does not need to be surrounded by quotes.
1659 		 * If it is a string, the assigned function as a nop,
1660 		 * (perf doesn't use it) and grab everything.
1661 		 */
1662 		if (strcmp(field->name, "ip") != 0) {
1663 			parse_error(pe, FILT_ERR_IP_FIELD_ONLY, pos + i);
1664 			goto err_free;
1665 		}
1666 		pred->fn_num = FILTER_PRED_FN_NOP;
1667 
1668 		/*
1669 		 * Quotes are not required, but if they exist then we need
1670 		 * to read them till we hit a matching one.
1671 		 */
1672 		if (str[i] == '\'' || str[i] == '"')
1673 			q = str[i];
1674 		else
1675 			q = 0;
1676 
1677 		for (i++; str[i]; i++) {
1678 			if (q && str[i] == q)
1679 				break;
1680 			if (!q && (str[i] == ')' || str[i] == '&' ||
1681 				   str[i] == '|'))
1682 				break;
1683 		}
1684 		/* Skip quotes */
1685 		if (q)
1686 			s++;
1687 		len = i - s;
1688 		if (len >= MAX_FILTER_STR_VAL) {
1689 			parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1690 			goto err_free;
1691 		}
1692 
1693 		pred->regex = kzalloc(sizeof(*pred->regex), GFP_KERNEL);
1694 		if (!pred->regex)
1695 			goto err_mem;
1696 		pred->regex->len = len;
1697 		strncpy(pred->regex->pattern, str + s, len);
1698 		pred->regex->pattern[len] = 0;
1699 
1700 	} else if (!strncmp(str + i, "CPUS", 4)) {
1701 		unsigned int maskstart;
1702 		bool single;
1703 		char *tmp;
1704 
1705 		switch (field->filter_type) {
1706 		case FILTER_CPUMASK:
1707 		case FILTER_CPU:
1708 		case FILTER_OTHER:
1709 			break;
1710 		default:
1711 			parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1712 			goto err_free;
1713 		}
1714 
1715 		switch (op) {
1716 		case OP_EQ:
1717 		case OP_NE:
1718 		case OP_BAND:
1719 			break;
1720 		default:
1721 			parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1722 			goto err_free;
1723 		}
1724 
1725 		/* Skip CPUS */
1726 		i += 4;
1727 		if (str[i++] != '{') {
1728 			parse_error(pe, FILT_ERR_MISSING_BRACE_OPEN, pos + i);
1729 			goto err_free;
1730 		}
1731 		maskstart = i;
1732 
1733 		/* Walk the cpulist until closing } */
1734 		for (; str[i] && str[i] != '}'; i++)
1735 			;
1736 
1737 		if (str[i] != '}') {
1738 			parse_error(pe, FILT_ERR_MISSING_BRACE_CLOSE, pos + i);
1739 			goto err_free;
1740 		}
1741 
1742 		if (maskstart == i) {
1743 			parse_error(pe, FILT_ERR_INVALID_CPULIST, pos + i);
1744 			goto err_free;
1745 		}
1746 
1747 		/* Copy the cpulist between { and } */
1748 		tmp = kmalloc((i - maskstart) + 1, GFP_KERNEL);
1749 		if (!tmp)
1750 			goto err_mem;
1751 
1752 		strscpy(tmp, str + maskstart, (i - maskstart) + 1);
1753 		pred->mask = kzalloc(cpumask_size(), GFP_KERNEL);
1754 		if (!pred->mask) {
1755 			kfree(tmp);
1756 			goto err_mem;
1757 		}
1758 
1759 		/* Now parse it */
1760 		if (cpulist_parse(tmp, pred->mask)) {
1761 			kfree(tmp);
1762 			parse_error(pe, FILT_ERR_INVALID_CPULIST, pos + i);
1763 			goto err_free;
1764 		}
1765 		kfree(tmp);
1766 
1767 		/* Move along */
1768 		i++;
1769 
1770 		/*
1771 		 * Optimisation: if the user-provided mask has a weight of one
1772 		 * then we can treat it as a scalar input.
1773 		 */
1774 		single = cpumask_weight(pred->mask) == 1;
1775 		if (single) {
1776 			pred->val = cpumask_first(pred->mask);
1777 			kfree(pred->mask);
1778 			pred->mask = NULL;
1779 		}
1780 
1781 		if (field->filter_type == FILTER_CPUMASK) {
1782 			pred->fn_num = single ?
1783 				FILTER_PRED_FN_CPUMASK_CPU :
1784 				FILTER_PRED_FN_CPUMASK;
1785 		} else if (field->filter_type == FILTER_CPU) {
1786 			if (single) {
1787 				if (pred->op == OP_BAND)
1788 					pred->op = OP_EQ;
1789 
1790 				pred->fn_num = FILTER_PRED_FN_CPU;
1791 			} else {
1792 				pred->fn_num = FILTER_PRED_FN_CPU_CPUMASK;
1793 			}
1794 		} else if (single) {
1795 			if (pred->op == OP_BAND)
1796 				pred->op = OP_EQ;
1797 
1798 			pred->fn_num = select_comparison_fn(pred->op, field->size, false);
1799 			if (pred->op == OP_NE)
1800 				pred->not = 1;
1801 		} else {
1802 			switch (field->size) {
1803 			case 8:
1804 				pred->fn_num = FILTER_PRED_FN_64_CPUMASK;
1805 				break;
1806 			case 4:
1807 				pred->fn_num = FILTER_PRED_FN_32_CPUMASK;
1808 				break;
1809 			case 2:
1810 				pred->fn_num = FILTER_PRED_FN_16_CPUMASK;
1811 				break;
1812 			case 1:
1813 				pred->fn_num = FILTER_PRED_FN_8_CPUMASK;
1814 				break;
1815 			}
1816 		}
1817 
1818 	/* This is either a string, or an integer */
1819 	} else if (str[i] == '\'' || str[i] == '"') {
1820 		char q = str[i];
1821 
1822 		/* Make sure the op is OK for strings */
1823 		switch (op) {
1824 		case OP_NE:
1825 			pred->not = 1;
1826 			fallthrough;
1827 		case OP_GLOB:
1828 		case OP_EQ:
1829 			break;
1830 		default:
1831 			parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1832 			goto err_free;
1833 		}
1834 
1835 		/* Make sure the field is OK for strings */
1836 		if (!is_string_field(field)) {
1837 			parse_error(pe, FILT_ERR_EXPECT_DIGIT, pos + i);
1838 			goto err_free;
1839 		}
1840 
1841 		for (i++; str[i]; i++) {
1842 			if (str[i] == q)
1843 				break;
1844 		}
1845 		if (!str[i]) {
1846 			parse_error(pe, FILT_ERR_MISSING_QUOTE, pos + i);
1847 			goto err_free;
1848 		}
1849 
1850 		/* Skip quotes */
1851 		s++;
1852 		len = i - s;
1853 		if (len >= MAX_FILTER_STR_VAL) {
1854 			parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1855 			goto err_free;
1856 		}
1857 
1858 		pred->regex = kzalloc(sizeof(*pred->regex), GFP_KERNEL);
1859 		if (!pred->regex)
1860 			goto err_mem;
1861 		pred->regex->len = len;
1862 		strncpy(pred->regex->pattern, str + s, len);
1863 		pred->regex->pattern[len] = 0;
1864 
1865 		filter_build_regex(pred);
1866 
1867 		if (field->filter_type == FILTER_COMM) {
1868 			pred->fn_num = FILTER_PRED_FN_COMM;
1869 
1870 		} else if (field->filter_type == FILTER_STATIC_STRING) {
1871 			pred->fn_num = FILTER_PRED_FN_STRING;
1872 			pred->regex->field_len = field->size;
1873 
1874 		} else if (field->filter_type == FILTER_DYN_STRING) {
1875 			pred->fn_num = FILTER_PRED_FN_STRLOC;
1876 		} else if (field->filter_type == FILTER_RDYN_STRING)
1877 			pred->fn_num = FILTER_PRED_FN_STRRELLOC;
1878 		else {
1879 
1880 			if (!ustring_per_cpu) {
1881 				/* Once allocated, keep it around for good */
1882 				ustring_per_cpu = alloc_percpu(struct ustring_buffer);
1883 				if (!ustring_per_cpu)
1884 					goto err_mem;
1885 			}
1886 
1887 			if (ustring)
1888 				pred->fn_num = FILTER_PRED_FN_PCHAR_USER;
1889 			else
1890 				pred->fn_num = FILTER_PRED_FN_PCHAR;
1891 		}
1892 		/* go past the last quote */
1893 		i++;
1894 
1895 	} else if (isdigit(str[i]) || str[i] == '-') {
1896 
1897 		/* Make sure the field is not a string */
1898 		if (is_string_field(field)) {
1899 			parse_error(pe, FILT_ERR_EXPECT_STRING, pos + i);
1900 			goto err_free;
1901 		}
1902 
1903 		if (op == OP_GLOB) {
1904 			parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
1905 			goto err_free;
1906 		}
1907 
1908 		if (str[i] == '-')
1909 			i++;
1910 
1911 		/* We allow 0xDEADBEEF */
1912 		while (isalnum(str[i]))
1913 			i++;
1914 
1915 		len = i - s;
1916 		/* 0xfeedfacedeadbeef is 18 chars max */
1917 		if (len >= sizeof(num_buf)) {
1918 			parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
1919 			goto err_free;
1920 		}
1921 
1922 		strncpy(num_buf, str + s, len);
1923 		num_buf[len] = 0;
1924 
1925 		/* Make sure it is a value */
1926 		if (field->is_signed)
1927 			ret = kstrtoll(num_buf, 0, &val);
1928 		else
1929 			ret = kstrtoull(num_buf, 0, &val);
1930 		if (ret) {
1931 			parse_error(pe, FILT_ERR_ILLEGAL_INTVAL, pos + s);
1932 			goto err_free;
1933 		}
1934 
1935 		pred->val = val;
1936 
1937 		if (field->filter_type == FILTER_CPU)
1938 			pred->fn_num = FILTER_PRED_FN_CPU;
1939 		else {
1940 			pred->fn_num = select_comparison_fn(pred->op, field->size,
1941 							    field->is_signed);
1942 			if (pred->op == OP_NE)
1943 				pred->not = 1;
1944 		}
1945 
1946 	} else {
1947 		parse_error(pe, FILT_ERR_INVALID_VALUE, pos + i);
1948 		goto err_free;
1949 	}
1950 
1951 	*pred_ptr = pred;
1952 	return i;
1953 
1954 err_free:
1955 	free_predicate(pred);
1956 	return -EINVAL;
1957 err_mem:
1958 	free_predicate(pred);
1959 	return -ENOMEM;
1960 }
1961 
1962 enum {
1963 	TOO_MANY_CLOSE		= -1,
1964 	TOO_MANY_OPEN		= -2,
1965 	MISSING_QUOTE		= -3,
1966 };
1967 
1968 /*
1969  * Read the filter string once to calculate the number of predicates
1970  * as well as how deep the parentheses go.
1971  *
1972  * Returns:
1973  *   0 - everything is fine (err is undefined)
1974  *  -1 - too many ')'
1975  *  -2 - too many '('
1976  *  -3 - No matching quote
1977  */
calc_stack(const char * str,int * parens,int * preds,int * err)1978 static int calc_stack(const char *str, int *parens, int *preds, int *err)
1979 {
1980 	bool is_pred = false;
1981 	int nr_preds = 0;
1982 	int open = 1; /* Count the expression as "(E)" */
1983 	int last_quote = 0;
1984 	int max_open = 1;
1985 	int quote = 0;
1986 	int i;
1987 
1988 	*err = 0;
1989 
1990 	for (i = 0; str[i]; i++) {
1991 		if (isspace(str[i]))
1992 			continue;
1993 		if (quote) {
1994 			if (str[i] == quote)
1995 			       quote = 0;
1996 			continue;
1997 		}
1998 
1999 		switch (str[i]) {
2000 		case '\'':
2001 		case '"':
2002 			quote = str[i];
2003 			last_quote = i;
2004 			break;
2005 		case '|':
2006 		case '&':
2007 			if (str[i+1] != str[i])
2008 				break;
2009 			is_pred = false;
2010 			continue;
2011 		case '(':
2012 			is_pred = false;
2013 			open++;
2014 			if (open > max_open)
2015 				max_open = open;
2016 			continue;
2017 		case ')':
2018 			is_pred = false;
2019 			if (open == 1) {
2020 				*err = i;
2021 				return TOO_MANY_CLOSE;
2022 			}
2023 			open--;
2024 			continue;
2025 		}
2026 		if (!is_pred) {
2027 			nr_preds++;
2028 			is_pred = true;
2029 		}
2030 	}
2031 
2032 	if (quote) {
2033 		*err = last_quote;
2034 		return MISSING_QUOTE;
2035 	}
2036 
2037 	if (open != 1) {
2038 		int level = open;
2039 
2040 		/* find the bad open */
2041 		for (i--; i; i--) {
2042 			if (quote) {
2043 				if (str[i] == quote)
2044 					quote = 0;
2045 				continue;
2046 			}
2047 			switch (str[i]) {
2048 			case '(':
2049 				if (level == open) {
2050 					*err = i;
2051 					return TOO_MANY_OPEN;
2052 				}
2053 				level--;
2054 				break;
2055 			case ')':
2056 				level++;
2057 				break;
2058 			case '\'':
2059 			case '"':
2060 				quote = str[i];
2061 				break;
2062 			}
2063 		}
2064 		/* First character is the '(' with missing ')' */
2065 		*err = 0;
2066 		return TOO_MANY_OPEN;
2067 	}
2068 
2069 	/* Set the size of the required stacks */
2070 	*parens = max_open;
2071 	*preds = nr_preds;
2072 	return 0;
2073 }
2074 
process_preds(struct trace_event_call * call,const char * filter_string,struct event_filter * filter,struct filter_parse_error * pe)2075 static int process_preds(struct trace_event_call *call,
2076 			 const char *filter_string,
2077 			 struct event_filter *filter,
2078 			 struct filter_parse_error *pe)
2079 {
2080 	struct prog_entry *prog;
2081 	int nr_parens;
2082 	int nr_preds;
2083 	int index;
2084 	int ret;
2085 
2086 	ret = calc_stack(filter_string, &nr_parens, &nr_preds, &index);
2087 	if (ret < 0) {
2088 		switch (ret) {
2089 		case MISSING_QUOTE:
2090 			parse_error(pe, FILT_ERR_MISSING_QUOTE, index);
2091 			break;
2092 		case TOO_MANY_OPEN:
2093 			parse_error(pe, FILT_ERR_TOO_MANY_OPEN, index);
2094 			break;
2095 		default:
2096 			parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, index);
2097 		}
2098 		return ret;
2099 	}
2100 
2101 	if (!nr_preds)
2102 		return -EINVAL;
2103 
2104 	prog = predicate_parse(filter_string, nr_parens, nr_preds,
2105 			       parse_pred, call, pe);
2106 	if (IS_ERR(prog))
2107 		return PTR_ERR(prog);
2108 
2109 	rcu_assign_pointer(filter->prog, prog);
2110 	return 0;
2111 }
2112 
event_set_filtered_flag(struct trace_event_file * file)2113 static inline void event_set_filtered_flag(struct trace_event_file *file)
2114 {
2115 	unsigned long old_flags = file->flags;
2116 
2117 	file->flags |= EVENT_FILE_FL_FILTERED;
2118 
2119 	if (old_flags != file->flags)
2120 		trace_buffered_event_enable();
2121 }
2122 
event_set_filter(struct trace_event_file * file,struct event_filter * filter)2123 static inline void event_set_filter(struct trace_event_file *file,
2124 				    struct event_filter *filter)
2125 {
2126 	rcu_assign_pointer(file->filter, filter);
2127 }
2128 
event_clear_filter(struct trace_event_file * file)2129 static inline void event_clear_filter(struct trace_event_file *file)
2130 {
2131 	RCU_INIT_POINTER(file->filter, NULL);
2132 }
2133 
2134 struct filter_list {
2135 	struct list_head	list;
2136 	struct event_filter	*filter;
2137 };
2138 
process_system_preds(struct trace_subsystem_dir * dir,struct trace_array * tr,struct filter_parse_error * pe,char * filter_string)2139 static int process_system_preds(struct trace_subsystem_dir *dir,
2140 				struct trace_array *tr,
2141 				struct filter_parse_error *pe,
2142 				char *filter_string)
2143 {
2144 	struct trace_event_file *file;
2145 	struct filter_list *filter_item;
2146 	struct event_filter *filter = NULL;
2147 	struct filter_list *tmp;
2148 	LIST_HEAD(filter_list);
2149 	bool fail = true;
2150 	int err;
2151 
2152 	list_for_each_entry(file, &tr->events, list) {
2153 
2154 		if (file->system != dir)
2155 			continue;
2156 
2157 		filter = kzalloc(sizeof(*filter), GFP_KERNEL);
2158 		if (!filter)
2159 			goto fail_mem;
2160 
2161 		filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
2162 		if (!filter->filter_string)
2163 			goto fail_mem;
2164 
2165 		err = process_preds(file->event_call, filter_string, filter, pe);
2166 		if (err) {
2167 			filter_disable(file);
2168 			parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
2169 			append_filter_err(tr, pe, filter);
2170 		} else
2171 			event_set_filtered_flag(file);
2172 
2173 
2174 		filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL);
2175 		if (!filter_item)
2176 			goto fail_mem;
2177 
2178 		list_add_tail(&filter_item->list, &filter_list);
2179 		/*
2180 		 * Regardless of if this returned an error, we still
2181 		 * replace the filter for the call.
2182 		 */
2183 		filter_item->filter = event_filter(file);
2184 		event_set_filter(file, filter);
2185 		filter = NULL;
2186 
2187 		fail = false;
2188 	}
2189 
2190 	if (fail)
2191 		goto fail;
2192 
2193 	/*
2194 	 * The calls can still be using the old filters.
2195 	 * Do a synchronize_rcu() and to ensure all calls are
2196 	 * done with them before we free them.
2197 	 */
2198 	tracepoint_synchronize_unregister();
2199 	list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
2200 		__free_filter(filter_item->filter);
2201 		list_del(&filter_item->list);
2202 		kfree(filter_item);
2203 	}
2204 	return 0;
2205  fail:
2206 	/* No call succeeded */
2207 	list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
2208 		list_del(&filter_item->list);
2209 		kfree(filter_item);
2210 	}
2211 	parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
2212 	return -EINVAL;
2213  fail_mem:
2214 	__free_filter(filter);
2215 	/* If any call succeeded, we still need to sync */
2216 	if (!fail)
2217 		tracepoint_synchronize_unregister();
2218 	list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
2219 		__free_filter(filter_item->filter);
2220 		list_del(&filter_item->list);
2221 		kfree(filter_item);
2222 	}
2223 	return -ENOMEM;
2224 }
2225 
create_filter_start(char * filter_string,bool set_str,struct filter_parse_error ** pse,struct event_filter ** filterp)2226 static int create_filter_start(char *filter_string, bool set_str,
2227 			       struct filter_parse_error **pse,
2228 			       struct event_filter **filterp)
2229 {
2230 	struct event_filter *filter;
2231 	struct filter_parse_error *pe = NULL;
2232 	int err = 0;
2233 
2234 	if (WARN_ON_ONCE(*pse || *filterp))
2235 		return -EINVAL;
2236 
2237 	filter = kzalloc(sizeof(*filter), GFP_KERNEL);
2238 	if (filter && set_str) {
2239 		filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
2240 		if (!filter->filter_string)
2241 			err = -ENOMEM;
2242 	}
2243 
2244 	pe = kzalloc(sizeof(*pe), GFP_KERNEL);
2245 
2246 	if (!filter || !pe || err) {
2247 		kfree(pe);
2248 		__free_filter(filter);
2249 		return -ENOMEM;
2250 	}
2251 
2252 	/* we're committed to creating a new filter */
2253 	*filterp = filter;
2254 	*pse = pe;
2255 
2256 	return 0;
2257 }
2258 
create_filter_finish(struct filter_parse_error * pe)2259 static void create_filter_finish(struct filter_parse_error *pe)
2260 {
2261 	kfree(pe);
2262 }
2263 
2264 /**
2265  * create_filter - create a filter for a trace_event_call
2266  * @tr: the trace array associated with these events
2267  * @call: trace_event_call to create a filter for
2268  * @filter_string: filter string
2269  * @set_str: remember @filter_str and enable detailed error in filter
2270  * @filterp: out param for created filter (always updated on return)
2271  *           Must be a pointer that references a NULL pointer.
2272  *
2273  * Creates a filter for @call with @filter_str.  If @set_str is %true,
2274  * @filter_str is copied and recorded in the new filter.
2275  *
2276  * On success, returns 0 and *@filterp points to the new filter.  On
2277  * failure, returns -errno and *@filterp may point to %NULL or to a new
2278  * filter.  In the latter case, the returned filter contains error
2279  * information if @set_str is %true and the caller is responsible for
2280  * freeing it.
2281  */
create_filter(struct trace_array * tr,struct trace_event_call * call,char * filter_string,bool set_str,struct event_filter ** filterp)2282 static int create_filter(struct trace_array *tr,
2283 			 struct trace_event_call *call,
2284 			 char *filter_string, bool set_str,
2285 			 struct event_filter **filterp)
2286 {
2287 	struct filter_parse_error *pe = NULL;
2288 	int err;
2289 
2290 	/* filterp must point to NULL */
2291 	if (WARN_ON(*filterp))
2292 		*filterp = NULL;
2293 
2294 	err = create_filter_start(filter_string, set_str, &pe, filterp);
2295 	if (err)
2296 		return err;
2297 
2298 	err = process_preds(call, filter_string, *filterp, pe);
2299 	if (err && set_str)
2300 		append_filter_err(tr, pe, *filterp);
2301 	create_filter_finish(pe);
2302 
2303 	return err;
2304 }
2305 
create_event_filter(struct trace_array * tr,struct trace_event_call * call,char * filter_str,bool set_str,struct event_filter ** filterp)2306 int create_event_filter(struct trace_array *tr,
2307 			struct trace_event_call *call,
2308 			char *filter_str, bool set_str,
2309 			struct event_filter **filterp)
2310 {
2311 	return create_filter(tr, call, filter_str, set_str, filterp);
2312 }
2313 
2314 /**
2315  * create_system_filter - create a filter for an event subsystem
2316  * @dir: the descriptor for the subsystem directory
2317  * @filter_str: filter string
2318  * @filterp: out param for created filter (always updated on return)
2319  *
2320  * Identical to create_filter() except that it creates a subsystem filter
2321  * and always remembers @filter_str.
2322  */
create_system_filter(struct trace_subsystem_dir * dir,char * filter_str,struct event_filter ** filterp)2323 static int create_system_filter(struct trace_subsystem_dir *dir,
2324 				char *filter_str, struct event_filter **filterp)
2325 {
2326 	struct filter_parse_error *pe = NULL;
2327 	int err;
2328 
2329 	err = create_filter_start(filter_str, true, &pe, filterp);
2330 	if (!err) {
2331 		err = process_system_preds(dir, dir->tr, pe, filter_str);
2332 		if (!err) {
2333 			/* System filters just show a default message */
2334 			kfree((*filterp)->filter_string);
2335 			(*filterp)->filter_string = NULL;
2336 		} else {
2337 			append_filter_err(dir->tr, pe, *filterp);
2338 		}
2339 	}
2340 	create_filter_finish(pe);
2341 
2342 	return err;
2343 }
2344 
2345 /* caller must hold event_mutex */
apply_event_filter(struct trace_event_file * file,char * filter_string)2346 int apply_event_filter(struct trace_event_file *file, char *filter_string)
2347 {
2348 	struct trace_event_call *call = file->event_call;
2349 	struct event_filter *filter = NULL;
2350 	int err;
2351 
2352 	if (file->flags & EVENT_FILE_FL_FREED)
2353 		return -ENODEV;
2354 
2355 	if (!strcmp(strstrip(filter_string), "0")) {
2356 		filter_disable(file);
2357 		filter = event_filter(file);
2358 
2359 		if (!filter)
2360 			return 0;
2361 
2362 		event_clear_filter(file);
2363 
2364 		/* Make sure the filter is not being used */
2365 		tracepoint_synchronize_unregister();
2366 		__free_filter(filter);
2367 
2368 		return 0;
2369 	}
2370 
2371 	err = create_filter(file->tr, call, filter_string, true, &filter);
2372 
2373 	/*
2374 	 * Always swap the call filter with the new filter
2375 	 * even if there was an error. If there was an error
2376 	 * in the filter, we disable the filter and show the error
2377 	 * string
2378 	 */
2379 	if (filter) {
2380 		struct event_filter *tmp;
2381 
2382 		tmp = event_filter(file);
2383 		if (!err)
2384 			event_set_filtered_flag(file);
2385 		else
2386 			filter_disable(file);
2387 
2388 		event_set_filter(file, filter);
2389 
2390 		if (tmp) {
2391 			/* Make sure the call is done with the filter */
2392 			tracepoint_synchronize_unregister();
2393 			__free_filter(tmp);
2394 		}
2395 	}
2396 
2397 	return err;
2398 }
2399 
apply_subsystem_event_filter(struct trace_subsystem_dir * dir,char * filter_string)2400 int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
2401 				 char *filter_string)
2402 {
2403 	struct event_subsystem *system = dir->subsystem;
2404 	struct trace_array *tr = dir->tr;
2405 	struct event_filter *filter = NULL;
2406 	int err = 0;
2407 
2408 	mutex_lock(&event_mutex);
2409 
2410 	/* Make sure the system still has events */
2411 	if (!dir->nr_events) {
2412 		err = -ENODEV;
2413 		goto out_unlock;
2414 	}
2415 
2416 	if (!strcmp(strstrip(filter_string), "0")) {
2417 		filter_free_subsystem_preds(dir, tr);
2418 		remove_filter_string(system->filter);
2419 		filter = system->filter;
2420 		system->filter = NULL;
2421 		/* Ensure all filters are no longer used */
2422 		tracepoint_synchronize_unregister();
2423 		filter_free_subsystem_filters(dir, tr);
2424 		__free_filter(filter);
2425 		goto out_unlock;
2426 	}
2427 
2428 	err = create_system_filter(dir, filter_string, &filter);
2429 	if (filter) {
2430 		/*
2431 		 * No event actually uses the system filter
2432 		 * we can free it without synchronize_rcu().
2433 		 */
2434 		__free_filter(system->filter);
2435 		system->filter = filter;
2436 	}
2437 out_unlock:
2438 	mutex_unlock(&event_mutex);
2439 
2440 	return err;
2441 }
2442 
2443 #ifdef CONFIG_PERF_EVENTS
2444 
ftrace_profile_free_filter(struct perf_event * event)2445 void ftrace_profile_free_filter(struct perf_event *event)
2446 {
2447 	struct event_filter *filter = event->filter;
2448 
2449 	event->filter = NULL;
2450 	__free_filter(filter);
2451 }
2452 
2453 struct function_filter_data {
2454 	struct ftrace_ops *ops;
2455 	int first_filter;
2456 	int first_notrace;
2457 };
2458 
2459 #ifdef CONFIG_FUNCTION_TRACER
2460 static char **
ftrace_function_filter_re(char * buf,int len,int * count)2461 ftrace_function_filter_re(char *buf, int len, int *count)
2462 {
2463 	char *str, **re;
2464 
2465 	str = kstrndup(buf, len, GFP_KERNEL);
2466 	if (!str)
2467 		return NULL;
2468 
2469 	/*
2470 	 * The argv_split function takes white space
2471 	 * as a separator, so convert ',' into spaces.
2472 	 */
2473 	strreplace(str, ',', ' ');
2474 
2475 	re = argv_split(GFP_KERNEL, str, count);
2476 	kfree(str);
2477 	return re;
2478 }
2479 
ftrace_function_set_regexp(struct ftrace_ops * ops,int filter,int reset,char * re,int len)2480 static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
2481 				      int reset, char *re, int len)
2482 {
2483 	int ret;
2484 
2485 	if (filter)
2486 		ret = ftrace_set_filter(ops, re, len, reset);
2487 	else
2488 		ret = ftrace_set_notrace(ops, re, len, reset);
2489 
2490 	return ret;
2491 }
2492 
__ftrace_function_set_filter(int filter,char * buf,int len,struct function_filter_data * data)2493 static int __ftrace_function_set_filter(int filter, char *buf, int len,
2494 					struct function_filter_data *data)
2495 {
2496 	int i, re_cnt, ret = -EINVAL;
2497 	int *reset;
2498 	char **re;
2499 
2500 	reset = filter ? &data->first_filter : &data->first_notrace;
2501 
2502 	/*
2503 	 * The 'ip' field could have multiple filters set, separated
2504 	 * either by space or comma. We first cut the filter and apply
2505 	 * all pieces separately.
2506 	 */
2507 	re = ftrace_function_filter_re(buf, len, &re_cnt);
2508 	if (!re)
2509 		return -EINVAL;
2510 
2511 	for (i = 0; i < re_cnt; i++) {
2512 		ret = ftrace_function_set_regexp(data->ops, filter, *reset,
2513 						 re[i], strlen(re[i]));
2514 		if (ret)
2515 			break;
2516 
2517 		if (*reset)
2518 			*reset = 0;
2519 	}
2520 
2521 	argv_free(re);
2522 	return ret;
2523 }
2524 
ftrace_function_check_pred(struct filter_pred * pred)2525 static int ftrace_function_check_pred(struct filter_pred *pred)
2526 {
2527 	struct ftrace_event_field *field = pred->field;
2528 
2529 	/*
2530 	 * Check the predicate for function trace, verify:
2531 	 *  - only '==' and '!=' is used
2532 	 *  - the 'ip' field is used
2533 	 */
2534 	if ((pred->op != OP_EQ) && (pred->op != OP_NE))
2535 		return -EINVAL;
2536 
2537 	if (strcmp(field->name, "ip"))
2538 		return -EINVAL;
2539 
2540 	return 0;
2541 }
2542 
ftrace_function_set_filter_pred(struct filter_pred * pred,struct function_filter_data * data)2543 static int ftrace_function_set_filter_pred(struct filter_pred *pred,
2544 					   struct function_filter_data *data)
2545 {
2546 	int ret;
2547 
2548 	/* Checking the node is valid for function trace. */
2549 	ret = ftrace_function_check_pred(pred);
2550 	if (ret)
2551 		return ret;
2552 
2553 	return __ftrace_function_set_filter(pred->op == OP_EQ,
2554 					    pred->regex->pattern,
2555 					    pred->regex->len,
2556 					    data);
2557 }
2558 
is_or(struct prog_entry * prog,int i)2559 static bool is_or(struct prog_entry *prog, int i)
2560 {
2561 	int target;
2562 
2563 	/*
2564 	 * Only "||" is allowed for function events, thus,
2565 	 * all true branches should jump to true, and any
2566 	 * false branch should jump to false.
2567 	 */
2568 	target = prog[i].target + 1;
2569 	/* True and false have NULL preds (all prog entries should jump to one */
2570 	if (prog[target].pred)
2571 		return false;
2572 
2573 	/* prog[target].target is 1 for TRUE, 0 for FALSE */
2574 	return prog[i].when_to_branch == prog[target].target;
2575 }
2576 
ftrace_function_set_filter(struct perf_event * event,struct event_filter * filter)2577 static int ftrace_function_set_filter(struct perf_event *event,
2578 				      struct event_filter *filter)
2579 {
2580 	struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2581 						lockdep_is_held(&event_mutex));
2582 	struct function_filter_data data = {
2583 		.first_filter  = 1,
2584 		.first_notrace = 1,
2585 		.ops           = &event->ftrace_ops,
2586 	};
2587 	int i;
2588 
2589 	for (i = 0; prog[i].pred; i++) {
2590 		struct filter_pred *pred = prog[i].pred;
2591 
2592 		if (!is_or(prog, i))
2593 			return -EINVAL;
2594 
2595 		if (ftrace_function_set_filter_pred(pred, &data) < 0)
2596 			return -EINVAL;
2597 	}
2598 	return 0;
2599 }
2600 #else
ftrace_function_set_filter(struct perf_event * event,struct event_filter * filter)2601 static int ftrace_function_set_filter(struct perf_event *event,
2602 				      struct event_filter *filter)
2603 {
2604 	return -ENODEV;
2605 }
2606 #endif /* CONFIG_FUNCTION_TRACER */
2607 
ftrace_profile_set_filter(struct perf_event * event,int event_id,char * filter_str)2608 int ftrace_profile_set_filter(struct perf_event *event, int event_id,
2609 			      char *filter_str)
2610 {
2611 	int err;
2612 	struct event_filter *filter = NULL;
2613 	struct trace_event_call *call;
2614 
2615 	mutex_lock(&event_mutex);
2616 
2617 	call = event->tp_event;
2618 
2619 	err = -EINVAL;
2620 	if (!call)
2621 		goto out_unlock;
2622 
2623 	err = -EEXIST;
2624 	if (event->filter)
2625 		goto out_unlock;
2626 
2627 	err = create_filter(NULL, call, filter_str, false, &filter);
2628 	if (err)
2629 		goto free_filter;
2630 
2631 	if (ftrace_event_is_function(call))
2632 		err = ftrace_function_set_filter(event, filter);
2633 	else
2634 		event->filter = filter;
2635 
2636 free_filter:
2637 	if (err || ftrace_event_is_function(call))
2638 		__free_filter(filter);
2639 
2640 out_unlock:
2641 	mutex_unlock(&event_mutex);
2642 
2643 	return err;
2644 }
2645 
2646 #endif /* CONFIG_PERF_EVENTS */
2647 
2648 #ifdef CONFIG_FTRACE_STARTUP_TEST
2649 
2650 #include <linux/types.h>
2651 #include <linux/tracepoint.h>
2652 
2653 #define CREATE_TRACE_POINTS
2654 #include "trace_events_filter_test.h"
2655 
2656 #define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
2657 { \
2658 	.filter = FILTER, \
2659 	.rec    = { .a = va, .b = vb, .c = vc, .d = vd, \
2660 		    .e = ve, .f = vf, .g = vg, .h = vh }, \
2661 	.match  = m, \
2662 	.not_visited = nvisit, \
2663 }
2664 #define YES 1
2665 #define NO  0
2666 
2667 static struct test_filter_data_t {
2668 	char *filter;
2669 	struct trace_event_raw_ftrace_test_filter rec;
2670 	int match;
2671 	char *not_visited;
2672 } test_filter_data[] = {
2673 #define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
2674 	       "e == 1 && f == 1 && g == 1 && h == 1"
2675 	DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
2676 	DATA_REC(NO,  0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
2677 	DATA_REC(NO,  1, 1, 1, 1, 1, 1, 1, 0, ""),
2678 #undef FILTER
2679 #define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
2680 	       "e == 1 || f == 1 || g == 1 || h == 1"
2681 	DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 0, ""),
2682 	DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
2683 	DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
2684 #undef FILTER
2685 #define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
2686 	       "(e == 1 || f == 1) && (g == 1 || h == 1)"
2687 	DATA_REC(NO,  0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
2688 	DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2689 	DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
2690 	DATA_REC(NO,  1, 0, 1, 0, 0, 1, 0, 0, "bd"),
2691 #undef FILTER
2692 #define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
2693 	       "(e == 1 && f == 1) || (g == 1 && h == 1)"
2694 	DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
2695 	DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
2696 	DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 1, ""),
2697 #undef FILTER
2698 #define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
2699 	       "(e == 1 && f == 1) || (g == 1 && h == 1)"
2700 	DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
2701 	DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 1, ""),
2702 	DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
2703 #undef FILTER
2704 #define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
2705 	       "(e == 1 || f == 1)) && (g == 1 || h == 1)"
2706 	DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
2707 	DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 0, ""),
2708 	DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
2709 #undef FILTER
2710 #define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
2711 	       "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
2712 	DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
2713 	DATA_REC(NO,  0, 1, 0, 1, 0, 1, 0, 1, ""),
2714 	DATA_REC(NO,  1, 0, 1, 0, 1, 0, 1, 0, ""),
2715 #undef FILTER
2716 #define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
2717 	       "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
2718 	DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
2719 	DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
2720 	DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
2721 };
2722 
2723 #undef DATA_REC
2724 #undef FILTER
2725 #undef YES
2726 #undef NO
2727 
2728 #define DATA_CNT ARRAY_SIZE(test_filter_data)
2729 
2730 static int test_pred_visited;
2731 
test_pred_visited_fn(struct filter_pred * pred,void * event)2732 static int test_pred_visited_fn(struct filter_pred *pred, void *event)
2733 {
2734 	struct ftrace_event_field *field = pred->field;
2735 
2736 	test_pred_visited = 1;
2737 	printk(KERN_INFO "\npred visited %s\n", field->name);
2738 	return 1;
2739 }
2740 
update_pred_fn(struct event_filter * filter,char * fields)2741 static void update_pred_fn(struct event_filter *filter, char *fields)
2742 {
2743 	struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2744 						lockdep_is_held(&event_mutex));
2745 	int i;
2746 
2747 	for (i = 0; prog[i].pred; i++) {
2748 		struct filter_pred *pred = prog[i].pred;
2749 		struct ftrace_event_field *field = pred->field;
2750 
2751 		WARN_ON_ONCE(pred->fn_num == FILTER_PRED_FN_NOP);
2752 
2753 		if (!field) {
2754 			WARN_ONCE(1, "all leafs should have field defined %d", i);
2755 			continue;
2756 		}
2757 
2758 		if (!strchr(fields, *field->name))
2759 			continue;
2760 
2761 		pred->fn_num = FILTER_PRED_TEST_VISITED;
2762 	}
2763 }
2764 
ftrace_test_event_filter(void)2765 static __init int ftrace_test_event_filter(void)
2766 {
2767 	int i;
2768 
2769 	printk(KERN_INFO "Testing ftrace filter: ");
2770 
2771 	for (i = 0; i < DATA_CNT; i++) {
2772 		struct event_filter *filter = NULL;
2773 		struct test_filter_data_t *d = &test_filter_data[i];
2774 		int err;
2775 
2776 		err = create_filter(NULL, &event_ftrace_test_filter,
2777 				    d->filter, false, &filter);
2778 		if (err) {
2779 			printk(KERN_INFO
2780 			       "Failed to get filter for '%s', err %d\n",
2781 			       d->filter, err);
2782 			__free_filter(filter);
2783 			break;
2784 		}
2785 
2786 		/* Needed to dereference filter->prog */
2787 		mutex_lock(&event_mutex);
2788 		/*
2789 		 * The preemption disabling is not really needed for self
2790 		 * tests, but the rcu dereference will complain without it.
2791 		 */
2792 		preempt_disable();
2793 		if (*d->not_visited)
2794 			update_pred_fn(filter, d->not_visited);
2795 
2796 		test_pred_visited = 0;
2797 		err = filter_match_preds(filter, &d->rec);
2798 		preempt_enable();
2799 
2800 		mutex_unlock(&event_mutex);
2801 
2802 		__free_filter(filter);
2803 
2804 		if (test_pred_visited) {
2805 			printk(KERN_INFO
2806 			       "Failed, unwanted pred visited for filter %s\n",
2807 			       d->filter);
2808 			break;
2809 		}
2810 
2811 		if (err != d->match) {
2812 			printk(KERN_INFO
2813 			       "Failed to match filter '%s', expected %d\n",
2814 			       d->filter, d->match);
2815 			break;
2816 		}
2817 	}
2818 
2819 	if (i == DATA_CNT)
2820 		printk(KERN_CONT "OK\n");
2821 
2822 	return 0;
2823 }
2824 
2825 late_initcall(ftrace_test_event_filter);
2826 
2827 #endif /* CONFIG_FTRACE_STARTUP_TEST */
2828