parse-events: Handle invalid opcode parsing gracefully

If an invalid opcode is encountered, trace-cmd exits with an error.
Instead it can be treated as a soft error where the event's print format
is not parsed and its binary data is dumped out.

This patch adds a return value to arg_num_eval() function to indicate if
the parsing was successful. If not, then the error is considered soft
and the parsing of the offending event fails.

Cc: Michael Rubin <mrubin@google.com>
Cc: David Sharp <dhsharp@google.com>
Signed-off-by: Vaibhav Nagarnaik <vnagarnaik@google.com>
Link: http://lkml.kernel.org/r/1310785241-3799-2-git-send-email-vnagarnaik@google.com
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@infradead.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Arun Sharma <asharma@fb.com>
Cc: Namhyung Kim <namhyung.kim@lge.com>
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>

diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 16da20c552bc4de5c5f13ce702ffe7cf15211b0f..ef2c65f91677e96d9bfb8c5ca5fdef23fc630ac8 100644 (file)
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -1915,90 +1915,120 @@ eval_type(unsigned long long val, struct print_arg *arg, int pointer)
        return eval_type_str(val, arg->typecast.type, pointer);
 }
 
-static long long arg_num_eval(struct print_arg *arg)
+static int arg_num_eval(struct print_arg *arg, long long *val)
 {
        long long left, right;
-       long long val = 0;
+       int ret = 1;
 
        switch (arg->type) {
        case PRINT_ATOM:
-               val = strtoll(arg->atom.atom, NULL, 0);
+               *val = strtoll(arg->atom.atom, NULL, 0);
                break;
        case PRINT_TYPE:
-               val = arg_num_eval(arg->typecast.item);
-               val = eval_type(val, arg, 0);
+               ret = arg_num_eval(arg->typecast.item, val);
+               if (!ret)
+                       break;
+               *val = eval_type(*val, arg, 0);
                break;
        case PRINT_OP:
                switch (arg->op.op[0]) {
                case '|':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
                        if (arg->op.op[1])
-                               val = left || right;
+                               *val = left || right;
                        else
-                               val = left | right;
+                               *val = left | right;
                        break;
                case '&':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
                        if (arg->op.op[1])
-                               val = left && right;
+                               *val = left && right;
                        else
-                               val = left & right;
+                               *val = left & right;
                        break;
                case '<':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
                        switch (arg->op.op[1]) {
                        case 0:
-                               val = left < right;
+                               *val = left < right;
                                break;
                        case '<':
-                               val = left << right;
+                               *val = left << right;
                                break;
                        case '=':
-                               val = left <= right;
+                               *val = left <= right;
                                break;
                        default:
-                               die("unknown op '%s'", arg->op.op);
+                               do_warning("unknown op '%s'", arg->op.op);
+                               ret = 0;
                        }
                        break;
                case '>':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
                        switch (arg->op.op[1]) {
                        case 0:
-                               val = left > right;
+                               *val = left > right;
                                break;
                        case '>':
-                               val = left >> right;
+                               *val = left >> right;
                                break;
                        case '=':
-                               val = left >= right;
+                               *val = left >= right;
                                break;
                        default:
-                               die("unknown op '%s'", arg->op.op);
+                               do_warning("unknown op '%s'", arg->op.op);
+                               ret = 0;
                        }
                        break;
                case '=':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
-
-                       if (arg->op.op[1] != '=')
-                               die("unknown op '%s'", arg->op.op);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
 
-                       val = left == right;
+                       if (arg->op.op[1] != '=') {
+                               do_warning("unknown op '%s'", arg->op.op);
+                               ret = 0;
+                       } else
+                               *val = left == right;
                        break;
                case '!':
-                       left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
+                       ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
 
                        switch (arg->op.op[1]) {
                        case '=':
-                               val = left != right;
+                               *val = left != right;
                                break;
                        default:
-                               die("unknown op '%s'", arg->op.op);
+                               do_warning("unknown op '%s'", arg->op.op);
+                               ret = 0;
                        }
                        break;
                case '-':
@@ -2006,12 +2036,17 @@ static long long arg_num_eval(struct print_arg *arg)
                        if (arg->op.left->type == PRINT_NULL)
                                left = 0;
                        else
-                               left = arg_num_eval(arg->op.left);
-                       right = arg_num_eval(arg->op.right);
-                       val = left - right;
+                               ret = arg_num_eval(arg->op.left, &left);
+                       if (!ret)
+                               break;
+                       ret = arg_num_eval(arg->op.right, &right);
+                       if (!ret)
+                               break;
+                       *val = left - right;
                        break;
                default:
-                       die("unknown op '%s'", arg->op.op);
+                       do_warning("unknown op '%s'", arg->op.op);
+                       ret = 0;
                }
                break;
 
@@ -2020,10 +2055,11 @@ static long long arg_num_eval(struct print_arg *arg)
        case PRINT_STRING:
        case PRINT_BSTRING:
        default:
-               die("invalid eval type %d", arg->type);
+               do_warning("invalid eval type %d", arg->type);
+               ret = 0;
 
        }
-       return val;
+       return ret;
 }
 
 static char *arg_eval (struct print_arg *arg)
@@ -2037,7 +2073,8 @@ static char *arg_eval (struct print_arg *arg)
        case PRINT_TYPE:
                return arg_eval(arg->typecast.item);
        case PRINT_OP:
-               val = arg_num_eval(arg);
+               if (!arg_num_eval(arg, &val))
+                       break;
                sprintf(buf, "%lld", val);
                return buf;
 
@@ -2079,6 +2116,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                memset(field, 0, sizeof(*field));
 
                value = arg_eval(arg);
+               if (value == NULL)
+                       goto out_free;
                field->value = strdup(value);
 
                free_arg(arg);
@@ -2090,6 +2129,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                        goto out_free;
 
                value = arg_eval(arg);
+               if (value == NULL)
+                       goto out_free;
                field->str = strdup(value);
                free_arg(arg);
                arg = NULL;