[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/compiler_attributes.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_common *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_common *event = lttng_krp->event[type];
	struct lttng_kernel_probe_ctx lttng_probe_ctx = {
		.event = event,
		.interruptible = !lttng_regs_irqs_disabled(regs),
	};
	struct {
		unsigned long ip;
		unsigned long parent_ip;
	} payload;

	switch (event->type) {
	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
	{
		struct lttng_kernel_event_recorder *event_recorder =
			container_of(event, struct lttng_kernel_event_recorder, parent);
		struct lttng_kernel_channel_buffer *chan = event_recorder->chan;

		if (unlikely(!LTTNG_READ_ONCE(chan->parent.session->active)))
			return 0;
		if (unlikely(!LTTNG_READ_ONCE(chan->parent.enabled)))
			return 0;
		break;
	}
	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
		lttng_fallthrough;
	default:
		WARN_ON_ONCE(1);
	}

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

	switch (event->type) {
	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
	{
		struct lttng_kernel_event_recorder *event_recorder =
			container_of(event, struct lttng_kernel_event_recorder, parent);
		struct lttng_kernel_channel_buffer *chan = event_recorder->chan;
		struct lttng_kernel_ring_buffer_ctx ctx;
		int ret;

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

		lib_ring_buffer_ctx_init(&ctx, event_recorder, sizeof(payload),
					 lttng_alignof(payload), &lttng_probe_ctx);
		ret = chan->ops->event_reserve(&ctx);
		if (ret < 0)
			return 0;
		chan->ops->event_write(&ctx, &payload, sizeof(payload), lttng_alignof(payload));
		chan->ops->event_commit(&ctx);
		break;
	}
	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
		lttng_fallthrough;
	default:
		WARN_ON_ONCE(1);
	}
	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_event_field *event_fields[] = {
	lttng_kernel_static_event_field("ip",
		lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
		false, false, false),
	lttng_kernel_static_event_field("parent_ip",
		lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
		false, false, false),
};

static const struct lttng_kernel_tracepoint_class tp_class = {
	.nr_fields = ARRAY_SIZE(event_fields),
	.fields = event_fields,
};

/*
 * Create event description
 */
static
int lttng_create_kprobe_event(const char *name, struct lttng_kernel_event_common *event,
			      enum lttng_kretprobe_type type)
{
	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->tp_class = &tp_class;
	desc->owner = THIS_MODULE;
	event->priv->desc = desc;

	return 0;

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_common *event_entry,
			   struct lttng_kernel_event_common *event_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_entry, EVENT_ENTRY);
	if (ret)
		goto error;
	ret = lttng_create_kprobe_event(name, event_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_entry->priv->u.kretprobe.symbol_name = alloc_symbol;
		event_exit->priv->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_entry;
	lttng_krp->event[EVENT_EXIT] = event_exit;
	event_entry->priv->u.kretprobe.lttng_krp = lttng_krp;
	event_exit->priv->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_exit->priv->desc->event_name);
	kfree(event_exit->priv->desc);
event_exit_error:
	kfree(event_entry->priv->desc->event_name);
	kfree(event_entry->priv->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_common *event)
{
	kref_put(&event->priv->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_common *event)
{
	kfree(event->priv->desc->event_name);
	kfree(event->priv->desc);
	kref_put(&event->priv->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_common *event,
		int enable)
{
	struct lttng_kernel_event_common *event_exit;
	struct lttng_krp *lttng_krp;

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