[lttng-modules.git] / src / probes / lttng-uprobes.c

/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only)
 *
 * probes/lttng-uprobes.c
 *
 * LTTng uprobes integration module.
 *
 * Copyright (C) 2013 Yannick Brosseau <yannick.brosseau@gmail.com>
 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 */

#include <wrapper/fdtable.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/namei.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <lttng/events.h>
#include <lttng/tracer.h>
#include <wrapper/irqflags.h>
#include <ringbuffer/frontend_types.h>
#include <wrapper/uprobes.h>
#include <wrapper/vmalloc.h>

static
int lttng_uprobes_event_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
{
	struct lttng_uprobe_handler *uprobe_handler =
		container_of(uc, struct lttng_uprobe_handler, up_consumer);
	struct lttng_event *event = uprobe_handler->u.event;
	struct lttng_probe_ctx lttng_probe_ctx = {
		.event = event,
		.interruptible = !lttng_regs_irqs_disabled(regs),
	};
	struct lttng_channel *chan = event->chan;
	struct lib_ring_buffer_ctx ctx;
	int ret;

	struct {
		unsigned long ip;
	} payload;

	if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
		return 0;
	if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
		return 0;
	if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
		return 0;

	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
		sizeof(payload), lttng_alignof(payload), -1);

	ret = chan->ops->event_reserve(&ctx, event->id);
	if (ret < 0)
		return 0;

	/* Event payload. */
	payload.ip = (unsigned long)instruction_pointer(regs);

	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	chan->ops->event_commit(&ctx);
	return 0;
}

static
int lttng_uprobes_event_notifier_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
{
	struct lttng_uprobe_handler *uprobe_handler =
		container_of(uc, struct lttng_uprobe_handler, up_consumer);
	struct lttng_event_notifier *event_notifier = uprobe_handler->u.event_notifier;
	struct lttng_kernel_notifier_ctx notif_ctx;

	if (unlikely(!READ_ONCE(event_notifier->enabled)))
		return 0;

	notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
	event_notifier->send_notification(event_notifier, NULL, NULL, &notif_ctx);
	return 0;
}

static const struct lttng_kernel_type_common *event_type =
	lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);

/*
 * Create event description.
 */
static
int lttng_create_uprobe_event(const char *name, struct lttng_event *event)
{
	const struct lttng_kernel_event_field **fieldp_array;
	struct lttng_kernel_event_field *field;
	struct lttng_kernel_event_desc *desc;
	int ret;

	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
	if (!desc)
		return -ENOMEM;
	desc->event_name = kstrdup(name, GFP_KERNEL);
	if (!desc->event_name) {
		ret = -ENOMEM;
		goto error_str;
	}
	desc->nr_fields = 1;
	fieldp_array = kzalloc(1 * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
	if (!fieldp_array) {
		ret = -ENOMEM;
		goto error_fieldp_array;
	}
	desc->fields = fieldp_array;
	desc->fields[0] = field =
		kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	if (!field) {
		ret = -ENOMEM;
		goto error_field;
	}
	field->name = "ip";
	field->type = event_type;
	desc->owner = THIS_MODULE;
	event->desc = desc;

	return 0;

error_field:
	kfree(fieldp_array);
error_fieldp_array:
	kfree(desc->event_name);
error_str:
	kfree(desc);
	return ret;
}

/*
 * Create event_notifier description.
 */
static
int lttng_create_uprobe_event_notifier(const char *name, struct lttng_event_notifier *event_notifier)
{
	struct lttng_kernel_event_desc *desc;
	int ret;

	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
	if (!desc)
		return -ENOMEM;
	desc->event_name = kstrdup(name, GFP_KERNEL);
	if (!desc->event_name) {
		ret = -ENOMEM;
		goto error_str;
	}

	desc->nr_fields = 0;

	desc->owner = THIS_MODULE;
	event_notifier->desc = desc;

	return 0;

error_str:
	kfree(desc);
	return ret;
}

/*
 * Returns the inode struct from the current task and an fd. The inode is
 * grabbed by this function and must be put once we are done with it using
 * iput().
 */
static struct inode *get_inode_from_fd(int fd)
{
	struct file *file;
	struct inode *inode;

	rcu_read_lock();
	/*
	 * Returns the file backing the given fd. Needs to be done inside an RCU
	 * critical section.
	 */
	file = lttng_lookup_fd_rcu(fd);
	if (file == NULL) {
		printk(KERN_WARNING "LTTng: Cannot access file backing the fd(%d)\n", fd);
		inode = NULL;
		goto error;
	}

	/* Grab a reference on the inode. */
	inode = igrab(file->f_path.dentry->d_inode);
	if (inode == NULL)
		printk(KERN_WARNING "LTTng: Cannot grab a reference on the inode.\n");
error:
	rcu_read_unlock();
	return inode;
}


static
int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
	struct lttng_kernel_event_callsite __user *callsite,
	int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs),
	void *priv_data)
{
	int ret = 0;
	struct lttng_uprobe_handler *uprobe_handler;

	if (!priv_data) {
		ret = -EINVAL;
		goto end;
	}

	uprobe_handler = kzalloc(sizeof(struct lttng_uprobe_handler), GFP_KERNEL);
	if (!uprobe_handler) {
		printk(KERN_WARNING "LTTng: Error allocating uprobe_handler");
		ret = -ENOMEM;
		goto end;
	}

	/* Ensure the memory we just allocated don't notify page faults. */
	wrapper_vmalloc_sync_mappings();

	uprobe_handler->u.event = priv_data;
	uprobe_handler->up_consumer.handler = handler;

	ret = copy_from_user(&uprobe_handler->offset, &callsite->u.uprobe.offset, sizeof(uint64_t));
	if (ret) {
		goto register_error;
	}

	ret = wrapper_uprobe_register(uprobe->inode,
		      uprobe_handler->offset, &uprobe_handler->up_consumer);
	if (ret) {
		printk(KERN_WARNING "LTTng: Error registering probe on inode %lu "
		       "and offset 0x%llx\n", uprobe->inode->i_ino,
		       uprobe_handler->offset);
		ret = -1;
		goto register_error;
	}

	list_add(&uprobe_handler->node, &uprobe->head);

	return ret;

register_error:
	kfree(uprobe_handler);
end:
	return ret;
}

int lttng_uprobes_event_add_callsite(struct lttng_event *event,
	struct lttng_kernel_event_callsite __user *callsite)
{
	return lttng_uprobes_add_callsite(&event->u.uprobe, callsite,
		lttng_uprobes_event_handler_pre, event);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_event_add_callsite);

int lttng_uprobes_event_notifier_add_callsite(struct lttng_event_notifier *event_notifier,
	struct lttng_kernel_event_callsite __user *callsite)
{
	return lttng_uprobes_add_callsite(&event_notifier->u.uprobe, callsite,
		lttng_uprobes_event_notifier_handler_pre, event_notifier);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_event_notifier_add_callsite);

static
int lttng_uprobes_register(struct lttng_uprobe *uprobe, int fd)
{
	int ret = 0;
	struct inode *inode;

	inode = get_inode_from_fd(fd);
	if (!inode) {
		printk(KERN_WARNING "LTTng: Cannot get inode from fd\n");
		ret = -EBADF;
		goto inode_error;
	}
	uprobe->inode = inode;
	INIT_LIST_HEAD(&uprobe->head);

inode_error:
	return ret;
}

int lttng_uprobes_register_event(const char *name, int fd, struct lttng_event *event)
{
	int ret = 0;

	ret = lttng_create_uprobe_event(name, event);
	if (ret)
		goto error;

	ret = lttng_uprobes_register(&event->u.uprobe, fd);
	if (ret)
		goto register_error;

	return 0;

register_error:
	kfree(event->desc->event_name);
	kfree(event->desc);
error:
	return ret;
}
EXPORT_SYMBOL_GPL(lttng_uprobes_register_event);

int lttng_uprobes_register_event_notifier(const char *name, int fd,
		struct lttng_event_notifier *event_notifier)
{
	int ret = 0;

	ret = lttng_create_uprobe_event_notifier(name, event_notifier);
	if (ret)
		goto error;

	ret = lttng_uprobes_register(&event_notifier->u.uprobe, fd);
	if (ret)
		goto register_error;

	return 0;

register_error:
	kfree(event_notifier->desc->event_name);
	kfree(event_notifier->desc);
error:
	return ret;
}
EXPORT_SYMBOL_GPL(lttng_uprobes_register_event_notifier);

static
void lttng_uprobes_unregister(struct inode *inode, struct list_head *head)
{
	struct lttng_uprobe_handler *iter, *tmp;

	/*
	 * Iterate over the list of handler, remove each handler from the list
	 * and free the struct.
	 */
	list_for_each_entry_safe(iter, tmp, head, node) {
		wrapper_uprobe_unregister(inode, iter->offset, &iter->up_consumer);
		list_del(&iter->node);
		kfree(iter);
	}

}

void lttng_uprobes_unregister_event(struct lttng_event *event)
{
	lttng_uprobes_unregister(event->u.uprobe.inode, &event->u.uprobe.head);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event);

void lttng_uprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier)
{
	lttng_uprobes_unregister(event_notifier->u.uprobe.inode, &event_notifier->u.uprobe.head);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier);

void lttng_uprobes_destroy_event_private(struct lttng_event *event)
{
	iput(event->u.uprobe.inode);
	kfree(event->desc->fields[0]);
	kfree(event->desc->fields);
	kfree(event->desc->event_name);
	kfree(event->desc);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private);

void lttng_uprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier)
{
	iput(event_notifier->u.uprobe.inode);
	kfree(event_notifier->desc->event_name);
	kfree(event_notifier->desc);
}
EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private);

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Yannick Brosseau");
MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support");
Commit	Line	Data
b7cdc182	1	/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only)
8134eb60	2	*
149b9a9d YB	3	* probes/lttng-uprobes.c
	4	*
	5	* LTTng uprobes integration module.
	6	*
	7	* Copyright (C) 2013 Yannick Brosseau <yannick.brosseau@gmail.com>
	8	* Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	9	*
149b9a9d YB	10	*/
149b9a9d YB	11
0aebcd68	12	#include <wrapper/fdtable.h>
3aed4dca	13	#include <linux/list.h>
149b9a9d YB	14	#include <linux/module.h>
	15	#include <linux/namei.h>
	16	#include <linux/slab.h>
3aed4dca	17	#include <linux/uaccess.h>
2df37e95 MD	18	#include <lttng/events.h>
2df37e95 MD	19	#include <lttng/tracer.h>
149b9a9d	20	#include <wrapper/irqflags.h>
24591303	21	#include <ringbuffer/frontend_types.h>
149b9a9d YB	22	#include <wrapper/uprobes.h>
	23	#include <wrapper/vmalloc.h>
	24
	25	static
83b802dc	26	int lttng_uprobes_event_handler_pre(struct uprobe_consumer uc, struct pt_regs regs)
149b9a9d	27	{
3aed4dca FD	28	struct lttng_uprobe_handler *uprobe_handler =
3aed4dca FD	29	container_of(uc, struct lttng_uprobe_handler, up_consumer);
83b802dc	30	struct lttng_event *event = uprobe_handler->u.event;
149b9a9d YB	31	struct lttng_probe_ctx lttng_probe_ctx = {
	32	.event = event,
	33	.interruptible = !lttng_regs_irqs_disabled(regs),
	34	};
	35	struct lttng_channel *chan = event->chan;
	36	struct lib_ring_buffer_ctx ctx;
	37	int ret;
	38
	39	struct {
	40	unsigned long ip;
56377c91	41	} payload;
149b9a9d	42
585e5dcc	43	if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
149b9a9d	44	return 0;
585e5dcc	45	if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
149b9a9d	46	return 0;
585e5dcc	47	if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
149b9a9d YB	48	return 0;
	49
	50	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
	51	sizeof(payload), lttng_alignof(payload), -1);
	52
	53	ret = chan->ops->event_reserve(&ctx, event->id);
	54	if (ret < 0)
	55	return 0;
	56
	57	/* Event payload. */
7445d54f	58	payload.ip = (unsigned long)instruction_pointer(regs);
56377c91	59
149b9a9d YB	60	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	61	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	62	chan->ops->event_commit(&ctx);
	63	return 0;
	64	}
	65
9de67196 FD	66	static
	67	int lttng_uprobes_event_notifier_handler_pre(struct uprobe_consumer uc, struct pt_regs regs)
	68	{
	69	struct lttng_uprobe_handler *uprobe_handler =
	70	container_of(uc, struct lttng_uprobe_handler, up_consumer);
	71	struct lttng_event_notifier *event_notifier = uprobe_handler->u.event_notifier;
c3eddb2e	72	struct lttng_kernel_notifier_ctx notif_ctx;
9de67196 FD	73
	74	if (unlikely(!READ_ONCE(event_notifier->enabled)))
	75	return 0;
	76
c3eddb2e MD	77	notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
c3eddb2e MD	78	event_notifier->send_notification(event_notifier, NULL, NULL, &notif_ctx);
9de67196 FD	79	return 0;
	80	}
	81
437d5aa5 MD	82	static const struct lttng_kernel_type_common *event_type =
	83	lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
	84
149b9a9d YB	85	/*
	86	* Create event description.
	87	*/
	88	static
	89	int lttng_create_uprobe_event(const char name, struct lttng_event event)
	90	{
437d5aa5 MD	91	const struct lttng_kernel_event_field **fieldp_array;
	92	struct lttng_kernel_event_field *field;
	93	struct lttng_kernel_event_desc *desc;
149b9a9d YB	94	int ret;
149b9a9d YB	95
437d5aa5	96	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
149b9a9d YB	97	if (!desc)
149b9a9d YB	98	return -ENOMEM;
437d5aa5 MD	99	desc->event_name = kstrdup(name, GFP_KERNEL);
437d5aa5 MD	100	if (!desc->event_name) {
149b9a9d YB	101	ret = -ENOMEM;
	102	goto error_str;
	103	}
149b9a9d	104	desc->nr_fields = 1;
437d5aa5 MD	105	fieldp_array = kzalloc(1 * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
437d5aa5 MD	106	if (!fieldp_array) {
149b9a9d	107	ret = -ENOMEM;
437d5aa5	108	goto error_fieldp_array;
149b9a9d	109	}
437d5aa5 MD	110	desc->fields = fieldp_array;
	111	desc->fields[0] = field =
	112	kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	113	if (!field) {
	114	ret = -ENOMEM;
	115	goto error_field;
	116	}
	117	field->name = "ip";
	118	field->type = event_type;
149b9a9d YB	119	desc->owner = THIS_MODULE;
	120	event->desc = desc;
	121
	122	return 0;
	123
437d5aa5 MD	124	error_field:
	125	kfree(fieldp_array);
	126	error_fieldp_array:
	127	kfree(desc->event_name);
149b9a9d YB	128	error_str:
	129	kfree(desc);
	130	return ret;
	131	}
	132
9de67196 FD	133	/*
	134	* Create event_notifier description.
	135	*/
	136	static
	137	int lttng_create_uprobe_event_notifier(const char name, struct lttng_event_notifier event_notifier)
	138	{
437d5aa5	139	struct lttng_kernel_event_desc *desc;
9de67196 FD	140	int ret;
9de67196 FD	141
437d5aa5	142	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
9de67196 FD	143	if (!desc)
9de67196 FD	144	return -ENOMEM;
437d5aa5 MD	145	desc->event_name = kstrdup(name, GFP_KERNEL);
437d5aa5 MD	146	if (!desc->event_name) {
9de67196 FD	147	ret = -ENOMEM;
	148	goto error_str;
	149	}
	150
	151	desc->nr_fields = 0;
	152
	153	desc->owner = THIS_MODULE;
	154	event_notifier->desc = desc;
	155
	156	return 0;
	157
	158	error_str:
	159	kfree(desc);
	160	return ret;
	161	}
	162
56377c91 FD	163	/*
	164	* Returns the inode struct from the current task and an fd. The inode is
	165	* grabbed by this function and must be put once we are done with it using
	166	* iput().
	167	*/
	168	static struct inode *get_inode_from_fd(int fd)
	169	{
	170	struct file *file;
	171	struct inode *inode;
	172
	173	rcu_read_lock();
	174	/*
	175	* Returns the file backing the given fd. Needs to be done inside an RCU
	176	* critical section.
	177	*/
0aebcd68	178	file = lttng_lookup_fd_rcu(fd);
56377c91	179	if (file == NULL) {
5a15f70c	180	printk(KERN_WARNING "LTTng: Cannot access file backing the fd(%d)\n", fd);
56377c91 FD	181	inode = NULL;
	182	goto error;
	183	}
	184
	185	/* Grab a reference on the inode. */
	186	inode = igrab(file->f_path.dentry->d_inode);
	187	if (inode == NULL)
5a15f70c	188	printk(KERN_WARNING "LTTng: Cannot grab a reference on the inode.\n");
56377c91 FD	189	error:
	190	rcu_read_unlock();
	191	return inode;
	192	}
	193
83b802dc FD	194
	195	static
	196	int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
	197	struct lttng_kernel_event_callsite __user *callsite,
	198	int (handler)(struct uprobe_consumer self, struct pt_regs *regs),
	199	void *priv_data)
149b9a9d	200	{
3aed4dca FD	201	int ret = 0;
	202	struct lttng_uprobe_handler *uprobe_handler;
	203
83b802dc	204	if (!priv_data) {
3aed4dca FD	205	ret = -EINVAL;
	206	goto end;
	207	}
	208
	209	uprobe_handler = kzalloc(sizeof(struct lttng_uprobe_handler), GFP_KERNEL);
	210	if (!uprobe_handler) {
5a15f70c	211	printk(KERN_WARNING "LTTng: Error allocating uprobe_handler");
3aed4dca FD	212	ret = -ENOMEM;
	213	goto end;
	214	}
	215
196bfc6a	216	/* Ensure the memory we just allocated don't notify page faults. */
263b6c88	217	wrapper_vmalloc_sync_mappings();
3aed4dca	218
83b802dc FD	219	uprobe_handler->u.event = priv_data;
83b802dc FD	220	uprobe_handler->up_consumer.handler = handler;
3aed4dca FD	221
	222	ret = copy_from_user(&uprobe_handler->offset, &callsite->u.uprobe.offset, sizeof(uint64_t));
	223	if (ret) {
	224	goto register_error;
	225	}
	226
83b802dc	227	ret = wrapper_uprobe_register(uprobe->inode,
3aed4dca FD	228	uprobe_handler->offset, &uprobe_handler->up_consumer);
3aed4dca FD	229	if (ret) {
5a15f70c	230	printk(KERN_WARNING "LTTng: Error registering probe on inode %lu "
83b802dc	231	"and offset 0x%llx\n", uprobe->inode->i_ino,
3aed4dca FD	232	uprobe_handler->offset);
	233	ret = -1;
	234	goto register_error;
	235	}
	236
83b802dc	237	list_add(&uprobe_handler->node, &uprobe->head);
3aed4dca FD	238
	239	return ret;
	240
	241	register_error:
	242	kfree(uprobe_handler);
	243	end:
	244	return ret;
	245	}
3aed4dca	246
83b802dc FD	247	int lttng_uprobes_event_add_callsite(struct lttng_event *event,
	248	struct lttng_kernel_event_callsite __user *callsite)
	249	{
	250	return lttng_uprobes_add_callsite(&event->u.uprobe, callsite,
	251	lttng_uprobes_event_handler_pre, event);
	252	}
	253	EXPORT_SYMBOL_GPL(lttng_uprobes_event_add_callsite);
	254
9de67196 FD	255	int lttng_uprobes_event_notifier_add_callsite(struct lttng_event_notifier *event_notifier,
	256	struct lttng_kernel_event_callsite __user *callsite)
	257	{
	258	return lttng_uprobes_add_callsite(&event_notifier->u.uprobe, callsite,
	259	lttng_uprobes_event_notifier_handler_pre, event_notifier);
	260	}
	261	EXPORT_SYMBOL_GPL(lttng_uprobes_event_notifier_add_callsite);
	262
83b802dc FD	263	static
83b802dc FD	264	int lttng_uprobes_register(struct lttng_uprobe *uprobe, int fd)
3aed4dca FD	265	{
3aed4dca FD	266	int ret = 0;
56377c91	267	struct inode *inode;
149b9a9d	268
56377c91 FD	269	inode = get_inode_from_fd(fd);
56377c91 FD	270	if (!inode) {
5a15f70c	271	printk(KERN_WARNING "LTTng: Cannot get inode from fd\n");
56377c91 FD	272	ret = -EBADF;
	273	goto inode_error;
	274	}
83b802dc FD	275	uprobe->inode = inode;
	276	INIT_LIST_HEAD(&uprobe->head);
	277
	278	inode_error:
	279	return ret;
	280	}
	281
	282	int lttng_uprobes_register_event(const char name, int fd, struct lttng_event event)
	283	{
	284	int ret = 0;
	285
	286	ret = lttng_create_uprobe_event(name, event);
	287	if (ret)
	288	goto error;
	289
	290	ret = lttng_uprobes_register(&event->u.uprobe, fd);
	291	if (ret)
	292	goto register_error;
149b9a9d	293
149b9a9d YB	294	return 0;
149b9a9d YB	295
83b802dc	296	register_error:
437d5aa5	297	kfree(event->desc->event_name);
149b9a9d YB	298	kfree(event->desc);
	299	error:
	300	return ret;
	301	}
83b802dc	302	EXPORT_SYMBOL_GPL(lttng_uprobes_register_event);
149b9a9d	303
9de67196 FD	304	int lttng_uprobes_register_event_notifier(const char *name, int fd,
	305	struct lttng_event_notifier *event_notifier)
	306	{
	307	int ret = 0;
	308
	309	ret = lttng_create_uprobe_event_notifier(name, event_notifier);
	310	if (ret)
	311	goto error;
	312
	313	ret = lttng_uprobes_register(&event_notifier->u.uprobe, fd);
	314	if (ret)
	315	goto register_error;
	316
	317	return 0;
	318
	319	register_error:
437d5aa5	320	kfree(event_notifier->desc->event_name);
9de67196 FD	321	kfree(event_notifier->desc);
	322	error:
	323	return ret;
	324	}
	325	EXPORT_SYMBOL_GPL(lttng_uprobes_register_event_notifier);
	326
	327	static
	328	void lttng_uprobes_unregister(struct inode inode, struct list_head head)
149b9a9d	329	{
3aed4dca FD	330	struct lttng_uprobe_handler iter, tmp;
	331
	332	/*
	333	* Iterate over the list of handler, remove each handler from the list
	334	* and free the struct.
	335	*/
9de67196 FD	336	list_for_each_entry_safe(iter, tmp, head, node) {
9de67196 FD	337	wrapper_uprobe_unregister(inode, iter->offset, &iter->up_consumer);
3aed4dca FD	338	list_del(&iter->node);
	339	kfree(iter);
	340	}
9de67196 FD	341
	342	}
	343
	344	void lttng_uprobes_unregister_event(struct lttng_event *event)
	345	{
	346	lttng_uprobes_unregister(event->u.uprobe.inode, &event->u.uprobe.head);
149b9a9d	347	}
83b802dc	348	EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event);
149b9a9d	349
9de67196 FD	350	void lttng_uprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier)
	351	{
	352	lttng_uprobes_unregister(event_notifier->u.uprobe.inode, &event_notifier->u.uprobe.head);
	353	}
	354	EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier);
	355
83b802dc	356	void lttng_uprobes_destroy_event_private(struct lttng_event *event)
149b9a9d YB	357	{
149b9a9d YB	358	iput(event->u.uprobe.inode);
437d5aa5 MD	359	kfree(event->desc->fields[0]);
	360	kfree(event->desc->fields);
	361	kfree(event->desc->event_name);
149b9a9d YB	362	kfree(event->desc);
149b9a9d YB	363	}
83b802dc	364	EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private);
149b9a9d	365
9de67196 FD	366	void lttng_uprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier)
	367	{
	368	iput(event_notifier->u.uprobe.inode);
437d5aa5	369	kfree(event_notifier->desc->event_name);
9de67196 FD	370	kfree(event_notifier->desc);
	371	}
	372	EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private);
	373
149b9a9d YB	374	MODULE_LICENSE("GPL and additional rights");
	375	MODULE_AUTHOR("Yannick Brosseau");
	376	MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support");