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>
26 #include "trace_probe.h"
28 #define UPROBE_EVENT_SYSTEM "uprobes"
31 * uprobe event core functions
34 struct uprobe_trace_consumer
{
35 struct uprobe_consumer cons
;
36 struct trace_uprobe
*tu
;
40 struct list_head list
;
41 struct ftrace_event_class
class;
42 struct ftrace_event_call call
;
43 struct uprobe_trace_consumer
*consumer
;
48 unsigned int flags
; /* For TP_FLAG_* */
49 ssize_t size
; /* trace entry size */
51 struct probe_arg args
[];
54 #define SIZEOF_TRACE_UPROBE(n) \
55 (offsetof(struct trace_uprobe, args) + \
56 (sizeof(struct probe_arg) * (n)))
58 static int register_uprobe_event(struct trace_uprobe
*tu
);
59 static void unregister_uprobe_event(struct trace_uprobe
*tu
);
61 static DEFINE_MUTEX(uprobe_lock
);
62 static LIST_HEAD(uprobe_list
);
64 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
);
67 * Allocate new trace_uprobe and initialize it (including uprobes).
69 static struct trace_uprobe
*
70 alloc_trace_uprobe(const char *group
, const char *event
, int nargs
)
72 struct trace_uprobe
*tu
;
74 if (!event
|| !is_good_name(event
))
75 return ERR_PTR(-EINVAL
);
77 if (!group
|| !is_good_name(group
))
78 return ERR_PTR(-EINVAL
);
80 tu
= kzalloc(SIZEOF_TRACE_UPROBE(nargs
), GFP_KERNEL
);
82 return ERR_PTR(-ENOMEM
);
84 tu
->call
.class = &tu
->class;
85 tu
->call
.name
= kstrdup(event
, GFP_KERNEL
);
89 tu
->class.system
= kstrdup(group
, GFP_KERNEL
);
90 if (!tu
->class.system
)
93 INIT_LIST_HEAD(&tu
->list
);
100 return ERR_PTR(-ENOMEM
);
103 static void free_trace_uprobe(struct trace_uprobe
*tu
)
107 for (i
= 0; i
< tu
->nr_args
; i
++)
108 traceprobe_free_probe_arg(&tu
->args
[i
]);
111 kfree(tu
->call
.class->system
);
112 kfree(tu
->call
.name
);
117 static struct trace_uprobe
*find_probe_event(const char *event
, const char *group
)
119 struct trace_uprobe
*tu
;
121 list_for_each_entry(tu
, &uprobe_list
, list
)
122 if (strcmp(tu
->call
.name
, event
) == 0 &&
123 strcmp(tu
->call
.class->system
, group
) == 0)
129 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
130 static void unregister_trace_uprobe(struct trace_uprobe
*tu
)
133 unregister_uprobe_event(tu
);
134 free_trace_uprobe(tu
);
137 /* Register a trace_uprobe and probe_event */
138 static int register_trace_uprobe(struct trace_uprobe
*tu
)
140 struct trace_uprobe
*old_tp
;
143 mutex_lock(&uprobe_lock
);
145 /* register as an event */
146 old_tp
= find_probe_event(tu
->call
.name
, tu
->call
.class->system
);
148 /* delete old event */
149 unregister_trace_uprobe(old_tp
);
151 ret
= register_uprobe_event(tu
);
153 pr_warning("Failed to register probe event(%d)\n", ret
);
157 list_add_tail(&tu
->list
, &uprobe_list
);
160 mutex_unlock(&uprobe_lock
);
167 * - Add uprobe: p[:[GRP/]EVENT] PATH:SYMBOL[+offs] [FETCHARGS]
169 * - Remove uprobe: -:[GRP/]EVENT
171 static int create_trace_uprobe(int argc
, char **argv
)
173 struct trace_uprobe
*tu
;
175 char *arg
, *event
, *group
, *filename
;
176 char buf
[MAX_EVENT_NAME_LEN
];
178 unsigned long offset
;
188 /* argc must be >= 1 */
189 if (argv
[0][0] == '-')
191 else if (argv
[0][0] != 'p') {
192 pr_info("Probe definition must be started with 'p', 'r' or" " '-'.\n");
196 if (argv
[0][1] == ':') {
198 arg
= strchr(event
, '/');
205 if (strlen(group
) == 0) {
206 pr_info("Group name is not specified\n");
210 if (strlen(event
) == 0) {
211 pr_info("Event name is not specified\n");
216 group
= UPROBE_EVENT_SYSTEM
;
220 pr_info("Delete command needs an event name.\n");
223 mutex_lock(&uprobe_lock
);
224 tu
= find_probe_event(event
, group
);
227 mutex_unlock(&uprobe_lock
);
228 pr_info("Event %s/%s doesn't exist.\n", group
, event
);
231 /* delete an event */
232 unregister_trace_uprobe(tu
);
233 mutex_unlock(&uprobe_lock
);
238 pr_info("Probe point is not specified.\n");
241 if (isdigit(argv
[1][0])) {
242 pr_info("probe point must be have a filename.\n");
245 arg
= strchr(argv
[1], ':');
247 goto fail_address_parse
;
251 ret
= kern_path(filename
, LOOKUP_FOLLOW
, &path
);
253 goto fail_address_parse
;
255 ret
= strict_strtoul(arg
, 0, &offset
);
257 goto fail_address_parse
;
259 inode
= igrab(path
.dentry
->d_inode
);
266 char *tail
= strrchr(filename
, '/');
269 ptr
= kstrdup((tail
? tail
+ 1 : filename
), GFP_KERNEL
);
272 goto fail_address_parse
;
276 ptr
= strpbrk(tail
, ".-_");
280 snprintf(buf
, MAX_EVENT_NAME_LEN
, "%c_%s_0x%lx", 'p', tail
, offset
);
285 tu
= alloc_trace_uprobe(group
, event
, argc
);
287 pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu
));
289 goto fail_address_parse
;
293 tu
->filename
= kstrdup(filename
, GFP_KERNEL
);
296 pr_info("Failed to allocate filename.\n");
301 /* parse arguments */
303 for (i
= 0; i
< argc
&& i
< MAX_TRACE_ARGS
; i
++) {
304 /* Increment count for freeing args in error case */
307 /* Parse argument name */
308 arg
= strchr(argv
[i
], '=');
311 tu
->args
[i
].name
= kstrdup(argv
[i
], GFP_KERNEL
);
314 /* If argument name is omitted, set "argN" */
315 snprintf(buf
, MAX_EVENT_NAME_LEN
, "arg%d", i
+ 1);
316 tu
->args
[i
].name
= kstrdup(buf
, GFP_KERNEL
);
319 if (!tu
->args
[i
].name
) {
320 pr_info("Failed to allocate argument[%d] name.\n", i
);
325 if (!is_good_name(tu
->args
[i
].name
)) {
326 pr_info("Invalid argument[%d] name: %s\n", i
, tu
->args
[i
].name
);
331 if (traceprobe_conflict_field_name(tu
->args
[i
].name
, tu
->args
, i
)) {
332 pr_info("Argument[%d] name '%s' conflicts with "
333 "another field.\n", i
, argv
[i
]);
338 /* Parse fetch argument */
339 ret
= traceprobe_parse_probe_arg(arg
, &tu
->size
, &tu
->args
[i
], false, false);
341 pr_info("Parse error at argument[%d]. (%d)\n", i
, ret
);
346 ret
= register_trace_uprobe(tu
);
352 free_trace_uprobe(tu
);
359 pr_info("Failed to parse address.\n");
364 static void cleanup_all_probes(void)
366 struct trace_uprobe
*tu
;
368 mutex_lock(&uprobe_lock
);
369 while (!list_empty(&uprobe_list
)) {
370 tu
= list_entry(uprobe_list
.next
, struct trace_uprobe
, list
);
371 unregister_trace_uprobe(tu
);
373 mutex_unlock(&uprobe_lock
);
376 /* Probes listing interfaces */
377 static void *probes_seq_start(struct seq_file
*m
, loff_t
*pos
)
379 mutex_lock(&uprobe_lock
);
380 return seq_list_start(&uprobe_list
, *pos
);
383 static void *probes_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
385 return seq_list_next(v
, &uprobe_list
, pos
);
388 static void probes_seq_stop(struct seq_file
*m
, void *v
)
390 mutex_unlock(&uprobe_lock
);
393 static int probes_seq_show(struct seq_file
*m
, void *v
)
395 struct trace_uprobe
*tu
= v
;
398 seq_printf(m
, "p:%s/%s", tu
->call
.class->system
, tu
->call
.name
);
399 seq_printf(m
, " %s:0x%p", tu
->filename
, (void *)tu
->offset
);
401 for (i
= 0; i
< tu
->nr_args
; i
++)
402 seq_printf(m
, " %s=%s", tu
->args
[i
].name
, tu
->args
[i
].comm
);
408 static const struct seq_operations probes_seq_op
= {
409 .start
= probes_seq_start
,
410 .next
= probes_seq_next
,
411 .stop
= probes_seq_stop
,
412 .show
= probes_seq_show
415 static int probes_open(struct inode
*inode
, struct file
*file
)
417 if ((file
->f_mode
& FMODE_WRITE
) && (file
->f_flags
& O_TRUNC
))
418 cleanup_all_probes();
420 return seq_open(file
, &probes_seq_op
);
423 static ssize_t
probes_write(struct file
*file
, const char __user
*buffer
,
424 size_t count
, loff_t
*ppos
)
426 return traceprobe_probes_write(file
, buffer
, count
, ppos
, create_trace_uprobe
);
429 static const struct file_operations uprobe_events_ops
= {
430 .owner
= THIS_MODULE
,
434 .release
= seq_release
,
435 .write
= probes_write
,
438 /* Probes profiling interfaces */
439 static int probes_profile_seq_show(struct seq_file
*m
, void *v
)
441 struct trace_uprobe
*tu
= v
;
443 seq_printf(m
, " %s %-44s %15lu\n", tu
->filename
, tu
->call
.name
, tu
->nhit
);
447 static const struct seq_operations profile_seq_op
= {
448 .start
= probes_seq_start
,
449 .next
= probes_seq_next
,
450 .stop
= probes_seq_stop
,
451 .show
= probes_profile_seq_show
454 static int profile_open(struct inode
*inode
, struct file
*file
)
456 return seq_open(file
, &profile_seq_op
);
459 static const struct file_operations uprobe_profile_ops
= {
460 .owner
= THIS_MODULE
,
461 .open
= profile_open
,
464 .release
= seq_release
,
468 static void uprobe_trace_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
470 struct uprobe_trace_entry_head
*entry
;
471 struct ring_buffer_event
*event
;
472 struct ring_buffer
*buffer
;
475 unsigned long irq_flags
;
476 struct ftrace_event_call
*call
= &tu
->call
;
480 local_save_flags(irq_flags
);
481 pc
= preempt_count();
483 size
= sizeof(*entry
) + tu
->size
;
485 event
= trace_current_buffer_lock_reserve(&buffer
, call
->event
.type
,
486 size
, irq_flags
, pc
);
490 entry
= ring_buffer_event_data(event
);
491 entry
->ip
= uprobe_get_swbp_addr(task_pt_regs(current
));
492 data
= (u8
*)&entry
[1];
493 for (i
= 0; i
< tu
->nr_args
; i
++)
494 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
496 if (!filter_current_check_discard(buffer
, call
, entry
, event
))
497 trace_buffer_unlock_commit(buffer
, event
, irq_flags
, pc
);
500 /* Event entry printers */
501 static enum print_line_t
502 print_uprobe_event(struct trace_iterator
*iter
, int flags
, struct trace_event
*event
)
504 struct uprobe_trace_entry_head
*field
;
505 struct trace_seq
*s
= &iter
->seq
;
506 struct trace_uprobe
*tu
;
510 field
= (struct uprobe_trace_entry_head
*)iter
->ent
;
511 tu
= container_of(event
, struct trace_uprobe
, call
.event
);
513 if (!trace_seq_printf(s
, "%s: (", tu
->call
.name
))
516 if (!seq_print_ip_sym(s
, field
->ip
, flags
| TRACE_ITER_SYM_OFFSET
))
519 if (!trace_seq_puts(s
, ")"))
522 data
= (u8
*)&field
[1];
523 for (i
= 0; i
< tu
->nr_args
; i
++) {
524 if (!tu
->args
[i
].type
->print(s
, tu
->args
[i
].name
,
525 data
+ tu
->args
[i
].offset
, field
))
529 if (trace_seq_puts(s
, "\n"))
530 return TRACE_TYPE_HANDLED
;
533 return TRACE_TYPE_PARTIAL_LINE
;
536 static int probe_event_enable(struct trace_uprobe
*tu
, int flag
)
538 struct uprobe_trace_consumer
*utc
;
541 if (!tu
->inode
|| tu
->consumer
)
544 utc
= kzalloc(sizeof(struct uprobe_trace_consumer
), GFP_KERNEL
);
548 utc
->cons
.handler
= uprobe_dispatcher
;
549 utc
->cons
.filter
= NULL
;
550 ret
= uprobe_register(tu
->inode
, tu
->offset
, &utc
->cons
);
563 static void probe_event_disable(struct trace_uprobe
*tu
, int flag
)
565 if (!tu
->inode
|| !tu
->consumer
)
568 uprobe_unregister(tu
->inode
, tu
->offset
, &tu
->consumer
->cons
);
574 static int uprobe_event_define_fields(struct ftrace_event_call
*event_call
)
577 struct uprobe_trace_entry_head field
;
578 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event_call
->data
;
580 DEFINE_FIELD(unsigned long, ip
, FIELD_STRING_IP
, 0);
581 /* Set argument names as fields */
582 for (i
= 0; i
< tu
->nr_args
; i
++) {
583 ret
= trace_define_field(event_call
, tu
->args
[i
].type
->fmttype
,
585 sizeof(field
) + tu
->args
[i
].offset
,
586 tu
->args
[i
].type
->size
,
587 tu
->args
[i
].type
->is_signed
,
596 #define LEN_OR_ZERO (len ? len - pos : 0)
597 static int __set_print_fmt(struct trace_uprobe
*tu
, char *buf
, int len
)
599 const char *fmt
, *arg
;
604 arg
= "REC->" FIELD_STRING_IP
;
606 /* When len=0, we just calculate the needed length */
608 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\"%s", fmt
);
610 for (i
= 0; i
< tu
->nr_args
; i
++) {
611 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, " %s=%s",
612 tu
->args
[i
].name
, tu
->args
[i
].type
->fmt
);
615 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\", %s", arg
);
617 for (i
= 0; i
< tu
->nr_args
; i
++) {
618 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, ", REC->%s",
622 return pos
; /* return the length of print_fmt */
626 static int set_print_fmt(struct trace_uprobe
*tu
)
631 /* First: called with 0 length to calculate the needed length */
632 len
= __set_print_fmt(tu
, NULL
, 0);
633 print_fmt
= kmalloc(len
+ 1, GFP_KERNEL
);
637 /* Second: actually write the @print_fmt */
638 __set_print_fmt(tu
, print_fmt
, len
+ 1);
639 tu
->call
.print_fmt
= print_fmt
;
644 #ifdef CONFIG_PERF_EVENTS
645 /* uprobe profile handler */
646 static void uprobe_perf_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
648 struct ftrace_event_call
*call
= &tu
->call
;
649 struct uprobe_trace_entry_head
*entry
;
650 struct hlist_head
*head
;
655 __size
= sizeof(*entry
) + tu
->size
;
656 size
= ALIGN(__size
+ sizeof(u32
), sizeof(u64
));
658 if (WARN_ONCE(size
> PERF_MAX_TRACE_SIZE
, "profile buffer not large enough"))
663 entry
= perf_trace_buf_prepare(size
, call
->event
.type
, regs
, &rctx
);
667 entry
->ip
= uprobe_get_swbp_addr(task_pt_regs(current
));
668 data
= (u8
*)&entry
[1];
669 for (i
= 0; i
< tu
->nr_args
; i
++)
670 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
672 head
= this_cpu_ptr(call
->perf_events
);
673 perf_trace_buf_submit(entry
, size
, rctx
, entry
->ip
, 1, regs
, head
, NULL
);
678 #endif /* CONFIG_PERF_EVENTS */
681 int trace_uprobe_register(struct ftrace_event_call
*event
, enum trace_reg type
, void *data
)
683 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event
->data
;
686 case TRACE_REG_REGISTER
:
687 return probe_event_enable(tu
, TP_FLAG_TRACE
);
689 case TRACE_REG_UNREGISTER
:
690 probe_event_disable(tu
, TP_FLAG_TRACE
);
693 #ifdef CONFIG_PERF_EVENTS
694 case TRACE_REG_PERF_REGISTER
:
695 return probe_event_enable(tu
, TP_FLAG_PROFILE
);
697 case TRACE_REG_PERF_UNREGISTER
:
698 probe_event_disable(tu
, TP_FLAG_PROFILE
);
707 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
)
709 struct uprobe_trace_consumer
*utc
;
710 struct trace_uprobe
*tu
;
712 utc
= container_of(con
, struct uprobe_trace_consumer
, cons
);
714 if (!tu
|| tu
->consumer
!= utc
)
717 if (tu
->flags
& TP_FLAG_TRACE
)
718 uprobe_trace_func(tu
, regs
);
720 #ifdef CONFIG_PERF_EVENTS
721 if (tu
->flags
& TP_FLAG_PROFILE
)
722 uprobe_perf_func(tu
, regs
);
727 static struct trace_event_functions uprobe_funcs
= {
728 .trace
= print_uprobe_event
731 static int register_uprobe_event(struct trace_uprobe
*tu
)
733 struct ftrace_event_call
*call
= &tu
->call
;
736 /* Initialize ftrace_event_call */
737 INIT_LIST_HEAD(&call
->class->fields
);
738 call
->event
.funcs
= &uprobe_funcs
;
739 call
->class->define_fields
= uprobe_event_define_fields
;
741 if (set_print_fmt(tu
) < 0)
744 ret
= register_ftrace_event(&call
->event
);
746 kfree(call
->print_fmt
);
750 call
->class->reg
= trace_uprobe_register
;
752 ret
= trace_add_event_call(call
);
755 pr_info("Failed to register uprobe event: %s\n", call
->name
);
756 kfree(call
->print_fmt
);
757 unregister_ftrace_event(&call
->event
);
763 static void unregister_uprobe_event(struct trace_uprobe
*tu
)
765 /* tu->event is unregistered in trace_remove_event_call() */
766 trace_remove_event_call(&tu
->call
);
767 kfree(tu
->call
.print_fmt
);
768 tu
->call
.print_fmt
= NULL
;
771 /* Make a trace interface for controling probe points */
772 static __init
int init_uprobe_trace(void)
774 struct dentry
*d_tracer
;
776 d_tracer
= tracing_init_dentry();
780 trace_create_file("uprobe_events", 0644, d_tracer
,
781 NULL
, &uprobe_events_ops
);
782 /* Profile interface */
783 trace_create_file("uprobe_profile", 0444, d_tracer
,
784 NULL
, &uprobe_profile_ops
);
788 fs_initcall(init_uprobe_trace
);