2 * uprobes-based tracing events
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 * Copyright (C) IBM Corporation, 2010-2012
18 * Author: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
21 #include <linux/module.h>
22 #include <linux/uaccess.h>
23 #include <linux/uprobes.h>
24 #include <linux/namei.h>
25 #include <linux/string.h>
27 #include "trace_probe.h"
29 #define UPROBE_EVENT_SYSTEM "uprobes"
32 * uprobe event core functions
35 struct list_head list
;
36 struct ftrace_event_class
class;
37 struct ftrace_event_call call
;
38 struct uprobe_consumer consumer
;
43 unsigned int flags
; /* For TP_FLAG_* */
44 ssize_t size
; /* trace entry size */
46 struct probe_arg args
[];
49 #define SIZEOF_TRACE_UPROBE(n) \
50 (offsetof(struct trace_uprobe, args) + \
51 (sizeof(struct probe_arg) * (n)))
53 static int register_uprobe_event(struct trace_uprobe
*tu
);
54 static void unregister_uprobe_event(struct trace_uprobe
*tu
);
56 static DEFINE_MUTEX(uprobe_lock
);
57 static LIST_HEAD(uprobe_list
);
59 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
);
62 * Allocate new trace_uprobe and initialize it (including uprobes).
64 static struct trace_uprobe
*
65 alloc_trace_uprobe(const char *group
, const char *event
, int nargs
)
67 struct trace_uprobe
*tu
;
69 if (!event
|| !is_good_name(event
))
70 return ERR_PTR(-EINVAL
);
72 if (!group
|| !is_good_name(group
))
73 return ERR_PTR(-EINVAL
);
75 tu
= kzalloc(SIZEOF_TRACE_UPROBE(nargs
), GFP_KERNEL
);
77 return ERR_PTR(-ENOMEM
);
79 tu
->call
.class = &tu
->class;
80 tu
->call
.name
= kstrdup(event
, GFP_KERNEL
);
84 tu
->class.system
= kstrdup(group
, GFP_KERNEL
);
85 if (!tu
->class.system
)
88 INIT_LIST_HEAD(&tu
->list
);
89 tu
->consumer
.handler
= uprobe_dispatcher
;
96 return ERR_PTR(-ENOMEM
);
99 static void free_trace_uprobe(struct trace_uprobe
*tu
)
103 for (i
= 0; i
< tu
->nr_args
; i
++)
104 traceprobe_free_probe_arg(&tu
->args
[i
]);
107 kfree(tu
->call
.class->system
);
108 kfree(tu
->call
.name
);
113 static struct trace_uprobe
*find_probe_event(const char *event
, const char *group
)
115 struct trace_uprobe
*tu
;
117 list_for_each_entry(tu
, &uprobe_list
, list
)
118 if (strcmp(tu
->call
.name
, event
) == 0 &&
119 strcmp(tu
->call
.class->system
, group
) == 0)
125 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
126 static void unregister_trace_uprobe(struct trace_uprobe
*tu
)
129 unregister_uprobe_event(tu
);
130 free_trace_uprobe(tu
);
133 /* Register a trace_uprobe and probe_event */
134 static int register_trace_uprobe(struct trace_uprobe
*tu
)
136 struct trace_uprobe
*old_tp
;
139 mutex_lock(&uprobe_lock
);
141 /* register as an event */
142 old_tp
= find_probe_event(tu
->call
.name
, tu
->call
.class->system
);
144 /* delete old event */
145 unregister_trace_uprobe(old_tp
);
147 ret
= register_uprobe_event(tu
);
149 pr_warning("Failed to register probe event(%d)\n", ret
);
153 list_add_tail(&tu
->list
, &uprobe_list
);
156 mutex_unlock(&uprobe_lock
);
163 * - Add uprobe: p[:[GRP/]EVENT] PATH:SYMBOL[+offs] [FETCHARGS]
165 * - Remove uprobe: -:[GRP/]EVENT
167 static int create_trace_uprobe(int argc
, char **argv
)
169 struct trace_uprobe
*tu
;
171 char *arg
, *event
, *group
, *filename
;
172 char buf
[MAX_EVENT_NAME_LEN
];
174 unsigned long offset
;
184 /* argc must be >= 1 */
185 if (argv
[0][0] == '-')
187 else if (argv
[0][0] != 'p') {
188 pr_info("Probe definition must be started with 'p' or '-'.\n");
192 if (argv
[0][1] == ':') {
194 arg
= strchr(event
, '/');
201 if (strlen(group
) == 0) {
202 pr_info("Group name is not specified\n");
206 if (strlen(event
) == 0) {
207 pr_info("Event name is not specified\n");
212 group
= UPROBE_EVENT_SYSTEM
;
216 pr_info("Delete command needs an event name.\n");
219 mutex_lock(&uprobe_lock
);
220 tu
= find_probe_event(event
, group
);
223 mutex_unlock(&uprobe_lock
);
224 pr_info("Event %s/%s doesn't exist.\n", group
, event
);
227 /* delete an event */
228 unregister_trace_uprobe(tu
);
229 mutex_unlock(&uprobe_lock
);
234 pr_info("Probe point is not specified.\n");
237 if (isdigit(argv
[1][0])) {
238 pr_info("probe point must be have a filename.\n");
241 arg
= strchr(argv
[1], ':');
243 goto fail_address_parse
;
247 ret
= kern_path(filename
, LOOKUP_FOLLOW
, &path
);
249 goto fail_address_parse
;
251 inode
= igrab(path
.dentry
->d_inode
);
254 if (!inode
|| !S_ISREG(inode
->i_mode
)) {
256 goto fail_address_parse
;
259 ret
= kstrtoul(arg
, 0, &offset
);
261 goto fail_address_parse
;
271 tail
= kstrdup(kbasename(filename
), GFP_KERNEL
);
274 goto fail_address_parse
;
277 ptr
= strpbrk(tail
, ".-_");
281 snprintf(buf
, MAX_EVENT_NAME_LEN
, "%c_%s_0x%lx", 'p', tail
, offset
);
286 tu
= alloc_trace_uprobe(group
, event
, argc
);
288 pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu
));
290 goto fail_address_parse
;
294 tu
->filename
= kstrdup(filename
, GFP_KERNEL
);
297 pr_info("Failed to allocate filename.\n");
302 /* parse arguments */
304 for (i
= 0; i
< argc
&& i
< MAX_TRACE_ARGS
; i
++) {
305 /* Increment count for freeing args in error case */
308 /* Parse argument name */
309 arg
= strchr(argv
[i
], '=');
312 tu
->args
[i
].name
= kstrdup(argv
[i
], GFP_KERNEL
);
315 /* If argument name is omitted, set "argN" */
316 snprintf(buf
, MAX_EVENT_NAME_LEN
, "arg%d", i
+ 1);
317 tu
->args
[i
].name
= kstrdup(buf
, GFP_KERNEL
);
320 if (!tu
->args
[i
].name
) {
321 pr_info("Failed to allocate argument[%d] name.\n", i
);
326 if (!is_good_name(tu
->args
[i
].name
)) {
327 pr_info("Invalid argument[%d] name: %s\n", i
, tu
->args
[i
].name
);
332 if (traceprobe_conflict_field_name(tu
->args
[i
].name
, tu
->args
, i
)) {
333 pr_info("Argument[%d] name '%s' conflicts with "
334 "another field.\n", i
, argv
[i
]);
339 /* Parse fetch argument */
340 ret
= traceprobe_parse_probe_arg(arg
, &tu
->size
, &tu
->args
[i
], false, false);
342 pr_info("Parse error at argument[%d]. (%d)\n", i
, ret
);
347 ret
= register_trace_uprobe(tu
);
353 free_trace_uprobe(tu
);
360 pr_info("Failed to parse address or file.\n");
365 static void cleanup_all_probes(void)
367 struct trace_uprobe
*tu
;
369 mutex_lock(&uprobe_lock
);
370 while (!list_empty(&uprobe_list
)) {
371 tu
= list_entry(uprobe_list
.next
, struct trace_uprobe
, list
);
372 unregister_trace_uprobe(tu
);
374 mutex_unlock(&uprobe_lock
);
377 /* Probes listing interfaces */
378 static void *probes_seq_start(struct seq_file
*m
, loff_t
*pos
)
380 mutex_lock(&uprobe_lock
);
381 return seq_list_start(&uprobe_list
, *pos
);
384 static void *probes_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
386 return seq_list_next(v
, &uprobe_list
, pos
);
389 static void probes_seq_stop(struct seq_file
*m
, void *v
)
391 mutex_unlock(&uprobe_lock
);
394 static int probes_seq_show(struct seq_file
*m
, void *v
)
396 struct trace_uprobe
*tu
= v
;
399 seq_printf(m
, "p:%s/%s", tu
->call
.class->system
, tu
->call
.name
);
400 seq_printf(m
, " %s:0x%p", tu
->filename
, (void *)tu
->offset
);
402 for (i
= 0; i
< tu
->nr_args
; i
++)
403 seq_printf(m
, " %s=%s", tu
->args
[i
].name
, tu
->args
[i
].comm
);
409 static const struct seq_operations probes_seq_op
= {
410 .start
= probes_seq_start
,
411 .next
= probes_seq_next
,
412 .stop
= probes_seq_stop
,
413 .show
= probes_seq_show
416 static int probes_open(struct inode
*inode
, struct file
*file
)
418 if ((file
->f_mode
& FMODE_WRITE
) && (file
->f_flags
& O_TRUNC
))
419 cleanup_all_probes();
421 return seq_open(file
, &probes_seq_op
);
424 static ssize_t
probes_write(struct file
*file
, const char __user
*buffer
,
425 size_t count
, loff_t
*ppos
)
427 return traceprobe_probes_write(file
, buffer
, count
, ppos
, create_trace_uprobe
);
430 static const struct file_operations uprobe_events_ops
= {
431 .owner
= THIS_MODULE
,
435 .release
= seq_release
,
436 .write
= probes_write
,
439 /* Probes profiling interfaces */
440 static int probes_profile_seq_show(struct seq_file
*m
, void *v
)
442 struct trace_uprobe
*tu
= v
;
444 seq_printf(m
, " %s %-44s %15lu\n", tu
->filename
, tu
->call
.name
, tu
->nhit
);
448 static const struct seq_operations profile_seq_op
= {
449 .start
= probes_seq_start
,
450 .next
= probes_seq_next
,
451 .stop
= probes_seq_stop
,
452 .show
= probes_profile_seq_show
455 static int profile_open(struct inode
*inode
, struct file
*file
)
457 return seq_open(file
, &profile_seq_op
);
460 static const struct file_operations uprobe_profile_ops
= {
461 .owner
= THIS_MODULE
,
462 .open
= profile_open
,
465 .release
= seq_release
,
469 static void uprobe_trace_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
471 struct uprobe_trace_entry_head
*entry
;
472 struct ring_buffer_event
*event
;
473 struct ring_buffer
*buffer
;
476 unsigned long irq_flags
;
477 struct ftrace_event_call
*call
= &tu
->call
;
481 local_save_flags(irq_flags
);
482 pc
= preempt_count();
484 size
= sizeof(*entry
) + tu
->size
;
486 event
= trace_current_buffer_lock_reserve(&buffer
, call
->event
.type
,
487 size
, irq_flags
, pc
);
491 entry
= ring_buffer_event_data(event
);
492 entry
->ip
= instruction_pointer(task_pt_regs(current
));
493 data
= (u8
*)&entry
[1];
494 for (i
= 0; i
< tu
->nr_args
; i
++)
495 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
497 if (!filter_current_check_discard(buffer
, call
, entry
, event
))
498 trace_buffer_unlock_commit(buffer
, event
, irq_flags
, pc
);
501 /* Event entry printers */
502 static enum print_line_t
503 print_uprobe_event(struct trace_iterator
*iter
, int flags
, struct trace_event
*event
)
505 struct uprobe_trace_entry_head
*field
;
506 struct trace_seq
*s
= &iter
->seq
;
507 struct trace_uprobe
*tu
;
511 field
= (struct uprobe_trace_entry_head
*)iter
->ent
;
512 tu
= container_of(event
, struct trace_uprobe
, call
.event
);
514 if (!trace_seq_printf(s
, "%s: (", tu
->call
.name
))
517 if (!seq_print_ip_sym(s
, field
->ip
, flags
| TRACE_ITER_SYM_OFFSET
))
520 if (!trace_seq_puts(s
, ")"))
523 data
= (u8
*)&field
[1];
524 for (i
= 0; i
< tu
->nr_args
; i
++) {
525 if (!tu
->args
[i
].type
->print(s
, tu
->args
[i
].name
,
526 data
+ tu
->args
[i
].offset
, field
))
530 if (trace_seq_puts(s
, "\n"))
531 return TRACE_TYPE_HANDLED
;
534 return TRACE_TYPE_PARTIAL_LINE
;
537 static inline bool is_trace_uprobe_enabled(struct trace_uprobe
*tu
)
539 return tu
->flags
& (TP_FLAG_TRACE
| TP_FLAG_PROFILE
);
542 static int probe_event_enable(struct trace_uprobe
*tu
, int flag
)
546 if (is_trace_uprobe_enabled(tu
))
550 ret
= uprobe_register(tu
->inode
, tu
->offset
, &tu
->consumer
);
557 static void probe_event_disable(struct trace_uprobe
*tu
, int flag
)
559 if (!is_trace_uprobe_enabled(tu
))
562 uprobe_unregister(tu
->inode
, tu
->offset
, &tu
->consumer
);
566 static int uprobe_event_define_fields(struct ftrace_event_call
*event_call
)
569 struct uprobe_trace_entry_head field
;
570 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event_call
->data
;
572 DEFINE_FIELD(unsigned long, ip
, FIELD_STRING_IP
, 0);
573 /* Set argument names as fields */
574 for (i
= 0; i
< tu
->nr_args
; i
++) {
575 ret
= trace_define_field(event_call
, tu
->args
[i
].type
->fmttype
,
577 sizeof(field
) + tu
->args
[i
].offset
,
578 tu
->args
[i
].type
->size
,
579 tu
->args
[i
].type
->is_signed
,
588 #define LEN_OR_ZERO (len ? len - pos : 0)
589 static int __set_print_fmt(struct trace_uprobe
*tu
, char *buf
, int len
)
591 const char *fmt
, *arg
;
596 arg
= "REC->" FIELD_STRING_IP
;
598 /* When len=0, we just calculate the needed length */
600 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\"%s", fmt
);
602 for (i
= 0; i
< tu
->nr_args
; i
++) {
603 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, " %s=%s",
604 tu
->args
[i
].name
, tu
->args
[i
].type
->fmt
);
607 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\", %s", arg
);
609 for (i
= 0; i
< tu
->nr_args
; i
++) {
610 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, ", REC->%s",
614 return pos
; /* return the length of print_fmt */
618 static int set_print_fmt(struct trace_uprobe
*tu
)
623 /* First: called with 0 length to calculate the needed length */
624 len
= __set_print_fmt(tu
, NULL
, 0);
625 print_fmt
= kmalloc(len
+ 1, GFP_KERNEL
);
629 /* Second: actually write the @print_fmt */
630 __set_print_fmt(tu
, print_fmt
, len
+ 1);
631 tu
->call
.print_fmt
= print_fmt
;
636 #ifdef CONFIG_PERF_EVENTS
637 /* uprobe profile handler */
638 static void uprobe_perf_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
640 struct ftrace_event_call
*call
= &tu
->call
;
641 struct uprobe_trace_entry_head
*entry
;
642 struct hlist_head
*head
;
647 __size
= sizeof(*entry
) + tu
->size
;
648 size
= ALIGN(__size
+ sizeof(u32
), sizeof(u64
));
650 if (WARN_ONCE(size
> PERF_MAX_TRACE_SIZE
, "profile buffer not large enough"))
655 entry
= perf_trace_buf_prepare(size
, call
->event
.type
, regs
, &rctx
);
659 entry
->ip
= instruction_pointer(task_pt_regs(current
));
660 data
= (u8
*)&entry
[1];
661 for (i
= 0; i
< tu
->nr_args
; i
++)
662 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
664 head
= this_cpu_ptr(call
->perf_events
);
665 perf_trace_buf_submit(entry
, size
, rctx
, entry
->ip
, 1, regs
, head
, NULL
);
670 #endif /* CONFIG_PERF_EVENTS */
673 int trace_uprobe_register(struct ftrace_event_call
*event
, enum trace_reg type
, void *data
)
675 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event
->data
;
678 case TRACE_REG_REGISTER
:
679 return probe_event_enable(tu
, TP_FLAG_TRACE
);
681 case TRACE_REG_UNREGISTER
:
682 probe_event_disable(tu
, TP_FLAG_TRACE
);
685 #ifdef CONFIG_PERF_EVENTS
686 case TRACE_REG_PERF_REGISTER
:
687 return probe_event_enable(tu
, TP_FLAG_PROFILE
);
689 case TRACE_REG_PERF_UNREGISTER
:
690 probe_event_disable(tu
, TP_FLAG_PROFILE
);
699 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
)
701 struct trace_uprobe
*tu
;
703 tu
= container_of(con
, struct trace_uprobe
, consumer
);
705 if (tu
->flags
& TP_FLAG_TRACE
)
706 uprobe_trace_func(tu
, regs
);
708 #ifdef CONFIG_PERF_EVENTS
709 if (tu
->flags
& TP_FLAG_PROFILE
)
710 uprobe_perf_func(tu
, regs
);
715 static struct trace_event_functions uprobe_funcs
= {
716 .trace
= print_uprobe_event
719 static int register_uprobe_event(struct trace_uprobe
*tu
)
721 struct ftrace_event_call
*call
= &tu
->call
;
724 /* Initialize ftrace_event_call */
725 INIT_LIST_HEAD(&call
->class->fields
);
726 call
->event
.funcs
= &uprobe_funcs
;
727 call
->class->define_fields
= uprobe_event_define_fields
;
729 if (set_print_fmt(tu
) < 0)
732 ret
= register_ftrace_event(&call
->event
);
734 kfree(call
->print_fmt
);
738 call
->class->reg
= trace_uprobe_register
;
740 ret
= trace_add_event_call(call
);
743 pr_info("Failed to register uprobe event: %s\n", call
->name
);
744 kfree(call
->print_fmt
);
745 unregister_ftrace_event(&call
->event
);
751 static void unregister_uprobe_event(struct trace_uprobe
*tu
)
753 /* tu->event is unregistered in trace_remove_event_call() */
754 trace_remove_event_call(&tu
->call
);
755 kfree(tu
->call
.print_fmt
);
756 tu
->call
.print_fmt
= NULL
;
759 /* Make a trace interface for controling probe points */
760 static __init
int init_uprobe_trace(void)
762 struct dentry
*d_tracer
;
764 d_tracer
= tracing_init_dentry();
768 trace_create_file("uprobe_events", 0644, d_tracer
,
769 NULL
, &uprobe_events_ops
);
770 /* Profile interface */
771 trace_create_file("uprobe_profile", 0444, d_tracer
,
772 NULL
, &uprobe_profile_ops
);
776 fs_initcall(init_uprobe_trace
);