Merge git://git.kernel.org/pub/scm/linux/kernel/git/lethal/sh-2.6
[safe/jmp/linux-2.6] / kernel / trace / trace_kprobe.c
index 97309d4..aff5f80 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * kprobe based kernel tracer
+ * Kprobes-based tracing events
  *
  * Created by Masami Hiramatsu <mhiramat@redhat.com>
  *
 #define MAX_EVENT_NAME_LEN 64
 #define KPROBE_EVENT_SYSTEM "kprobes"
 
-/* currently, trace_kprobe only supports X86. */
+/* Reserved field names */
+#define FIELD_STRING_IP "__probe_ip"
+#define FIELD_STRING_NARGS "__probe_nargs"
+#define FIELD_STRING_RETIP "__probe_ret_ip"
+#define FIELD_STRING_FUNC "__probe_func"
+
+const char *reserved_field_names[] = {
+       "common_type",
+       "common_flags",
+       "common_preempt_count",
+       "common_pid",
+       "common_tgid",
+       "common_lock_depth",
+       FIELD_STRING_IP,
+       FIELD_STRING_NARGS,
+       FIELD_STRING_RETIP,
+       FIELD_STRING_FUNC,
+};
 
 struct fetch_func {
        unsigned long (*func)(struct pt_regs *, void *);
@@ -85,11 +102,6 @@ static __kprobes unsigned long fetch_retvalue(struct pt_regs *regs,
        return regs_return_value(regs);
 }
 
-static __kprobes unsigned long fetch_ip(struct pt_regs *regs, void *dummy)
-{
-       return instruction_pointer(regs);
-}
-
 static __kprobes unsigned long fetch_stack_address(struct pt_regs *regs,
                                                   void *dummy)
 {
@@ -177,7 +189,7 @@ static __kprobes void free_indirect_fetch_data(struct indirect_fetch_data *data)
 }
 
 /**
- * Kprobe tracer core functions
+ * Kprobe event core functions
  */
 
 struct probe_arg {
@@ -220,24 +232,26 @@ static int probe_arg_string(char *buf, size_t n, struct fetch_func *ff)
        int ret = -EINVAL;
 
        if (ff->func == fetch_argument)
-               ret = snprintf(buf, n, "a%lu", (unsigned long)ff->data);
+               ret = snprintf(buf, n, "$arg%lu", (unsigned long)ff->data);
        else if (ff->func == fetch_register) {
                const char *name;
                name = regs_query_register_name((unsigned int)((long)ff->data));
                ret = snprintf(buf, n, "%%%s", name);
        } else if (ff->func == fetch_stack)
-               ret = snprintf(buf, n, "s%lu", (unsigned long)ff->data);
+               ret = snprintf(buf, n, "$stack%lu", (unsigned long)ff->data);
        else if (ff->func == fetch_memory)
                ret = snprintf(buf, n, "@0x%p", ff->data);
        else if (ff->func == fetch_symbol) {
                struct symbol_cache *sc = ff->data;
-               ret = snprintf(buf, n, "@%s%+ld", sc->symbol, sc->offset);
+               if (sc->offset)
+                       ret = snprintf(buf, n, "@%s%+ld", sc->symbol,
+                                       sc->offset);
+               else
+                       ret = snprintf(buf, n, "@%s", sc->symbol);
        } else if (ff->func == fetch_retvalue)
-               ret = snprintf(buf, n, "rv");
-       else if (ff->func == fetch_ip)
-               ret = snprintf(buf, n, "ra");
+               ret = snprintf(buf, n, "$retval");
        else if (ff->func == fetch_stack_address)
-               ret = snprintf(buf, n, "sa");
+               ret = snprintf(buf, n, "$stack");
        else if (ff->func == fetch_indirect) {
                struct indirect_fetch_data *id = ff->data;
                size_t l = 0;
@@ -341,12 +355,14 @@ static void free_trace_probe(struct trace_probe *tp)
        kfree(tp);
 }
 
-static struct trace_probe *find_probe_event(const char *event)
+static struct trace_probe *find_probe_event(const char *event,
+                                           const char *group)
 {
        struct trace_probe *tp;
 
        list_for_each_entry(tp, &probe_list, list)
-               if (!strcmp(tp->call.name, event))
+               if (strcmp(tp->call.name, event) == 0 &&
+                   strcmp(tp->call.system, group) == 0)
                        return tp;
        return NULL;
 }
@@ -371,7 +387,7 @@ static int register_trace_probe(struct trace_probe *tp)
        mutex_lock(&probe_lock);
 
        /* register as an event */
-       old_tp = find_probe_event(tp->call.name);
+       old_tp = find_probe_event(tp->call.name, tp->call.system);
        if (old_tp) {
                /* delete old event */
                unregister_trace_probe(old_tp);
@@ -429,32 +445,55 @@ static int split_symbol_offset(char *symbol, unsigned long *offset)
 #define PARAM_MAX_ARGS 16
 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
 
-static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
+static int parse_probe_vars(char *arg, struct fetch_func *ff, int is_return)
 {
        int ret = 0;
        unsigned long param;
-       long offset;
-       char *tmp;
 
-       switch (arg[0]) {
-       case 'a':       /* argument */
-               ret = strict_strtoul(arg + 1, 10, &param);
+       if (strcmp(arg, "retval") == 0) {
+               if (is_return) {
+                       ff->func = fetch_retvalue;
+                       ff->data = NULL;
+               } else
+                       ret = -EINVAL;
+       } else if (strncmp(arg, "stack", 5) == 0) {
+               if (arg[5] == '\0') {
+                       ff->func = fetch_stack_address;
+                       ff->data = NULL;
+               } else if (isdigit(arg[5])) {
+                       ret = strict_strtoul(arg + 5, 10, &param);
+                       if (ret || param > PARAM_MAX_STACK)
+                               ret = -EINVAL;
+                       else {
+                               ff->func = fetch_stack;
+                               ff->data = (void *)param;
+                       }
+               } else
+                       ret = -EINVAL;
+       } else if (strncmp(arg, "arg", 3) == 0 && isdigit(arg[3])) {
+               ret = strict_strtoul(arg + 3, 10, &param);
                if (ret || param > PARAM_MAX_ARGS)
                        ret = -EINVAL;
                else {
                        ff->func = fetch_argument;
                        ff->data = (void *)param;
                }
-               break;
-       case 'r':       /* retval or retaddr */
-               if (is_return && arg[1] == 'v') {
-                       ff->func = fetch_retvalue;
-                       ff->data = NULL;
-               } else if (is_return && arg[1] == 'a') {
-                       ff->func = fetch_ip;
-                       ff->data = NULL;
-               } else
-                       ret = -EINVAL;
+       } else
+               ret = -EINVAL;
+       return ret;
+}
+
+/* Recursive argument parser */
+static int __parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
+{
+       int ret = 0;
+       unsigned long param;
+       long offset;
+       char *tmp;
+
+       switch (arg[0]) {
+       case '$':
+               ret = parse_probe_vars(arg + 1, ff, is_return);
                break;
        case '%':       /* named register */
                ret = regs_query_register_offset(arg + 1);
@@ -464,20 +503,6 @@ static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
                        ret = 0;
                }
                break;
-       case 's':       /* stack */
-               if (arg[1] == 'a') {
-                       ff->func = fetch_stack_address;
-                       ff->data = NULL;
-               } else {
-                       ret = strict_strtoul(arg + 1, 10, &param);
-                       if (ret || param > PARAM_MAX_STACK)
-                               ret = -EINVAL;
-                       else {
-                               ff->func = fetch_stack;
-                               ff->data = (void *)param;
-                       }
-               }
-               break;
        case '@':       /* memory or symbol */
                if (isdigit(arg[1])) {
                        ret = strict_strtoul(arg + 1, 0, &param);
@@ -489,8 +514,7 @@ static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
                        ret = split_symbol_offset(arg + 1, &offset);
                        if (ret)
                                break;
-                       ff->data = alloc_symbol_cache(arg + 1,
-                                                             offset);
+                       ff->data = alloc_symbol_cache(arg + 1, offset);
                        if (ff->data)
                                ff->func = fetch_symbol;
                        else
@@ -520,7 +544,7 @@ static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
                        if (!id)
                                return -ENOMEM;
                        id->offset = offset;
-                       ret = parse_probe_arg(arg, &id->orig, is_return);
+                       ret = __parse_probe_arg(arg, &id->orig, is_return);
                        if (ret)
                                kfree(id);
                        else {
@@ -537,6 +561,30 @@ static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
        return ret;
 }
 
+/* String length checking wrapper */
+static int parse_probe_arg(char *arg, struct fetch_func *ff, int is_return)
+{
+       if (strlen(arg) > MAX_ARGSTR_LEN) {
+               pr_info("Argument is too long.: %s\n",  arg);
+               return -ENOSPC;
+       }
+       return __parse_probe_arg(arg, ff, is_return);
+}
+
+/* Return 1 if name is reserved or already used by another argument */
+static int conflict_field_name(const char *name,
+                              struct probe_arg *args, int narg)
+{
+       int i;
+       for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
+               if (strcmp(reserved_field_names[i], name) == 0)
+                       return 1;
+       for (i = 0; i < narg; i++)
+               if (strcmp(args[i].name, name) == 0)
+                       return 1;
+       return 0;
+}
+
 static int create_trace_probe(int argc, char **argv)
 {
        /*
@@ -544,11 +592,10 @@ static int create_trace_probe(int argc, char **argv)
         *  - Add kprobe: p[:[GRP/]EVENT] KSYM[+OFFS]|KADDR [FETCHARGS]
         *  - Add kretprobe: r[:[GRP/]EVENT] KSYM[+0] [FETCHARGS]
         * Fetch args:
-        *  aN  : fetch Nth of function argument. (N:0-)
-        *  rv  : fetch return value
-        *  ra  : fetch return address
-        *  sa  : fetch stack address
-        *  sN  : fetch Nth of stack (N:0-)
+        *  $argN       : fetch Nth of function argument. (N:0-)
+        *  $retval     : fetch return value
+        *  $stack      : fetch stack address
+        *  $stackN     : fetch Nth of stack (N:0-)
         *  @ADDR       : fetch memory at ADDR (ADDR should be in kernel)
         *  @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol)
         *  %REG        : fetch register REG
@@ -565,15 +612,19 @@ static int create_trace_probe(int argc, char **argv)
        void *addr = NULL;
        char buf[MAX_EVENT_NAME_LEN];
 
-       if (argc < 2)
+       if (argc < 2) {
+               pr_info("Probe point is not specified.\n");
                return -EINVAL;
+       }
 
        if (argv[0][0] == 'p')
                is_return = 0;
        else if (argv[0][0] == 'r')
                is_return = 1;
-       else
+       else {
+               pr_info("Probe definition must be started with 'p' or 'r'.\n");
                return -EINVAL;
+       }
 
        if (argv[0][1] == ':') {
                event = &argv[0][2];
@@ -593,21 +644,29 @@ static int create_trace_probe(int argc, char **argv)
        }
 
        if (isdigit(argv[1][0])) {
-               if (is_return)
+               if (is_return) {
+                       pr_info("Return probe point must be a symbol.\n");
                        return -EINVAL;
+               }
                /* an address specified */
                ret = strict_strtoul(&argv[0][2], 0, (unsigned long *)&addr);
-               if (ret)
+               if (ret) {
+                       pr_info("Failed to parse address.\n");
                        return ret;
+               }
        } else {
                /* a symbol specified */
                symbol = argv[1];
                /* TODO: support .init module functions */
                ret = split_symbol_offset(symbol, &offset);
-               if (ret)
+               if (ret) {
+                       pr_info("Failed to parse symbol.\n");
                        return ret;
-               if (offset && is_return)
+               }
+               if (offset && is_return) {
+                       pr_info("Return probe must be used without offset.\n");
                        return -EINVAL;
+               }
        }
        argc -= 2; argv += 2;
 
@@ -626,8 +685,11 @@ static int create_trace_probe(int argc, char **argv)
        }
        tp = alloc_trace_probe(group, event, addr, symbol, offset, argc,
                               is_return);
-       if (IS_ERR(tp))
+       if (IS_ERR(tp)) {
+               pr_info("Failed to allocate trace_probe.(%d)\n",
+                       (int)PTR_ERR(tp));
                return PTR_ERR(tp);
+       }
 
        /* parse arguments */
        ret = 0;
@@ -638,19 +700,32 @@ static int create_trace_probe(int argc, char **argv)
                        *arg++ = '\0';
                else
                        arg = argv[i];
-               tp->args[i].name = kstrdup(argv[i], GFP_KERNEL);
 
-               /* Parse fetch argument */
-               if (strlen(arg) > MAX_ARGSTR_LEN) {
-                       pr_info("Argument%d(%s) is too long.\n", i, arg);
-                       ret = -ENOSPC;
+               if (conflict_field_name(argv[i], tp->args, i)) {
+                       pr_info("Argument%d name '%s' conflicts with "
+                               "another field.\n", i, argv[i]);
+                       ret = -EINVAL;
+                       goto error;
+               }
+
+               tp->args[i].name = kstrdup(argv[i], GFP_KERNEL);
+               if (!tp->args[i].name) {
+                       pr_info("Failed to allocate argument%d name '%s'.\n",
+                               i, argv[i]);
+                       ret = -ENOMEM;
                        goto error;
                }
+
+               /* Parse fetch argument */
                ret = parse_probe_arg(arg, &tp->args[i].fetch, is_return);
-               if (ret)
+               if (ret) {
+                       pr_info("Parse error at argument%d. (%d)\n", i, ret);
+                       kfree(tp->args[i].name);
                        goto error;
+               }
+
+               tp->nr_args++;
        }
-       tp->nr_args = i;
 
        ret = register_trace_probe(tp);
        if (ret)
@@ -701,12 +776,14 @@ static int probes_seq_show(struct seq_file *m, void *v)
        char buf[MAX_ARGSTR_LEN + 1];
 
        seq_printf(m, "%c", probe_is_return(tp) ? 'r' : 'p');
-       seq_printf(m, ":%s", tp->call.name);
+       seq_printf(m, ":%s/%s", tp->call.system, tp->call.name);
 
-       if (tp->symbol)
+       if (!tp->symbol)
+               seq_printf(m, " 0x%p", tp->rp.kp.addr);
+       else if (tp->rp.kp.offset)
                seq_printf(m, " %s+%u", probe_symbol(tp), tp->rp.kp.offset);
        else
-               seq_printf(m, " 0x%p", tp->rp.kp.addr);
+               seq_printf(m, " %s", probe_symbol(tp));
 
        for (i = 0; i < tp->nr_args; i++) {
                ret = probe_arg_string(buf, MAX_ARGSTR_LEN, &tp->args[i].fetch);
@@ -1040,8 +1117,8 @@ static int kprobe_event_define_fields(struct ftrace_event_call *event_call)
        if (!ret)
                return ret;
 
-       DEFINE_FIELD(unsigned long, ip, "ip", 0);
-       DEFINE_FIELD(int, nargs, "nargs", 1);
+       DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
+       DEFINE_FIELD(int, nargs, FIELD_STRING_NARGS, 1);
        /* Set argument names as fields */
        for (i = 0; i < tp->nr_args; i++)
                DEFINE_FIELD(unsigned long, args[i], tp->args[i].name, 0);
@@ -1058,9 +1135,9 @@ static int kretprobe_event_define_fields(struct ftrace_event_call *event_call)
        if (!ret)
                return ret;
 
-       DEFINE_FIELD(unsigned long, func, "func", 0);
-       DEFINE_FIELD(unsigned long, ret_ip, "ret_ip", 0);
-       DEFINE_FIELD(int, nargs, "nargs", 1);
+       DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
+       DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
+       DEFINE_FIELD(int, nargs, FIELD_STRING_NARGS, 1);
        /* Set argument names as fields */
        for (i = 0; i < tp->nr_args; i++)
                DEFINE_FIELD(unsigned long, args[i], tp->args[i].name, 0);
@@ -1109,15 +1186,16 @@ static int kprobe_event_show_format(struct ftrace_event_call *call,
        int ret, i;
        struct trace_probe *tp = (struct trace_probe *)call->data;
 
-       SHOW_FIELD(unsigned long, ip, "ip");
-       SHOW_FIELD(int, nargs, "nargs");
+       SHOW_FIELD(unsigned long, ip, FIELD_STRING_IP);
+       SHOW_FIELD(int, nargs, FIELD_STRING_NARGS);
 
        /* Show fields */
        for (i = 0; i < tp->nr_args; i++)
                SHOW_FIELD(unsigned long, args[i], tp->args[i].name);
        trace_seq_puts(s, "\n");
 
-       return __probe_event_show_format(s, tp, "(%lx)", "REC->ip");
+       return __probe_event_show_format(s, tp, "(%lx)",
+                                        "REC->" FIELD_STRING_IP);
 }
 
 static int kretprobe_event_show_format(struct ftrace_event_call *call,
@@ -1127,9 +1205,9 @@ static int kretprobe_event_show_format(struct ftrace_event_call *call,
        int ret, i;
        struct trace_probe *tp = (struct trace_probe *)call->data;
 
-       SHOW_FIELD(unsigned long, func, "func");
-       SHOW_FIELD(unsigned long, ret_ip, "ret_ip");
-       SHOW_FIELD(int, nargs, "nargs");
+       SHOW_FIELD(unsigned long, func, FIELD_STRING_FUNC);
+       SHOW_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP);
+       SHOW_FIELD(int, nargs, FIELD_STRING_NARGS);
 
        /* Show fields */
        for (i = 0; i < tp->nr_args; i++)
@@ -1137,7 +1215,8 @@ static int kretprobe_event_show_format(struct ftrace_event_call *call,
        trace_seq_puts(s, "\n");
 
        return __probe_event_show_format(s, tp, "(%lx <- %lx)",
-                                         "REC->func, REC->ret_ip");
+                                        "REC->" FIELD_STRING_FUNC
+                                        ", REC->" FIELD_STRING_RETIP);
 }
 
 #ifdef CONFIG_EVENT_PROFILE
@@ -1152,7 +1231,9 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,
        struct trace_entry *ent;
        int size, __size, i, pc, __cpu;
        unsigned long irq_flags;
+       char *trace_buf;
        char *raw_data;
+       int rctx;
 
        pc = preempt_count();
        __size = SIZEOF_KPROBE_TRACE_ENTRY(tp->nr_args);
@@ -1167,17 +1248,23 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,
         * This also protects the rcu read side
         */
        local_irq_save(irq_flags);
+
+       rctx = perf_swevent_get_recursion_context();
+       if (rctx < 0)
+               goto end_recursion;
+
        __cpu = smp_processor_id();
 
        if (in_nmi())
-               raw_data = rcu_dereference(trace_profile_buf_nmi);
+               trace_buf = rcu_dereference(perf_trace_buf_nmi);
        else
-               raw_data = rcu_dereference(trace_profile_buf);
+               trace_buf = rcu_dereference(perf_trace_buf);
 
-       if (!raw_data)
+       if (!trace_buf)
                goto end;
 
-       raw_data = per_cpu_ptr(raw_data, __cpu);
+       raw_data = per_cpu_ptr(trace_buf, __cpu);
+
        /* Zero dead bytes from alignment to avoid buffer leak to userspace */
        *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
        entry = (struct kprobe_trace_entry *)raw_data;
@@ -1190,8 +1277,12 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,
        for (i = 0; i < tp->nr_args; i++)
                entry->args[i] = call_fetch(&tp->args[i].fetch, regs);
        perf_tp_event(call->id, entry->ip, 1, entry, size);
+
 end:
+       perf_swevent_put_recursion_context(rctx);
+end_recursion:
        local_irq_restore(irq_flags);
+
        return 0;
 }
 
@@ -1205,7 +1296,9 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,
        struct trace_entry *ent;
        int size, __size, i, pc, __cpu;
        unsigned long irq_flags;
+       char *trace_buf;
        char *raw_data;
+       int rctx;
 
        pc = preempt_count();
        __size = SIZEOF_KRETPROBE_TRACE_ENTRY(tp->nr_args);
@@ -1220,17 +1313,23 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,
         * This also protects the rcu read side
         */
        local_irq_save(irq_flags);
+
+       rctx = perf_swevent_get_recursion_context();
+       if (rctx < 0)
+               goto end_recursion;
+
        __cpu = smp_processor_id();
 
        if (in_nmi())
-               raw_data = rcu_dereference(trace_profile_buf_nmi);
+               trace_buf = rcu_dereference(perf_trace_buf_nmi);
        else
-               raw_data = rcu_dereference(trace_profile_buf);
+               trace_buf = rcu_dereference(perf_trace_buf);
 
-       if (!raw_data)
+       if (!trace_buf)
                goto end;
 
-       raw_data = per_cpu_ptr(raw_data, __cpu);
+       raw_data = per_cpu_ptr(trace_buf, __cpu);
+
        /* Zero dead bytes from alignment to avoid buffer leak to userspace */
        *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
        entry = (struct kretprobe_trace_entry *)raw_data;
@@ -1244,8 +1343,12 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,
        for (i = 0; i < tp->nr_args; i++)
                entry->args[i] = call_fetch(&tp->args[i].fetch, regs);
        perf_tp_event(call->id, entry->ret_ip, 1, entry, size);
+
 end:
+       perf_swevent_put_recursion_context(rctx);
+end_recursion:
        local_irq_restore(irq_flags);
+
        return 0;
 }
 
@@ -1398,12 +1501,12 @@ static __init int kprobe_trace_self_tests_init(void)
        pr_info("Testing kprobe tracing: ");
 
        ret = command_trace_probe("p:testprobe kprobe_trace_selftest_target "
-                                 "a1 a2 a3 a4 a5 a6");
+                                 "$arg1 $arg2 $arg3 $arg4 $stack $stack0");
        if (WARN_ON_ONCE(ret))
                pr_warning("error enabling function entry\n");
 
        ret = command_trace_probe("r:testprobe2 kprobe_trace_selftest_target "
-                                 "ra rv");
+                                 "$retval");
        if (WARN_ON_ONCE(ret))
                pr_warning("error enabling function return\n");