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>

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index d8aa100cb22e42b424958d6dd01795f3e171d5a6..f44e68b89f15208b1ef7f19b5d0f19479d51b7af 100644 (file)
--- 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,