[deliverable/lttng-modules.git] / probes / lttng-ftrace.c

/*
 * probes/lttng-ftrace.c
 *
 * LTTng function tracer integration module.
 *
 * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; only
 * version 2.1 of the License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * Ftrace function tracer does not seem to provide synchronization between probe
 * teardown and callback execution. Therefore, we make this module permanently
 * loaded (unloadable).
 *
 * TODO: Move to register_ftrace_function() (which is exported for
 * modules) for Linux >= 3.0. It is faster (only enables the selected
 * functions), and will stay there.
 */

#include <linux/module.h>
#include <linux/ftrace.h>
#include <linux/slab.h>
#include <lttng-events.h>
#include <wrapper/ringbuffer/frontend_types.h>
#include <wrapper/ftrace.h>
#include <wrapper/vmalloc.h>
#include <lttng-tracer.h>

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
static
void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip,
		struct trace_array *tr, struct ftrace_probe_ops *ops,
		void *data)
{
	struct lttng_event *event = data;
	struct lttng_probe_ctx lttng_probe_ctx = {
		.event = event,
		.interruptible = !irqs_disabled(),
	};
	struct lttng_channel *chan = event->chan;
	struct lib_ring_buffer_ctx ctx;
	struct {
		unsigned long ip;
		unsigned long parent_ip;
	} payload;
	int ret;

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

	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;
	payload.ip = ip;
	payload.parent_ip = parent_ip;
	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	chan->ops->event_commit(&ctx);
	return;
}
#else
static
void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
{
	struct lttng_event *event = *data;
	struct lttng_probe_ctx lttng_probe_ctx = {
		.event = event,
		.interruptible = !irqs_disabled(),
	};
	struct lttng_channel *chan = event->chan;
	struct lib_ring_buffer_ctx ctx;
	struct {
		unsigned long ip;
		unsigned long parent_ip;
	} payload;
	int ret;

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

	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;
	payload.ip = ip;
	payload.parent_ip = parent_ip;
	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	chan->ops->event_commit(&ctx);
	return;
}
#endif

/*
 * Create event description
 */
static
int lttng_create_ftrace_event(const char *name, struct lttng_event *event)
{
	struct lttng_event_field *fields;
	struct lttng_event_desc *desc;
	int ret;

	desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
	if (!desc)
		return -ENOMEM;
	desc->name = kstrdup(name, GFP_KERNEL);
	if (!desc->name) {
		ret = -ENOMEM;
		goto error_str;
	}
	desc->nr_fields = 2;
	desc->fields = fields =
		kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
	if (!desc->fields) {
		ret = -ENOMEM;
		goto error_fields;
	}
	fields[0].name = "ip";
	fields[0].type.atype = atype_integer;
	fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
	fields[0].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
	fields[0].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
	fields[0].type.u.basic.integer.reverse_byte_order = 0;
	fields[0].type.u.basic.integer.base = 16;
	fields[0].type.u.basic.integer.encoding = lttng_encode_none;

	fields[1].name = "parent_ip";
	fields[1].type.atype = atype_integer;
	fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
	fields[1].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
	fields[1].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
	fields[1].type.u.basic.integer.reverse_byte_order = 0;
	fields[1].type.u.basic.integer.base = 16;
	fields[1].type.u.basic.integer.encoding = lttng_encode_none;

	desc->owner = THIS_MODULE;
	event->desc = desc;

	return 0;

error_fields:
	kfree(desc->name);
error_str:
	kfree(desc);
	return ret;
}

static
struct ftrace_probe_ops lttng_ftrace_ops = {
	.func = lttng_ftrace_handler,
};

int lttng_ftrace_register(const char *name,
			  const char *symbol_name,
			  struct lttng_event *event)
{
	int ret;

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

	event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL);
	if (!event->u.ftrace.symbol_name)
		goto name_error;

	/* Ensure the memory we just allocated don't trigger page faults */
	wrapper_vmalloc_sync_all();

	ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
			&lttng_ftrace_ops, event);
	if (ret < 0)
		goto register_error;
	return 0;

register_error:
	kfree(event->u.ftrace.symbol_name);
name_error:
	kfree(event->desc->name);
	kfree(event->desc);
error:
	return ret;
}
EXPORT_SYMBOL_GPL(lttng_ftrace_register);

void lttng_ftrace_unregister(struct lttng_event *event)
{
	wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
			&lttng_ftrace_ops, event);
}
EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);

void lttng_ftrace_destroy_private(struct lttng_event *event)
{
	kfree(event->u.ftrace.symbol_name);
	kfree(event->desc->fields);
	kfree(event->desc->name);
	kfree(event->desc);
}
EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private);

int lttng_ftrace_init(void)
{
	wrapper_vmalloc_sync_all();
	return 0;
}
module_init(lttng_ftrace_init)

/*
 * Ftrace takes care of waiting for a grace period (RCU sched) at probe
 * unregistration, and disables preemption around probe call.
 */
void lttng_ftrace_exit(void)
{
}
module_exit(lttng_ftrace_exit)

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");
MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	LTTNG_MODULES_EXTRAVERSION);
Commit	Line	Data
	1	/*
	2	* probes/lttng-ftrace.c
	3	*
	4	* LTTng function tracer integration module.
	5	*
	6	* Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; only
	11	* version 2.1 of the License.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	/*
	24	* Ftrace function tracer does not seem to provide synchronization between probe
	25	* teardown and callback execution. Therefore, we make this module permanently
	26	* loaded (unloadable).
	27	*
	28	* TODO: Move to register_ftrace_function() (which is exported for
	29	* modules) for Linux >= 3.0. It is faster (only enables the selected
	30	* functions), and will stay there.
	31	*/
	32
	33	#include <linux/module.h>
	34	#include <linux/ftrace.h>
	35	#include <linux/slab.h>
	36	#include <lttng-events.h>
	37	#include <wrapper/ringbuffer/frontend_types.h>
	38	#include <wrapper/ftrace.h>
	39	#include <wrapper/vmalloc.h>
	40	#include <lttng-tracer.h>
	41
	42	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
	43	static
	44	void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip,
	45	struct trace_array tr, struct ftrace_probe_ops ops,
	46	void *data)
	47	{
	48	struct lttng_event *event = data;
	49	struct lttng_probe_ctx lttng_probe_ctx = {
	50	.event = event,
	51	.interruptible = !irqs_disabled(),
	52	};
	53	struct lttng_channel *chan = event->chan;
	54	struct lib_ring_buffer_ctx ctx;
	55	struct {
	56	unsigned long ip;
	57	unsigned long parent_ip;
	58	} payload;
	59	int ret;
	60
	61	if (unlikely(!READ_ONCE(chan->session->active)))
	62	return;
	63	if (unlikely(!READ_ONCE(chan->enabled)))
	64	return;
	65	if (unlikely(!READ_ONCE(event->enabled)))
	66	return;
	67
	68	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
	69	sizeof(payload), lttng_alignof(payload), -1);
	70	ret = chan->ops->event_reserve(&ctx, event->id);
	71	if (ret < 0)
	72	return;
	73	payload.ip = ip;
	74	payload.parent_ip = parent_ip;
	75	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	76	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	77	chan->ops->event_commit(&ctx);
	78	return;
	79	}
	80	#else
	81	static
	82	void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
	83	{
	84	struct lttng_event event = data;
	85	struct lttng_probe_ctx lttng_probe_ctx = {
	86	.event = event,
	87	.interruptible = !irqs_disabled(),
	88	};
	89	struct lttng_channel *chan = event->chan;
	90	struct lib_ring_buffer_ctx ctx;
	91	struct {
	92	unsigned long ip;
	93	unsigned long parent_ip;
	94	} payload;
	95	int ret;
	96
	97	if (unlikely(!READ_ONCE(chan->session->active)))
	98	return;
	99	if (unlikely(!READ_ONCE(chan->enabled)))
	100	return;
	101	if (unlikely(!READ_ONCE(event->enabled)))
	102	return;
	103
	104	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
	105	sizeof(payload), lttng_alignof(payload), -1);
	106	ret = chan->ops->event_reserve(&ctx, event->id);
	107	if (ret < 0)
	108	return;
	109	payload.ip = ip;
	110	payload.parent_ip = parent_ip;
	111	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
	112	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	113	chan->ops->event_commit(&ctx);
	114	return;
	115	}
	116	#endif
	117
	118	/*
	119	* Create event description
	120	*/
	121	static
	122	int lttng_create_ftrace_event(const char name, struct lttng_event event)
	123	{
	124	struct lttng_event_field *fields;
	125	struct lttng_event_desc *desc;
	126	int ret;
	127
	128	desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
	129	if (!desc)
	130	return -ENOMEM;
	131	desc->name = kstrdup(name, GFP_KERNEL);
	132	if (!desc->name) {
	133	ret = -ENOMEM;
	134	goto error_str;
	135	}
	136	desc->nr_fields = 2;
	137	desc->fields = fields =
	138	kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
	139	if (!desc->fields) {
	140	ret = -ENOMEM;
	141	goto error_fields;
	142	}
	143	fields[0].name = "ip";
	144	fields[0].type.atype = atype_integer;
	145	fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
	146	fields[0].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
	147	fields[0].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
	148	fields[0].type.u.basic.integer.reverse_byte_order = 0;
	149	fields[0].type.u.basic.integer.base = 16;
	150	fields[0].type.u.basic.integer.encoding = lttng_encode_none;
	151
	152	fields[1].name = "parent_ip";
	153	fields[1].type.atype = atype_integer;
	154	fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
	155	fields[1].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
	156	fields[1].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
	157	fields[1].type.u.basic.integer.reverse_byte_order = 0;
	158	fields[1].type.u.basic.integer.base = 16;
	159	fields[1].type.u.basic.integer.encoding = lttng_encode_none;
	160
	161	desc->owner = THIS_MODULE;
	162	event->desc = desc;
	163
	164	return 0;
	165
	166	error_fields:
	167	kfree(desc->name);
	168	error_str:
	169	kfree(desc);
	170	return ret;
	171	}
	172
	173	static
	174	struct ftrace_probe_ops lttng_ftrace_ops = {
	175	.func = lttng_ftrace_handler,
	176	};
	177
	178	int lttng_ftrace_register(const char *name,
	179	const char *symbol_name,
	180	struct lttng_event *event)
	181	{
	182	int ret;
	183
	184	ret = lttng_create_ftrace_event(name, event);
	185	if (ret)
	186	goto error;
	187
	188	event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL);
	189	if (!event->u.ftrace.symbol_name)
	190	goto name_error;
	191
	192	/* Ensure the memory we just allocated don't trigger page faults */
	193	wrapper_vmalloc_sync_all();
	194
	195	ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
	196	&lttng_ftrace_ops, event);
	197	if (ret < 0)
	198	goto register_error;
	199	return 0;
	200
	201	register_error:
	202	kfree(event->u.ftrace.symbol_name);
	203	name_error:
	204	kfree(event->desc->name);
	205	kfree(event->desc);
	206	error:
	207	return ret;
	208	}
	209	EXPORT_SYMBOL_GPL(lttng_ftrace_register);
	210
	211	void lttng_ftrace_unregister(struct lttng_event *event)
	212	{
	213	wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
	214	&lttng_ftrace_ops, event);
	215	}
	216	EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);
	217
	218	void lttng_ftrace_destroy_private(struct lttng_event *event)
	219	{
	220	kfree(event->u.ftrace.symbol_name);
	221	kfree(event->desc->fields);
	222	kfree(event->desc->name);
	223	kfree(event->desc);
	224	}
	225	EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private);
	226
	227	int lttng_ftrace_init(void)
	228	{
	229	wrapper_vmalloc_sync_all();
	230	return 0;
	231	}
	232	module_init(lttng_ftrace_init)
	233
	234	/*
	235	* Ftrace takes care of waiting for a grace period (RCU sched) at probe
	236	* unregistration, and disables preemption around probe call.
	237	*/
	238	void lttng_ftrace_exit(void)
	239	{
	240	}
	241	module_exit(lttng_ftrace_exit)
	242
	243	MODULE_LICENSE("GPL and additional rights");
	244	MODULE_AUTHOR("Mathieu Desnoyers");
	245	MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");
	246	MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	247	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	248	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	249	LTTNG_MODULES_EXTRAVERSION);