1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
3 * probes/lttng-kprobes.c
5 * LTTng kprobes 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 <lttng/events.h>
14 #include <lttng/events-internal.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>
22 int lttng_kprobes_event_handler_pre(struct kprobe
*p
, struct pt_regs
*regs
)
24 struct lttng_kernel_event_common_private
*event_priv
=
25 container_of(p
, struct lttng_kernel_event_common_private
, u
.kprobe
.kp
);
26 struct lttng_kernel_event_recorder_private
*event_recorder_priv
=
27 container_of(event_priv
, struct lttng_kernel_event_recorder_private
, parent
);
28 struct lttng_kernel_event_recorder
*event_recorder
=
29 event_recorder_priv
->pub
;
30 struct lttng_probe_ctx lttng_probe_ctx
= {
31 .event
= event_recorder
,
32 .interruptible
= !lttng_regs_irqs_disabled(regs
),
34 struct lttng_channel
*chan
= event_recorder
->chan
;
35 struct lib_ring_buffer_ctx ctx
;
37 unsigned long data
= (unsigned long) p
->addr
;
39 if (unlikely(!LTTNG_READ_ONCE(chan
->session
->active
)))
41 if (unlikely(!LTTNG_READ_ONCE(chan
->enabled
)))
43 if (unlikely(!LTTNG_READ_ONCE(event_recorder
->parent
.enabled
)))
46 lib_ring_buffer_ctx_init(&ctx
, chan
->chan
, <tng_probe_ctx
, sizeof(data
),
47 lttng_alignof(data
), -1);
48 ret
= chan
->ops
->event_reserve(&ctx
, event_recorder
->priv
->id
);
51 lib_ring_buffer_align_ctx(&ctx
, lttng_alignof(data
));
52 chan
->ops
->event_write(&ctx
, &data
, sizeof(data
));
53 chan
->ops
->event_commit(&ctx
);
58 int lttng_kprobes_event_notifier_handler_pre(struct kprobe
*p
, struct pt_regs
*regs
)
60 struct lttng_kernel_event_common_private
*event_priv
=
61 container_of(p
, struct lttng_kernel_event_common_private
, u
.kprobe
.kp
);
62 struct lttng_kernel_event_notifier_private
*event_notifier_priv
=
63 container_of(event_priv
, struct lttng_kernel_event_notifier_private
, parent
);
64 struct lttng_kernel_event_notifier
*event_notifier
=
65 event_notifier_priv
->pub
;
66 struct lttng_kernel_notification_ctx notif_ctx
;
68 if (unlikely(!READ_ONCE(event_notifier
->parent
.enabled
)))
71 notif_ctx
.eval_capture
= LTTNG_READ_ONCE(event_notifier
->eval_capture
);
72 event_notifier
->notification_send(event_notifier
, NULL
, NULL
, ¬if_ctx
);
77 static const struct lttng_kernel_type_common
*event_type
=
78 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16);
81 * Create event description
84 int lttng_create_kprobe_event(const char *name
, struct lttng_kernel_event_recorder
*event_recorder
)
86 const struct lttng_kernel_event_field
**fieldp_array
;
87 struct lttng_kernel_event_field
*field
;
88 struct lttng_kernel_event_desc
*desc
;
91 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
94 desc
->event_name
= kstrdup(name
, GFP_KERNEL
);
95 if (!desc
->event_name
) {
100 fieldp_array
= kzalloc(1 * sizeof(struct lttng_kernel_event_field
*), GFP_KERNEL
);
103 goto error_fieldp_array
;
105 desc
->fields
= fieldp_array
;
106 desc
->fields
[0] = field
=
107 kzalloc(sizeof(struct lttng_kernel_event_field
), GFP_KERNEL
);
113 field
->type
= event_type
;
114 desc
->owner
= THIS_MODULE
;
115 event_recorder
->priv
->parent
.desc
= desc
;
122 kfree(desc
->event_name
);
129 * Create event_notifier description
132 int lttng_create_kprobe_event_notifier(const char *name
, struct lttng_kernel_event_notifier
*event_notifier
)
134 struct lttng_kernel_event_desc
*desc
;
137 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
140 desc
->event_name
= kstrdup(name
, GFP_KERNEL
);
141 if (!desc
->event_name
) {
147 desc
->owner
= THIS_MODULE
;
148 event_notifier
->priv
->parent
.desc
= desc
;
158 int _lttng_kprobes_register(const char *symbol_name
,
161 struct lttng_kprobe
*lttng_kp
,
162 kprobe_pre_handler_t pre_handler
)
166 /* Kprobes expects a NULL symbol name if unused */
167 if (symbol_name
[0] == '\0')
170 memset(<tng_kp
->kp
, 0, sizeof(lttng_kp
->kp
));
171 lttng_kp
->kp
.pre_handler
= pre_handler
;
174 lttng_kp
->symbol_name
=
175 kzalloc(LTTNG_KERNEL_ABI_SYM_NAME_LEN
* sizeof(char),
177 if (!lttng_kp
->symbol_name
) {
181 memcpy(lttng_kp
->symbol_name
, symbol_name
,
182 LTTNG_KERNEL_ABI_SYM_NAME_LEN
* sizeof(char));
183 lttng_kp
->kp
.symbol_name
= lttng_kp
->symbol_name
;
186 lttng_kp
->kp
.offset
= offset
;
187 lttng_kp
->kp
.addr
= (void *) (unsigned long) addr
;
190 * Ensure the memory we just allocated don't notify page faults.
191 * Well.. kprobes itself puts the page fault handler on the blacklist,
192 * but we can never be too careful.
194 wrapper_vmalloc_sync_mappings();
196 ret
= register_kprobe(<tng_kp
->kp
);
203 kfree(lttng_kp
->symbol_name
);
208 int lttng_kprobes_register_event(const char *name
,
209 const char *symbol_name
,
212 struct lttng_kernel_event_recorder
*event_recorder
)
216 ret
= lttng_create_kprobe_event(name
, event_recorder
);
220 ret
= _lttng_kprobes_register(symbol_name
, offset
, addr
,
221 &event_recorder
->priv
->parent
.u
.kprobe
, lttng_kprobes_event_handler_pre
);
228 kfree(event_recorder
->priv
->parent
.desc
->fields
);
229 kfree(event_recorder
->priv
->parent
.desc
->event_name
);
230 kfree(event_recorder
->priv
->parent
.desc
);
234 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event
);
236 int lttng_kprobes_register_event_notifier(const char *symbol_name
,
239 struct lttng_kernel_event_notifier
*event_notifier
)
242 ret
= lttng_create_kprobe_event_notifier(symbol_name
, event_notifier
);
246 ret
= _lttng_kprobes_register(symbol_name
, offset
, addr
,
247 &event_notifier
->priv
->parent
.u
.kprobe
, lttng_kprobes_event_notifier_handler_pre
);
254 kfree(event_notifier
->priv
->parent
.desc
->event_name
);
255 kfree(event_notifier
->priv
->parent
.desc
);
259 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event_notifier
);
261 void lttng_kprobes_unregister_event(struct lttng_kernel_event_recorder
*event_recorder
)
263 unregister_kprobe(&event_recorder
->priv
->parent
.u
.kprobe
.kp
);
265 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event
);
267 void lttng_kprobes_unregister_event_notifier(struct lttng_kernel_event_notifier
*event_notifier
)
269 unregister_kprobe(&event_notifier
->priv
->parent
.u
.kprobe
.kp
);
271 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event_notifier
);
273 void lttng_kprobes_destroy_event_private(struct lttng_kernel_event_recorder
*event_recorder
)
275 kfree(event_recorder
->priv
->parent
.u
.kprobe
.symbol_name
);
276 kfree(event_recorder
->priv
->parent
.desc
->fields
[0]);
277 kfree(event_recorder
->priv
->parent
.desc
->fields
);
278 kfree(event_recorder
->priv
->parent
.desc
->event_name
);
279 kfree(event_recorder
->priv
->parent
.desc
);
281 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_private
);
283 void lttng_kprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier
*event_notifier
)
285 kfree(event_notifier
->priv
->parent
.u
.kprobe
.symbol_name
);
286 kfree(event_notifier
->priv
->parent
.desc
->event_name
);
287 kfree(event_notifier
->priv
->parent
.desc
);
289 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_notifier_private
);
291 MODULE_LICENSE("GPL and additional rights");
292 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
293 MODULE_DESCRIPTION("LTTng kprobes probes");
294 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
295 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
296 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
297 LTTNG_MODULES_EXTRAVERSION
);