kernel/trace/trace_events_filter.c

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