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>

1 files changed, 20 insertions, 45 deletions

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index ebbb2611982e..d8aa100cb22e 100644
--- 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,