tracing/filter: Change fold_pred 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-9-git-send-email-jolsa@redhat.com
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

1 files changed, 33 insertions, 35 deletions

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index d8aa100cb22e..f44e68b89f15 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -1439,13 +1439,40 @@ static int count_leafs(struct filter_pred *preds, struct filter_pred *root)
         return count;
 }
 
+struct fold_pred_data {
+        struct filter_pred *root;
+        int count;
+        int children;
+};
+
+static int fold_pred_cb(enum move_type move, struct filter_pred *pred,
+                        int *err, void *data)
+{
+        struct fold_pred_data *d = data;
+        struct filter_pred *root = d->root;
+
+        if (move != MOVE_DOWN)
+                return WALK_PRED_DEFAULT;
+        if (pred->left != FILTER_PRED_INVALID)
+                return WALK_PRED_DEFAULT;
+
+        if (WARN_ON(d->count == d->children)) {
+                *err = -EINVAL;
+                return WALK_PRED_ABORT;
+        }
+
+        pred->index &= ~FILTER_PRED_FOLD;
+        root->ops[d->count++] = pred->index;
+        return WALK_PRED_DEFAULT;
+}
+
 static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
 {
-        struct filter_pred *pred;
-        enum move_type move = MOVE_DOWN;
-        int count = 0;
+        struct fold_pred_data data = {
+                .root  = root,
+                .count = 0,
+        };
         int children;
-        int done = 0;
 
         /* No need to keep the fold flag */
         root->index &= ~FILTER_PRED_FOLD;
@@ -1463,37 +1490,8 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
                 return -ENOMEM;
 
         root->val = children;
-
-        pred = root;
-        do {
-                switch (move) {
-                case MOVE_DOWN:
-                        if (pred->left != FILTER_PRED_INVALID) {
-                                pred = &preds[pred->left];
-                                continue;
-                        }
-                        if (WARN_ON(count == children))
-                                return -EINVAL;
-                        pred->index &= ~FILTER_PRED_FOLD;
-                        root->ops[count++] = pred->index;
-                        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;
+        data.children = children;
+        return walk_pred_tree(preds, root, fold_pred_cb, &data);
 }
 
 static int fold_pred_tree_cb(enum move_type move, struct filter_pred *pred,