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 uprobe_trace_consumer
{
36 struct uprobe_consumer cons
;
37 struct trace_uprobe
*tu
;
41 struct list_head list
;
42 struct ftrace_event_class
class;
43 struct ftrace_event_call call
;
44 struct uprobe_trace_consumer
*consumer
;
49 unsigned int flags
; /* For TP_FLAG_* */
50 ssize_t size
; /* trace entry size */
52 struct probe_arg args
[];
55 #define SIZEOF_TRACE_UPROBE(n) \
56 (offsetof(struct trace_uprobe, args) + \
57 (sizeof(struct probe_arg) * (n)))
59 static int register_uprobe_event(struct trace_uprobe
*tu
);
60 static void unregister_uprobe_event(struct trace_uprobe
*tu
);
62 static DEFINE_MUTEX(uprobe_lock
);
63 static LIST_HEAD(uprobe_list
);
65 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
);
68 * Allocate new trace_uprobe and initialize it (including uprobes).
70 static struct trace_uprobe
*
71 alloc_trace_uprobe(const char *group
, const char *event
, int nargs
)
73 struct trace_uprobe
*tu
;
75 if (!event
|| !is_good_name(event
))
76 return ERR_PTR(-EINVAL
);
78 if (!group
|| !is_good_name(group
))
79 return ERR_PTR(-EINVAL
);
81 tu
= kzalloc(SIZEOF_TRACE_UPROBE(nargs
), GFP_KERNEL
);
83 return ERR_PTR(-ENOMEM
);
85 tu
->call
.class = &tu
->class;
86 tu
->call
.name
= kstrdup(event
, GFP_KERNEL
);
90 tu
->class.system
= kstrdup(group
, GFP_KERNEL
);
91 if (!tu
->class.system
)
94 INIT_LIST_HEAD(&tu
->list
);
101 return ERR_PTR(-ENOMEM
);
104 static void free_trace_uprobe(struct trace_uprobe
*tu
)
108 for (i
= 0; i
< tu
->nr_args
; i
++)
109 traceprobe_free_probe_arg(&tu
->args
[i
]);
112 kfree(tu
->call
.class->system
);
113 kfree(tu
->call
.name
);
118 static struct trace_uprobe
*find_probe_event(const char *event
, const char *group
)
120 struct trace_uprobe
*tu
;
122 list_for_each_entry(tu
, &uprobe_list
, list
)
123 if (strcmp(tu
->call
.name
, event
) == 0 &&
124 strcmp(tu
->call
.class->system
, group
) == 0)
130 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
131 static void unregister_trace_uprobe(struct trace_uprobe
*tu
)
134 unregister_uprobe_event(tu
);
135 free_trace_uprobe(tu
);
138 /* Register a trace_uprobe and probe_event */
139 static int register_trace_uprobe(struct trace_uprobe
*tu
)
141 struct trace_uprobe
*old_tp
;
144 mutex_lock(&uprobe_lock
);
146 /* register as an event */
147 old_tp
= find_probe_event(tu
->call
.name
, tu
->call
.class->system
);
149 /* delete old event */
150 unregister_trace_uprobe(old_tp
);
152 ret
= register_uprobe_event(tu
);
154 pr_warning("Failed to register probe event(%d)\n", ret
);
158 list_add_tail(&tu
->list
, &uprobe_list
);
161 mutex_unlock(&uprobe_lock
);
168 * - Add uprobe: p[:[GRP/]EVENT] PATH:SYMBOL[+offs] [FETCHARGS]
170 * - Remove uprobe: -:[GRP/]EVENT
172 static int create_trace_uprobe(int argc
, char **argv
)
174 struct trace_uprobe
*tu
;
176 char *arg
, *event
, *group
, *filename
;
177 char buf
[MAX_EVENT_NAME_LEN
];
179 unsigned long offset
;
189 /* argc must be >= 1 */
190 if (argv
[0][0] == '-')
192 else if (argv
[0][0] != 'p') {
193 pr_info("Probe definition must be started with 'p' or '-'.\n");
197 if (argv
[0][1] == ':') {
199 arg
= strchr(event
, '/');
206 if (strlen(group
) == 0) {
207 pr_info("Group name is not specified\n");
211 if (strlen(event
) == 0) {
212 pr_info("Event name is not specified\n");
217 group
= UPROBE_EVENT_SYSTEM
;
221 pr_info("Delete command needs an event name.\n");
224 mutex_lock(&uprobe_lock
);
225 tu
= find_probe_event(event
, group
);
228 mutex_unlock(&uprobe_lock
);
229 pr_info("Event %s/%s doesn't exist.\n", group
, event
);
232 /* delete an event */
233 unregister_trace_uprobe(tu
);
234 mutex_unlock(&uprobe_lock
);
239 pr_info("Probe point is not specified.\n");
242 if (isdigit(argv
[1][0])) {
243 pr_info("probe point must be have a filename.\n");
246 arg
= strchr(argv
[1], ':');
248 goto fail_address_parse
;
252 ret
= kern_path(filename
, LOOKUP_FOLLOW
, &path
);
254 goto fail_address_parse
;
256 inode
= igrab(path
.dentry
->d_inode
);
259 if (!inode
|| !S_ISREG(inode
->i_mode
)) {
261 goto fail_address_parse
;
264 ret
= kstrtoul(arg
, 0, &offset
);
266 goto fail_address_parse
;
276 tail
= kstrdup(kbasename(filename
), GFP_KERNEL
);
279 goto fail_address_parse
;
282 ptr
= strpbrk(tail
, ".-_");
286 snprintf(buf
, MAX_EVENT_NAME_LEN
, "%c_%s_0x%lx", 'p', tail
, offset
);
291 tu
= alloc_trace_uprobe(group
, event
, argc
);
293 pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu
));
295 goto fail_address_parse
;
299 tu
->filename
= kstrdup(filename
, GFP_KERNEL
);
302 pr_info("Failed to allocate filename.\n");
307 /* parse arguments */
309 for (i
= 0; i
< argc
&& i
< MAX_TRACE_ARGS
; i
++) {
310 /* Increment count for freeing args in error case */
313 /* Parse argument name */
314 arg
= strchr(argv
[i
], '=');
317 tu
->args
[i
].name
= kstrdup(argv
[i
], GFP_KERNEL
);
320 /* If argument name is omitted, set "argN" */
321 snprintf(buf
, MAX_EVENT_NAME_LEN
, "arg%d", i
+ 1);
322 tu
->args
[i
].name
= kstrdup(buf
, GFP_KERNEL
);
325 if (!tu
->args
[i
].name
) {
326 pr_info("Failed to allocate argument[%d] name.\n", i
);
331 if (!is_good_name(tu
->args
[i
].name
)) {
332 pr_info("Invalid argument[%d] name: %s\n", i
, tu
->args
[i
].name
);
337 if (traceprobe_conflict_field_name(tu
->args
[i
].name
, tu
->args
, i
)) {
338 pr_info("Argument[%d] name '%s' conflicts with "
339 "another field.\n", i
, argv
[i
]);
344 /* Parse fetch argument */
345 ret
= traceprobe_parse_probe_arg(arg
, &tu
->size
, &tu
->args
[i
], false, false);
347 pr_info("Parse error at argument[%d]. (%d)\n", i
, ret
);
352 ret
= register_trace_uprobe(tu
);
358 free_trace_uprobe(tu
);
365 pr_info("Failed to parse address or file.\n");
370 static void cleanup_all_probes(void)
372 struct trace_uprobe
*tu
;
374 mutex_lock(&uprobe_lock
);
375 while (!list_empty(&uprobe_list
)) {
376 tu
= list_entry(uprobe_list
.next
, struct trace_uprobe
, list
);
377 unregister_trace_uprobe(tu
);
379 mutex_unlock(&uprobe_lock
);
382 /* Probes listing interfaces */
383 static void *probes_seq_start(struct seq_file
*m
, loff_t
*pos
)
385 mutex_lock(&uprobe_lock
);
386 return seq_list_start(&uprobe_list
, *pos
);
389 static void *probes_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
391 return seq_list_next(v
, &uprobe_list
, pos
);
394 static void probes_seq_stop(struct seq_file
*m
, void *v
)
396 mutex_unlock(&uprobe_lock
);
399 static int probes_seq_show(struct seq_file
*m
, void *v
)
401 struct trace_uprobe
*tu
= v
;
404 seq_printf(m
, "p:%s/%s", tu
->call
.class->system
, tu
->call
.name
);
405 seq_printf(m
, " %s:0x%p", tu
->filename
, (void *)tu
->offset
);
407 for (i
= 0; i
< tu
->nr_args
; i
++)
408 seq_printf(m
, " %s=%s", tu
->args
[i
].name
, tu
->args
[i
].comm
);
414 static const struct seq_operations probes_seq_op
= {
415 .start
= probes_seq_start
,
416 .next
= probes_seq_next
,
417 .stop
= probes_seq_stop
,
418 .show
= probes_seq_show
421 static int probes_open(struct inode
*inode
, struct file
*file
)
423 if ((file
->f_mode
& FMODE_WRITE
) && (file
->f_flags
& O_TRUNC
))
424 cleanup_all_probes();
426 return seq_open(file
, &probes_seq_op
);
429 static ssize_t
probes_write(struct file
*file
, const char __user
*buffer
,
430 size_t count
, loff_t
*ppos
)
432 return traceprobe_probes_write(file
, buffer
, count
, ppos
, create_trace_uprobe
);
435 static const struct file_operations uprobe_events_ops
= {
436 .owner
= THIS_MODULE
,
440 .release
= seq_release
,
441 .write
= probes_write
,
444 /* Probes profiling interfaces */
445 static int probes_profile_seq_show(struct seq_file
*m
, void *v
)
447 struct trace_uprobe
*tu
= v
;
449 seq_printf(m
, " %s %-44s %15lu\n", tu
->filename
, tu
->call
.name
, tu
->nhit
);
453 static const struct seq_operations profile_seq_op
= {
454 .start
= probes_seq_start
,
455 .next
= probes_seq_next
,
456 .stop
= probes_seq_stop
,
457 .show
= probes_profile_seq_show
460 static int profile_open(struct inode
*inode
, struct file
*file
)
462 return seq_open(file
, &profile_seq_op
);
465 static const struct file_operations uprobe_profile_ops
= {
466 .owner
= THIS_MODULE
,
467 .open
= profile_open
,
470 .release
= seq_release
,
474 static void uprobe_trace_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
476 struct uprobe_trace_entry_head
*entry
;
477 struct ring_buffer_event
*event
;
478 struct ring_buffer
*buffer
;
481 unsigned long irq_flags
;
482 struct ftrace_event_call
*call
= &tu
->call
;
486 local_save_flags(irq_flags
);
487 pc
= preempt_count();
489 size
= sizeof(*entry
) + tu
->size
;
491 event
= trace_current_buffer_lock_reserve(&buffer
, call
->event
.type
,
492 size
, irq_flags
, pc
);
496 entry
= ring_buffer_event_data(event
);
497 entry
->ip
= instruction_pointer(task_pt_regs(current
));
498 data
= (u8
*)&entry
[1];
499 for (i
= 0; i
< tu
->nr_args
; i
++)
500 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
502 if (!filter_current_check_discard(buffer
, call
, entry
, event
))
503 trace_buffer_unlock_commit(buffer
, event
, irq_flags
, pc
);
506 /* Event entry printers */
507 static enum print_line_t
508 print_uprobe_event(struct trace_iterator
*iter
, int flags
, struct trace_event
*event
)
510 struct uprobe_trace_entry_head
*field
;
511 struct trace_seq
*s
= &iter
->seq
;
512 struct trace_uprobe
*tu
;
516 field
= (struct uprobe_trace_entry_head
*)iter
->ent
;
517 tu
= container_of(event
, struct trace_uprobe
, call
.event
);
519 if (!trace_seq_printf(s
, "%s: (", tu
->call
.name
))
522 if (!seq_print_ip_sym(s
, field
->ip
, flags
| TRACE_ITER_SYM_OFFSET
))
525 if (!trace_seq_puts(s
, ")"))
528 data
= (u8
*)&field
[1];
529 for (i
= 0; i
< tu
->nr_args
; i
++) {
530 if (!tu
->args
[i
].type
->print(s
, tu
->args
[i
].name
,
531 data
+ tu
->args
[i
].offset
, field
))
535 if (trace_seq_puts(s
, "\n"))
536 return TRACE_TYPE_HANDLED
;
539 return TRACE_TYPE_PARTIAL_LINE
;
542 static int probe_event_enable(struct trace_uprobe
*tu
, int flag
)
544 struct uprobe_trace_consumer
*utc
;
550 utc
= kzalloc(sizeof(struct uprobe_trace_consumer
), GFP_KERNEL
);
554 utc
->cons
.handler
= uprobe_dispatcher
;
559 ret
= uprobe_register(tu
->inode
, tu
->offset
, &utc
->cons
);
569 static void probe_event_disable(struct trace_uprobe
*tu
, int flag
)
574 uprobe_unregister(tu
->inode
, tu
->offset
, &tu
->consumer
->cons
);
580 static int uprobe_event_define_fields(struct ftrace_event_call
*event_call
)
583 struct uprobe_trace_entry_head field
;
584 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event_call
->data
;
586 DEFINE_FIELD(unsigned long, ip
, FIELD_STRING_IP
, 0);
587 /* Set argument names as fields */
588 for (i
= 0; i
< tu
->nr_args
; i
++) {
589 ret
= trace_define_field(event_call
, tu
->args
[i
].type
->fmttype
,
591 sizeof(field
) + tu
->args
[i
].offset
,
592 tu
->args
[i
].type
->size
,
593 tu
->args
[i
].type
->is_signed
,
602 #define LEN_OR_ZERO (len ? len - pos : 0)
603 static int __set_print_fmt(struct trace_uprobe
*tu
, char *buf
, int len
)
605 const char *fmt
, *arg
;
610 arg
= "REC->" FIELD_STRING_IP
;
612 /* When len=0, we just calculate the needed length */
614 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\"%s", fmt
);
616 for (i
= 0; i
< tu
->nr_args
; i
++) {
617 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, " %s=%s",
618 tu
->args
[i
].name
, tu
->args
[i
].type
->fmt
);
621 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\", %s", arg
);
623 for (i
= 0; i
< tu
->nr_args
; i
++) {
624 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, ", REC->%s",
628 return pos
; /* return the length of print_fmt */
632 static int set_print_fmt(struct trace_uprobe
*tu
)
637 /* First: called with 0 length to calculate the needed length */
638 len
= __set_print_fmt(tu
, NULL
, 0);
639 print_fmt
= kmalloc(len
+ 1, GFP_KERNEL
);
643 /* Second: actually write the @print_fmt */
644 __set_print_fmt(tu
, print_fmt
, len
+ 1);
645 tu
->call
.print_fmt
= print_fmt
;
650 #ifdef CONFIG_PERF_EVENTS
651 /* uprobe profile handler */
652 static void uprobe_perf_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
654 struct ftrace_event_call
*call
= &tu
->call
;
655 struct uprobe_trace_entry_head
*entry
;
656 struct hlist_head
*head
;
661 __size
= sizeof(*entry
) + tu
->size
;
662 size
= ALIGN(__size
+ sizeof(u32
), sizeof(u64
));
664 if (WARN_ONCE(size
> PERF_MAX_TRACE_SIZE
, "profile buffer not large enough"))
669 entry
= perf_trace_buf_prepare(size
, call
->event
.type
, regs
, &rctx
);
673 entry
->ip
= instruction_pointer(task_pt_regs(current
));
674 data
= (u8
*)&entry
[1];
675 for (i
= 0; i
< tu
->nr_args
; i
++)
676 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
678 head
= this_cpu_ptr(call
->perf_events
);
679 perf_trace_buf_submit(entry
, size
, rctx
, entry
->ip
, 1, regs
, head
, NULL
);
684 #endif /* CONFIG_PERF_EVENTS */
687 int trace_uprobe_register(struct ftrace_event_call
*event
, enum trace_reg type
, void *data
)
689 struct trace_uprobe
*tu
= (struct trace_uprobe
*)event
->data
;
692 case TRACE_REG_REGISTER
:
693 return probe_event_enable(tu
, TP_FLAG_TRACE
);
695 case TRACE_REG_UNREGISTER
:
696 probe_event_disable(tu
, TP_FLAG_TRACE
);
699 #ifdef CONFIG_PERF_EVENTS
700 case TRACE_REG_PERF_REGISTER
:
701 return probe_event_enable(tu
, TP_FLAG_PROFILE
);
703 case TRACE_REG_PERF_UNREGISTER
:
704 probe_event_disable(tu
, TP_FLAG_PROFILE
);
713 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
)
715 struct uprobe_trace_consumer
*utc
;
716 struct trace_uprobe
*tu
;
718 utc
= container_of(con
, struct uprobe_trace_consumer
, cons
);
720 if (!tu
|| tu
->consumer
!= utc
)
723 if (tu
->flags
& TP_FLAG_TRACE
)
724 uprobe_trace_func(tu
, regs
);
726 #ifdef CONFIG_PERF_EVENTS
727 if (tu
->flags
& TP_FLAG_PROFILE
)
728 uprobe_perf_func(tu
, regs
);
733 static struct trace_event_functions uprobe_funcs
= {
734 .trace
= print_uprobe_event
737 static int register_uprobe_event(struct trace_uprobe
*tu
)
739 struct ftrace_event_call
*call
= &tu
->call
;
742 /* Initialize ftrace_event_call */
743 INIT_LIST_HEAD(&call
->class->fields
);
744 call
->event
.funcs
= &uprobe_funcs
;
745 call
->class->define_fields
= uprobe_event_define_fields
;
747 if (set_print_fmt(tu
) < 0)
750 ret
= register_ftrace_event(&call
->event
);
752 kfree(call
->print_fmt
);
756 call
->class->reg
= trace_uprobe_register
;
758 ret
= trace_add_event_call(call
);
761 pr_info("Failed to register uprobe event: %s\n", call
->name
);
762 kfree(call
->print_fmt
);
763 unregister_ftrace_event(&call
->event
);
769 static void unregister_uprobe_event(struct trace_uprobe
*tu
)
771 /* tu->event is unregistered in trace_remove_event_call() */
772 trace_remove_event_call(&tu
->call
);
773 kfree(tu
->call
.print_fmt
);
774 tu
->call
.print_fmt
= NULL
;
777 /* Make a trace interface for controling probe points */
778 static __init
int init_uprobe_trace(void)
780 struct dentry
*d_tracer
;
782 d_tracer
= tracing_init_dentry();
786 trace_create_file("uprobe_events", 0644, d_tracer
,
787 NULL
, &uprobe_events_ops
);
788 /* Profile interface */
789 trace_create_file("uprobe_profile", 0444, d_tracer
,
790 NULL
, &uprobe_profile_ops
);
794 fs_initcall(init_uprobe_trace
);