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

/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
 *
 * probes/lttng-kretprobes.c
 *
 * LTTng kretprobes integration module.
 *
 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#include <linux/module.h>
#include <wrapper/kprobes.h>
#include <linux/slab.h>
#include <linux/kref.h>
#include <lttng/events.h>
#include <lttng/events-internal.h>
#include <ringbuffer/frontend_types.h>
#include <wrapper/vmalloc.h>
#include <wrapper/irqflags.h>
#include <lttng/tracer.h>
#include <blacklist/kprobes.h>

enum lttng_kretprobe_type {
	EVENT_ENTRY	= 0,
	EVENT_EXIT	= 1,
};

struct lttng_krp {
	struct kretprobe krp;
	struct lttng_kernel_event_recorder *event[2];	/* ENTRY and EXIT */
	struct kref kref_register;
	struct kref kref_alloc;
};

static
int _lttng_kretprobes_handler(struct kretprobe_instance *krpi,
			      struct pt_regs *regs,
			      enum lttng_kretprobe_type type)
{
	struct lttng_krp *lttng_krp =
		container_of(lttng_get_kretprobe(krpi), struct lttng_krp, krp);
	struct lttng_kernel_event_recorder *event_recorder =
		lttng_krp->event[type];
	struct lttng_probe_ctx lttng_probe_ctx = {
		.event = event_recorder,
		.interruptible = !lttng_regs_irqs_disabled(regs),
	};
	struct lttng_channel *chan = event_recorder->chan;
	struct lib_ring_buffer_ctx ctx;
	int ret;
	struct {
		unsigned long ip;
		unsigned long parent_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_recorder->parent.enabled)))
		return 0;

	payload.ip = (unsigned long) lttng_get_kretprobe(krpi)->kp.addr;
	payload.parent_ip = (unsigned long) krpi->ret_addr;

	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(payload),
				 lttng_alignof(payload), -1);
	ret = chan->ops->event_reserve(&ctx, event_recorder->priv->id);
	if (ret < 0)
		return 0;
	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_kretprobes_handler_entry(struct kretprobe_instance *krpi,
				   struct pt_regs *regs)
{
	return _lttng_kretprobes_handler(krpi, regs, EVENT_ENTRY);
}

static
int lttng_kretprobes_handler_exit(struct kretprobe_instance *krpi,
				  struct pt_regs *regs)
{
	return _lttng_kretprobes_handler(krpi, regs, EVENT_EXIT);
}

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_kprobe_event(const char *name, struct lttng_kernel_event_recorder *event_recorder,
			      enum lttng_kretprobe_type type)
{
	const struct lttng_kernel_event_field **fieldp_array;
	struct lttng_kernel_event_field *field;
	struct lttng_kernel_event_desc *desc;
	char *alloc_name;
	size_t name_len;
	const char *suffix = NULL;
	int ret;

	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
	if (!desc)
		return -ENOMEM;
	name_len = strlen(name);
	switch (type) {
	case EVENT_ENTRY:
		suffix = "_entry";
		break;
	case EVENT_EXIT:
		suffix = "_exit";
		break;
	}
	name_len += strlen(suffix);
	alloc_name = kmalloc(name_len + 1, GFP_KERNEL);
	if (!alloc_name) {
		ret = -ENOMEM;
		goto error_str;
	}
	strcpy(alloc_name, name);
	strcat(alloc_name, suffix);
	desc->event_name = alloc_name;
	desc->nr_fields = 2;
	fieldp_array = kzalloc(desc->nr_fields * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
	if (!fieldp_array) {
		ret = -ENOMEM;
		goto error_fieldp_array;
	}
	desc->fields = fieldp_array;

	field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	if (!field) {
		ret = -ENOMEM;
		goto error_field0;
	}
	field->name = "ip";
	field->type = event_type;
	desc->fields[0] = field;

	field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	if (!field) {
		ret = -ENOMEM;
		goto error_field1;
	}
	field->name = "parent_ip";
	field->type = event_type;
	desc->fields[1] = field;

	desc->owner = THIS_MODULE;
	event_recorder->priv->parent.desc = desc;

	return 0;

error_field1:
	kfree(desc->fields[0]);
error_field0:
	kfree(fieldp_array);
error_fieldp_array:
	kfree(desc->event_name);
error_str:
	kfree(desc);
	return ret;
}

int lttng_kretprobes_register(const char *name,
			   const char *symbol_name,
			   uint64_t offset,
			   uint64_t addr,
			   struct lttng_kernel_event_recorder *event_recorder_entry,
			   struct lttng_kernel_event_recorder *event_recorder_exit)
{
	int ret;
	struct lttng_krp *lttng_krp;

	/* Kprobes expects a NULL symbol name if unused */
	if (symbol_name[0] == '\0')
		symbol_name = NULL;

	ret = lttng_create_kprobe_event(name, event_recorder_entry, EVENT_ENTRY);
	if (ret)
		goto error;
	ret = lttng_create_kprobe_event(name, event_recorder_exit, EVENT_EXIT);
	if (ret)
		goto event_exit_error;
	lttng_krp = kzalloc(sizeof(*lttng_krp), GFP_KERNEL);
	if (!lttng_krp)
		goto krp_error;
	lttng_krp->krp.entry_handler = lttng_kretprobes_handler_entry;
	lttng_krp->krp.handler = lttng_kretprobes_handler_exit;
	if (symbol_name) {
		char *alloc_symbol;

		alloc_symbol = kstrdup(symbol_name, GFP_KERNEL);
		if (!alloc_symbol) {
			ret = -ENOMEM;
			goto name_error;
		}
		lttng_krp->krp.kp.symbol_name =
			alloc_symbol;
		event_recorder_entry->priv->parent.u.kretprobe.symbol_name =
			alloc_symbol;
		event_recorder_exit->priv->parent.u.kretprobe.symbol_name =
			alloc_symbol;
	}
	lttng_krp->krp.kp.offset = offset;
	lttng_krp->krp.kp.addr = (void *) (unsigned long) addr;

	/* Allow probe handler to find event structures */
	lttng_krp->event[EVENT_ENTRY] = event_recorder_entry;
	lttng_krp->event[EVENT_EXIT] = event_recorder_exit;
	event_recorder_entry->priv->parent.u.kretprobe.lttng_krp = lttng_krp;
	event_recorder_exit->priv->parent.u.kretprobe.lttng_krp = lttng_krp;

	/*
	 * Both events must be unregistered before the kretprobe is
	 * unregistered. Same for memory allocation.
	 */
	kref_init(&lttng_krp->kref_alloc);
	kref_get(&lttng_krp->kref_alloc);	/* inc refcount to 2, no overflow. */
	kref_init(&lttng_krp->kref_register);
	kref_get(&lttng_krp->kref_register);	/* inc refcount to 2, no overflow. */

	/*
	 * Ensure the memory we just allocated don't trigger page faults.
	 * Well.. kprobes itself puts the page fault handler on the blacklist,
	 * but we can never be too careful.
	 */
	wrapper_vmalloc_sync_mappings();

	ret = register_kretprobe(&lttng_krp->krp);
	if (ret)
		goto register_error;
	return 0;

register_error:
	kfree(lttng_krp->krp.kp.symbol_name);
name_error:
	kfree(lttng_krp);
krp_error:
	kfree(event_recorder_exit->priv->parent.desc->fields[0]);
	kfree(event_recorder_exit->priv->parent.desc->fields[1]);
	kfree(event_recorder_exit->priv->parent.desc->fields);
	kfree(event_recorder_exit->priv->parent.desc->event_name);
	kfree(event_recorder_exit->priv->parent.desc);
event_exit_error:
	kfree(event_recorder_entry->priv->parent.desc->fields[0]);
	kfree(event_recorder_entry->priv->parent.desc->fields[1]);
	kfree(event_recorder_entry->priv->parent.desc->fields);
	kfree(event_recorder_entry->priv->parent.desc->event_name);
	kfree(event_recorder_entry->priv->parent.desc);
error:
	return ret;
}
EXPORT_SYMBOL_GPL(lttng_kretprobes_register);

static
void _lttng_kretprobes_unregister_release(struct kref *kref)
{
	struct lttng_krp *lttng_krp =
		container_of(kref, struct lttng_krp, kref_register);
	unregister_kretprobe(&lttng_krp->krp);
}

void lttng_kretprobes_unregister(struct lttng_kernel_event_recorder *event_recorder)
{
	kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_register,
		_lttng_kretprobes_unregister_release);
}
EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister);

static
void _lttng_kretprobes_release(struct kref *kref)
{
	struct lttng_krp *lttng_krp =
		container_of(kref, struct lttng_krp, kref_alloc);
	kfree(lttng_krp->krp.kp.symbol_name);
}

void lttng_kretprobes_destroy_private(struct lttng_kernel_event_recorder *event_recorder)
{
	kfree(event_recorder->priv->parent.desc->fields[0]);
	kfree(event_recorder->priv->parent.desc->fields[1]);
	kfree(event_recorder->priv->parent.desc->fields);
	kfree(event_recorder->priv->parent.desc->event_name);
	kfree(event_recorder->priv->parent.desc);
	kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_alloc,
		_lttng_kretprobes_release);
}
EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private);

int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_recorder *event_recorder,
		int enable)
{
	struct lttng_kernel_event_recorder *event_recorder_exit;
	struct lttng_krp *lttng_krp;

	if (event_recorder->priv->parent.instrumentation != LTTNG_KERNEL_ABI_KRETPROBE) {
		return -EINVAL;
	}
	if (event_recorder->parent.enabled == enable) {
		return -EBUSY;
	}
	lttng_krp = event_recorder->priv->parent.u.kretprobe.lttng_krp;
	event_recorder_exit = lttng_krp->event[EVENT_EXIT];
	WRITE_ONCE(event_recorder->parent.enabled, enable);
	WRITE_ONCE(event_recorder_exit->parent.enabled, enable);
	return 0;
}
EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state);

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
MODULE_DESCRIPTION("LTTng kretprobes probes");
MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	LTTNG_MODULES_EXTRAVERSION);
Commit	Line	Data
b7cdc182	1	/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
9f36eaed MJ	2	*
9f36eaed MJ	3	* probes/lttng-kretprobes.c
7371f44c MD	4	*
	5	* LTTng kretprobes integration module.
	6	*
886d51a3	7	* Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7371f44c MD	8	*/
	9
	10	#include <linux/module.h>
08726907	11	#include <wrapper/kprobes.h>
7371f44c MD	12	#include <linux/slab.h>
7371f44c MD	13	#include <linux/kref.h>
2df37e95	14	#include <lttng/events.h>
a67ba386	15	#include <lttng/events-internal.h>
24591303	16	#include <ringbuffer/frontend_types.h>
156a3977 MD	17	#include <wrapper/vmalloc.h>
156a3977 MD	18	#include <wrapper/irqflags.h>
2df37e95	19	#include <lttng/tracer.h>
caa068b5	20	#include <blacklist/kprobes.h>
7371f44c MD	21
7371f44c MD	22	enum lttng_kretprobe_type {
1b6cc48a MD	23	EVENT_ENTRY = 0,
1b6cc48a MD	24	EVENT_EXIT = 1,
7371f44c MD	25	};
	26
	27	struct lttng_krp {
	28	struct kretprobe krp;
a67ba386	29	struct lttng_kernel_event_recorder event[2]; / ENTRY and EXIT */
7371f44c MD	30	struct kref kref_register;
	31	struct kref kref_alloc;
	32	};
	33
	34	static
	35	int _lttng_kretprobes_handler(struct kretprobe_instance *krpi,
	36	struct pt_regs *regs,
	37	enum lttng_kretprobe_type type)
	38	{
	39	struct lttng_krp *lttng_krp =
08726907	40	container_of(lttng_get_kretprobe(krpi), struct lttng_krp, krp);
a67ba386	41	struct lttng_kernel_event_recorder *event_recorder =
7371f44c	42	lttng_krp->event[type];
79150a49	43	struct lttng_probe_ctx lttng_probe_ctx = {
a67ba386	44	.event = event_recorder,
ccecf3fb	45	.interruptible = !lttng_regs_irqs_disabled(regs),
79150a49	46	};
a67ba386	47	struct lttng_channel *chan = event_recorder->chan;
7371f44c MD	48	struct lib_ring_buffer_ctx ctx;
	49	int ret;
	50	struct {
	51	unsigned long ip;
	52	unsigned long parent_ip;
	53	} payload;
	54
585e5dcc	55	if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
7371f44c	56	return 0;
585e5dcc	57	if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
7371f44c	58	return 0;
a67ba386	59	if (unlikely(!LTTNG_READ_ONCE(event_recorder->parent.enabled)))
7371f44c MD	60	return 0;
7371f44c MD	61
08726907	62	payload.ip = (unsigned long) lttng_get_kretprobe(krpi)->kp.addr;
7371f44c MD	63	payload.parent_ip = (unsigned long) krpi->ret_addr;
7371f44c MD	64
79150a49	65	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(payload),
a90917c3	66	lttng_alignof(payload), -1);
a67ba386	67	ret = chan->ops->event_reserve(&ctx, event_recorder->priv->id);
7371f44c MD	68	if (ret < 0)
7371f44c MD	69	return 0;
a90917c3	70	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
7371f44c MD	71	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	72	chan->ops->event_commit(&ctx);
	73	return 0;
	74	}
	75
	76	static
	77	int lttng_kretprobes_handler_entry(struct kretprobe_instance *krpi,
	78	struct pt_regs *regs)
	79	{
	80	return _lttng_kretprobes_handler(krpi, regs, EVENT_ENTRY);
	81	}
	82
	83	static
1b6cc48a MD	84	int lttng_kretprobes_handler_exit(struct kretprobe_instance *krpi,
1b6cc48a MD	85	struct pt_regs *regs)
7371f44c	86	{
1b6cc48a	87	return _lttng_kretprobes_handler(krpi, regs, EVENT_EXIT);
7371f44c MD	88	}
7371f44c MD	89
437d5aa5 MD	90	static const struct lttng_kernel_type_common *event_type =
	91	lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
	92
7371f44c MD	93	/*
	94	* Create event description
	95	*/
	96	static
a67ba386	97	int lttng_create_kprobe_event(const char name, struct lttng_kernel_event_recorder event_recorder,
7371f44c MD	98	enum lttng_kretprobe_type type)
7371f44c MD	99	{
437d5aa5 MD	100	const struct lttng_kernel_event_field **fieldp_array;
	101	struct lttng_kernel_event_field *field;
	102	struct lttng_kernel_event_desc *desc;
7371f44c MD	103	char *alloc_name;
	104	size_t name_len;
	105	const char *suffix = NULL;
437d5aa5	106	int ret;
7371f44c	107
437d5aa5	108	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
7371f44c MD	109	if (!desc)
	110	return -ENOMEM;
	111	name_len = strlen(name);
	112	switch (type) {
	113	case EVENT_ENTRY:
	114	suffix = "_entry";
	115	break;
1b6cc48a MD	116	case EVENT_EXIT:
1b6cc48a MD	117	suffix = "_exit";
7371f44c MD	118	break;
	119	}
	120	name_len += strlen(suffix);
	121	alloc_name = kmalloc(name_len + 1, GFP_KERNEL);
	122	if (!alloc_name) {
	123	ret = -ENOMEM;
	124	goto error_str;
	125	}
	126	strcpy(alloc_name, name);
	127	strcat(alloc_name, suffix);
437d5aa5	128	desc->event_name = alloc_name;
7371f44c	129	desc->nr_fields = 2;
437d5aa5 MD	130	fieldp_array = kzalloc(desc->nr_fields * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
	131	if (!fieldp_array) {
	132	ret = -ENOMEM;
	133	goto error_fieldp_array;
	134	}
	135	desc->fields = fieldp_array;
	136
	137	field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	138	if (!field) {
7371f44c	139	ret = -ENOMEM;
437d5aa5	140	goto error_field0;
7371f44c	141	}
437d5aa5 MD	142	field->name = "ip";
	143	field->type = event_type;
	144	desc->fields[0] = field;
7371f44c	145
437d5aa5 MD	146	field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
	147	if (!field) {
	148	ret = -ENOMEM;
	149	goto error_field1;
	150	}
	151	field->name = "parent_ip";
	152	field->type = event_type;
	153	desc->fields[1] = field;
7371f44c MD	154
7371f44c MD	155	desc->owner = THIS_MODULE;
a67ba386	156	event_recorder->priv->parent.desc = desc;
7371f44c MD	157
	158	return 0;
	159
437d5aa5 MD	160	error_field1:
	161	kfree(desc->fields[0]);
	162	error_field0:
	163	kfree(fieldp_array);
	164	error_fieldp_array:
	165	kfree(desc->event_name);
7371f44c MD	166	error_str:
	167	kfree(desc);
	168	return ret;
	169	}
	170
	171	int lttng_kretprobes_register(const char *name,
	172	const char *symbol_name,
	173	uint64_t offset,
	174	uint64_t addr,
a67ba386 MD	175	struct lttng_kernel_event_recorder *event_recorder_entry,
a67ba386 MD	176	struct lttng_kernel_event_recorder *event_recorder_exit)
7371f44c MD	177	{
	178	int ret;
	179	struct lttng_krp *lttng_krp;
	180
	181	/* Kprobes expects a NULL symbol name if unused */
	182	if (symbol_name[0] == '\0')
	183	symbol_name = NULL;
	184
a67ba386	185	ret = lttng_create_kprobe_event(name, event_recorder_entry, EVENT_ENTRY);
7371f44c MD	186	if (ret)
7371f44c MD	187	goto error;
a67ba386	188	ret = lttng_create_kprobe_event(name, event_recorder_exit, EVENT_EXIT);
7371f44c	189	if (ret)
1b6cc48a	190	goto event_exit_error;
7371f44c MD	191	lttng_krp = kzalloc(sizeof(*lttng_krp), GFP_KERNEL);
	192	if (!lttng_krp)
	193	goto krp_error;
	194	lttng_krp->krp.entry_handler = lttng_kretprobes_handler_entry;
1b6cc48a	195	lttng_krp->krp.handler = lttng_kretprobes_handler_exit;
7371f44c MD	196	if (symbol_name) {
	197	char *alloc_symbol;
	198
	199	alloc_symbol = kstrdup(symbol_name, GFP_KERNEL);
	200	if (!alloc_symbol) {
	201	ret = -ENOMEM;
	202	goto name_error;
	203	}
	204	lttng_krp->krp.kp.symbol_name =
	205	alloc_symbol;
a67ba386	206	event_recorder_entry->priv->parent.u.kretprobe.symbol_name =
7371f44c	207	alloc_symbol;
a67ba386	208	event_recorder_exit->priv->parent.u.kretprobe.symbol_name =
7371f44c MD	209	alloc_symbol;
	210	}
	211	lttng_krp->krp.kp.offset = offset;
b2c4e8fb	212	lttng_krp->krp.kp.addr = (void *) (unsigned long) addr;
7371f44c MD	213
7371f44c MD	214	/* Allow probe handler to find event structures */
a67ba386 MD	215	lttng_krp->event[EVENT_ENTRY] = event_recorder_entry;
	216	lttng_krp->event[EVENT_EXIT] = event_recorder_exit;
	217	event_recorder_entry->priv->parent.u.kretprobe.lttng_krp = lttng_krp;
	218	event_recorder_exit->priv->parent.u.kretprobe.lttng_krp = lttng_krp;
7371f44c MD	219
	220	/*
	221	* Both events must be unregistered before the kretprobe is
	222	* unregistered. Same for memory allocation.
	223	*/
	224	kref_init(&lttng_krp->kref_alloc);
9c1f4643	225	kref_get(&lttng_krp->kref_alloc); /* inc refcount to 2, no overflow. */
7371f44c	226	kref_init(&lttng_krp->kref_register);
9c1f4643	227	kref_get(&lttng_krp->kref_register); /* inc refcount to 2, no overflow. */
7371f44c MD	228
	229	/*
	230	* Ensure the memory we just allocated don't trigger page faults.
	231	* Well.. kprobes itself puts the page fault handler on the blacklist,
	232	* but we can never be too careful.
	233	*/
263b6c88	234	wrapper_vmalloc_sync_mappings();
7371f44c MD	235
	236	ret = register_kretprobe(&lttng_krp->krp);
	237	if (ret)
	238	goto register_error;
	239	return 0;
	240
	241	register_error:
	242	kfree(lttng_krp->krp.kp.symbol_name);
	243	name_error:
	244	kfree(lttng_krp);
	245	krp_error:
a67ba386 MD	246	kfree(event_recorder_exit->priv->parent.desc->fields[0]);
	247	kfree(event_recorder_exit->priv->parent.desc->fields[1]);
	248	kfree(event_recorder_exit->priv->parent.desc->fields);
	249	kfree(event_recorder_exit->priv->parent.desc->event_name);
	250	kfree(event_recorder_exit->priv->parent.desc);
1b6cc48a	251	event_exit_error:
a67ba386 MD	252	kfree(event_recorder_entry->priv->parent.desc->fields[0]);
	253	kfree(event_recorder_entry->priv->parent.desc->fields[1]);
	254	kfree(event_recorder_entry->priv->parent.desc->fields);
	255	kfree(event_recorder_entry->priv->parent.desc->event_name);
	256	kfree(event_recorder_entry->priv->parent.desc);
7371f44c MD	257	error:
	258	return ret;
	259	}
	260	EXPORT_SYMBOL_GPL(lttng_kretprobes_register);
	261
	262	static
	263	void _lttng_kretprobes_unregister_release(struct kref *kref)
	264	{
	265	struct lttng_krp *lttng_krp =
	266	container_of(kref, struct lttng_krp, kref_register);
	267	unregister_kretprobe(&lttng_krp->krp);
	268	}
	269
a67ba386	270	void lttng_kretprobes_unregister(struct lttng_kernel_event_recorder *event_recorder)
7371f44c	271	{
a67ba386	272	kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_register,
7371f44c MD	273	_lttng_kretprobes_unregister_release);
	274	}
	275	EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister);
	276
	277	static
	278	void _lttng_kretprobes_release(struct kref *kref)
	279	{
	280	struct lttng_krp *lttng_krp =
	281	container_of(kref, struct lttng_krp, kref_alloc);
	282	kfree(lttng_krp->krp.kp.symbol_name);
	283	}
	284
a67ba386	285	void lttng_kretprobes_destroy_private(struct lttng_kernel_event_recorder *event_recorder)
7371f44c	286	{
a67ba386 MD	287	kfree(event_recorder->priv->parent.desc->fields[0]);
	288	kfree(event_recorder->priv->parent.desc->fields[1]);
	289	kfree(event_recorder->priv->parent.desc->fields);
	290	kfree(event_recorder->priv->parent.desc->event_name);
	291	kfree(event_recorder->priv->parent.desc);
	292	kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_alloc,
7371f44c MD	293	_lttng_kretprobes_release);
	294	}
	295	EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private);
	296
a67ba386	297	int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_recorder *event_recorder,
a0493bef MD	298	int enable)
a0493bef MD	299	{
a67ba386	300	struct lttng_kernel_event_recorder *event_recorder_exit;
a0493bef MD	301	struct lttng_krp *lttng_krp;
a0493bef MD	302
a67ba386	303	if (event_recorder->priv->parent.instrumentation != LTTNG_KERNEL_ABI_KRETPROBE) {
a0493bef MD	304	return -EINVAL;
a0493bef MD	305	}
a67ba386	306	if (event_recorder->parent.enabled == enable) {
a0493bef MD	307	return -EBUSY;
a0493bef MD	308	}
a67ba386 MD	309	lttng_krp = event_recorder->priv->parent.u.kretprobe.lttng_krp;
	310	event_recorder_exit = lttng_krp->event[EVENT_EXIT];
	311	WRITE_ONCE(event_recorder->parent.enabled, enable);
	312	WRITE_ONCE(event_recorder_exit->parent.enabled, enable);
a0493bef MD	313	return 0;
	314	}
	315	EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state);
	316
7371f44c	317	MODULE_LICENSE("GPL and additional rights");
1c124020 MJ	318	MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
1c124020 MJ	319	MODULE_DESCRIPTION("LTTng kretprobes probes");
13ab8b0a MD	320	MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	321	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	322	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	323	LTTNG_MODULES_EXTRAVERSION);