1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
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 <wrapper/kprobes.h>
12 #include <linux/slab.h>
13 #include <linux/kref.h>
14 #include <lttng/events.h>
15 #include <ringbuffer/frontend_types.h>
16 #include <wrapper/vmalloc.h>
17 #include <wrapper/irqflags.h>
18 #include <lttng/tracer.h>
19 #include <blacklist/kprobes.h>
21 enum lttng_kretprobe_type
{
28 struct lttng_event
*event
[2]; /* ENTRY and EXIT */
29 struct kref kref_register
;
30 struct kref kref_alloc
;
34 int _lttng_kretprobes_handler(struct kretprobe_instance
*krpi
,
36 enum lttng_kretprobe_type type
)
38 struct lttng_krp
*lttng_krp
=
39 container_of(lttng_get_kretprobe(krpi
), struct lttng_krp
, krp
);
40 struct lttng_event
*event
=
41 lttng_krp
->event
[type
];
42 struct lttng_probe_ctx lttng_probe_ctx
= {
44 .interruptible
= !lttng_regs_irqs_disabled(regs
),
46 struct lttng_channel
*chan
= event
->chan
;
47 struct lib_ring_buffer_ctx ctx
;
51 unsigned long parent_ip
;
54 if (unlikely(!LTTNG_READ_ONCE(chan
->session
->active
)))
56 if (unlikely(!LTTNG_READ_ONCE(chan
->enabled
)))
58 if (unlikely(!LTTNG_READ_ONCE(event
->enabled
)))
61 payload
.ip
= (unsigned long) lttng_get_kretprobe(krpi
)->kp
.addr
;
62 payload
.parent_ip
= (unsigned long) krpi
->ret_addr
;
64 lib_ring_buffer_ctx_init(&ctx
, chan
->chan
, <tng_probe_ctx
, sizeof(payload
),
65 lttng_alignof(payload
), -1);
66 ret
= chan
->ops
->event_reserve(&ctx
, event
->id
);
69 lib_ring_buffer_align_ctx(&ctx
, lttng_alignof(payload
));
70 chan
->ops
->event_write(&ctx
, &payload
, sizeof(payload
));
71 chan
->ops
->event_commit(&ctx
);
76 int lttng_kretprobes_handler_entry(struct kretprobe_instance
*krpi
,
79 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_ENTRY
);
83 int lttng_kretprobes_handler_exit(struct kretprobe_instance
*krpi
,
86 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_EXIT
);
89 static const struct lttng_kernel_type_common
*event_type
=
90 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16);
93 * Create event description
96 int lttng_create_kprobe_event(const char *name
, struct lttng_event
*event
,
97 enum lttng_kretprobe_type type
)
99 const struct lttng_kernel_event_field
**fieldp_array
;
100 struct lttng_kernel_event_field
*field
;
101 struct lttng_kernel_event_desc
*desc
;
104 const char *suffix
= NULL
;
107 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
110 name_len
= strlen(name
);
119 name_len
+= strlen(suffix
);
120 alloc_name
= kmalloc(name_len
+ 1, GFP_KERNEL
);
125 strcpy(alloc_name
, name
);
126 strcat(alloc_name
, suffix
);
127 desc
->event_name
= alloc_name
;
129 fieldp_array
= kzalloc(desc
->nr_fields
* sizeof(struct lttng_kernel_event_field
*), GFP_KERNEL
);
132 goto error_fieldp_array
;
134 desc
->fields
= fieldp_array
;
136 field
= kzalloc(sizeof(struct lttng_kernel_event_field
), GFP_KERNEL
);
142 field
->type
= event_type
;
143 desc
->fields
[0] = field
;
145 field
= kzalloc(sizeof(struct lttng_kernel_event_field
), GFP_KERNEL
);
150 field
->name
= "parent_ip";
151 field
->type
= event_type
;
152 desc
->fields
[1] = field
;
154 desc
->owner
= THIS_MODULE
;
160 kfree(desc
->fields
[0]);
164 kfree(desc
->event_name
);
170 int lttng_kretprobes_register(const char *name
,
171 const char *symbol_name
,
174 struct lttng_event
*event_entry
,
175 struct lttng_event
*event_exit
)
178 struct lttng_krp
*lttng_krp
;
180 /* Kprobes expects a NULL symbol name if unused */
181 if (symbol_name
[0] == '\0')
184 ret
= lttng_create_kprobe_event(name
, event_entry
, EVENT_ENTRY
);
187 ret
= lttng_create_kprobe_event(name
, event_exit
, EVENT_EXIT
);
189 goto event_exit_error
;
190 lttng_krp
= kzalloc(sizeof(*lttng_krp
), GFP_KERNEL
);
193 lttng_krp
->krp
.entry_handler
= lttng_kretprobes_handler_entry
;
194 lttng_krp
->krp
.handler
= lttng_kretprobes_handler_exit
;
198 alloc_symbol
= kstrdup(symbol_name
, GFP_KERNEL
);
203 lttng_krp
->krp
.kp
.symbol_name
=
205 event_entry
->u
.kretprobe
.symbol_name
=
207 event_exit
->u
.kretprobe
.symbol_name
=
210 lttng_krp
->krp
.kp
.offset
= offset
;
211 lttng_krp
->krp
.kp
.addr
= (void *) (unsigned long) addr
;
213 /* Allow probe handler to find event structures */
214 lttng_krp
->event
[EVENT_ENTRY
] = event_entry
;
215 lttng_krp
->event
[EVENT_EXIT
] = event_exit
;
216 event_entry
->u
.kretprobe
.lttng_krp
= lttng_krp
;
217 event_exit
->u
.kretprobe
.lttng_krp
= lttng_krp
;
220 * Both events must be unregistered before the kretprobe is
221 * unregistered. Same for memory allocation.
223 kref_init(<tng_krp
->kref_alloc
);
224 kref_get(<tng_krp
->kref_alloc
); /* inc refcount to 2, no overflow. */
225 kref_init(<tng_krp
->kref_register
);
226 kref_get(<tng_krp
->kref_register
); /* inc refcount to 2, no overflow. */
229 * Ensure the memory we just allocated don't trigger page faults.
230 * Well.. kprobes itself puts the page fault handler on the blacklist,
231 * but we can never be too careful.
233 wrapper_vmalloc_sync_mappings();
235 ret
= register_kretprobe(<tng_krp
->krp
);
241 kfree(lttng_krp
->krp
.kp
.symbol_name
);
245 kfree(event_exit
->desc
->fields
[0]);
246 kfree(event_exit
->desc
->fields
[1]);
247 kfree(event_exit
->desc
->fields
);
248 kfree(event_exit
->desc
->event_name
);
249 kfree(event_exit
->desc
);
251 kfree(event_entry
->desc
->fields
[0]);
252 kfree(event_entry
->desc
->fields
[1]);
253 kfree(event_entry
->desc
->fields
);
254 kfree(event_entry
->desc
->event_name
);
255 kfree(event_entry
->desc
);
259 EXPORT_SYMBOL_GPL(lttng_kretprobes_register
);
262 void _lttng_kretprobes_unregister_release(struct kref
*kref
)
264 struct lttng_krp
*lttng_krp
=
265 container_of(kref
, struct lttng_krp
, kref_register
);
266 unregister_kretprobe(<tng_krp
->krp
);
269 void lttng_kretprobes_unregister(struct lttng_event
*event
)
271 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_register
,
272 _lttng_kretprobes_unregister_release
);
274 EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister
);
277 void _lttng_kretprobes_release(struct kref
*kref
)
279 struct lttng_krp
*lttng_krp
=
280 container_of(kref
, struct lttng_krp
, kref_alloc
);
281 kfree(lttng_krp
->krp
.kp
.symbol_name
);
284 void lttng_kretprobes_destroy_private(struct lttng_event
*event
)
286 kfree(event
->desc
->fields
[0]);
287 kfree(event
->desc
->fields
[1]);
288 kfree(event
->desc
->fields
);
289 kfree(event
->desc
->event_name
);
291 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_alloc
,
292 _lttng_kretprobes_release
);
294 EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private
);
296 int lttng_kretprobes_event_enable_state(struct lttng_event
*event
,
299 struct lttng_event
*event_exit
;
300 struct lttng_krp
*lttng_krp
;
302 if (event
->instrumentation
!= LTTNG_KERNEL_KRETPROBE
) {
305 if (event
->enabled
== enable
) {
308 lttng_krp
= event
->u
.kretprobe
.lttng_krp
;
309 event_exit
= lttng_krp
->event
[EVENT_EXIT
];
310 WRITE_ONCE(event
->enabled
, enable
);
311 WRITE_ONCE(event_exit
->enabled
, enable
);
314 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state
);
316 MODULE_LICENSE("GPL and additional rights");
317 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
318 MODULE_DESCRIPTION("LTTng kretprobes probes");
319 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
320 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
321 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
322 LTTNG_MODULES_EXTRAVERSION
);