tools lib traceevent: Get rid of die() in reparent_op_arg()

To do that, make the function returns the error code.  Also pass
error_str so that it can set proper error message when error occurred.

Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Reviewed-by: Steven Rostedt <rostedt@goodmis.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung.kim@lge.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Steven Rostedt <rostedt@goodmis.org>
Link: http://lkml.kernel.org/r/1386833777-3790-9-git-send-email-namhyung@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 89e4dfd40db62b6633a26a11cf15eeaa2b49fa11..5e4392d8e2d438e19e8a3c545c6518028c466c11 100644 (file)
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -364,7 +364,10 @@ enum pevent_flag {
        _PE(ILLEGAL_LVALUE,     "illegal lvalue for string comparison"),      \
        _PE(INVALID_REGEX,      "regex did not compute"),                     \
        _PE(ILLEGAL_STRING_CMP, "illegal comparison for string"),             \
-       _PE(ILLEGAL_INTEGER_CMP,"illegal comparison for integer")
+       _PE(ILLEGAL_INTEGER_CMP,"illegal comparison for integer"),            \
+       _PE(REPARENT_NOT_OP,    "cannot reparent other than OP"),             \
+       _PE(REPARENT_FAILED,    "failed to reparent filter OP"),              \
+       _PE(BAD_FILTER_ARG,     "bad arg in filter tree")
 
 #undef _PE
 #define _PE(__code, __str) PEVENT_ERRNO__ ## __code

diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index 774c3e4c1d9fe53bcd6405d039b4365644a40f1c..9b05892566e06b59cf2f2b169fed101bf9e0de4a 100644 (file)
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -784,15 +784,18 @@ enum filter_vals {
        FILTER_VAL_TRUE,
 };
 
-void reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
-                 struct filter_arg *arg)
+static enum pevent_errno
+reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
+               struct filter_arg *arg, char **error_str)
 {
        struct filter_arg *other_child;
        struct filter_arg **ptr;
 
        if (parent->type != FILTER_ARG_OP &&
-           arg->type != FILTER_ARG_OP)
-               die("can not reparent other than OP");
+           arg->type != FILTER_ARG_OP) {
+               show_error(error_str, "can not reparent other than OP");
+               return PEVENT_ERRNO__REPARENT_NOT_OP;
+       }
 
        /* Get the sibling */
        if (old_child->op.right == arg) {
@@ -801,8 +804,10 @@ void reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
        } else if (old_child->op.left == arg) {
                ptr = &old_child->op.left;
                other_child = old_child->op.right;
-       } else
-               die("Error in reparent op, find other child");
+       } else {
+               show_error(error_str, "Error in reparent op, find other child");
+               return PEVENT_ERRNO__REPARENT_FAILED;
+       }
 
        /* Detach arg from old_child */
        *ptr = NULL;
@@ -813,23 +818,29 @@ void reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
                *parent = *arg;
                /* Free arg without recussion */
                free(arg);
-               return;
+               return 0;
        }
 
        if (parent->op.right == old_child)
                ptr = &parent->op.right;
        else if (parent->op.left == old_child)
                ptr = &parent->op.left;
-       else
-               die("Error in reparent op");
+       else {
+               show_error(error_str, "Error in reparent op");
+               return PEVENT_ERRNO__REPARENT_FAILED;
+       }
+
        *ptr = arg;
 
        free_arg(old_child);
+       return 0;
 }
 
-enum filter_vals test_arg(struct filter_arg *parent, struct filter_arg *arg)
+/* Returns either filter_vals (success) or pevent_errno (failfure) */
+static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
+                   char **error_str)
 {
-       enum filter_vals lval, rval;
+       int lval, rval;
 
        switch (arg->type) {
 
@@ -844,63 +855,68 @@ enum filter_vals test_arg(struct filter_arg *parent, struct filter_arg *arg)
                return FILTER_VAL_NORM;
 
        case FILTER_ARG_EXP:
-               lval = test_arg(arg, arg->exp.left);
+               lval = test_arg(arg, arg->exp.left, error_str);
                if (lval != FILTER_VAL_NORM)
                        return lval;
-               rval = test_arg(arg, arg->exp.right);
+               rval = test_arg(arg, arg->exp.right, error_str);
                if (rval != FILTER_VAL_NORM)
                        return rval;
                return FILTER_VAL_NORM;
 
        case FILTER_ARG_NUM:
-               lval = test_arg(arg, arg->num.left);
+               lval = test_arg(arg, arg->num.left, error_str);
                if (lval != FILTER_VAL_NORM)
                        return lval;
-               rval = test_arg(arg, arg->num.right);
+               rval = test_arg(arg, arg->num.right, error_str);
                if (rval != FILTER_VAL_NORM)
                        return rval;
                return FILTER_VAL_NORM;
 
        case FILTER_ARG_OP:
                if (arg->op.type != FILTER_OP_NOT) {
-                       lval = test_arg(arg, arg->op.left);
+                       lval = test_arg(arg, arg->op.left, error_str);
                        switch (lval) {
                        case FILTER_VAL_NORM:
                                break;
                        case FILTER_VAL_TRUE:
                                if (arg->op.type == FILTER_OP_OR)
                                        return FILTER_VAL_TRUE;
-                               rval = test_arg(arg, arg->op.right);
+                               rval = test_arg(arg, arg->op.right, error_str);
                                if (rval != FILTER_VAL_NORM)
                                        return rval;
 
-                               reparent_op_arg(parent, arg, arg->op.right);
-                               return FILTER_VAL_NORM;
+                               return reparent_op_arg(parent, arg, arg->op.right,
+                                                      error_str);
 
                        case FILTER_VAL_FALSE:
                                if (arg->op.type == FILTER_OP_AND)
                                        return FILTER_VAL_FALSE;
-                               rval = test_arg(arg, arg->op.right);
+                               rval = test_arg(arg, arg->op.right, error_str);
                                if (rval != FILTER_VAL_NORM)
                                        return rval;
 
-                               reparent_op_arg(parent, arg, arg->op.right);
-                               return FILTER_VAL_NORM;
+                               return reparent_op_arg(parent, arg, arg->op.right,
+                                                      error_str);
+
+                       default:
+                               return lval;
                        }
                }
 
-               rval = test_arg(arg, arg->op.right);
+               rval = test_arg(arg, arg->op.right, error_str);
                switch (rval) {
                case FILTER_VAL_NORM:
+               default:
                        break;
+
                case FILTER_VAL_TRUE:
                        if (arg->op.type == FILTER_OP_OR)
                                return FILTER_VAL_TRUE;
                        if (arg->op.type == FILTER_OP_NOT)
                                return FILTER_VAL_FALSE;
 
-                       reparent_op_arg(parent, arg, arg->op.left);
-                       return FILTER_VAL_NORM;
+                       return reparent_op_arg(parent, arg, arg->op.left,
+                                              error_str);
 
                case FILTER_VAL_FALSE:
                        if (arg->op.type == FILTER_OP_AND)
@@ -908,26 +924,27 @@ enum filter_vals test_arg(struct filter_arg *parent, struct filter_arg *arg)
                        if (arg->op.type == FILTER_OP_NOT)
                                return FILTER_VAL_TRUE;
 
-                       reparent_op_arg(parent, arg, arg->op.left);
-                       return FILTER_VAL_NORM;
+                       return reparent_op_arg(parent, arg, arg->op.left,
+                                              error_str);
                }
 
-               return FILTER_VAL_NORM;
+               return rval;
        default:
-               die("bad arg in filter tree");
+               show_error(error_str, "bad arg in filter tree");
+               return PEVENT_ERRNO__BAD_FILTER_ARG;
        }
        return FILTER_VAL_NORM;
 }
 
 /* Remove any unknown event fields */
-static struct filter_arg *collapse_tree(struct filter_arg *arg)
+static struct filter_arg *collapse_tree(struct filter_arg *arg, char **error_str)
 {
        enum filter_vals ret;
 
-       ret = test_arg(arg, arg);
+       ret = test_arg(arg, arg, error_str);
        switch (ret) {
        case FILTER_VAL_NORM:
-               return arg;
+               break;
 
        case FILTER_VAL_TRUE:
        case FILTER_VAL_FALSE:
@@ -936,7 +953,16 @@ static struct filter_arg *collapse_tree(struct filter_arg *arg)
                if (arg) {
                        arg->type = FILTER_ARG_BOOLEAN;
                        arg->boolean.value = ret == FILTER_VAL_TRUE;
+               } else {
+                       show_error(error_str, "Failed to allocate filter arg");
                }
+               break;
+
+       default:
+               /* test_arg() already set the error_str */
+               free_arg(arg);
+               arg = NULL;
+               break;
        }
 
        return arg;
@@ -1152,9 +1178,9 @@ process_filter(struct event_format *event, struct filter_arg **parg,
        if (!current_op)
                current_op = current_exp;
 
-       current_op = collapse_tree(current_op);
+       current_op = collapse_tree(current_op, error_str);
        if (current_op == NULL)
-               goto fail_alloc;
+               goto fail;
 
        *parg = current_op;