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 *kstr; 671 672 if (!ustring_per_cpu) 673 return NULL; 674 675 ubuf = this_cpu_ptr(ustring_per_cpu); 676 kstr = ubuf->buffer; 677 678 /* For safety, do not trust the string pointer */ 679 if (!strncpy_from_kernel_nofault(kstr, str, USTRING_BUF_SIZE)) 680 return NULL; 681 return kstr; 682 } 683 684 static __always_inline char *test_ustring(char *str) 685 { 686 struct ustring_buffer *ubuf; 687 char __user *ustr; 688 char *kstr; 689 690 if (!ustring_per_cpu) 691 return NULL; 692 693 ubuf = this_cpu_ptr(ustring_per_cpu); 694 kstr = ubuf->buffer; 695 696 /* user space address? */ 697 ustr = (char __user *)str; 698 if (!strncpy_from_user_nofault(kstr, ustr, USTRING_BUF_SIZE)) 699 return NULL; 700 701 return kstr; 702 } 703 704 /* Filter predicate for fixed sized arrays of characters */ 705 static int filter_pred_string(struct filter_pred *pred, void *event) 706 { 707 char *addr = (char *)(event + pred->offset); 708 int cmp, match; 709 710 cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len); 711 712 match = cmp ^ pred->not; 713 714 return match; 715 } 716 717 static __always_inline int filter_pchar(struct filter_pred *pred, char *str) 718 { 719 int cmp, match; 720 int len; 721 722 len = strlen(str) + 1; /* including tailing '\0' */ 723 cmp = pred->regex.match(str, &pred->regex, len); 724 725 match = cmp ^ pred->not; 726 727 return match; 728 } 729 /* Filter predicate for char * pointers */ 730 static int filter_pred_pchar(struct filter_pred *pred, void *event) 731 { 732 char **addr = (char **)(event + pred->offset); 733 char *str; 734 735 str = test_string(*addr); 736 if (!str) 737 return 0; 738 739 return filter_pchar(pred, str); 740 } 741 742 /* Filter predicate for char * pointers in user space*/ 743 static int filter_pred_pchar_user(struct filter_pred *pred, void *event) 744 { 745 char **addr = (char **)(event + pred->offset); 746 char *str; 747 748 str = test_ustring(*addr); 749 if (!str) 750 return 0; 751 752 return filter_pchar(pred, str); 753 } 754 755 /* 756 * Filter predicate for dynamic sized arrays of characters. 757 * These are implemented through a list of strings at the end 758 * of the entry. 759 * Also each of these strings have a field in the entry which 760 * contains its offset from the beginning of the entry. 761 * We have then first to get this field, dereference it 762 * and add it to the address of the entry, and at last we have 763 * the address of the string. 764 */ 765 static int filter_pred_strloc(struct filter_pred *pred, void *event) 766 { 767 u32 str_item = *(u32 *)(event + pred->offset); 768 int str_loc = str_item & 0xffff; 769 int str_len = str_item >> 16; 770 char *addr = (char *)(event + 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 /* 781 * Filter predicate for relative dynamic sized arrays of characters. 782 * These are implemented through a list of strings at the end 783 * of the entry as same as dynamic string. 784 * The difference is that the relative one records the location offset 785 * from the field itself, not the event entry. 786 */ 787 static int filter_pred_strrelloc(struct filter_pred *pred, void *event) 788 { 789 u32 *item = (u32 *)(event + pred->offset); 790 u32 str_item = *item; 791 int str_loc = str_item & 0xffff; 792 int str_len = str_item >> 16; 793 char *addr = (char *)(&item[1]) + str_loc; 794 int cmp, match; 795 796 cmp = pred->regex.match(addr, &pred->regex, str_len); 797 798 match = cmp ^ pred->not; 799 800 return match; 801 } 802 803 /* Filter predicate for CPUs. */ 804 static int filter_pred_cpu(struct filter_pred *pred, void *event) 805 { 806 int cpu, cmp; 807 808 cpu = raw_smp_processor_id(); 809 cmp = pred->val; 810 811 switch (pred->op) { 812 case OP_EQ: 813 return cpu == cmp; 814 case OP_NE: 815 return cpu != cmp; 816 case OP_LT: 817 return cpu < cmp; 818 case OP_LE: 819 return cpu <= cmp; 820 case OP_GT: 821 return cpu > cmp; 822 case OP_GE: 823 return cpu >= cmp; 824 default: 825 return 0; 826 } 827 } 828 829 /* Filter predicate for COMM. */ 830 static int filter_pred_comm(struct filter_pred *pred, void *event) 831 { 832 int cmp; 833 834 cmp = pred->regex.match(current->comm, &pred->regex, 835 TASK_COMM_LEN); 836 return cmp ^ pred->not; 837 } 838 839 static int filter_pred_none(struct filter_pred *pred, void *event) 840 { 841 return 0; 842 } 843 844 /* 845 * regex_match_foo - Basic regex callbacks 846 * 847 * @str: the string to be searched 848 * @r: the regex structure containing the pattern string 849 * @len: the length of the string to be searched (including '\0') 850 * 851 * Note: 852 * - @str might not be NULL-terminated if it's of type DYN_STRING 853 * RDYN_STRING, or STATIC_STRING, unless @len is zero. 854 */ 855 856 static int regex_match_full(char *str, struct regex *r, int len) 857 { 858 /* len of zero means str is dynamic and ends with '\0' */ 859 if (!len) 860 return strcmp(str, r->pattern) == 0; 861 862 return strncmp(str, r->pattern, len) == 0; 863 } 864 865 static int regex_match_front(char *str, struct regex *r, int len) 866 { 867 if (len && len < r->len) 868 return 0; 869 870 return strncmp(str, r->pattern, r->len) == 0; 871 } 872 873 static int regex_match_middle(char *str, struct regex *r, int len) 874 { 875 if (!len) 876 return strstr(str, r->pattern) != NULL; 877 878 return strnstr(str, r->pattern, len) != NULL; 879 } 880 881 static int regex_match_end(char *str, struct regex *r, int len) 882 { 883 int strlen = len - 1; 884 885 if (strlen >= r->len && 886 memcmp(str + strlen - r->len, r->pattern, r->len) == 0) 887 return 1; 888 return 0; 889 } 890 891 static int regex_match_glob(char *str, struct regex *r, int len __maybe_unused) 892 { 893 if (glob_match(r->pattern, str)) 894 return 1; 895 return 0; 896 } 897 898 /** 899 * filter_parse_regex - parse a basic regex 900 * @buff: the raw regex 901 * @len: length of the regex 902 * @search: will point to the beginning of the string to compare 903 * @not: tell whether the match will have to be inverted 904 * 905 * This passes in a buffer containing a regex and this function will 906 * set search to point to the search part of the buffer and 907 * return the type of search it is (see enum above). 908 * This does modify buff. 909 * 910 * Returns enum type. 911 * search returns the pointer to use for comparison. 912 * not returns 1 if buff started with a '!' 913 * 0 otherwise. 914 */ 915 enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not) 916 { 917 int type = MATCH_FULL; 918 int i; 919 920 if (buff[0] == '!') { 921 *not = 1; 922 buff++; 923 len--; 924 } else 925 *not = 0; 926 927 *search = buff; 928 929 if (isdigit(buff[0])) 930 return MATCH_INDEX; 931 932 for (i = 0; i < len; i++) { 933 if (buff[i] == '*') { 934 if (!i) { 935 type = MATCH_END_ONLY; 936 } else if (i == len - 1) { 937 if (type == MATCH_END_ONLY) 938 type = MATCH_MIDDLE_ONLY; 939 else 940 type = MATCH_FRONT_ONLY; 941 buff[i] = 0; 942 break; 943 } else { /* pattern continues, use full glob */ 944 return MATCH_GLOB; 945 } 946 } else if (strchr("[?\\", buff[i])) { 947 return MATCH_GLOB; 948 } 949 } 950 if (buff[0] == '*') 951 *search = buff + 1; 952 953 return type; 954 } 955 956 static void filter_build_regex(struct filter_pred *pred) 957 { 958 struct regex *r = &pred->regex; 959 char *search; 960 enum regex_type type = MATCH_FULL; 961 962 if (pred->op == OP_GLOB) { 963 type = filter_parse_regex(r->pattern, r->len, &search, &pred->not); 964 r->len = strlen(search); 965 memmove(r->pattern, search, r->len+1); 966 } 967 968 switch (type) { 969 /* MATCH_INDEX should not happen, but if it does, match full */ 970 case MATCH_INDEX: 971 case MATCH_FULL: 972 r->match = regex_match_full; 973 break; 974 case MATCH_FRONT_ONLY: 975 r->match = regex_match_front; 976 break; 977 case MATCH_MIDDLE_ONLY: 978 r->match = regex_match_middle; 979 break; 980 case MATCH_END_ONLY: 981 r->match = regex_match_end; 982 break; 983 case MATCH_GLOB: 984 r->match = regex_match_glob; 985 break; 986 } 987 } 988 989 /* return 1 if event matches, 0 otherwise (discard) */ 990 int filter_match_preds(struct event_filter *filter, void *rec) 991 { 992 struct prog_entry *prog; 993 int i; 994 995 /* no filter is considered a match */ 996 if (!filter) 997 return 1; 998 999 /* Protected by either SRCU(tracepoint_srcu) or preempt_disable */ 1000 prog = rcu_dereference_raw(filter->prog); 1001 if (!prog) 1002 return 1; 1003 1004 for (i = 0; prog[i].pred; i++) { 1005 struct filter_pred *pred = prog[i].pred; 1006 int match = pred->fn(pred, rec); 1007 if (match == prog[i].when_to_branch) 1008 i = prog[i].target; 1009 } 1010 return prog[i].target; 1011 } 1012 EXPORT_SYMBOL_GPL(filter_match_preds); 1013 1014 static void remove_filter_string(struct event_filter *filter) 1015 { 1016 if (!filter) 1017 return; 1018 1019 kfree(filter->filter_string); 1020 filter->filter_string = NULL; 1021 } 1022 1023 static void append_filter_err(struct trace_array *tr, 1024 struct filter_parse_error *pe, 1025 struct event_filter *filter) 1026 { 1027 struct trace_seq *s; 1028 int pos = pe->lasterr_pos; 1029 char *buf; 1030 int len; 1031 1032 if (WARN_ON(!filter->filter_string)) 1033 return; 1034 1035 s = kmalloc(sizeof(*s), GFP_KERNEL); 1036 if (!s) 1037 return; 1038 trace_seq_init(s); 1039 1040 len = strlen(filter->filter_string); 1041 if (pos > len) 1042 pos = len; 1043 1044 /* indexing is off by one */ 1045 if (pos) 1046 pos++; 1047 1048 trace_seq_puts(s, filter->filter_string); 1049 if (pe->lasterr > 0) { 1050 trace_seq_printf(s, "\n%*s", pos, "^"); 1051 trace_seq_printf(s, "\nparse_error: %s\n", err_text[pe->lasterr]); 1052 tracing_log_err(tr, "event filter parse error", 1053 filter->filter_string, err_text, 1054 pe->lasterr, pe->lasterr_pos); 1055 } else { 1056 trace_seq_printf(s, "\nError: (%d)\n", pe->lasterr); 1057 tracing_log_err(tr, "event filter parse error", 1058 filter->filter_string, err_text, 1059 FILT_ERR_ERRNO, 0); 1060 } 1061 trace_seq_putc(s, 0); 1062 buf = kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL); 1063 if (buf) { 1064 kfree(filter->filter_string); 1065 filter->filter_string = buf; 1066 } 1067 kfree(s); 1068 } 1069 1070 static inline struct event_filter *event_filter(struct trace_event_file *file) 1071 { 1072 return file->filter; 1073 } 1074 1075 /* caller must hold event_mutex */ 1076 void print_event_filter(struct trace_event_file *file, struct trace_seq *s) 1077 { 1078 struct event_filter *filter = event_filter(file); 1079 1080 if (filter && filter->filter_string) 1081 trace_seq_printf(s, "%s\n", filter->filter_string); 1082 else 1083 trace_seq_puts(s, "none\n"); 1084 } 1085 1086 void print_subsystem_event_filter(struct event_subsystem *system, 1087 struct trace_seq *s) 1088 { 1089 struct event_filter *filter; 1090 1091 mutex_lock(&event_mutex); 1092 filter = system->filter; 1093 if (filter && filter->filter_string) 1094 trace_seq_printf(s, "%s\n", filter->filter_string); 1095 else 1096 trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n"); 1097 mutex_unlock(&event_mutex); 1098 } 1099 1100 static void free_prog(struct event_filter *filter) 1101 { 1102 struct prog_entry *prog; 1103 int i; 1104 1105 prog = rcu_access_pointer(filter->prog); 1106 if (!prog) 1107 return; 1108 1109 for (i = 0; prog[i].pred; i++) 1110 kfree(prog[i].pred); 1111 kfree(prog); 1112 } 1113 1114 static void filter_disable(struct trace_event_file *file) 1115 { 1116 unsigned long old_flags = file->flags; 1117 1118 file->flags &= ~EVENT_FILE_FL_FILTERED; 1119 1120 if (old_flags != file->flags) 1121 trace_buffered_event_disable(); 1122 } 1123 1124 static void __free_filter(struct event_filter *filter) 1125 { 1126 if (!filter) 1127 return; 1128 1129 free_prog(filter); 1130 kfree(filter->filter_string); 1131 kfree(filter); 1132 } 1133 1134 void free_event_filter(struct event_filter *filter) 1135 { 1136 __free_filter(filter); 1137 } 1138 1139 static inline void __remove_filter(struct trace_event_file *file) 1140 { 1141 filter_disable(file); 1142 remove_filter_string(file->filter); 1143 } 1144 1145 static void filter_free_subsystem_preds(struct trace_subsystem_dir *dir, 1146 struct trace_array *tr) 1147 { 1148 struct trace_event_file *file; 1149 1150 list_for_each_entry(file, &tr->events, list) { 1151 if (file->system != dir) 1152 continue; 1153 __remove_filter(file); 1154 } 1155 } 1156 1157 static inline void __free_subsystem_filter(struct trace_event_file *file) 1158 { 1159 __free_filter(file->filter); 1160 file->filter = NULL; 1161 } 1162 1163 static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir, 1164 struct trace_array *tr) 1165 { 1166 struct trace_event_file *file; 1167 1168 list_for_each_entry(file, &tr->events, list) { 1169 if (file->system != dir) 1170 continue; 1171 __free_subsystem_filter(file); 1172 } 1173 } 1174 1175 int filter_assign_type(const char *type) 1176 { 1177 if (strstr(type, "__data_loc") && strstr(type, "char")) 1178 return FILTER_DYN_STRING; 1179 1180 if (strstr(type, "__rel_loc") && strstr(type, "char")) 1181 return FILTER_RDYN_STRING; 1182 1183 if (strchr(type, '[') && strstr(type, "char")) 1184 return FILTER_STATIC_STRING; 1185 1186 if (strcmp(type, "char *") == 0 || strcmp(type, "const char *") == 0) 1187 return FILTER_PTR_STRING; 1188 1189 return FILTER_OTHER; 1190 } 1191 1192 static filter_pred_fn_t select_comparison_fn(enum filter_op_ids op, 1193 int field_size, int field_is_signed) 1194 { 1195 filter_pred_fn_t fn = NULL; 1196 int pred_func_index = -1; 1197 1198 switch (op) { 1199 case OP_EQ: 1200 case OP_NE: 1201 break; 1202 default: 1203 if (WARN_ON_ONCE(op < PRED_FUNC_START)) 1204 return NULL; 1205 pred_func_index = op - PRED_FUNC_START; 1206 if (WARN_ON_ONCE(pred_func_index > PRED_FUNC_MAX)) 1207 return NULL; 1208 } 1209 1210 switch (field_size) { 1211 case 8: 1212 if (pred_func_index < 0) 1213 fn = filter_pred_64; 1214 else if (field_is_signed) 1215 fn = pred_funcs_s64[pred_func_index]; 1216 else 1217 fn = pred_funcs_u64[pred_func_index]; 1218 break; 1219 case 4: 1220 if (pred_func_index < 0) 1221 fn = filter_pred_32; 1222 else if (field_is_signed) 1223 fn = pred_funcs_s32[pred_func_index]; 1224 else 1225 fn = pred_funcs_u32[pred_func_index]; 1226 break; 1227 case 2: 1228 if (pred_func_index < 0) 1229 fn = filter_pred_16; 1230 else if (field_is_signed) 1231 fn = pred_funcs_s16[pred_func_index]; 1232 else 1233 fn = pred_funcs_u16[pred_func_index]; 1234 break; 1235 case 1: 1236 if (pred_func_index < 0) 1237 fn = filter_pred_8; 1238 else if (field_is_signed) 1239 fn = pred_funcs_s8[pred_func_index]; 1240 else 1241 fn = pred_funcs_u8[pred_func_index]; 1242 break; 1243 } 1244 1245 return fn; 1246 } 1247 1248 /* Called when a predicate is encountered by predicate_parse() */ 1249 static int parse_pred(const char *str, void *data, 1250 int pos, struct filter_parse_error *pe, 1251 struct filter_pred **pred_ptr) 1252 { 1253 struct trace_event_call *call = data; 1254 struct ftrace_event_field *field; 1255 struct filter_pred *pred = NULL; 1256 char num_buf[24]; /* Big enough to hold an address */ 1257 char *field_name; 1258 bool ustring = false; 1259 char q; 1260 u64 val; 1261 int len; 1262 int ret; 1263 int op; 1264 int s; 1265 int i = 0; 1266 1267 /* First find the field to associate to */ 1268 while (isspace(str[i])) 1269 i++; 1270 s = i; 1271 1272 while (isalnum(str[i]) || str[i] == '_') 1273 i++; 1274 1275 len = i - s; 1276 1277 if (!len) 1278 return -1; 1279 1280 field_name = kmemdup_nul(str + s, len, GFP_KERNEL); 1281 if (!field_name) 1282 return -ENOMEM; 1283 1284 /* Make sure that the field exists */ 1285 1286 field = trace_find_event_field(call, field_name); 1287 kfree(field_name); 1288 if (!field) { 1289 parse_error(pe, FILT_ERR_FIELD_NOT_FOUND, pos + i); 1290 return -EINVAL; 1291 } 1292 1293 /* See if the field is a user space string */ 1294 if ((len = str_has_prefix(str + i, ".ustring"))) { 1295 ustring = true; 1296 i += len; 1297 } 1298 1299 while (isspace(str[i])) 1300 i++; 1301 1302 /* Make sure this op is supported */ 1303 for (op = 0; ops[op]; op++) { 1304 /* This is why '<=' must come before '<' in ops[] */ 1305 if (strncmp(str + i, ops[op], strlen(ops[op])) == 0) 1306 break; 1307 } 1308 1309 if (!ops[op]) { 1310 parse_error(pe, FILT_ERR_INVALID_OP, pos + i); 1311 goto err_free; 1312 } 1313 1314 i += strlen(ops[op]); 1315 1316 while (isspace(str[i])) 1317 i++; 1318 1319 s = i; 1320 1321 pred = kzalloc(sizeof(*pred), GFP_KERNEL); 1322 if (!pred) 1323 return -ENOMEM; 1324 1325 pred->field = field; 1326 pred->offset = field->offset; 1327 pred->op = op; 1328 1329 if (ftrace_event_is_function(call)) { 1330 /* 1331 * Perf does things different with function events. 1332 * It only allows an "ip" field, and expects a string. 1333 * But the string does not need to be surrounded by quotes. 1334 * If it is a string, the assigned function as a nop, 1335 * (perf doesn't use it) and grab everything. 1336 */ 1337 if (strcmp(field->name, "ip") != 0) { 1338 parse_error(pe, FILT_ERR_IP_FIELD_ONLY, pos + i); 1339 goto err_free; 1340 } 1341 pred->fn = filter_pred_none; 1342 1343 /* 1344 * Quotes are not required, but if they exist then we need 1345 * to read them till we hit a matching one. 1346 */ 1347 if (str[i] == '\'' || str[i] == '"') 1348 q = str[i]; 1349 else 1350 q = 0; 1351 1352 for (i++; str[i]; i++) { 1353 if (q && str[i] == q) 1354 break; 1355 if (!q && (str[i] == ')' || str[i] == '&' || 1356 str[i] == '|')) 1357 break; 1358 } 1359 /* Skip quotes */ 1360 if (q) 1361 s++; 1362 len = i - s; 1363 if (len >= MAX_FILTER_STR_VAL) { 1364 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i); 1365 goto err_free; 1366 } 1367 1368 pred->regex.len = len; 1369 strncpy(pred->regex.pattern, str + s, len); 1370 pred->regex.pattern[len] = 0; 1371 1372 /* This is either a string, or an integer */ 1373 } else if (str[i] == '\'' || str[i] == '"') { 1374 char q = str[i]; 1375 1376 /* Make sure the op is OK for strings */ 1377 switch (op) { 1378 case OP_NE: 1379 pred->not = 1; 1380 fallthrough; 1381 case OP_GLOB: 1382 case OP_EQ: 1383 break; 1384 default: 1385 parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i); 1386 goto err_free; 1387 } 1388 1389 /* Make sure the field is OK for strings */ 1390 if (!is_string_field(field)) { 1391 parse_error(pe, FILT_ERR_EXPECT_DIGIT, pos + i); 1392 goto err_free; 1393 } 1394 1395 for (i++; str[i]; i++) { 1396 if (str[i] == q) 1397 break; 1398 } 1399 if (!str[i]) { 1400 parse_error(pe, FILT_ERR_MISSING_QUOTE, pos + i); 1401 goto err_free; 1402 } 1403 1404 /* Skip quotes */ 1405 s++; 1406 len = i - s; 1407 if (len >= MAX_FILTER_STR_VAL) { 1408 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i); 1409 goto err_free; 1410 } 1411 1412 pred->regex.len = len; 1413 strncpy(pred->regex.pattern, str + s, len); 1414 pred->regex.pattern[len] = 0; 1415 1416 filter_build_regex(pred); 1417 1418 if (field->filter_type == FILTER_COMM) { 1419 pred->fn = filter_pred_comm; 1420 1421 } else if (field->filter_type == FILTER_STATIC_STRING) { 1422 pred->fn = filter_pred_string; 1423 pred->regex.field_len = field->size; 1424 1425 } else if (field->filter_type == FILTER_DYN_STRING) { 1426 pred->fn = filter_pred_strloc; 1427 } else if (field->filter_type == FILTER_RDYN_STRING) 1428 pred->fn = filter_pred_strrelloc; 1429 else { 1430 1431 if (!ustring_per_cpu) { 1432 /* Once allocated, keep it around for good */ 1433 ustring_per_cpu = alloc_percpu(struct ustring_buffer); 1434 if (!ustring_per_cpu) 1435 goto err_mem; 1436 } 1437 1438 if (ustring) 1439 pred->fn = filter_pred_pchar_user; 1440 else 1441 pred->fn = filter_pred_pchar; 1442 } 1443 /* go past the last quote */ 1444 i++; 1445 1446 } else if (isdigit(str[i]) || str[i] == '-') { 1447 1448 /* Make sure the field is not a string */ 1449 if (is_string_field(field)) { 1450 parse_error(pe, FILT_ERR_EXPECT_STRING, pos + i); 1451 goto err_free; 1452 } 1453 1454 if (op == OP_GLOB) { 1455 parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i); 1456 goto err_free; 1457 } 1458 1459 if (str[i] == '-') 1460 i++; 1461 1462 /* We allow 0xDEADBEEF */ 1463 while (isalnum(str[i])) 1464 i++; 1465 1466 len = i - s; 1467 /* 0xfeedfacedeadbeef is 18 chars max */ 1468 if (len >= sizeof(num_buf)) { 1469 parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i); 1470 goto err_free; 1471 } 1472 1473 strncpy(num_buf, str + s, len); 1474 num_buf[len] = 0; 1475 1476 /* Make sure it is a value */ 1477 if (field->is_signed) 1478 ret = kstrtoll(num_buf, 0, &val); 1479 else 1480 ret = kstrtoull(num_buf, 0, &val); 1481 if (ret) { 1482 parse_error(pe, FILT_ERR_ILLEGAL_INTVAL, pos + s); 1483 goto err_free; 1484 } 1485 1486 pred->val = val; 1487 1488 if (field->filter_type == FILTER_CPU) 1489 pred->fn = filter_pred_cpu; 1490 else { 1491 pred->fn = select_comparison_fn(pred->op, field->size, 1492 field->is_signed); 1493 if (pred->op == OP_NE) 1494 pred->not = 1; 1495 } 1496 1497 } else { 1498 parse_error(pe, FILT_ERR_INVALID_VALUE, pos + i); 1499 goto err_free; 1500 } 1501 1502 *pred_ptr = pred; 1503 return i; 1504 1505 err_free: 1506 kfree(pred); 1507 return -EINVAL; 1508 err_mem: 1509 kfree(pred); 1510 return -ENOMEM; 1511 } 1512 1513 enum { 1514 TOO_MANY_CLOSE = -1, 1515 TOO_MANY_OPEN = -2, 1516 MISSING_QUOTE = -3, 1517 }; 1518 1519 /* 1520 * Read the filter string once to calculate the number of predicates 1521 * as well as how deep the parentheses go. 1522 * 1523 * Returns: 1524 * 0 - everything is fine (err is undefined) 1525 * -1 - too many ')' 1526 * -2 - too many '(' 1527 * -3 - No matching quote 1528 */ 1529 static int calc_stack(const char *str, int *parens, int *preds, int *err) 1530 { 1531 bool is_pred = false; 1532 int nr_preds = 0; 1533 int open = 1; /* Count the expression as "(E)" */ 1534 int last_quote = 0; 1535 int max_open = 1; 1536 int quote = 0; 1537 int i; 1538 1539 *err = 0; 1540 1541 for (i = 0; str[i]; i++) { 1542 if (isspace(str[i])) 1543 continue; 1544 if (quote) { 1545 if (str[i] == quote) 1546 quote = 0; 1547 continue; 1548 } 1549 1550 switch (str[i]) { 1551 case '\'': 1552 case '"': 1553 quote = str[i]; 1554 last_quote = i; 1555 break; 1556 case '|': 1557 case '&': 1558 if (str[i+1] != str[i]) 1559 break; 1560 is_pred = false; 1561 continue; 1562 case '(': 1563 is_pred = false; 1564 open++; 1565 if (open > max_open) 1566 max_open = open; 1567 continue; 1568 case ')': 1569 is_pred = false; 1570 if (open == 1) { 1571 *err = i; 1572 return TOO_MANY_CLOSE; 1573 } 1574 open--; 1575 continue; 1576 } 1577 if (!is_pred) { 1578 nr_preds++; 1579 is_pred = true; 1580 } 1581 } 1582 1583 if (quote) { 1584 *err = last_quote; 1585 return MISSING_QUOTE; 1586 } 1587 1588 if (open != 1) { 1589 int level = open; 1590 1591 /* find the bad open */ 1592 for (i--; i; i--) { 1593 if (quote) { 1594 if (str[i] == quote) 1595 quote = 0; 1596 continue; 1597 } 1598 switch (str[i]) { 1599 case '(': 1600 if (level == open) { 1601 *err = i; 1602 return TOO_MANY_OPEN; 1603 } 1604 level--; 1605 break; 1606 case ')': 1607 level++; 1608 break; 1609 case '\'': 1610 case '"': 1611 quote = str[i]; 1612 break; 1613 } 1614 } 1615 /* First character is the '(' with missing ')' */ 1616 *err = 0; 1617 return TOO_MANY_OPEN; 1618 } 1619 1620 /* Set the size of the required stacks */ 1621 *parens = max_open; 1622 *preds = nr_preds; 1623 return 0; 1624 } 1625 1626 static int process_preds(struct trace_event_call *call, 1627 const char *filter_string, 1628 struct event_filter *filter, 1629 struct filter_parse_error *pe) 1630 { 1631 struct prog_entry *prog; 1632 int nr_parens; 1633 int nr_preds; 1634 int index; 1635 int ret; 1636 1637 ret = calc_stack(filter_string, &nr_parens, &nr_preds, &index); 1638 if (ret < 0) { 1639 switch (ret) { 1640 case MISSING_QUOTE: 1641 parse_error(pe, FILT_ERR_MISSING_QUOTE, index); 1642 break; 1643 case TOO_MANY_OPEN: 1644 parse_error(pe, FILT_ERR_TOO_MANY_OPEN, index); 1645 break; 1646 default: 1647 parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, index); 1648 } 1649 return ret; 1650 } 1651 1652 if (!nr_preds) 1653 return -EINVAL; 1654 1655 prog = predicate_parse(filter_string, nr_parens, nr_preds, 1656 parse_pred, call, pe); 1657 if (IS_ERR(prog)) 1658 return PTR_ERR(prog); 1659 1660 rcu_assign_pointer(filter->prog, prog); 1661 return 0; 1662 } 1663 1664 static inline void event_set_filtered_flag(struct trace_event_file *file) 1665 { 1666 unsigned long old_flags = file->flags; 1667 1668 file->flags |= EVENT_FILE_FL_FILTERED; 1669 1670 if (old_flags != file->flags) 1671 trace_buffered_event_enable(); 1672 } 1673 1674 static inline void event_set_filter(struct trace_event_file *file, 1675 struct event_filter *filter) 1676 { 1677 rcu_assign_pointer(file->filter, filter); 1678 } 1679 1680 static inline void event_clear_filter(struct trace_event_file *file) 1681 { 1682 RCU_INIT_POINTER(file->filter, NULL); 1683 } 1684 1685 struct filter_list { 1686 struct list_head list; 1687 struct event_filter *filter; 1688 }; 1689 1690 static int process_system_preds(struct trace_subsystem_dir *dir, 1691 struct trace_array *tr, 1692 struct filter_parse_error *pe, 1693 char *filter_string) 1694 { 1695 struct trace_event_file *file; 1696 struct filter_list *filter_item; 1697 struct event_filter *filter = NULL; 1698 struct filter_list *tmp; 1699 LIST_HEAD(filter_list); 1700 bool fail = true; 1701 int err; 1702 1703 list_for_each_entry(file, &tr->events, list) { 1704 1705 if (file->system != dir) 1706 continue; 1707 1708 filter = kzalloc(sizeof(*filter), GFP_KERNEL); 1709 if (!filter) 1710 goto fail_mem; 1711 1712 filter->filter_string = kstrdup(filter_string, GFP_KERNEL); 1713 if (!filter->filter_string) 1714 goto fail_mem; 1715 1716 err = process_preds(file->event_call, filter_string, filter, pe); 1717 if (err) { 1718 filter_disable(file); 1719 parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0); 1720 append_filter_err(tr, pe, filter); 1721 } else 1722 event_set_filtered_flag(file); 1723 1724 1725 filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL); 1726 if (!filter_item) 1727 goto fail_mem; 1728 1729 list_add_tail(&filter_item->list, &filter_list); 1730 /* 1731 * Regardless of if this returned an error, we still 1732 * replace the filter for the call. 1733 */ 1734 filter_item->filter = event_filter(file); 1735 event_set_filter(file, filter); 1736 filter = NULL; 1737 1738 fail = false; 1739 } 1740 1741 if (fail) 1742 goto fail; 1743 1744 /* 1745 * The calls can still be using the old filters. 1746 * Do a synchronize_rcu() and to ensure all calls are 1747 * done with them before we free them. 1748 */ 1749 tracepoint_synchronize_unregister(); 1750 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { 1751 __free_filter(filter_item->filter); 1752 list_del(&filter_item->list); 1753 kfree(filter_item); 1754 } 1755 return 0; 1756 fail: 1757 /* No call succeeded */ 1758 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { 1759 list_del(&filter_item->list); 1760 kfree(filter_item); 1761 } 1762 parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0); 1763 return -EINVAL; 1764 fail_mem: 1765 __free_filter(filter); 1766 /* If any call succeeded, we still need to sync */ 1767 if (!fail) 1768 tracepoint_synchronize_unregister(); 1769 list_for_each_entry_safe(filter_item, tmp, &filter_list, list) { 1770 __free_filter(filter_item->filter); 1771 list_del(&filter_item->list); 1772 kfree(filter_item); 1773 } 1774 return -ENOMEM; 1775 } 1776 1777 static int create_filter_start(char *filter_string, bool set_str, 1778 struct filter_parse_error **pse, 1779 struct event_filter **filterp) 1780 { 1781 struct event_filter *filter; 1782 struct filter_parse_error *pe = NULL; 1783 int err = 0; 1784 1785 if (WARN_ON_ONCE(*pse || *filterp)) 1786 return -EINVAL; 1787 1788 filter = kzalloc(sizeof(*filter), GFP_KERNEL); 1789 if (filter && set_str) { 1790 filter->filter_string = kstrdup(filter_string, GFP_KERNEL); 1791 if (!filter->filter_string) 1792 err = -ENOMEM; 1793 } 1794 1795 pe = kzalloc(sizeof(*pe), GFP_KERNEL); 1796 1797 if (!filter || !pe || err) { 1798 kfree(pe); 1799 __free_filter(filter); 1800 return -ENOMEM; 1801 } 1802 1803 /* we're committed to creating a new filter */ 1804 *filterp = filter; 1805 *pse = pe; 1806 1807 return 0; 1808 } 1809 1810 static void create_filter_finish(struct filter_parse_error *pe) 1811 { 1812 kfree(pe); 1813 } 1814 1815 /** 1816 * create_filter - create a filter for a trace_event_call 1817 * @tr: the trace array associated with these events 1818 * @call: trace_event_call to create a filter for 1819 * @filter_str: filter string 1820 * @set_str: remember @filter_str and enable detailed error in filter 1821 * @filterp: out param for created filter (always updated on return) 1822 * Must be a pointer that references a NULL pointer. 1823 * 1824 * Creates a filter for @call with @filter_str. If @set_str is %true, 1825 * @filter_str is copied and recorded in the new filter. 1826 * 1827 * On success, returns 0 and *@filterp points to the new filter. On 1828 * failure, returns -errno and *@filterp may point to %NULL or to a new 1829 * filter. In the latter case, the returned filter contains error 1830 * information if @set_str is %true and the caller is responsible for 1831 * freeing it. 1832 */ 1833 static int create_filter(struct trace_array *tr, 1834 struct trace_event_call *call, 1835 char *filter_string, bool set_str, 1836 struct event_filter **filterp) 1837 { 1838 struct filter_parse_error *pe = NULL; 1839 int err; 1840 1841 /* filterp must point to NULL */ 1842 if (WARN_ON(*filterp)) 1843 *filterp = NULL; 1844 1845 err = create_filter_start(filter_string, set_str, &pe, filterp); 1846 if (err) 1847 return err; 1848 1849 err = process_preds(call, filter_string, *filterp, pe); 1850 if (err && set_str) 1851 append_filter_err(tr, pe, *filterp); 1852 create_filter_finish(pe); 1853 1854 return err; 1855 } 1856 1857 int create_event_filter(struct trace_array *tr, 1858 struct trace_event_call *call, 1859 char *filter_str, bool set_str, 1860 struct event_filter **filterp) 1861 { 1862 return create_filter(tr, call, filter_str, set_str, filterp); 1863 } 1864 1865 /** 1866 * create_system_filter - create a filter for an event subsystem 1867 * @dir: the descriptor for the subsystem directory 1868 * @filter_str: filter string 1869 * @filterp: out param for created filter (always updated on return) 1870 * 1871 * Identical to create_filter() except that it creates a subsystem filter 1872 * and always remembers @filter_str. 1873 */ 1874 static int create_system_filter(struct trace_subsystem_dir *dir, 1875 char *filter_str, struct event_filter **filterp) 1876 { 1877 struct filter_parse_error *pe = NULL; 1878 int err; 1879 1880 err = create_filter_start(filter_str, true, &pe, filterp); 1881 if (!err) { 1882 err = process_system_preds(dir, dir->tr, pe, filter_str); 1883 if (!err) { 1884 /* System filters just show a default message */ 1885 kfree((*filterp)->filter_string); 1886 (*filterp)->filter_string = NULL; 1887 } else { 1888 append_filter_err(dir->tr, pe, *filterp); 1889 } 1890 } 1891 create_filter_finish(pe); 1892 1893 return err; 1894 } 1895 1896 /* caller must hold event_mutex */ 1897 int apply_event_filter(struct trace_event_file *file, char *filter_string) 1898 { 1899 struct trace_event_call *call = file->event_call; 1900 struct event_filter *filter = NULL; 1901 int err; 1902 1903 if (!strcmp(strstrip(filter_string), "0")) { 1904 filter_disable(file); 1905 filter = event_filter(file); 1906 1907 if (!filter) 1908 return 0; 1909 1910 event_clear_filter(file); 1911 1912 /* Make sure the filter is not being used */ 1913 tracepoint_synchronize_unregister(); 1914 __free_filter(filter); 1915 1916 return 0; 1917 } 1918 1919 err = create_filter(file->tr, call, filter_string, true, &filter); 1920 1921 /* 1922 * Always swap the call filter with the new filter 1923 * even if there was an error. If there was an error 1924 * in the filter, we disable the filter and show the error 1925 * string 1926 */ 1927 if (filter) { 1928 struct event_filter *tmp; 1929 1930 tmp = event_filter(file); 1931 if (!err) 1932 event_set_filtered_flag(file); 1933 else 1934 filter_disable(file); 1935 1936 event_set_filter(file, filter); 1937 1938 if (tmp) { 1939 /* Make sure the call is done with the filter */ 1940 tracepoint_synchronize_unregister(); 1941 __free_filter(tmp); 1942 } 1943 } 1944 1945 return err; 1946 } 1947 1948 int apply_subsystem_event_filter(struct trace_subsystem_dir *dir, 1949 char *filter_string) 1950 { 1951 struct event_subsystem *system = dir->subsystem; 1952 struct trace_array *tr = dir->tr; 1953 struct event_filter *filter = NULL; 1954 int err = 0; 1955 1956 mutex_lock(&event_mutex); 1957 1958 /* Make sure the system still has events */ 1959 if (!dir->nr_events) { 1960 err = -ENODEV; 1961 goto out_unlock; 1962 } 1963 1964 if (!strcmp(strstrip(filter_string), "0")) { 1965 filter_free_subsystem_preds(dir, tr); 1966 remove_filter_string(system->filter); 1967 filter = system->filter; 1968 system->filter = NULL; 1969 /* Ensure all filters are no longer used */ 1970 tracepoint_synchronize_unregister(); 1971 filter_free_subsystem_filters(dir, tr); 1972 __free_filter(filter); 1973 goto out_unlock; 1974 } 1975 1976 err = create_system_filter(dir, filter_string, &filter); 1977 if (filter) { 1978 /* 1979 * No event actually uses the system filter 1980 * we can free it without synchronize_rcu(). 1981 */ 1982 __free_filter(system->filter); 1983 system->filter = filter; 1984 } 1985 out_unlock: 1986 mutex_unlock(&event_mutex); 1987 1988 return err; 1989 } 1990 1991 #ifdef CONFIG_PERF_EVENTS 1992 1993 void ftrace_profile_free_filter(struct perf_event *event) 1994 { 1995 struct event_filter *filter = event->filter; 1996 1997 event->filter = NULL; 1998 __free_filter(filter); 1999 } 2000 2001 struct function_filter_data { 2002 struct ftrace_ops *ops; 2003 int first_filter; 2004 int first_notrace; 2005 }; 2006 2007 #ifdef CONFIG_FUNCTION_TRACER 2008 static char ** 2009 ftrace_function_filter_re(char *buf, int len, int *count) 2010 { 2011 char *str, **re; 2012 2013 str = kstrndup(buf, len, GFP_KERNEL); 2014 if (!str) 2015 return NULL; 2016 2017 /* 2018 * The argv_split function takes white space 2019 * as a separator, so convert ',' into spaces. 2020 */ 2021 strreplace(str, ',', ' '); 2022 2023 re = argv_split(GFP_KERNEL, str, count); 2024 kfree(str); 2025 return re; 2026 } 2027 2028 static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter, 2029 int reset, char *re, int len) 2030 { 2031 int ret; 2032 2033 if (filter) 2034 ret = ftrace_set_filter(ops, re, len, reset); 2035 else 2036 ret = ftrace_set_notrace(ops, re, len, reset); 2037 2038 return ret; 2039 } 2040 2041 static int __ftrace_function_set_filter(int filter, char *buf, int len, 2042 struct function_filter_data *data) 2043 { 2044 int i, re_cnt, ret = -EINVAL; 2045 int *reset; 2046 char **re; 2047 2048 reset = filter ? &data->first_filter : &data->first_notrace; 2049 2050 /* 2051 * The 'ip' field could have multiple filters set, separated 2052 * either by space or comma. We first cut the filter and apply 2053 * all pieces separately. 2054 */ 2055 re = ftrace_function_filter_re(buf, len, &re_cnt); 2056 if (!re) 2057 return -EINVAL; 2058 2059 for (i = 0; i < re_cnt; i++) { 2060 ret = ftrace_function_set_regexp(data->ops, filter, *reset, 2061 re[i], strlen(re[i])); 2062 if (ret) 2063 break; 2064 2065 if (*reset) 2066 *reset = 0; 2067 } 2068 2069 argv_free(re); 2070 return ret; 2071 } 2072 2073 static int ftrace_function_check_pred(struct filter_pred *pred) 2074 { 2075 struct ftrace_event_field *field = pred->field; 2076 2077 /* 2078 * Check the predicate for function trace, verify: 2079 * - only '==' and '!=' is used 2080 * - the 'ip' field is used 2081 */ 2082 if ((pred->op != OP_EQ) && (pred->op != OP_NE)) 2083 return -EINVAL; 2084 2085 if (strcmp(field->name, "ip")) 2086 return -EINVAL; 2087 2088 return 0; 2089 } 2090 2091 static int ftrace_function_set_filter_pred(struct filter_pred *pred, 2092 struct function_filter_data *data) 2093 { 2094 int ret; 2095 2096 /* Checking the node is valid for function trace. */ 2097 ret = ftrace_function_check_pred(pred); 2098 if (ret) 2099 return ret; 2100 2101 return __ftrace_function_set_filter(pred->op == OP_EQ, 2102 pred->regex.pattern, 2103 pred->regex.len, 2104 data); 2105 } 2106 2107 static bool is_or(struct prog_entry *prog, int i) 2108 { 2109 int target; 2110 2111 /* 2112 * Only "||" is allowed for function events, thus, 2113 * all true branches should jump to true, and any 2114 * false branch should jump to false. 2115 */ 2116 target = prog[i].target + 1; 2117 /* True and false have NULL preds (all prog entries should jump to one */ 2118 if (prog[target].pred) 2119 return false; 2120 2121 /* prog[target].target is 1 for TRUE, 0 for FALSE */ 2122 return prog[i].when_to_branch == prog[target].target; 2123 } 2124 2125 static int ftrace_function_set_filter(struct perf_event *event, 2126 struct event_filter *filter) 2127 { 2128 struct prog_entry *prog = rcu_dereference_protected(filter->prog, 2129 lockdep_is_held(&event_mutex)); 2130 struct function_filter_data data = { 2131 .first_filter = 1, 2132 .first_notrace = 1, 2133 .ops = &event->ftrace_ops, 2134 }; 2135 int i; 2136 2137 for (i = 0; prog[i].pred; i++) { 2138 struct filter_pred *pred = prog[i].pred; 2139 2140 if (!is_or(prog, i)) 2141 return -EINVAL; 2142 2143 if (ftrace_function_set_filter_pred(pred, &data) < 0) 2144 return -EINVAL; 2145 } 2146 return 0; 2147 } 2148 #else 2149 static int ftrace_function_set_filter(struct perf_event *event, 2150 struct event_filter *filter) 2151 { 2152 return -ENODEV; 2153 } 2154 #endif /* CONFIG_FUNCTION_TRACER */ 2155 2156 int ftrace_profile_set_filter(struct perf_event *event, int event_id, 2157 char *filter_str) 2158 { 2159 int err; 2160 struct event_filter *filter = NULL; 2161 struct trace_event_call *call; 2162 2163 mutex_lock(&event_mutex); 2164 2165 call = event->tp_event; 2166 2167 err = -EINVAL; 2168 if (!call) 2169 goto out_unlock; 2170 2171 err = -EEXIST; 2172 if (event->filter) 2173 goto out_unlock; 2174 2175 err = create_filter(NULL, call, filter_str, false, &filter); 2176 if (err) 2177 goto free_filter; 2178 2179 if (ftrace_event_is_function(call)) 2180 err = ftrace_function_set_filter(event, filter); 2181 else 2182 event->filter = filter; 2183 2184 free_filter: 2185 if (err || ftrace_event_is_function(call)) 2186 __free_filter(filter); 2187 2188 out_unlock: 2189 mutex_unlock(&event_mutex); 2190 2191 return err; 2192 } 2193 2194 #endif /* CONFIG_PERF_EVENTS */ 2195 2196 #ifdef CONFIG_FTRACE_STARTUP_TEST 2197 2198 #include <linux/types.h> 2199 #include <linux/tracepoint.h> 2200 2201 #define CREATE_TRACE_POINTS 2202 #include "trace_events_filter_test.h" 2203 2204 #define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \ 2205 { \ 2206 .filter = FILTER, \ 2207 .rec = { .a = va, .b = vb, .c = vc, .d = vd, \ 2208 .e = ve, .f = vf, .g = vg, .h = vh }, \ 2209 .match = m, \ 2210 .not_visited = nvisit, \ 2211 } 2212 #define YES 1 2213 #define NO 0 2214 2215 static struct test_filter_data_t { 2216 char *filter; 2217 struct trace_event_raw_ftrace_test_filter rec; 2218 int match; 2219 char *not_visited; 2220 } test_filter_data[] = { 2221 #define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \ 2222 "e == 1 && f == 1 && g == 1 && h == 1" 2223 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""), 2224 DATA_REC(NO, 0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"), 2225 DATA_REC(NO, 1, 1, 1, 1, 1, 1, 1, 0, ""), 2226 #undef FILTER 2227 #define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \ 2228 "e == 1 || f == 1 || g == 1 || h == 1" 2229 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""), 2230 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""), 2231 DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"), 2232 #undef FILTER 2233 #define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \ 2234 "(e == 1 || f == 1) && (g == 1 || h == 1)" 2235 DATA_REC(NO, 0, 0, 1, 1, 1, 1, 1, 1, "dfh"), 2236 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""), 2237 DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"), 2238 DATA_REC(NO, 1, 0, 1, 0, 0, 1, 0, 0, "bd"), 2239 #undef FILTER 2240 #define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \ 2241 "(e == 1 && f == 1) || (g == 1 && h == 1)" 2242 DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"), 2243 DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""), 2244 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""), 2245 #undef FILTER 2246 #define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \ 2247 "(e == 1 && f == 1) || (g == 1 && h == 1)" 2248 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"), 2249 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""), 2250 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""), 2251 #undef FILTER 2252 #define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \ 2253 "(e == 1 || f == 1)) && (g == 1 || h == 1)" 2254 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"), 2255 DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""), 2256 DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"), 2257 #undef FILTER 2258 #define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \ 2259 "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))" 2260 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"), 2261 DATA_REC(NO, 0, 1, 0, 1, 0, 1, 0, 1, ""), 2262 DATA_REC(NO, 1, 0, 1, 0, 1, 0, 1, 0, ""), 2263 #undef FILTER 2264 #define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \ 2265 "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))" 2266 DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"), 2267 DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""), 2268 DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"), 2269 }; 2270 2271 #undef DATA_REC 2272 #undef FILTER 2273 #undef YES 2274 #undef NO 2275 2276 #define DATA_CNT ARRAY_SIZE(test_filter_data) 2277 2278 static int test_pred_visited; 2279 2280 static int test_pred_visited_fn(struct filter_pred *pred, void *event) 2281 { 2282 struct ftrace_event_field *field = pred->field; 2283 2284 test_pred_visited = 1; 2285 printk(KERN_INFO "\npred visited %s\n", field->name); 2286 return 1; 2287 } 2288 2289 static void update_pred_fn(struct event_filter *filter, char *fields) 2290 { 2291 struct prog_entry *prog = rcu_dereference_protected(filter->prog, 2292 lockdep_is_held(&event_mutex)); 2293 int i; 2294 2295 for (i = 0; prog[i].pred; i++) { 2296 struct filter_pred *pred = prog[i].pred; 2297 struct ftrace_event_field *field = pred->field; 2298 2299 WARN_ON_ONCE(!pred->fn); 2300 2301 if (!field) { 2302 WARN_ONCE(1, "all leafs should have field defined %d", i); 2303 continue; 2304 } 2305 2306 if (!strchr(fields, *field->name)) 2307 continue; 2308 2309 pred->fn = test_pred_visited_fn; 2310 } 2311 } 2312 2313 static __init int ftrace_test_event_filter(void) 2314 { 2315 int i; 2316 2317 printk(KERN_INFO "Testing ftrace filter: "); 2318 2319 for (i = 0; i < DATA_CNT; i++) { 2320 struct event_filter *filter = NULL; 2321 struct test_filter_data_t *d = &test_filter_data[i]; 2322 int err; 2323 2324 err = create_filter(NULL, &event_ftrace_test_filter, 2325 d->filter, false, &filter); 2326 if (err) { 2327 printk(KERN_INFO 2328 "Failed to get filter for '%s', err %d\n", 2329 d->filter, err); 2330 __free_filter(filter); 2331 break; 2332 } 2333 2334 /* Needed to dereference filter->prog */ 2335 mutex_lock(&event_mutex); 2336 /* 2337 * The preemption disabling is not really needed for self 2338 * tests, but the rcu dereference will complain without it. 2339 */ 2340 preempt_disable(); 2341 if (*d->not_visited) 2342 update_pred_fn(filter, d->not_visited); 2343 2344 test_pred_visited = 0; 2345 err = filter_match_preds(filter, &d->rec); 2346 preempt_enable(); 2347 2348 mutex_unlock(&event_mutex); 2349 2350 __free_filter(filter); 2351 2352 if (test_pred_visited) { 2353 printk(KERN_INFO 2354 "Failed, unwanted pred visited for filter %s\n", 2355 d->filter); 2356 break; 2357 } 2358 2359 if (err != d->match) { 2360 printk(KERN_INFO 2361 "Failed to match filter '%s', expected %d\n", 2362 d->filter, d->match); 2363 break; 2364 } 2365 } 2366 2367 if (i == DATA_CNT) 2368 printk(KERN_CONT "OK\n"); 2369 2370 return 0; 2371 } 2372 2373 late_initcall(ftrace_test_event_filter); 2374 2375 #endif /* CONFIG_FTRACE_STARTUP_TEST */ 2376