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 <lttng/events-internal.h>
16 #include <ringbuffer/frontend_types.h>
17 #include <wrapper/compiler_attributes.h>
18 #include <wrapper/vmalloc.h>
19 #include <wrapper/irqflags.h>
20 #include <lttng/tracer.h>
21 #include <blacklist/kprobes.h>
23 enum lttng_kretprobe_type
{
30 struct lttng_kernel_event_common
*event
[2]; /* ENTRY and EXIT */
31 struct kref kref_register
;
32 struct kref kref_alloc
;
36 int _lttng_kretprobes_handler(struct kretprobe_instance
*krpi
,
38 enum lttng_kretprobe_type type
)
40 struct lttng_krp
*lttng_krp
=
41 container_of(lttng_get_kretprobe(krpi
), struct lttng_krp
, krp
);
42 struct lttng_kernel_event_common
*event
= lttng_krp
->event
[type
];
43 struct lttng_kernel_probe_ctx lttng_probe_ctx
= {
45 .interruptible
= !lttng_regs_irqs_disabled(regs
),
49 unsigned long parent_ip
;
52 switch (event
->type
) {
53 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
55 struct lttng_kernel_event_recorder
*event_recorder
=
56 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
57 struct lttng_kernel_channel_buffer
*chan
= event_recorder
->chan
;
59 if (unlikely(!LTTNG_READ_ONCE(chan
->parent
.session
->active
)))
61 if (unlikely(!LTTNG_READ_ONCE(chan
->parent
.enabled
)))
65 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
71 if (unlikely(!LTTNG_READ_ONCE(event
->enabled
)))
74 switch (event
->type
) {
75 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
77 struct lttng_kernel_event_recorder
*event_recorder
=
78 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
79 struct lttng_kernel_channel_buffer
*chan
= event_recorder
->chan
;
80 struct lttng_kernel_ring_buffer_ctx ctx
;
83 payload
.ip
= (unsigned long) lttng_get_kretprobe(krpi
)->kp
.addr
;
84 payload
.parent_ip
= (unsigned long) krpi
->ret_addr
;
86 lib_ring_buffer_ctx_init(&ctx
, event_recorder
, sizeof(payload
),
87 lttng_alignof(payload
), <tng_probe_ctx
);
88 ret
= chan
->ops
->event_reserve(&ctx
);
91 chan
->ops
->event_write(&ctx
, &payload
, sizeof(payload
), lttng_alignof(payload
));
92 chan
->ops
->event_commit(&ctx
);
95 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
104 int lttng_kretprobes_handler_entry(struct kretprobe_instance
*krpi
,
105 struct pt_regs
*regs
)
107 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_ENTRY
);
111 int lttng_kretprobes_handler_exit(struct kretprobe_instance
*krpi
,
112 struct pt_regs
*regs
)
114 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_EXIT
);
117 static const struct lttng_kernel_event_field
*event_fields
[] = {
118 lttng_kernel_static_event_field("ip",
119 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16),
120 false, false, false),
121 lttng_kernel_static_event_field("parent_ip",
122 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16),
123 false, false, false),
126 static const struct lttng_kernel_tracepoint_class tp_class
= {
127 .nr_fields
= ARRAY_SIZE(event_fields
),
128 .fields
= event_fields
,
132 * Create event description
135 int lttng_create_kprobe_event(const char *name
, struct lttng_kernel_event_common
*event
,
136 enum lttng_kretprobe_type type
)
138 struct lttng_kernel_event_desc
*desc
;
141 const char *suffix
= NULL
;
144 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
147 name_len
= strlen(name
);
156 name_len
+= strlen(suffix
);
157 alloc_name
= kmalloc(name_len
+ 1, GFP_KERNEL
);
162 strcpy(alloc_name
, name
);
163 strcat(alloc_name
, suffix
);
164 desc
->event_name
= alloc_name
;
165 desc
->tp_class
= &tp_class
;
166 desc
->owner
= THIS_MODULE
;
167 event
->priv
->desc
= desc
;
176 int lttng_kretprobes_register(const char *name
,
177 const char *symbol_name
,
180 struct lttng_kernel_event_common
*event_entry
,
181 struct lttng_kernel_event_common
*event_exit
)
184 struct lttng_krp
*lttng_krp
;
186 /* Kprobes expects a NULL symbol name if unused */
187 if (symbol_name
[0] == '\0')
190 ret
= lttng_create_kprobe_event(name
, event_entry
, EVENT_ENTRY
);
193 ret
= lttng_create_kprobe_event(name
, event_exit
, EVENT_EXIT
);
195 goto event_exit_error
;
196 lttng_krp
= kzalloc(sizeof(*lttng_krp
), GFP_KERNEL
);
199 lttng_krp
->krp
.entry_handler
= lttng_kretprobes_handler_entry
;
200 lttng_krp
->krp
.handler
= lttng_kretprobes_handler_exit
;
204 alloc_symbol
= kstrdup(symbol_name
, GFP_KERNEL
);
209 lttng_krp
->krp
.kp
.symbol_name
= alloc_symbol
;
210 event_entry
->priv
->u
.kretprobe
.symbol_name
= alloc_symbol
;
211 event_exit
->priv
->u
.kretprobe
.symbol_name
= alloc_symbol
;
213 lttng_krp
->krp
.kp
.offset
= offset
;
214 lttng_krp
->krp
.kp
.addr
= (void *) (unsigned long) addr
;
216 /* Allow probe handler to find event structures */
217 lttng_krp
->event
[EVENT_ENTRY
] = event_entry
;
218 lttng_krp
->event
[EVENT_EXIT
] = event_exit
;
219 event_entry
->priv
->u
.kretprobe
.lttng_krp
= lttng_krp
;
220 event_exit
->priv
->u
.kretprobe
.lttng_krp
= lttng_krp
;
223 * Both events must be unregistered before the kretprobe is
224 * unregistered. Same for memory allocation.
226 kref_init(<tng_krp
->kref_alloc
);
227 kref_get(<tng_krp
->kref_alloc
); /* inc refcount to 2, no overflow. */
228 kref_init(<tng_krp
->kref_register
);
229 kref_get(<tng_krp
->kref_register
); /* inc refcount to 2, no overflow. */
232 * Ensure the memory we just allocated don't trigger page faults.
233 * Well.. kprobes itself puts the page fault handler on the blacklist,
234 * but we can never be too careful.
236 wrapper_vmalloc_sync_mappings();
238 ret
= register_kretprobe(<tng_krp
->krp
);
244 kfree(lttng_krp
->krp
.kp
.symbol_name
);
248 kfree(event_exit
->priv
->desc
->event_name
);
249 kfree(event_exit
->priv
->desc
);
251 kfree(event_entry
->priv
->desc
->event_name
);
252 kfree(event_entry
->priv
->desc
);
256 EXPORT_SYMBOL_GPL(lttng_kretprobes_register
);
259 void _lttng_kretprobes_unregister_release(struct kref
*kref
)
261 struct lttng_krp
*lttng_krp
=
262 container_of(kref
, struct lttng_krp
, kref_register
);
263 unregister_kretprobe(<tng_krp
->krp
);
266 void lttng_kretprobes_unregister(struct lttng_kernel_event_common
*event
)
268 kref_put(&event
->priv
->u
.kretprobe
.lttng_krp
->kref_register
,
269 _lttng_kretprobes_unregister_release
);
271 EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister
);
274 void _lttng_kretprobes_release(struct kref
*kref
)
276 struct lttng_krp
*lttng_krp
=
277 container_of(kref
, struct lttng_krp
, kref_alloc
);
278 kfree(lttng_krp
->krp
.kp
.symbol_name
);
281 void lttng_kretprobes_destroy_private(struct lttng_kernel_event_common
*event
)
283 kfree(event
->priv
->desc
->event_name
);
284 kfree(event
->priv
->desc
);
285 kref_put(&event
->priv
->u
.kretprobe
.lttng_krp
->kref_alloc
,
286 _lttng_kretprobes_release
);
288 EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private
);
290 int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_common
*event
,
293 struct lttng_kernel_event_common
*event_exit
;
294 struct lttng_krp
*lttng_krp
;
296 if (event
->priv
->instrumentation
!= LTTNG_KERNEL_ABI_KRETPROBE
) {
299 if (event
->enabled
== enable
) {
302 lttng_krp
= event
->priv
->u
.kretprobe
.lttng_krp
;
303 event_exit
= lttng_krp
->event
[EVENT_EXIT
];
304 WRITE_ONCE(event
->enabled
, enable
);
305 WRITE_ONCE(event_exit
->enabled
, enable
);
308 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state
);
310 MODULE_LICENSE("GPL and additional rights");
311 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
312 MODULE_DESCRIPTION("LTTng kretprobes probes");
313 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
314 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
315 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
316 LTTNG_MODULES_EXTRAVERSION
);