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