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