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"
31 struct uprobe_trace_entry_head
{
32 struct trace_entry ent
;
33 unsigned long vaddr
[];
36 #define SIZEOF_TRACE_ENTRY(is_return) \
37 (sizeof(struct uprobe_trace_entry_head) + \
38 sizeof(unsigned long) * (is_return ? 2 : 1))
40 #define DATAOF_TRACE_ENTRY(entry, is_return) \
41 ((void*)(entry) + SIZEOF_TRACE_ENTRY(is_return))
43 struct trace_uprobe_filter
{
46 struct list_head perf_events
;
50 * uprobe event core functions
53 struct list_head list
;
54 struct ftrace_event_class
class;
55 struct ftrace_event_call call
;
56 struct trace_uprobe_filter filter
;
57 struct uprobe_consumer consumer
;
62 unsigned int flags
; /* For TP_FLAG_* */
63 ssize_t size
; /* trace entry size */
65 struct probe_arg args
[];
68 #define SIZEOF_TRACE_UPROBE(n) \
69 (offsetof(struct trace_uprobe, args) + \
70 (sizeof(struct probe_arg) * (n)))
72 static int register_uprobe_event(struct trace_uprobe
*tu
);
73 static void unregister_uprobe_event(struct trace_uprobe
*tu
);
75 static DEFINE_MUTEX(uprobe_lock
);
76 static LIST_HEAD(uprobe_list
);
78 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
);
79 static int uretprobe_dispatcher(struct uprobe_consumer
*con
,
80 unsigned long func
, struct pt_regs
*regs
);
82 static inline void init_trace_uprobe_filter(struct trace_uprobe_filter
*filter
)
84 rwlock_init(&filter
->rwlock
);
85 filter
->nr_systemwide
= 0;
86 INIT_LIST_HEAD(&filter
->perf_events
);
89 static inline bool uprobe_filter_is_empty(struct trace_uprobe_filter
*filter
)
91 return !filter
->nr_systemwide
&& list_empty(&filter
->perf_events
);
94 static inline bool is_ret_probe(struct trace_uprobe
*tu
)
96 return tu
->consumer
.ret_handler
!= NULL
;
100 * Allocate new trace_uprobe and initialize it (including uprobes).
102 static struct trace_uprobe
*
103 alloc_trace_uprobe(const char *group
, const char *event
, int nargs
, bool is_ret
)
105 struct trace_uprobe
*tu
;
107 if (!event
|| !is_good_name(event
))
108 return ERR_PTR(-EINVAL
);
110 if (!group
|| !is_good_name(group
))
111 return ERR_PTR(-EINVAL
);
113 tu
= kzalloc(SIZEOF_TRACE_UPROBE(nargs
), GFP_KERNEL
);
115 return ERR_PTR(-ENOMEM
);
117 tu
->call
.class = &tu
->class;
118 tu
->call
.name
= kstrdup(event
, GFP_KERNEL
);
122 tu
->class.system
= kstrdup(group
, GFP_KERNEL
);
123 if (!tu
->class.system
)
126 INIT_LIST_HEAD(&tu
->list
);
127 tu
->consumer
.handler
= uprobe_dispatcher
;
129 tu
->consumer
.ret_handler
= uretprobe_dispatcher
;
130 init_trace_uprobe_filter(&tu
->filter
);
134 kfree(tu
->call
.name
);
137 return ERR_PTR(-ENOMEM
);
140 static void free_trace_uprobe(struct trace_uprobe
*tu
)
144 for (i
= 0; i
< tu
->nr_args
; i
++)
145 traceprobe_free_probe_arg(&tu
->args
[i
]);
148 kfree(tu
->call
.class->system
);
149 kfree(tu
->call
.name
);
154 static struct trace_uprobe
*find_probe_event(const char *event
, const char *group
)
156 struct trace_uprobe
*tu
;
158 list_for_each_entry(tu
, &uprobe_list
, list
)
159 if (strcmp(tu
->call
.name
, event
) == 0 &&
160 strcmp(tu
->call
.class->system
, group
) == 0)
166 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
167 static void unregister_trace_uprobe(struct trace_uprobe
*tu
)
170 unregister_uprobe_event(tu
);
171 free_trace_uprobe(tu
);
174 /* Register a trace_uprobe and probe_event */
175 static int register_trace_uprobe(struct trace_uprobe
*tu
)
177 struct trace_uprobe
*old_tp
;
180 mutex_lock(&uprobe_lock
);
182 /* register as an event */
183 old_tp
= find_probe_event(tu
->call
.name
, tu
->call
.class->system
);
185 /* delete old event */
186 unregister_trace_uprobe(old_tp
);
188 ret
= register_uprobe_event(tu
);
190 pr_warning("Failed to register probe event(%d)\n", ret
);
194 list_add_tail(&tu
->list
, &uprobe_list
);
197 mutex_unlock(&uprobe_lock
);
204 * - Add uprobe: p|r[:[GRP/]EVENT] PATH:SYMBOL [FETCHARGS]
206 * - Remove uprobe: -:[GRP/]EVENT
208 static int create_trace_uprobe(int argc
, char **argv
)
210 struct trace_uprobe
*tu
;
212 char *arg
, *event
, *group
, *filename
;
213 char buf
[MAX_EVENT_NAME_LEN
];
215 unsigned long offset
;
216 bool is_delete
, is_return
;
226 /* argc must be >= 1 */
227 if (argv
[0][0] == '-')
229 else if (argv
[0][0] == 'r')
231 else if (argv
[0][0] != 'p') {
232 pr_info("Probe definition must be started with 'p', 'r' or '-'.\n");
236 if (argv
[0][1] == ':') {
238 arg
= strchr(event
, '/');
245 if (strlen(group
) == 0) {
246 pr_info("Group name is not specified\n");
250 if (strlen(event
) == 0) {
251 pr_info("Event name is not specified\n");
256 group
= UPROBE_EVENT_SYSTEM
;
260 pr_info("Delete command needs an event name.\n");
263 mutex_lock(&uprobe_lock
);
264 tu
= find_probe_event(event
, group
);
267 mutex_unlock(&uprobe_lock
);
268 pr_info("Event %s/%s doesn't exist.\n", group
, event
);
271 /* delete an event */
272 unregister_trace_uprobe(tu
);
273 mutex_unlock(&uprobe_lock
);
278 pr_info("Probe point is not specified.\n");
281 if (isdigit(argv
[1][0])) {
282 pr_info("probe point must be have a filename.\n");
285 arg
= strchr(argv
[1], ':');
288 goto fail_address_parse
;
293 ret
= kern_path(filename
, LOOKUP_FOLLOW
, &path
);
295 goto fail_address_parse
;
297 inode
= igrab(path
.dentry
->d_inode
);
300 if (!inode
|| !S_ISREG(inode
->i_mode
)) {
302 goto fail_address_parse
;
305 ret
= kstrtoul(arg
, 0, &offset
);
307 goto fail_address_parse
;
317 tail
= kstrdup(kbasename(filename
), GFP_KERNEL
);
320 goto fail_address_parse
;
323 ptr
= strpbrk(tail
, ".-_");
327 snprintf(buf
, MAX_EVENT_NAME_LEN
, "%c_%s_0x%lx", 'p', tail
, offset
);
332 tu
= alloc_trace_uprobe(group
, event
, argc
, is_return
);
334 pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu
));
336 goto fail_address_parse
;
340 tu
->filename
= kstrdup(filename
, GFP_KERNEL
);
343 pr_info("Failed to allocate filename.\n");
348 /* parse arguments */
350 for (i
= 0; i
< argc
&& i
< MAX_TRACE_ARGS
; i
++) {
351 /* Increment count for freeing args in error case */
354 /* Parse argument name */
355 arg
= strchr(argv
[i
], '=');
358 tu
->args
[i
].name
= kstrdup(argv
[i
], GFP_KERNEL
);
361 /* If argument name is omitted, set "argN" */
362 snprintf(buf
, MAX_EVENT_NAME_LEN
, "arg%d", i
+ 1);
363 tu
->args
[i
].name
= kstrdup(buf
, GFP_KERNEL
);
366 if (!tu
->args
[i
].name
) {
367 pr_info("Failed to allocate argument[%d] name.\n", i
);
372 if (!is_good_name(tu
->args
[i
].name
)) {
373 pr_info("Invalid argument[%d] name: %s\n", i
, tu
->args
[i
].name
);
378 if (traceprobe_conflict_field_name(tu
->args
[i
].name
, tu
->args
, i
)) {
379 pr_info("Argument[%d] name '%s' conflicts with "
380 "another field.\n", i
, argv
[i
]);
385 /* Parse fetch argument */
386 ret
= traceprobe_parse_probe_arg(arg
, &tu
->size
, &tu
->args
[i
], false, false);
388 pr_info("Parse error at argument[%d]. (%d)\n", i
, ret
);
393 ret
= register_trace_uprobe(tu
);
399 free_trace_uprobe(tu
);
406 pr_info("Failed to parse address or file.\n");
411 static void cleanup_all_probes(void)
413 struct trace_uprobe
*tu
;
415 mutex_lock(&uprobe_lock
);
416 while (!list_empty(&uprobe_list
)) {
417 tu
= list_entry(uprobe_list
.next
, struct trace_uprobe
, list
);
418 unregister_trace_uprobe(tu
);
420 mutex_unlock(&uprobe_lock
);
423 /* Probes listing interfaces */
424 static void *probes_seq_start(struct seq_file
*m
, loff_t
*pos
)
426 mutex_lock(&uprobe_lock
);
427 return seq_list_start(&uprobe_list
, *pos
);
430 static void *probes_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
432 return seq_list_next(v
, &uprobe_list
, pos
);
435 static void probes_seq_stop(struct seq_file
*m
, void *v
)
437 mutex_unlock(&uprobe_lock
);
440 static int probes_seq_show(struct seq_file
*m
, void *v
)
442 struct trace_uprobe
*tu
= v
;
443 char c
= is_ret_probe(tu
) ? 'r' : 'p';
446 seq_printf(m
, "%c:%s/%s", c
, tu
->call
.class->system
, tu
->call
.name
);
447 seq_printf(m
, " %s:0x%p", tu
->filename
, (void *)tu
->offset
);
449 for (i
= 0; i
< tu
->nr_args
; i
++)
450 seq_printf(m
, " %s=%s", tu
->args
[i
].name
, tu
->args
[i
].comm
);
456 static const struct seq_operations probes_seq_op
= {
457 .start
= probes_seq_start
,
458 .next
= probes_seq_next
,
459 .stop
= probes_seq_stop
,
460 .show
= probes_seq_show
463 static int probes_open(struct inode
*inode
, struct file
*file
)
465 if ((file
->f_mode
& FMODE_WRITE
) && (file
->f_flags
& O_TRUNC
))
466 cleanup_all_probes();
468 return seq_open(file
, &probes_seq_op
);
471 static ssize_t
probes_write(struct file
*file
, const char __user
*buffer
,
472 size_t count
, loff_t
*ppos
)
474 return traceprobe_probes_write(file
, buffer
, count
, ppos
, create_trace_uprobe
);
477 static const struct file_operations uprobe_events_ops
= {
478 .owner
= THIS_MODULE
,
482 .release
= seq_release
,
483 .write
= probes_write
,
486 /* Probes profiling interfaces */
487 static int probes_profile_seq_show(struct seq_file
*m
, void *v
)
489 struct trace_uprobe
*tu
= v
;
491 seq_printf(m
, " %s %-44s %15lu\n", tu
->filename
, tu
->call
.name
, tu
->nhit
);
495 static const struct seq_operations profile_seq_op
= {
496 .start
= probes_seq_start
,
497 .next
= probes_seq_next
,
498 .stop
= probes_seq_stop
,
499 .show
= probes_profile_seq_show
502 static int profile_open(struct inode
*inode
, struct file
*file
)
504 return seq_open(file
, &profile_seq_op
);
507 static const struct file_operations uprobe_profile_ops
= {
508 .owner
= THIS_MODULE
,
509 .open
= profile_open
,
512 .release
= seq_release
,
515 static void uprobe_trace_print(struct trace_uprobe
*tu
,
516 unsigned long func
, struct pt_regs
*regs
)
518 struct uprobe_trace_entry_head
*entry
;
519 struct ring_buffer_event
*event
;
520 struct ring_buffer
*buffer
;
523 struct ftrace_event_call
*call
= &tu
->call
;
525 size
= SIZEOF_TRACE_ENTRY(is_ret_probe(tu
));
526 event
= trace_current_buffer_lock_reserve(&buffer
, call
->event
.type
,
527 size
+ tu
->size
, 0, 0);
531 entry
= ring_buffer_event_data(event
);
532 if (is_ret_probe(tu
)) {
533 entry
->vaddr
[0] = func
;
534 entry
->vaddr
[1] = instruction_pointer(regs
);
535 data
= DATAOF_TRACE_ENTRY(entry
, true);
537 entry
->vaddr
[0] = instruction_pointer(regs
);
538 data
= DATAOF_TRACE_ENTRY(entry
, false);
541 for (i
= 0; i
< tu
->nr_args
; i
++)
542 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
544 if (!filter_current_check_discard(buffer
, call
, entry
, event
))
545 trace_buffer_unlock_commit(buffer
, event
, 0, 0);
549 static int uprobe_trace_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
551 if (!is_ret_probe(tu
))
552 uprobe_trace_print(tu
, 0, regs
);
556 static void uretprobe_trace_func(struct trace_uprobe
*tu
, unsigned long func
,
557 struct pt_regs
*regs
)
559 uprobe_trace_print(tu
, func
, regs
);
562 /* Event entry printers */
563 static enum print_line_t
564 print_uprobe_event(struct trace_iterator
*iter
, int flags
, struct trace_event
*event
)
566 struct uprobe_trace_entry_head
*entry
;
567 struct trace_seq
*s
= &iter
->seq
;
568 struct trace_uprobe
*tu
;
572 entry
= (struct uprobe_trace_entry_head
*)iter
->ent
;
573 tu
= container_of(event
, struct trace_uprobe
, call
.event
);
575 if (is_ret_probe(tu
)) {
576 if (!trace_seq_printf(s
, "%s: (0x%lx <- 0x%lx)", tu
->call
.name
,
577 entry
->vaddr
[1], entry
->vaddr
[0]))
579 data
= DATAOF_TRACE_ENTRY(entry
, true);
581 if (!trace_seq_printf(s
, "%s: (0x%lx)", tu
->call
.name
,
584 data
= DATAOF_TRACE_ENTRY(entry
, false);
587 for (i
= 0; i
< tu
->nr_args
; i
++) {
588 if (!tu
->args
[i
].type
->print(s
, tu
->args
[i
].name
,
589 data
+ tu
->args
[i
].offset
, entry
))
593 if (trace_seq_puts(s
, "\n"))
594 return TRACE_TYPE_HANDLED
;
597 return TRACE_TYPE_PARTIAL_LINE
;
600 static inline bool is_trace_uprobe_enabled(struct trace_uprobe
*tu
)
602 return tu
->flags
& (TP_FLAG_TRACE
| TP_FLAG_PROFILE
);
605 typedef bool (*filter_func_t
)(struct uprobe_consumer
*self
,
606 enum uprobe_filter_ctx ctx
,
607 struct mm_struct
*mm
);
610 probe_event_enable(struct trace_uprobe
*tu
, int flag
, filter_func_t filter
)
614 if (is_trace_uprobe_enabled(tu
))
617 WARN_ON(!uprobe_filter_is_empty(&tu
->filter
));
620 tu
->consumer
.filter
= filter
;
621 ret
= uprobe_register(tu
->inode
, tu
->offset
, &tu
->consumer
);
628 static void probe_event_disable(struct trace_uprobe
*tu
, int flag
)
630 if (!is_trace_uprobe_enabled(tu
))
633 WARN_ON(!uprobe_filter_is_empty(&tu
->filter
));
635 uprobe_unregister(tu
->inode
, tu
->offset
, &tu
->consumer
);
639 static int uprobe_event_define_fields(struct ftrace_event_call
*event_call
)
642 struct uprobe_trace_entry_head field
;
643 struct trace_uprobe
*tu
= event_call
->data
;
645 if (is_ret_probe(tu
)) {
646 DEFINE_FIELD(unsigned long, vaddr
[0], FIELD_STRING_FUNC
, 0);
647 DEFINE_FIELD(unsigned long, vaddr
[1], FIELD_STRING_RETIP
, 0);
648 size
= SIZEOF_TRACE_ENTRY(true);
650 DEFINE_FIELD(unsigned long, vaddr
[0], FIELD_STRING_IP
, 0);
651 size
= SIZEOF_TRACE_ENTRY(false);
653 /* Set argument names as fields */
654 for (i
= 0; i
< tu
->nr_args
; i
++) {
655 ret
= trace_define_field(event_call
, tu
->args
[i
].type
->fmttype
,
657 size
+ tu
->args
[i
].offset
,
658 tu
->args
[i
].type
->size
,
659 tu
->args
[i
].type
->is_signed
,
668 #define LEN_OR_ZERO (len ? len - pos : 0)
669 static int __set_print_fmt(struct trace_uprobe
*tu
, char *buf
, int len
)
671 const char *fmt
, *arg
;
675 if (is_ret_probe(tu
)) {
676 fmt
= "(%lx <- %lx)";
677 arg
= "REC->" FIELD_STRING_FUNC
", REC->" FIELD_STRING_RETIP
;
680 arg
= "REC->" FIELD_STRING_IP
;
683 /* When len=0, we just calculate the needed length */
685 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\"%s", fmt
);
687 for (i
= 0; i
< tu
->nr_args
; i
++) {
688 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, " %s=%s",
689 tu
->args
[i
].name
, tu
->args
[i
].type
->fmt
);
692 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, "\", %s", arg
);
694 for (i
= 0; i
< tu
->nr_args
; i
++) {
695 pos
+= snprintf(buf
+ pos
, LEN_OR_ZERO
, ", REC->%s",
699 return pos
; /* return the length of print_fmt */
703 static int set_print_fmt(struct trace_uprobe
*tu
)
708 /* First: called with 0 length to calculate the needed length */
709 len
= __set_print_fmt(tu
, NULL
, 0);
710 print_fmt
= kmalloc(len
+ 1, GFP_KERNEL
);
714 /* Second: actually write the @print_fmt */
715 __set_print_fmt(tu
, print_fmt
, len
+ 1);
716 tu
->call
.print_fmt
= print_fmt
;
721 #ifdef CONFIG_PERF_EVENTS
723 __uprobe_perf_filter(struct trace_uprobe_filter
*filter
, struct mm_struct
*mm
)
725 struct perf_event
*event
;
727 if (filter
->nr_systemwide
)
730 list_for_each_entry(event
, &filter
->perf_events
, hw
.tp_list
) {
731 if (event
->hw
.tp_target
->mm
== mm
)
739 uprobe_filter_event(struct trace_uprobe
*tu
, struct perf_event
*event
)
741 return __uprobe_perf_filter(&tu
->filter
, event
->hw
.tp_target
->mm
);
744 static int uprobe_perf_open(struct trace_uprobe
*tu
, struct perf_event
*event
)
748 write_lock(&tu
->filter
.rwlock
);
749 if (event
->hw
.tp_target
) {
751 * event->parent != NULL means copy_process(), we can avoid
752 * uprobe_apply(). current->mm must be probed and we can rely
753 * on dup_mmap() which preserves the already installed bp's.
755 * attr.enable_on_exec means that exec/mmap will install the
756 * breakpoints we need.
758 done
= tu
->filter
.nr_systemwide
||
759 event
->parent
|| event
->attr
.enable_on_exec
||
760 uprobe_filter_event(tu
, event
);
761 list_add(&event
->hw
.tp_list
, &tu
->filter
.perf_events
);
763 done
= tu
->filter
.nr_systemwide
;
764 tu
->filter
.nr_systemwide
++;
766 write_unlock(&tu
->filter
.rwlock
);
769 uprobe_apply(tu
->inode
, tu
->offset
, &tu
->consumer
, true);
774 static int uprobe_perf_close(struct trace_uprobe
*tu
, struct perf_event
*event
)
778 write_lock(&tu
->filter
.rwlock
);
779 if (event
->hw
.tp_target
) {
780 list_del(&event
->hw
.tp_list
);
781 done
= tu
->filter
.nr_systemwide
||
782 (event
->hw
.tp_target
->flags
& PF_EXITING
) ||
783 uprobe_filter_event(tu
, event
);
785 tu
->filter
.nr_systemwide
--;
786 done
= tu
->filter
.nr_systemwide
;
788 write_unlock(&tu
->filter
.rwlock
);
791 uprobe_apply(tu
->inode
, tu
->offset
, &tu
->consumer
, false);
796 static bool uprobe_perf_filter(struct uprobe_consumer
*uc
,
797 enum uprobe_filter_ctx ctx
, struct mm_struct
*mm
)
799 struct trace_uprobe
*tu
;
802 tu
= container_of(uc
, struct trace_uprobe
, consumer
);
803 read_lock(&tu
->filter
.rwlock
);
804 ret
= __uprobe_perf_filter(&tu
->filter
, mm
);
805 read_unlock(&tu
->filter
.rwlock
);
810 static void uprobe_perf_print(struct trace_uprobe
*tu
,
811 unsigned long func
, struct pt_regs
*regs
)
813 struct ftrace_event_call
*call
= &tu
->call
;
814 struct uprobe_trace_entry_head
*entry
;
815 struct hlist_head
*head
;
819 size
= SIZEOF_TRACE_ENTRY(is_ret_probe(tu
));
820 size
= ALIGN(size
+ tu
->size
+ sizeof(u32
), sizeof(u64
)) - sizeof(u32
);
821 if (WARN_ONCE(size
> PERF_MAX_TRACE_SIZE
, "profile buffer not large enough"))
825 head
= this_cpu_ptr(call
->perf_events
);
826 if (hlist_empty(head
))
829 entry
= perf_trace_buf_prepare(size
, call
->event
.type
, regs
, &rctx
);
833 if (is_ret_probe(tu
)) {
834 entry
->vaddr
[0] = func
;
835 entry
->vaddr
[1] = instruction_pointer(regs
);
836 data
= DATAOF_TRACE_ENTRY(entry
, true);
838 entry
->vaddr
[0] = instruction_pointer(regs
);
839 data
= DATAOF_TRACE_ENTRY(entry
, false);
842 for (i
= 0; i
< tu
->nr_args
; i
++)
843 call_fetch(&tu
->args
[i
].fetch
, regs
, data
+ tu
->args
[i
].offset
);
845 perf_trace_buf_submit(entry
, size
, rctx
, 0, 1, regs
, head
, NULL
);
850 /* uprobe profile handler */
851 static int uprobe_perf_func(struct trace_uprobe
*tu
, struct pt_regs
*regs
)
853 if (!uprobe_perf_filter(&tu
->consumer
, 0, current
->mm
))
854 return UPROBE_HANDLER_REMOVE
;
856 if (!is_ret_probe(tu
))
857 uprobe_perf_print(tu
, 0, regs
);
861 static void uretprobe_perf_func(struct trace_uprobe
*tu
, unsigned long func
,
862 struct pt_regs
*regs
)
864 uprobe_perf_print(tu
, func
, regs
);
866 #endif /* CONFIG_PERF_EVENTS */
869 int trace_uprobe_register(struct ftrace_event_call
*event
, enum trace_reg type
, void *data
)
871 struct trace_uprobe
*tu
= event
->data
;
874 case TRACE_REG_REGISTER
:
875 return probe_event_enable(tu
, TP_FLAG_TRACE
, NULL
);
877 case TRACE_REG_UNREGISTER
:
878 probe_event_disable(tu
, TP_FLAG_TRACE
);
881 #ifdef CONFIG_PERF_EVENTS
882 case TRACE_REG_PERF_REGISTER
:
883 return probe_event_enable(tu
, TP_FLAG_PROFILE
, uprobe_perf_filter
);
885 case TRACE_REG_PERF_UNREGISTER
:
886 probe_event_disable(tu
, TP_FLAG_PROFILE
);
889 case TRACE_REG_PERF_OPEN
:
890 return uprobe_perf_open(tu
, data
);
892 case TRACE_REG_PERF_CLOSE
:
893 return uprobe_perf_close(tu
, data
);
902 static int uprobe_dispatcher(struct uprobe_consumer
*con
, struct pt_regs
*regs
)
904 struct trace_uprobe
*tu
;
907 tu
= container_of(con
, struct trace_uprobe
, consumer
);
910 if (tu
->flags
& TP_FLAG_TRACE
)
911 ret
|= uprobe_trace_func(tu
, regs
);
913 #ifdef CONFIG_PERF_EVENTS
914 if (tu
->flags
& TP_FLAG_PROFILE
)
915 ret
|= uprobe_perf_func(tu
, regs
);
920 static int uretprobe_dispatcher(struct uprobe_consumer
*con
,
921 unsigned long func
, struct pt_regs
*regs
)
923 struct trace_uprobe
*tu
;
925 tu
= container_of(con
, struct trace_uprobe
, consumer
);
927 if (tu
->flags
& TP_FLAG_TRACE
)
928 uretprobe_trace_func(tu
, func
, regs
);
930 #ifdef CONFIG_PERF_EVENTS
931 if (tu
->flags
& TP_FLAG_PROFILE
)
932 uretprobe_perf_func(tu
, func
, regs
);
937 static struct trace_event_functions uprobe_funcs
= {
938 .trace
= print_uprobe_event
941 static int register_uprobe_event(struct trace_uprobe
*tu
)
943 struct ftrace_event_call
*call
= &tu
->call
;
946 /* Initialize ftrace_event_call */
947 INIT_LIST_HEAD(&call
->class->fields
);
948 call
->event
.funcs
= &uprobe_funcs
;
949 call
->class->define_fields
= uprobe_event_define_fields
;
951 if (set_print_fmt(tu
) < 0)
954 ret
= register_ftrace_event(&call
->event
);
956 kfree(call
->print_fmt
);
960 call
->class->reg
= trace_uprobe_register
;
962 ret
= trace_add_event_call(call
);
965 pr_info("Failed to register uprobe event: %s\n", call
->name
);
966 kfree(call
->print_fmt
);
967 unregister_ftrace_event(&call
->event
);
973 static void unregister_uprobe_event(struct trace_uprobe
*tu
)
975 /* tu->event is unregistered in trace_remove_event_call() */
976 trace_remove_event_call(&tu
->call
);
977 kfree(tu
->call
.print_fmt
);
978 tu
->call
.print_fmt
= NULL
;
981 /* Make a trace interface for controling probe points */
982 static __init
int init_uprobe_trace(void)
984 struct dentry
*d_tracer
;
986 d_tracer
= tracing_init_dentry();
990 trace_create_file("uprobe_events", 0644, d_tracer
,
991 NULL
, &uprobe_events_ops
);
992 /* Profile interface */
993 trace_create_file("uprobe_profile", 0444, d_tracer
,
994 NULL
, &uprobe_profile_ops
);
998 fs_initcall(init_uprobe_trace
);