tracing/filter: Change fold_pred_tree function to use walk_pred_tree

Changing fold_pred_tree function to use unified predicates tree
processing.

Signed-off-by: Jiri Olsa <jolsa@redhat.com>
Link: http://lkml.kernel.org/r/1313072754-4620-8-git-send-email-jolsa@redhat.com
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index ebbb261..d8aa100 100644 (file)
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -1496,6 +1496,24 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
        return 0;
 }
 
+static int fold_pred_tree_cb(enum move_type move, struct filter_pred *pred,
+                            int *err, void *data)
+{
+       struct filter_pred *preds = data;
+
+       if (move != MOVE_DOWN)
+               return WALK_PRED_DEFAULT;
+       if (!(pred->index & FILTER_PRED_FOLD))
+               return WALK_PRED_DEFAULT;
+
+       *err = fold_pred(preds, pred);
+       if (*err)
+               return WALK_PRED_ABORT;
+
+       /* eveyrhing below is folded, continue with parent */
+       return WALK_PRED_PARENT;
+}
+
 /*
  * To optimize the processing of the ops, if we have several "ors" or
  * "ands" together, we can put them in an array and process them all
@@ -1504,51 +1522,8 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
 static int fold_pred_tree(struct event_filter *filter,
                           struct filter_pred *root)
 {
-       struct filter_pred *preds;
-       struct filter_pred *pred;
-       enum move_type move = MOVE_DOWN;
-       int done = 0;
-       int err;
-
-       preds = filter->preds;
-       if  (!preds)
-               return -EINVAL;
-       pred = root;
-
-       do {
-               switch (move) {
-               case MOVE_DOWN:
-                       if (pred->index & FILTER_PRED_FOLD) {
-                               err = fold_pred(preds, pred);
-                               if (err)
-                                       return err;
-                               /* Folded nodes are like leafs */
-                       } else if (pred->left != FILTER_PRED_INVALID) {
-                               pred = &preds[pred->left];
-                               continue;
-                       }
-
-                       /* A leaf at the root is just a leaf in the tree */
-                       if (pred == root)
-                               break;
-                       pred = get_pred_parent(pred, preds,
-                                              pred->parent, &move);
-                       continue;
-               case MOVE_UP_FROM_LEFT:
-                       pred = &preds[pred->right];
-                       move = MOVE_DOWN;
-                       continue;
-               case MOVE_UP_FROM_RIGHT:
-                       if (pred == root)
-                               break;
-                       pred = get_pred_parent(pred, preds,
-                                              pred->parent, &move);
-                       continue;
-               }
-               done = 1;
-       } while (!done);
-
-       return 0;
+       return walk_pred_tree(filter->preds, root, fold_pred_tree_cb,
+                             filter->preds);
 }
 
 static int replace_preds(struct ftrace_event_call *call,