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 RETURN */
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_event_container
*container
= event
->container
;
50 unsigned long parent_ip
;
53 if (unlikely(!LTTNG_READ_ONCE(container
->session
->active
)))
55 if (unlikely(!LTTNG_READ_ONCE(container
->enabled
)))
57 if (unlikely(!LTTNG_READ_ONCE(event
->enabled
)))
60 switch (container
->type
) {
61 case LTTNG_EVENT_CONTAINER_CHANNEL
:
63 struct lttng_channel
*chan
= lttng_event_container_get_channel(container
);
64 struct lib_ring_buffer_ctx ctx
;
66 payload
.ip
= (unsigned long) lttng_get_kretprobe(krpi
)->kp
.addr
;
67 payload
.parent_ip
= (unsigned long) krpi
->ret_addr
;
69 lib_ring_buffer_ctx_init(&ctx
, chan
->chan
, <tng_probe_ctx
, sizeof(payload
),
70 lttng_alignof(payload
), -1);
71 ret
= chan
->ops
->event_reserve(&ctx
, event
->id
);
74 lib_ring_buffer_align_ctx(&ctx
, lttng_alignof(payload
));
75 chan
->ops
->event_write(&ctx
, &payload
, sizeof(payload
));
76 chan
->ops
->event_commit(&ctx
);
79 case LTTNG_EVENT_CONTAINER_COUNTER
:
81 struct lttng_counter
*counter
= lttng_event_container_get_counter(container
);
82 size_t index
= event
->id
;
84 (void) counter
->ops
->counter_add(counter
->counter
, &index
, 1);
92 int lttng_kretprobes_handler_entry(struct kretprobe_instance
*krpi
,
95 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_ENTRY
);
99 int lttng_kretprobes_handler_return(struct kretprobe_instance
*krpi
,
100 struct pt_regs
*regs
)
102 return _lttng_kretprobes_handler(krpi
, regs
, EVENT_RETURN
);
106 * Create event description
109 int lttng_create_kprobe_event(const char *name
, struct lttng_event
*event
,
110 enum lttng_kretprobe_type type
)
112 struct lttng_event_field
*fields
;
113 struct lttng_event_desc
*desc
;
117 const char *suffix
= NULL
;
119 desc
= kzalloc(sizeof(*event
->desc
), GFP_KERNEL
);
122 name_len
= strlen(name
);
131 name_len
+= strlen(suffix
);
132 alloc_name
= kmalloc(name_len
+ 1, GFP_KERNEL
);
137 strcpy(alloc_name
, name
);
138 strcat(alloc_name
, suffix
);
139 desc
->name
= alloc_name
;
141 desc
->fields
= fields
=
142 kzalloc(2 * sizeof(struct lttng_event_field
), GFP_KERNEL
);
147 fields
[0].name
= "ip";
148 fields
[0].type
.atype
= atype_integer
;
149 fields
[0].type
.u
.integer
.size
= sizeof(unsigned long) * CHAR_BIT
;
150 fields
[0].type
.u
.integer
.alignment
= lttng_alignof(unsigned long) * CHAR_BIT
;
151 fields
[0].type
.u
.integer
.signedness
= lttng_is_signed_type(unsigned long);
152 fields
[0].type
.u
.integer
.reverse_byte_order
= 0;
153 fields
[0].type
.u
.integer
.base
= 16;
154 fields
[0].type
.u
.integer
.encoding
= lttng_encode_none
;
156 fields
[1].name
= "parent_ip";
157 fields
[1].type
.atype
= atype_integer
;
158 fields
[1].type
.u
.integer
.size
= sizeof(unsigned long) * CHAR_BIT
;
159 fields
[1].type
.u
.integer
.alignment
= lttng_alignof(unsigned long) * CHAR_BIT
;
160 fields
[1].type
.u
.integer
.signedness
= lttng_is_signed_type(unsigned long);
161 fields
[1].type
.u
.integer
.reverse_byte_order
= 0;
162 fields
[1].type
.u
.integer
.base
= 16;
163 fields
[1].type
.u
.integer
.encoding
= lttng_encode_none
;
165 desc
->owner
= THIS_MODULE
;
177 int lttng_kretprobes_register(const char *name
,
178 const char *symbol_name
,
181 struct lttng_event
*event_entry
,
182 struct lttng_event
*event_return
)
185 struct lttng_krp
*lttng_krp
;
187 /* Kprobes expects a NULL symbol name if unused */
188 if (symbol_name
[0] == '\0')
191 ret
= lttng_create_kprobe_event(name
, event_entry
, EVENT_ENTRY
);
194 ret
= lttng_create_kprobe_event(name
, event_return
, EVENT_RETURN
);
196 goto event_return_error
;
197 lttng_krp
= kzalloc(sizeof(*lttng_krp
), GFP_KERNEL
);
200 lttng_krp
->krp
.entry_handler
= lttng_kretprobes_handler_entry
;
201 lttng_krp
->krp
.handler
= lttng_kretprobes_handler_return
;
205 alloc_symbol
= kstrdup(symbol_name
, GFP_KERNEL
);
210 lttng_krp
->krp
.kp
.symbol_name
=
212 event_entry
->u
.kretprobe
.symbol_name
=
214 event_return
->u
.kretprobe
.symbol_name
=
217 lttng_krp
->krp
.kp
.offset
= offset
;
218 lttng_krp
->krp
.kp
.addr
= (void *) (unsigned long) addr
;
220 /* Allow probe handler to find event structures */
221 lttng_krp
->event
[EVENT_ENTRY
] = event_entry
;
222 lttng_krp
->event
[EVENT_RETURN
] = event_return
;
223 event_entry
->u
.kretprobe
.lttng_krp
= lttng_krp
;
224 event_return
->u
.kretprobe
.lttng_krp
= lttng_krp
;
227 * Both events must be unregistered before the kretprobe is
228 * unregistered. Same for memory allocation.
230 kref_init(<tng_krp
->kref_alloc
);
231 kref_get(<tng_krp
->kref_alloc
); /* inc refcount to 2, no overflow. */
232 kref_init(<tng_krp
->kref_register
);
233 kref_get(<tng_krp
->kref_register
); /* inc refcount to 2, no overflow. */
236 * Ensure the memory we just allocated don't trigger page faults.
237 * Well.. kprobes itself puts the page fault handler on the blacklist,
238 * but we can never be too careful.
240 wrapper_vmalloc_sync_mappings();
242 ret
= register_kretprobe(<tng_krp
->krp
);
248 kfree(lttng_krp
->krp
.kp
.symbol_name
);
252 kfree(event_return
->desc
->fields
);
253 kfree(event_return
->desc
->name
);
254 kfree(event_return
->desc
);
256 kfree(event_entry
->desc
->fields
);
257 kfree(event_entry
->desc
->name
);
258 kfree(event_entry
->desc
);
262 EXPORT_SYMBOL_GPL(lttng_kretprobes_register
);
265 void _lttng_kretprobes_unregister_release(struct kref
*kref
)
267 struct lttng_krp
*lttng_krp
=
268 container_of(kref
, struct lttng_krp
, kref_register
);
269 unregister_kretprobe(<tng_krp
->krp
);
272 void lttng_kretprobes_unregister(struct lttng_event
*event
)
274 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_register
,
275 _lttng_kretprobes_unregister_release
);
277 EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister
);
280 void _lttng_kretprobes_release(struct kref
*kref
)
282 struct lttng_krp
*lttng_krp
=
283 container_of(kref
, struct lttng_krp
, kref_alloc
);
284 kfree(lttng_krp
->krp
.kp
.symbol_name
);
287 void lttng_kretprobes_destroy_private(struct lttng_event
*event
)
289 kfree(event
->desc
->fields
);
290 kfree(event
->desc
->name
);
292 kref_put(&event
->u
.kretprobe
.lttng_krp
->kref_alloc
,
293 _lttng_kretprobes_release
);
295 EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private
);
297 int lttng_kretprobes_event_enable_state(struct lttng_event
*event
,
300 struct lttng_event
*event_return
;
301 struct lttng_krp
*lttng_krp
;
303 if (event
->instrumentation
!= LTTNG_KERNEL_KRETPROBE
) {
306 if (event
->enabled
== enable
) {
309 lttng_krp
= event
->u
.kretprobe
.lttng_krp
;
310 event_return
= lttng_krp
->event
[EVENT_RETURN
];
311 WRITE_ONCE(event
->enabled
, enable
);
312 WRITE_ONCE(event_return
->enabled
, enable
);
315 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state
);
317 MODULE_LICENSE("GPL and additional rights");
318 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
319 MODULE_DESCRIPTION("LTTng kretprobes probes");
320 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
321 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
322 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
323 LTTNG_MODULES_EXTRAVERSION
);