tracing/probes: Move event parameter fetching code to common parser

Move trace event parameter fetching code to common parser in
trace_probe.c. This simplifies eprobe's trace-event variable fetching
code by introducing a parse context data structure.

Link: https://lore.kernel.org/all/168507472950.913472.2812253181558471278.stgit@mhiramat.roam.corp.google.com/
Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>

diff --git a/kernel/trace/trace_eprobe.c b/kernel/trace/trace_eprobe.c
index fd64cd5d57451a6a82c304d317f97f116e9b15f4..cb0077ba2b49694b50e650155efba7f70406cd85 100644 (file)
--- a/kernel/trace/trace_eprobe.c
+++ b/kernel/trace/trace_eprobe.c
@@ -227,37 +227,6 @@ error:
        return ERR_PTR(ret);
 }
 
        return ERR_PTR(ret);
 }
 

-static int trace_eprobe_tp_arg_update(struct trace_eprobe *ep, int i)
-{
-       struct probe_arg *parg = &ep->tp.args[i];
-       struct ftrace_event_field *field;
-       struct list_head *head;
-       int ret = -ENOENT;
-
-       head = trace_get_fields(ep->event);
-       list_for_each_entry(field, head, link) {
-               if (!strcmp(parg->code->data, field->name)) {
-                       kfree(parg->code->data);
-                       parg->code->data = field;
-                       return 0;
-               }
-       }
-
-       /*
-        * Argument not found on event. But allow for comm and COMM
-        * to be used to get the current->comm.
-        */
-       if (strcmp(parg->code->data, "COMM") == 0 ||
-           strcmp(parg->code->data, "comm") == 0) {
-               parg->code->op = FETCH_OP_COMM;
-               ret = 0;
-       }
-
-       kfree(parg->code->data);
-       parg->code->data = NULL;
-       return ret;
-}
-

 static int eprobe_event_define_fields(struct trace_event_call *event_call)
 {
        struct eprobe_trace_entry_head field;
 static int eprobe_event_define_fields(struct trace_event_call *event_call)
 {
        struct eprobe_trace_entry_head field;


@@ -817,19 +786,16 @@ find_and_get_event(const char *system, const char *event_name)
 
 static int trace_eprobe_tp_update_arg(struct trace_eprobe *ep, const char *argv[], int i)
 {
 
 static int trace_eprobe_tp_update_arg(struct trace_eprobe *ep, const char *argv[], int i)
 {

-       unsigned int flags = TPARG_FL_KERNEL | TPARG_FL_TEVENT;
+       struct traceprobe_parse_context ctx = {
+               .event = ep->event,
+               .flags = TPARG_FL_KERNEL | TPARG_FL_TEVENT,
+       };

        int ret;
 
        int ret;
 

-       ret = traceprobe_parse_probe_arg(&ep->tp, i, argv[i], flags);
+       ret = traceprobe_parse_probe_arg(&ep->tp, i, argv[i], &ctx);

        if (ret)
                return ret;
 
        if (ret)
                return ret;
 

-       if (ep->tp.args[i].code->op == FETCH_OP_TP_ARG) {
-               ret = trace_eprobe_tp_arg_update(ep, i);
-               if (ret)
-                       trace_probe_log_err(0, BAD_ATTACH_ARG);
-       }
-

        /* Handle symbols "@" */
        if (!ret)
                ret = traceprobe_update_arg(&ep->tp.args[i]);
        /* Handle symbols "@" */
        if (!ret)
                ret = traceprobe_update_arg(&ep->tp.args[i]);

diff --git a/kernel/trace/trace_fprobe.c b/kernel/trace/trace_fprobe.c
index aa71ccb4205c9003762ceea3d3b780b128cf404e..7d144e4a3fb6678cef627cfe15e224505736cea5 100644 (file)
--- a/kernel/trace/trace_fprobe.c
+++ b/kernel/trace/trace_fprobe.c
@@ -1047,8 +1047,10 @@ static int __trace_fprobe_create(int argc, const char *argv[])
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {

+               struct traceprobe_parse_context ctx = { .flags = flags };
+

                trace_probe_log_set_index(i + 2);
                trace_probe_log_set_index(i + 2);

-               ret = traceprobe_parse_probe_arg(&tf->tp, i, argv[i], flags);
+               ret = traceprobe_parse_probe_arg(&tf->tp, i, argv[i], &ctx);

                if (ret)
                        goto error;     /* This can be -ENOMEM */
        }
                if (ret)
                        goto error;     /* This can be -ENOMEM */
        }

diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index b7a4409674b322d8ac0b825963178eb09e76a031..1a3497719ada4a22a5fc2086905d2d448018e9bd 100644 (file)
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -867,8 +867,10 @@ static int __trace_kprobe_create(int argc, const char *argv[])
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {

+               struct traceprobe_parse_context ctx = { .flags = flags };
+

                trace_probe_log_set_index(i + 2);
                trace_probe_log_set_index(i + 2);

-               ret = traceprobe_parse_probe_arg(&tk->tp, i, argv[i], flags);
+               ret = traceprobe_parse_probe_arg(&tk->tp, i, argv[i], &ctx);

                if (ret)
                        goto error;     /* This can be -ENOMEM */
        }
                if (ret)
                        goto error;     /* This can be -ENOMEM */
        }

diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
index 798f18d24ebc756d894bb9473e05b4560bcdd51e..9ebefacb6372fc96e0d3fd9338dce6bd0494da0e 100644 (file)
--- a/kernel/trace/trace_probe.c
+++ b/kernel/trace/trace_probe.c
@@ -283,74 +283,114 @@ int traceprobe_parse_event_name(const char **pevent, const char **pgroup,
        return 0;
 }
 
        return 0;
 }
 

+static int parse_trace_event_arg(char *arg, struct fetch_insn *code,
+                                struct traceprobe_parse_context *ctx)
+{
+       struct ftrace_event_field *field;
+       struct list_head *head;
+
+       head = trace_get_fields(ctx->event);
+       list_for_each_entry(field, head, link) {
+               if (!strcmp(arg, field->name)) {
+                       code->op = FETCH_OP_TP_ARG;
+                       code->data = field;
+                       return 0;
+               }
+       }
+       return -ENOENT;
+}
+

 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
 
 static int parse_probe_vars(char *arg, const struct fetch_type *t,
 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
 
 static int parse_probe_vars(char *arg, const struct fetch_type *t,

-                       struct fetch_insn *code, unsigned int flags, int offs)
+                           struct fetch_insn *code,
+                           struct traceprobe_parse_context *ctx)

 {
        unsigned long param;
 {
        unsigned long param;

+       int err = TP_ERR_BAD_VAR;

        int ret = 0;
        int len;
 
        int ret = 0;
        int len;
 

-       if (flags & TPARG_FL_TEVENT) {
+       if (ctx->flags & TPARG_FL_TEVENT) {

                if (code->data)
                        return -EFAULT;
                if (code->data)
                        return -EFAULT;

-               code->data = kstrdup(arg, GFP_KERNEL);
-               if (!code->data)
-                       return -ENOMEM;
-               code->op = FETCH_OP_TP_ARG;
-       } else if (strcmp(arg, "retval") == 0) {
-               if (flags & TPARG_FL_RETURN) {
+               ret = parse_trace_event_arg(arg, code, ctx);
+               if (!ret)
+                       return 0;
+               if (strcmp(arg, "comm") == 0 || strcmp(arg, "COMM") == 0) {
+                       code->op = FETCH_OP_COMM;
+                       return 0;
+               }
+               /* backward compatibility */
+               ctx->offset = 0;
+               goto inval;
+       }
+
+       if (strcmp(arg, "retval") == 0) {
+               if (ctx->flags & TPARG_FL_RETURN) {

                        code->op = FETCH_OP_RETVAL;
                        code->op = FETCH_OP_RETVAL;

-               } else {
-                       trace_probe_log_err(offs, RETVAL_ON_PROBE);
-                       ret = -EINVAL;
+                       return 0;

                }
                }

-       } else if ((len = str_has_prefix(arg, "stack"))) {
+               err = TP_ERR_RETVAL_ON_PROBE;
+               goto inval;
+       }
+
+       len = str_has_prefix(arg, "stack");
+       if (len) {
+

                if (arg[len] == '\0') {
                        code->op = FETCH_OP_STACKP;
                if (arg[len] == '\0') {
                        code->op = FETCH_OP_STACKP;

-               } else if (isdigit(arg[len])) {
+                       return 0;
+               }
+
+               if (isdigit(arg[len])) {

                        ret = kstrtoul(arg + len, 10, &param);
                        ret = kstrtoul(arg + len, 10, &param);

-                       if (ret) {
-                               goto inval_var;
-                       } else if ((flags & TPARG_FL_KERNEL) &&
-                                   param > PARAM_MAX_STACK) {
-                               trace_probe_log_err(offs, BAD_STACK_NUM);
-                               ret = -EINVAL;
-                       } else {
-                               code->op = FETCH_OP_STACK;
-                               code->param = (unsigned int)param;
+                       if (ret)
+                               goto inval;
+
+                       if ((ctx->flags & TPARG_FL_KERNEL) &&
+                           param > PARAM_MAX_STACK) {
+                               err = TP_ERR_BAD_STACK_NUM;
+                               goto inval;

                        }
                        }

-               } else
-                       goto inval_var;
-       } else if (strcmp(arg, "comm") == 0 || strcmp(arg, "COMM") == 0) {
+                       code->op = FETCH_OP_STACK;
+                       code->param = (unsigned int)param;
+                       return 0;
+               }
+               goto inval;
+       }
+
+       if (strcmp(arg, "comm") == 0 || strcmp(arg, "COMM") == 0) {

                code->op = FETCH_OP_COMM;
                code->op = FETCH_OP_COMM;

+               return 0;
+       }
+

 #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API
 #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API

-       } else if (tparg_is_function_entry(flags) &&
-                  (len = str_has_prefix(arg, "arg"))) {
+       len = str_has_prefix(arg, "arg");
+       if (len && tparg_is_function_entry(ctx->flags)) {

                ret = kstrtoul(arg + len, 10, &param);
                ret = kstrtoul(arg + len, 10, &param);

-               if (ret) {
-                       goto inval_var;
-               } else if (!param || param > PARAM_MAX_STACK) {
-                       trace_probe_log_err(offs, BAD_ARG_NUM);
-                       return -EINVAL;
+               if (ret)
+                       goto inval;
+
+               if (!param || param > PARAM_MAX_STACK) {
+                       err = TP_ERR_BAD_ARG_NUM;
+                       goto inval;

                }
                }

+

                code->op = FETCH_OP_ARG;
                code->param = (unsigned int)param - 1;
                /*
                 * The tracepoint probe will probe a stub function, and the
                 * first parameter of the stub is a dummy and should be ignored.
                 */
                code->op = FETCH_OP_ARG;
                code->param = (unsigned int)param - 1;
                /*
                 * The tracepoint probe will probe a stub function, and the
                 * first parameter of the stub is a dummy and should be ignored.
                 */

-               if (flags & TPARG_FL_TPOINT)
+               if (ctx->flags & TPARG_FL_TPOINT)

                        code->param++;
                        code->param++;

+               return 0;
+       }

 #endif
 #endif

-       } else
-               goto inval_var;

 
 

-       return ret;
-
-inval_var:
-       trace_probe_log_err(offs, BAD_VAR);
+inval:
+       __trace_probe_log_err(ctx->offset, err);

        return -EINVAL;
 }
 
        return -EINVAL;
 }
 


@@ -383,7 +423,7 @@ static int __parse_imm_string(char *str, char **pbuf, int offs)
 static int
 parse_probe_arg(char *arg, const struct fetch_type *type,
                struct fetch_insn **pcode, struct fetch_insn *end,
 static int
 parse_probe_arg(char *arg, const struct fetch_type *type,
                struct fetch_insn **pcode, struct fetch_insn *end,

-               unsigned int flags, int offs)
+               struct traceprobe_parse_context *ctx)

 {
        struct fetch_insn *code = *pcode;
        unsigned long param;
 {
        struct fetch_insn *code = *pcode;
        unsigned long param;


@@ -394,13 +434,13 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
 
        switch (arg[0]) {
        case '$':
 
        switch (arg[0]) {
        case '$':

-               ret = parse_probe_vars(arg + 1, type, code, flags, offs);
+               ret = parse_probe_vars(arg + 1, type, code, ctx);

                break;
 
        case '%':       /* named register */
                break;
 
        case '%':       /* named register */

-               if (flags & (TPARG_FL_TEVENT | TPARG_FL_FPROBE)) {
+               if (ctx->flags & (TPARG_FL_TEVENT | TPARG_FL_FPROBE)) {

                        /* eprobe and fprobe do not handle registers */
                        /* eprobe and fprobe do not handle registers */

-                       trace_probe_log_err(offs, BAD_VAR);
+                       trace_probe_log_err(ctx->offset, BAD_VAR);

                        break;
                }
                ret = regs_query_register_offset(arg + 1);
                        break;
                }
                ret = regs_query_register_offset(arg + 1);


@@ -409,14 +449,14 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                        code->param = (unsigned int)ret;
                        ret = 0;
                } else
                        code->param = (unsigned int)ret;
                        ret = 0;
                } else

-                       trace_probe_log_err(offs, BAD_REG_NAME);
+                       trace_probe_log_err(ctx->offset, BAD_REG_NAME);

                break;
 
        case '@':       /* memory, file-offset or symbol */
                if (isdigit(arg[1])) {
                        ret = kstrtoul(arg + 1, 0, &param);
                        if (ret) {
                break;
 
        case '@':       /* memory, file-offset or symbol */
                if (isdigit(arg[1])) {
                        ret = kstrtoul(arg + 1, 0, &param);
                        if (ret) {

-                               trace_probe_log_err(offs, BAD_MEM_ADDR);
+                               trace_probe_log_err(ctx->offset, BAD_MEM_ADDR);

                                break;
                        }
                        /* load address */
                                break;
                        }
                        /* load address */


@@ -424,13 +464,13 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                        code->immediate = param;
                } else if (arg[1] == '+') {
                        /* kprobes don't support file offsets */
                        code->immediate = param;
                } else if (arg[1] == '+') {
                        /* kprobes don't support file offsets */

-                       if (flags & TPARG_FL_KERNEL) {
-                               trace_probe_log_err(offs, FILE_ON_KPROBE);
+                       if (ctx->flags & TPARG_FL_KERNEL) {
+                               trace_probe_log_err(ctx->offset, FILE_ON_KPROBE);

                                return -EINVAL;
                        }
                        ret = kstrtol(arg + 2, 0, &offset);
                        if (ret) {
                                return -EINVAL;
                        }
                        ret = kstrtol(arg + 2, 0, &offset);
                        if (ret) {

-                               trace_probe_log_err(offs, BAD_FILE_OFFS);
+                               trace_probe_log_err(ctx->offset, BAD_FILE_OFFS);

                                break;
                        }
 
                                break;
                        }
 


@@ -438,8 +478,8 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                        code->immediate = (unsigned long)offset;  // imm64?
                } else {
                        /* uprobes don't support symbols */
                        code->immediate = (unsigned long)offset;  // imm64?
                } else {
                        /* uprobes don't support symbols */

-                       if (!(flags & TPARG_FL_KERNEL)) {
-                               trace_probe_log_err(offs, SYM_ON_UPROBE);
+                       if (!(ctx->flags & TPARG_FL_KERNEL)) {
+                               trace_probe_log_err(ctx->offset, SYM_ON_UPROBE);

                                return -EINVAL;
                        }
                        /* Preserve symbol for updating */
                                return -EINVAL;
                        }
                        /* Preserve symbol for updating */


@@ -448,7 +488,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                        if (!code->data)
                                return -ENOMEM;
                        if (++code == end) {
                        if (!code->data)
                                return -ENOMEM;
                        if (++code == end) {

-                               trace_probe_log_err(offs, TOO_MANY_OPS);
+                               trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                                return -EINVAL;
                        }
                        code->op = FETCH_OP_IMM;
                                return -EINVAL;
                        }
                        code->op = FETCH_OP_IMM;


@@ -456,7 +496,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                }
                /* These are fetching from memory */
                if (++code == end) {
                }
                /* These are fetching from memory */
                if (++code == end) {

-                       trace_probe_log_err(offs, TOO_MANY_OPS);
+                       trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                        return -EINVAL;
                }
                *pcode = code;
                        return -EINVAL;
                }
                *pcode = code;


@@ -475,36 +515,38 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                        arg++;  /* Skip '+', because kstrtol() rejects it. */
                tmp = strchr(arg, '(');
                if (!tmp) {
                        arg++;  /* Skip '+', because kstrtol() rejects it. */
                tmp = strchr(arg, '(');
                if (!tmp) {

-                       trace_probe_log_err(offs, DEREF_NEED_BRACE);
+                       trace_probe_log_err(ctx->offset, DEREF_NEED_BRACE);

                        return -EINVAL;
                }
                *tmp = '\0';
                ret = kstrtol(arg, 0, &offset);
                if (ret) {
                        return -EINVAL;
                }
                *tmp = '\0';
                ret = kstrtol(arg, 0, &offset);
                if (ret) {

-                       trace_probe_log_err(offs, BAD_DEREF_OFFS);
+                       trace_probe_log_err(ctx->offset, BAD_DEREF_OFFS);

                        break;
                }
                        break;
                }

-               offs += (tmp + 1 - arg) + (arg[0] != '-' ? 1 : 0);
+               ctx->offset += (tmp + 1 - arg) + (arg[0] != '-' ? 1 : 0);

                arg = tmp + 1;
                tmp = strrchr(arg, ')');
                if (!tmp) {
                arg = tmp + 1;
                tmp = strrchr(arg, ')');
                if (!tmp) {

-                       trace_probe_log_err(offs + strlen(arg),
+                       trace_probe_log_err(ctx->offset + strlen(arg),

                                            DEREF_OPEN_BRACE);
                        return -EINVAL;
                } else {
                                            DEREF_OPEN_BRACE);
                        return -EINVAL;
                } else {

-                       const struct fetch_type *t2 = find_fetch_type(NULL, flags);
+                       const struct fetch_type *t2 = find_fetch_type(NULL, ctx->flags);
+                       int cur_offs = ctx->offset;

 
                        *tmp = '\0';
 
                        *tmp = '\0';

-                       ret = parse_probe_arg(arg, t2, &code, end, flags, offs);
+                       ret = parse_probe_arg(arg, t2, &code, end, ctx);

                        if (ret)
                                break;
                        if (ret)
                                break;

+                       ctx->offset = cur_offs;

                        if (code->op == FETCH_OP_COMM ||
                            code->op == FETCH_OP_DATA) {
                        if (code->op == FETCH_OP_COMM ||
                            code->op == FETCH_OP_DATA) {

-                               trace_probe_log_err(offs, COMM_CANT_DEREF);
+                               trace_probe_log_err(ctx->offset, COMM_CANT_DEREF);

                                return -EINVAL;
                        }
                        if (++code == end) {
                                return -EINVAL;
                        }
                        if (++code == end) {

-                               trace_probe_log_err(offs, TOO_MANY_OPS);
+                               trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                                return -EINVAL;
                        }
                        *pcode = code;
                                return -EINVAL;
                        }
                        *pcode = code;


@@ -515,7 +557,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                break;
        case '\\':      /* Immediate value */
                if (arg[1] == '"') {    /* Immediate string */
                break;
        case '\\':      /* Immediate value */
                if (arg[1] == '"') {    /* Immediate string */

-                       ret = __parse_imm_string(arg + 2, &tmp, offs + 2);
+                       ret = __parse_imm_string(arg + 2, &tmp, ctx->offset + 2);

                        if (ret)
                                break;
                        code->op = FETCH_OP_DATA;
                        if (ret)
                                break;
                        code->op = FETCH_OP_DATA;


@@ -523,7 +565,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
                } else {
                        ret = str_to_immediate(arg + 1, &code->immediate);
                        if (ret)
                } else {
                        ret = str_to_immediate(arg + 1, &code->immediate);
                        if (ret)

-                               trace_probe_log_err(offs + 1, BAD_IMM);
+                               trace_probe_log_err(ctx->offset + 1, BAD_IMM);

                        else
                                code->op = FETCH_OP_IMM;
                }
                        else
                                code->op = FETCH_OP_IMM;
                }


@@ -531,7 +573,7 @@ parse_probe_arg(char *arg, const struct fetch_type *type,
        }
        if (!ret && code->op == FETCH_OP_NOP) {
                /* Parsed, but do not find fetch method */
        }
        if (!ret && code->op == FETCH_OP_NOP) {
                /* Parsed, but do not find fetch method */

-               trace_probe_log_err(offs, BAD_FETCH_ARG);
+               trace_probe_log_err(ctx->offset, BAD_FETCH_ARG);

                ret = -EINVAL;
        }
        return ret;
                ret = -EINVAL;
        }
        return ret;


@@ -576,12 +618,13 @@ static int __parse_bitfield_probe_arg(const char *bf,
 
 /* String length checking wrapper */
 static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
 
 /* String length checking wrapper */
 static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,

-               struct probe_arg *parg, unsigned int flags, int offset)
+                                          struct probe_arg *parg,
+                                          struct traceprobe_parse_context *ctx)

 {
        struct fetch_insn *code, *scode, *tmp = NULL;
        char *t, *t2, *t3;
 {
        struct fetch_insn *code, *scode, *tmp = NULL;
        char *t, *t2, *t3;

-       char *arg;

        int ret, len;
        int ret, len;

+       char *arg;

 
        arg = kstrdup(argv, GFP_KERNEL);
        if (!arg)
 
        arg = kstrdup(argv, GFP_KERNEL);
        if (!arg)


@@ -590,10 +633,10 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
        ret = -EINVAL;
        len = strlen(arg);
        if (len > MAX_ARGSTR_LEN) {
        ret = -EINVAL;
        len = strlen(arg);
        if (len > MAX_ARGSTR_LEN) {

-               trace_probe_log_err(offset, ARG_TOO_LONG);
+               trace_probe_log_err(ctx->offset, ARG_TOO_LONG);

                goto out;
        } else if (len == 0) {
                goto out;
        } else if (len == 0) {

-               trace_probe_log_err(offset, NO_ARG_BODY);
+               trace_probe_log_err(ctx->offset, NO_ARG_BODY);

                goto out;
        }
 
                goto out;
        }
 


@@ -611,23 +654,24 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
                        *t2++ = '\0';
                        t3 = strchr(t2, ']');
                        if (!t3) {
                        *t2++ = '\0';
                        t3 = strchr(t2, ']');
                        if (!t3) {

-                               offset += t2 + strlen(t2) - arg;
-                               trace_probe_log_err(offset,
+                               int offs = t2 + strlen(t2) - arg;
+
+                               trace_probe_log_err(ctx->offset + offs,

                                                    ARRAY_NO_CLOSE);
                                goto out;
                        } else if (t3[1] != '\0') {
                                                    ARRAY_NO_CLOSE);
                                goto out;
                        } else if (t3[1] != '\0') {

-                               trace_probe_log_err(offset + t3 + 1 - arg,
+                               trace_probe_log_err(ctx->offset + t3 + 1 - arg,

                                                    BAD_ARRAY_SUFFIX);
                                goto out;
                        }
                        *t3 = '\0';
                        if (kstrtouint(t2, 0, &parg->count) || !parg->count) {
                                                    BAD_ARRAY_SUFFIX);
                                goto out;
                        }
                        *t3 = '\0';
                        if (kstrtouint(t2, 0, &parg->count) || !parg->count) {

-                               trace_probe_log_err(offset + t2 - arg,
+                               trace_probe_log_err(ctx->offset + t2 - arg,

                                                    BAD_ARRAY_NUM);
                                goto out;
                        }
                        if (parg->count > MAX_ARRAY_LEN) {
                                                    BAD_ARRAY_NUM);
                                goto out;
                        }
                        if (parg->count > MAX_ARRAY_LEN) {

-                               trace_probe_log_err(offset + t2 - arg,
+                               trace_probe_log_err(ctx->offset + t2 - arg,

                                                    ARRAY_TOO_BIG);
                                goto out;
                        }
                                                    ARRAY_TOO_BIG);
                                goto out;
                        }


@@ -638,17 +682,17 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
         * Since $comm and immediate string can not be dereferenced,
         * we can find those by strcmp. But ignore for eprobes.
         */
         * Since $comm and immediate string can not be dereferenced,
         * we can find those by strcmp. But ignore for eprobes.
         */

-       if (!(flags & TPARG_FL_TEVENT) &&
+       if (!(ctx->flags & TPARG_FL_TEVENT) &&

            (strcmp(arg, "$comm") == 0 || strcmp(arg, "$COMM") == 0 ||
             strncmp(arg, "\\\"", 2) == 0)) {
                /* The type of $comm must be "string", and not an array. */
                if (parg->count || (t && strcmp(t, "string")))
                        goto out;
            (strcmp(arg, "$comm") == 0 || strcmp(arg, "$COMM") == 0 ||
             strncmp(arg, "\\\"", 2) == 0)) {
                /* The type of $comm must be "string", and not an array. */
                if (parg->count || (t && strcmp(t, "string")))
                        goto out;

-               parg->type = find_fetch_type("string", flags);
+               parg->type = find_fetch_type("string", ctx->flags);

        } else
        } else

-               parg->type = find_fetch_type(t, flags);
+               parg->type = find_fetch_type(t, ctx->flags);

        if (!parg->type) {
        if (!parg->type) {

-               trace_probe_log_err(offset + (t ? (t - arg) : 0), BAD_TYPE);
+               trace_probe_log_err(ctx->offset + (t ? (t - arg) : 0), BAD_TYPE);

                goto out;
        }
        parg->offset = *size;
                goto out;
        }
        parg->offset = *size;


@@ -670,7 +714,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
        code[FETCH_INSN_MAX - 1].op = FETCH_OP_END;
 
        ret = parse_probe_arg(arg, parg->type, &code, &code[FETCH_INSN_MAX - 1],
        code[FETCH_INSN_MAX - 1].op = FETCH_OP_END;
 
        ret = parse_probe_arg(arg, parg->type, &code, &code[FETCH_INSN_MAX - 1],

-                             flags, offset);
+                             ctx);

        if (ret)
                goto fail;
 
        if (ret)
                goto fail;
 


@@ -681,7 +725,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
                        if (code->op != FETCH_OP_REG && code->op != FETCH_OP_STACK &&
                            code->op != FETCH_OP_RETVAL && code->op != FETCH_OP_ARG &&
                            code->op != FETCH_OP_DEREF && code->op != FETCH_OP_TP_ARG) {
                        if (code->op != FETCH_OP_REG && code->op != FETCH_OP_STACK &&
                            code->op != FETCH_OP_RETVAL && code->op != FETCH_OP_ARG &&
                            code->op != FETCH_OP_DEREF && code->op != FETCH_OP_TP_ARG) {

-                               trace_probe_log_err(offset + (t ? (t - arg) : 0),
+                               trace_probe_log_err(ctx->offset + (t ? (t - arg) : 0),

                                                    BAD_SYMSTRING);
                                goto fail;
                        }
                                                    BAD_SYMSTRING);
                                goto fail;
                        }


@@ -689,7 +733,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
                        if (code->op != FETCH_OP_DEREF && code->op != FETCH_OP_UDEREF &&
                            code->op != FETCH_OP_IMM && code->op != FETCH_OP_COMM &&
                            code->op != FETCH_OP_DATA && code->op != FETCH_OP_TP_ARG) {
                        if (code->op != FETCH_OP_DEREF && code->op != FETCH_OP_UDEREF &&
                            code->op != FETCH_OP_IMM && code->op != FETCH_OP_COMM &&
                            code->op != FETCH_OP_DATA && code->op != FETCH_OP_TP_ARG) {

-                               trace_probe_log_err(offset + (t ? (t - arg) : 0),
+                               trace_probe_log_err(ctx->offset + (t ? (t - arg) : 0),

                                                    BAD_STRING);
                                goto fail;
                        }
                                                    BAD_STRING);
                                goto fail;
                        }


@@ -708,7 +752,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
                         */
                        code++;
                        if (code->op != FETCH_OP_NOP) {
                         */
                        code++;
                        if (code->op != FETCH_OP_NOP) {

-                               trace_probe_log_err(offset, TOO_MANY_OPS);
+                               trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                                goto fail;
                        }
                }
                                goto fail;
                        }
                }


@@ -731,7 +775,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
        } else {
                code++;
                if (code->op != FETCH_OP_NOP) {
        } else {
                code++;
                if (code->op != FETCH_OP_NOP) {

-                       trace_probe_log_err(offset, TOO_MANY_OPS);
+                       trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                        goto fail;
                }
                code->op = FETCH_OP_ST_RAW;
                        goto fail;
                }
                code->op = FETCH_OP_ST_RAW;


@@ -742,7 +786,7 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
        if (t != NULL) {
                ret = __parse_bitfield_probe_arg(t, parg->type, &code);
                if (ret) {
        if (t != NULL) {
                ret = __parse_bitfield_probe_arg(t, parg->type, &code);
                if (ret) {

-                       trace_probe_log_err(offset + t - arg, BAD_BITFIELD);
+                       trace_probe_log_err(ctx->offset + t - arg, BAD_BITFIELD);

                        goto fail;
                }
        }
                        goto fail;
                }
        }


@@ -752,13 +796,13 @@ static int traceprobe_parse_probe_arg_body(const char *argv, ssize_t *size,
                if (scode->op != FETCH_OP_ST_MEM &&
                    scode->op != FETCH_OP_ST_STRING &&
                    scode->op != FETCH_OP_ST_USTRING) {
                if (scode->op != FETCH_OP_ST_MEM &&
                    scode->op != FETCH_OP_ST_STRING &&
                    scode->op != FETCH_OP_ST_USTRING) {

-                       trace_probe_log_err(offset + (t ? (t - arg) : 0),
+                       trace_probe_log_err(ctx->offset + (t ? (t - arg) : 0),

                                            BAD_STRING);
                        goto fail;
                }
                code++;
                if (code->op != FETCH_OP_NOP) {
                                            BAD_STRING);
                        goto fail;
                }
                code++;
                if (code->op != FETCH_OP_NOP) {

-                       trace_probe_log_err(offset, TOO_MANY_OPS);
+                       trace_probe_log_err(ctx->offset, TOO_MANY_OPS);

                        goto fail;
                }
                code->op = FETCH_OP_LP_ARRAY;
                        goto fail;
                }
                code->op = FETCH_OP_LP_ARRAY;


@@ -807,7 +851,7 @@ static int traceprobe_conflict_field_name(const char *name,
 }
 
 int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, const char *arg,
 }
 
 int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, const char *arg,

-                               unsigned int flags)
+                              struct traceprobe_parse_context *ctx)

 {
        struct probe_arg *parg = &tp->args[i];
        const char *body;
 {
        struct probe_arg *parg = &tp->args[i];
        const char *body;


@@ -842,9 +886,9 @@ int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, const char *arg,
                trace_probe_log_err(0, USED_ARG_NAME);
                return -EINVAL;
        }
                trace_probe_log_err(0, USED_ARG_NAME);
                return -EINVAL;
        }

+       ctx->offset = body - arg;

        /* Parse fetch argument */
        /* Parse fetch argument */

-       return traceprobe_parse_probe_arg_body(body, &tp->size, parg, flags,
-                                              body - arg);
+       return traceprobe_parse_probe_arg_body(body, &tp->size, parg, ctx);

 }
 
 void traceprobe_free_probe_arg(struct probe_arg *arg)
 }
 
 void traceprobe_free_probe_arg(struct probe_arg *arg)

diff --git a/kernel/trace/trace_probe.h b/kernel/trace/trace_probe.h
index e6b94fcdb88681884caa44008f61065311c20805..f622340ae1713d9e5293bcc8d9cd0222894dcc04 100644 (file)
--- a/kernel/trace/trace_probe.h
+++ b/kernel/trace/trace_probe.h
@@ -378,8 +378,15 @@ static inline bool tparg_is_function_entry(unsigned int flags)
        return (flags & TPARG_FL_LOC_MASK) == (TPARG_FL_KERNEL | TPARG_FL_FENTRY);
 }
 
        return (flags & TPARG_FL_LOC_MASK) == (TPARG_FL_KERNEL | TPARG_FL_FENTRY);
 }
 

+struct traceprobe_parse_context {
+       struct trace_event_call *event;
+       unsigned int flags;
+       int offset;
+};
+

 extern int traceprobe_parse_probe_arg(struct trace_probe *tp, int i,
 extern int traceprobe_parse_probe_arg(struct trace_probe *tp, int i,

-                               const char *argv, unsigned int flags);
+                                     const char *argv,
+                                     struct traceprobe_parse_context *ctx);

 
 extern int traceprobe_update_arg(struct probe_arg *arg);
 extern void traceprobe_free_probe_arg(struct probe_arg *arg);
 
 extern int traceprobe_update_arg(struct probe_arg *arg);
 extern void traceprobe_free_probe_arg(struct probe_arg *arg);

diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 8b92e34ff0c832888ef394ae91270f5cbec544c2..fa09b33ee7315bcf4af61c2faf322bbd12265a05 100644 (file)
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -686,10 +686,12 @@ static int __trace_uprobe_create(int argc, const char **argv)
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
 
        /* parse arguments */
        for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {

+               struct traceprobe_parse_context ctx = {
+                       .flags = (is_return ? TPARG_FL_RETURN : 0) | TPARG_FL_USER,
+               };
+

                trace_probe_log_set_index(i + 2);
                trace_probe_log_set_index(i + 2);

-               ret = traceprobe_parse_probe_arg(&tu->tp, i, argv[i],
-                                       (is_return ? TPARG_FL_RETURN : 0) |
-                                       TPARG_FL_USER);
+               ret = traceprobe_parse_probe_arg(&tu->tp, i, argv[i], &ctx);

                if (ret)
                        goto error;
        }
                if (ret)
                        goto error;
        }