1 /* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only)
3 * probes/lttng-uprobes.c
5 * LTTng uprobes integration module.
7 * Copyright (C) 2013 Yannick Brosseau <yannick.brosseau@gmail.com>
8 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 #include <wrapper/fdtable.h>
13 #include <linux/list.h>
14 #include <linux/module.h>
15 #include <linux/namei.h>
16 #include <linux/slab.h>
17 #include <linux/uaccess.h>
18 #include <lttng/events.h>
19 #include <lttng/events-internal.h>
20 #include <lttng/tracer.h>
21 #include <wrapper/irqflags.h>
22 #include <ringbuffer/frontend_types.h>
23 #include <wrapper/uprobes.h>
24 #include <wrapper/vmalloc.h>
27 int lttng_uprobes_event_handler_pre(struct uprobe_consumer
*uc
, struct pt_regs
*regs
)
29 struct lttng_uprobe_handler
*uprobe_handler
=
30 container_of(uc
, struct lttng_uprobe_handler
, up_consumer
);
31 struct lttng_kernel_event_common
*event
= uprobe_handler
->event
;
32 struct lttng_kernel_probe_ctx lttng_probe_ctx
= {
34 .interruptible
= !lttng_regs_irqs_disabled(regs
),
40 switch (event
->type
) {
41 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
43 struct lttng_kernel_event_recorder
*event_recorder
=
44 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
45 struct lttng_channel
*chan
= event_recorder
->chan
;
47 if (unlikely(!LTTNG_READ_ONCE(chan
->session
->active
)))
49 if (unlikely(!LTTNG_READ_ONCE(chan
->enabled
)))
53 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
59 if (unlikely(!LTTNG_READ_ONCE(event
->enabled
)))
62 switch (event
->type
) {
63 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
65 struct lttng_kernel_event_recorder
*event_recorder
=
66 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
67 struct lttng_channel
*chan
= event_recorder
->chan
;
68 struct lib_ring_buffer_ctx ctx
;
71 lib_ring_buffer_ctx_init(&ctx
, event_recorder
,
72 sizeof(payload
), lttng_alignof(payload
), <tng_probe_ctx
);
74 ret
= chan
->ops
->event_reserve(&ctx
);
79 payload
.ip
= (unsigned long)instruction_pointer(regs
);
81 lib_ring_buffer_align_ctx(&ctx
, lttng_alignof(payload
));
82 chan
->ops
->event_write(&ctx
, &payload
, sizeof(payload
));
83 chan
->ops
->event_commit(&ctx
);
86 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
88 struct lttng_kernel_event_notifier
*event_notifier
=
89 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
90 struct lttng_kernel_notification_ctx notif_ctx
;
92 notif_ctx
.eval_capture
= LTTNG_READ_ONCE(event_notifier
->eval_capture
);
93 event_notifier
->notification_send(event_notifier
, NULL
, NULL
, ¬if_ctx
);
102 static const struct lttng_kernel_type_common
*event_type
=
103 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16);
106 * Create event description.
109 int lttng_create_uprobe_event(const char *name
, struct lttng_kernel_event_recorder
*event_recorder
)
111 const struct lttng_kernel_event_field
**fieldp_array
;
112 struct lttng_kernel_event_field
*field
;
113 struct lttng_kernel_event_desc
*desc
;
116 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
119 desc
->event_name
= kstrdup(name
, GFP_KERNEL
);
120 if (!desc
->event_name
) {
125 fieldp_array
= kzalloc(1 * sizeof(struct lttng_kernel_event_field
*), GFP_KERNEL
);
128 goto error_fieldp_array
;
130 desc
->fields
= fieldp_array
;
131 desc
->fields
[0] = field
=
132 kzalloc(sizeof(struct lttng_kernel_event_field
), GFP_KERNEL
);
138 field
->type
= event_type
;
139 desc
->owner
= THIS_MODULE
;
140 event_recorder
->priv
->parent
.desc
= desc
;
147 kfree(desc
->event_name
);
154 * Create event_notifier description.
157 int lttng_create_uprobe_event_notifier(const char *name
, struct lttng_kernel_event_notifier
*event_notifier
)
159 struct lttng_kernel_event_desc
*desc
;
162 desc
= kzalloc(sizeof(*desc
), GFP_KERNEL
);
165 desc
->event_name
= kstrdup(name
, GFP_KERNEL
);
166 if (!desc
->event_name
) {
173 desc
->owner
= THIS_MODULE
;
174 event_notifier
->priv
->parent
.desc
= desc
;
184 * Returns the inode struct from the current task and an fd. The inode is
185 * grabbed by this function and must be put once we are done with it using
188 static struct inode
*get_inode_from_fd(int fd
)
195 * Returns the file backing the given fd. Needs to be done inside an RCU
198 file
= lttng_lookup_fd_rcu(fd
);
200 printk(KERN_WARNING
"LTTng: Cannot access file backing the fd(%d)\n", fd
);
205 /* Grab a reference on the inode. */
206 inode
= igrab(file
->f_path
.dentry
->d_inode
);
208 printk(KERN_WARNING
"LTTng: Cannot grab a reference on the inode.\n");
216 int lttng_uprobes_add_callsite(struct lttng_uprobe
*uprobe
,
217 struct lttng_kernel_abi_event_callsite __user
*callsite
,
218 int (*handler
)(struct uprobe_consumer
*self
, struct pt_regs
*regs
),
222 struct lttng_uprobe_handler
*uprobe_handler
;
229 uprobe_handler
= kzalloc(sizeof(struct lttng_uprobe_handler
), GFP_KERNEL
);
230 if (!uprobe_handler
) {
231 printk(KERN_WARNING
"LTTng: Error allocating uprobe_handler");
236 /* Ensure the memory we just allocated don't notify page faults. */
237 wrapper_vmalloc_sync_mappings();
239 uprobe_handler
->event
= priv_data
;
240 uprobe_handler
->up_consumer
.handler
= handler
;
242 ret
= copy_from_user(&uprobe_handler
->offset
, &callsite
->u
.uprobe
.offset
, sizeof(uint64_t));
247 ret
= wrapper_uprobe_register(uprobe
->inode
,
248 uprobe_handler
->offset
, &uprobe_handler
->up_consumer
);
250 printk(KERN_WARNING
"LTTng: Error registering probe on inode %lu "
251 "and offset 0x%llx\n", uprobe
->inode
->i_ino
,
252 uprobe_handler
->offset
);
257 list_add(&uprobe_handler
->node
, &uprobe
->head
);
262 kfree(uprobe_handler
);
267 int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_common
*event
,
268 struct lttng_kernel_abi_event_callsite __user
*callsite
)
270 return lttng_uprobes_add_callsite(&event
->priv
->u
.uprobe
, callsite
,
271 lttng_uprobes_event_handler_pre
, event
);
273 EXPORT_SYMBOL_GPL(lttng_uprobes_event_add_callsite
);
276 int lttng_uprobes_register(struct lttng_uprobe
*uprobe
, int fd
)
281 inode
= get_inode_from_fd(fd
);
283 printk(KERN_WARNING
"LTTng: Cannot get inode from fd\n");
287 uprobe
->inode
= inode
;
288 INIT_LIST_HEAD(&uprobe
->head
);
294 int lttng_uprobes_register_event(const char *name
, int fd
, struct lttng_kernel_event_recorder
*event_recorder
)
298 ret
= lttng_create_uprobe_event(name
, event_recorder
);
302 ret
= lttng_uprobes_register(&event_recorder
->priv
->parent
.u
.uprobe
, fd
);
309 kfree(event_recorder
->priv
->parent
.desc
->event_name
);
310 kfree(event_recorder
->priv
->parent
.desc
);
314 EXPORT_SYMBOL_GPL(lttng_uprobes_register_event
);
316 int lttng_uprobes_register_event_notifier(const char *name
, int fd
,
317 struct lttng_kernel_event_notifier
*event_notifier
)
321 ret
= lttng_create_uprobe_event_notifier(name
, event_notifier
);
325 ret
= lttng_uprobes_register(&event_notifier
->priv
->parent
.u
.uprobe
, fd
);
332 kfree(event_notifier
->priv
->parent
.desc
->event_name
);
333 kfree(event_notifier
->priv
->parent
.desc
);
337 EXPORT_SYMBOL_GPL(lttng_uprobes_register_event_notifier
);
340 void lttng_uprobes_unregister(struct inode
*inode
, struct list_head
*head
)
342 struct lttng_uprobe_handler
*iter
, *tmp
;
345 * Iterate over the list of handler, remove each handler from the list
346 * and free the struct.
348 list_for_each_entry_safe(iter
, tmp
, head
, node
) {
349 wrapper_uprobe_unregister(inode
, iter
->offset
, &iter
->up_consumer
);
350 list_del(&iter
->node
);
355 void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder
*event_recorder
)
357 lttng_uprobes_unregister(event_recorder
->priv
->parent
.u
.uprobe
.inode
, &event_recorder
->priv
->parent
.u
.uprobe
.head
);
359 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event
);
361 void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier
*event_notifier
)
363 lttng_uprobes_unregister(event_notifier
->priv
->parent
.u
.uprobe
.inode
, &event_notifier
->priv
->parent
.u
.uprobe
.head
);
365 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier
);
367 void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder
*event_recorder
)
369 iput(event_recorder
->priv
->parent
.u
.uprobe
.inode
);
370 kfree(event_recorder
->priv
->parent
.desc
->fields
[0]);
371 kfree(event_recorder
->priv
->parent
.desc
->fields
);
372 kfree(event_recorder
->priv
->parent
.desc
->event_name
);
373 kfree(event_recorder
->priv
->parent
.desc
);
375 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private
);
377 void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier
*event_notifier
)
379 iput(event_notifier
->priv
->parent
.u
.uprobe
.inode
);
380 kfree(event_notifier
->priv
->parent
.desc
->event_name
);
381 kfree(event_notifier
->priv
->parent
.desc
);
383 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private
);
385 MODULE_LICENSE("GPL and additional rights");
386 MODULE_AUTHOR("Yannick Brosseau");
387 MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support");