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