1 /* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
3 * probes/lttng-kretprobes.c
5 * LTTng kretprobes integration module.
7 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 #include <linux/module.h>
11 #include <linux/kprobes.h>
12 #include <linux/slab.h>
13 #include <linux/kref.h>
14 #include <lttng-events.h>
15 #include <wrapper/ringbuffer/frontend_types.h>
16 #include <wrapper/vmalloc.h>
17 #include <wrapper/irqflags.h>
18 #include <lttng-tracer.h>
20 enum lttng_kretprobe_type
{
27 struct lttng_event
*event
[2]; /* ENTRY and RETURN */
28 struct kref kref_register
;
29 struct kref kref_alloc
;
33 int _lttng_kretprobes_handler(struct kretprobe_instance
*krpi
,
35 enum lttng_kretprobe_type type
)
37 struct lttng_krp
*lttng_krp
=
38 container_of(krpi
->rp
, struct lttng_krp
, krp
);
39 struct lttng_event
*event
=
40 lttng_krp
->event
[type
];
41 struct lttng_probe_ctx lttng_probe_ctx
= {
43 .interruptible
= !lttng_regs_irqs_disabled(regs
),
45 struct lttng_channel
*chan
= event
->chan
;
46 struct lib_ring_buffer_ctx ctx
;
50 unsigned long parent_ip
;
53 if (unlikely(!READ_ONCE(chan
->session
->active
)))
55 if (unlikely(!READ_ONCE(chan
->enabled
)))
57 if (unlikely(!READ_ONCE(event
->enabled
)))
60 payload
.ip
= (unsigned long) krpi
->rp
->kp
.addr
;
61 payload
.parent_ip
= (unsigned long) krpi
->ret_addr
;
63 lib_ring_buffer_ctx_init(&ctx
, chan
->chan
, <tng_probe_ctx
, sizeof(payload
),
64 lttng_alignof(payload
), -1);
65 ret
= chan
->ops
->event_reserve(&ctx
, event
->id
);
68 lib_ring_buffer_align_ctx(&ctx
, lttng_alignof(payload
));
69 chan
->ops
->event_write(&ctx
, &payload
, sizeof(payload
));
70 chan
->ops
->event_commit(&ctx
);
75 int lttng_kretprobes_handler_entry(struct kretprobe_instance
*krpi
,
78 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_ENTRY
);
82 int lttng_kretprobes_handler_return(struct kretprobe_instance
*krpi
,
85 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_RETURN
);
89 * Create event description
92 int lttng_create_kprobe_event(const char *name
, struct lttng_event
*event
,
93 enum lttng_kretprobe_type type
)
95 struct lttng_event_field
*fields
;
96 struct lttng_event_desc
*desc
;
100 const char *suffix
= NULL
;
102 desc
= kzalloc(sizeof(*event
->desc
), GFP_KERNEL
);
105 name_len
= strlen(name
);
114 name_len
+= strlen(suffix
);
115 alloc_name
= kmalloc(name_len
+ 1, GFP_KERNEL
);
120 strcpy(alloc_name
, name
);
121 strcat(alloc_name
, suffix
);
122 desc
->name
= alloc_name
;
124 desc
->fields
= fields
=
125 kzalloc(2 * sizeof(struct lttng_event_field
), GFP_KERNEL
);
130 fields
[0].name
= "ip";
131 fields
[0].type
.atype
= atype_integer
;
132 fields
[0].type
.u
.basic
.integer
.size
= sizeof(unsigned long) * CHAR_BIT
;
133 fields
[0].type
.u
.basic
.integer
.alignment
= lttng_alignof(unsigned long) * CHAR_BIT
;
134 fields
[0].type
.u
.basic
.integer
.signedness
= lttng_is_signed_type(unsigned long);
135 fields
[0].type
.u
.basic
.integer
.reverse_byte_order
= 0;
136 fields
[0].type
.u
.basic
.integer
.base
= 16;
137 fields
[0].type
.u
.basic
.integer
.encoding
= lttng_encode_none
;
139 fields
[1].name
= "parent_ip";
140 fields
[1].type
.atype
= atype_integer
;
141 fields
[1].type
.u
.basic
.integer
.size
= sizeof(unsigned long) * CHAR_BIT
;
142 fields
[1].type
.u
.basic
.integer
.alignment
= lttng_alignof(unsigned long) * CHAR_BIT
;
143 fields
[1].type
.u
.basic
.integer
.signedness
= lttng_is_signed_type(unsigned long);
144 fields
[1].type
.u
.basic
.integer
.reverse_byte_order
= 0;
145 fields
[1].type
.u
.basic
.integer
.base
= 16;
146 fields
[1].type
.u
.basic
.integer
.encoding
= lttng_encode_none
;
148 desc
->owner
= THIS_MODULE
;
160 int lttng_kretprobes_register(const char *name
,
161 const char *symbol_name
,
164 struct lttng_event
*event_entry
,
165 struct lttng_event
*event_return
)
168 struct lttng_krp
*lttng_krp
;
170 /* Kprobes expects a NULL symbol name if unused */
171 if (symbol_name
[0] == '\0')
174 ret
= lttng_create_kprobe_event(name
, event_entry
, EVENT_ENTRY
);
177 ret
= lttng_create_kprobe_event(name
, event_return
, EVENT_RETURN
);
179 goto event_return_error
;
180 lttng_krp
= kzalloc(sizeof(*lttng_krp
), GFP_KERNEL
);
183 lttng_krp
->krp
.entry_handler
= lttng_kretprobes_handler_entry
;
184 lttng_krp
->krp
.handler
= lttng_kretprobes_handler_return
;
188 alloc_symbol
= kstrdup(symbol_name
, GFP_KERNEL
);
193 lttng_krp
->krp
.kp
.symbol_name
=
195 event_entry
->u
.kretprobe
.symbol_name
=
197 event_return
->u
.kretprobe
.symbol_name
=
200 lttng_krp
->krp
.kp
.offset
= offset
;
201 lttng_krp
->krp
.kp
.addr
= (void *) (unsigned long) addr
;
203 /* Allow probe handler to find event structures */
204 lttng_krp
->event
[EVENT_ENTRY
] = event_entry
;
205 lttng_krp
->event
[EVENT_RETURN
] = event_return
;
206 event_entry
->u
.kretprobe
.lttng_krp
= lttng_krp
;
207 event_return
->u
.kretprobe
.lttng_krp
= lttng_krp
;
210 * Both events must be unregistered before the kretprobe is
211 * unregistered. Same for memory allocation.
213 kref_init(<tng_krp
->kref_alloc
);
214 kref_get(<tng_krp
->kref_alloc
); /* inc refcount to 2, no overflow. */
215 kref_init(<tng_krp
->kref_register
);
216 kref_get(<tng_krp
->kref_register
); /* inc refcount to 2, no overflow. */
219 * Ensure the memory we just allocated don't trigger page faults.
220 * Well.. kprobes itself puts the page fault handler on the blacklist,
221 * but we can never be too careful.
223 wrapper_vmalloc_sync_all();
225 ret
= register_kretprobe(<tng_krp
->krp
);
231 kfree(lttng_krp
->krp
.kp
.symbol_name
);
235 kfree(event_return
->desc
->fields
);
236 kfree(event_return
->desc
->name
);
237 kfree(event_return
->desc
);
239 kfree(event_entry
->desc
->fields
);
240 kfree(event_entry
->desc
->name
);
241 kfree(event_entry
->desc
);
245 EXPORT_SYMBOL_GPL(lttng_kretprobes_register
);
248 void _lttng_kretprobes_unregister_release(struct kref
*kref
)
250 struct lttng_krp
*lttng_krp
=
251 container_of(kref
, struct lttng_krp
, kref_register
);
252 unregister_kretprobe(<tng_krp
->krp
);
255 void lttng_kretprobes_unregister(struct lttng_event
*event
)
257 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_register
,
258 _lttng_kretprobes_unregister_release
);
260 EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister
);
263 void _lttng_kretprobes_release(struct kref
*kref
)
265 struct lttng_krp
*lttng_krp
=
266 container_of(kref
, struct lttng_krp
, kref_alloc
);
267 kfree(lttng_krp
->krp
.kp
.symbol_name
);
270 void lttng_kretprobes_destroy_private(struct lttng_event
*event
)
272 kfree(event
->desc
->fields
);
273 kfree(event
->desc
->name
);
275 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_alloc
,
276 _lttng_kretprobes_release
);
278 EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private
);
280 int lttng_kretprobes_event_enable_state(struct lttng_event
*event
,
283 struct lttng_event
*event_return
;
284 struct lttng_krp
*lttng_krp
;
286 if (event
->instrumentation
!= LTTNG_KERNEL_KRETPROBE
) {
289 if (event
->enabled
== enable
) {
292 lttng_krp
= event
->u
.kretprobe
.lttng_krp
;
293 event_return
= lttng_krp
->event
[EVENT_RETURN
];
294 WRITE_ONCE(event
->enabled
, enable
);
295 WRITE_ONCE(event_return
->enabled
, enable
);
298 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state
);
300 MODULE_LICENSE("GPL and additional rights");
301 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
302 MODULE_DESCRIPTION("LTTng kretprobes probes");
303 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
304 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
305 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
306 LTTNG_MODULES_EXTRAVERSION
);