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

/*
 * (C) Copyright	2009-2011 -
 * 		Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * LTTng function tracer integration module.
 *
 * Dual LGPL v2.1/GPL v2 license.
 */

/*
 * Ftrace function tracer does not seem to provide synchronization between probe
 * teardown and callback execution. Therefore, we make this module permanently
 * loaded (unloadable).
 */

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

static
void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
{
	struct ltt_event *event = *data;
	struct ltt_channel *chan = event->chan;
	struct lib_ring_buffer_ctx ctx;
	struct {
		unsigned long ip;
		unsigned long parent_ip;
	} payload;
	int ret;

	if (!ACCESS_ONCE(chan->session->active))
		return;
	lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL,
				 sizeof(payload), ltt_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, ltt_alignof(payload));
	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	chan->ops->event_commit(&ctx);
	return;
}

/*
 * Create event description
 */
static
int lttng_create_ftrace_event(const char *name, struct ltt_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 = ltt_alignof(unsigned long) * CHAR_BIT;
	fields[0].type.u.basic.integer.signedness = 0;
	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 = ltt_alignof(unsigned long) * CHAR_BIT;
	fields[1].type.u.basic.integer.signedness = 0;
	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 ltt_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 ltt_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 ltt_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");
Commit	Line	Data
e0a7a7c4 MD	1	/*
	2	* (C) Copyright 2009-2011 -
	3	* Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	*
	5	* LTTng function tracer integration module.
	6	*
	7	* Dual LGPL v2.1/GPL v2 license.
	8	*/
	9
e3de3dde MD	10	/*
	11	* Ftrace function tracer does not seem to provide synchronization between probe
	12	* teardown and callback execution. Therefore, we make this module permanently
	13	* loaded (unloadable).
	14	*/
	15
e0a7a7c4 MD	16	#include <linux/module.h>
	17	#include <linux/ftrace.h>
	18	#include <linux/slab.h>
	19	#include "../ltt-events.h"
	20	#include "../wrapper/ringbuffer/frontend_types.h"
5a9479dc	21	#include "../wrapper/ftrace.h"
16a9a591	22	#include "../wrapper/vmalloc.h"
e0a7a7c4 MD	23	#include "../ltt-tracer.h"
	24
	25	static
5a9479dc	26	void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
e0a7a7c4 MD	27	{
	28	struct ltt_event event = data;
	29	struct ltt_channel *chan = event->chan;
	30	struct lib_ring_buffer_ctx ctx;
	31	struct {
	32	unsigned long ip;
	33	unsigned long parent_ip;
	34	} payload;
	35	int ret;
	36
	37	if (!ACCESS_ONCE(chan->session->active))
5a9479dc	38	return;
e0a7a7c4 MD	39	lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL,
e0a7a7c4 MD	40	sizeof(payload), ltt_alignof(payload), -1);
4e1f08f4	41	ret = chan->ops->event_reserve(&ctx, event->id);
e0a7a7c4	42	if (ret < 0)
5a9479dc	43	return;
e0a7a7c4 MD	44	payload.ip = ip;
	45	payload.parent_ip = parent_ip;
	46	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(payload));
	47	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	48	chan->ops->event_commit(&ctx);
5a9479dc	49	return;
e0a7a7c4 MD	50	}
	51
	52	/*
	53	* Create event description
	54	*/
	55	static
	56	int lttng_create_ftrace_event(const char name, struct ltt_event event)
	57	{
	58	struct lttng_event_field *fields;
	59	struct lttng_event_desc *desc;
	60	int ret;
	61
	62	desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
	63	if (!desc)
	64	return -ENOMEM;
	65	desc->name = kstrdup(name, GFP_KERNEL);
	66	if (!desc->name) {
	67	ret = -ENOMEM;
	68	goto error_str;
	69	}
	70	desc->nr_fields = 2;
	71	desc->fields = fields =
	72	kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
0d1a681e MD	73	if (!desc->fields) {
	74	ret = -ENOMEM;
	75	goto error_fields;
	76	}
e0a7a7c4 MD	77	fields[0].name = "ip";
e0a7a7c4 MD	78	fields[0].type.atype = atype_integer;
ba1f5986 MD	79	fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
ba1f5986 MD	80	fields[0].type.u.basic.integer.alignment = ltt_alignof(unsigned long) * CHAR_BIT;
e0a7a7c4 MD	81	fields[0].type.u.basic.integer.signedness = 0;
	82	fields[0].type.u.basic.integer.reverse_byte_order = 0;
	83	fields[0].type.u.basic.integer.base = 16;
	84	fields[0].type.u.basic.integer.encoding = lttng_encode_none;
	85
	86	fields[1].name = "parent_ip";
	87	fields[1].type.atype = atype_integer;
ba1f5986 MD	88	fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
ba1f5986 MD	89	fields[1].type.u.basic.integer.alignment = ltt_alignof(unsigned long) * CHAR_BIT;
e0a7a7c4 MD	90	fields[1].type.u.basic.integer.signedness = 0;
	91	fields[1].type.u.basic.integer.reverse_byte_order = 0;
	92	fields[1].type.u.basic.integer.base = 16;
	93	fields[1].type.u.basic.integer.encoding = lttng_encode_none;
	94
dc7f600a	95	desc->owner = THIS_MODULE;
e0a7a7c4 MD	96	event->desc = desc;
	97
	98	return 0;
	99
0d1a681e MD	100	error_fields:
0d1a681e MD	101	kfree(desc->name);
e0a7a7c4 MD	102	error_str:
	103	kfree(desc);
	104	return ret;
	105	}
	106
	107	static
	108	struct ftrace_probe_ops lttng_ftrace_ops = {
	109	.func = lttng_ftrace_handler,
	110	};
	111
	112	int lttng_ftrace_register(const char *name,
	113	const char *symbol_name,
	114	struct ltt_event *event)
	115	{
	116	int ret;
	117
	118	ret = lttng_create_ftrace_event(name, event);
	119	if (ret)
	120	goto error;
	121
8a586098	122	event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL);
e0a7a7c4 MD	123	if (!event->u.ftrace.symbol_name)
	124	goto name_error;
	125
16a9a591 MD	126	/* Ensure the memory we just allocated don't trigger page faults */
	127	wrapper_vmalloc_sync_all();
	128
5a9479dc	129	ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
e0a7a7c4	130	&lttng_ftrace_ops, event);
8a586098	131	if (ret < 0)
e0a7a7c4 MD	132	goto register_error;
	133	return 0;
	134
	135	register_error:
	136	kfree(event->u.ftrace.symbol_name);
	137	name_error:
	138	kfree(event->desc->name);
	139	kfree(event->desc);
	140	error:
	141	return ret;
	142	}
	143	EXPORT_SYMBOL_GPL(lttng_ftrace_register);
	144
	145	void lttng_ftrace_unregister(struct ltt_event *event)
	146	{
5a9479dc	147	wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
e0a7a7c4	148	&lttng_ftrace_ops, event);
edeb3137 MD	149	}
	150	EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);
	151
	152	void lttng_ftrace_destroy_private(struct ltt_event *event)
	153	{
e0a7a7c4	154	kfree(event->u.ftrace.symbol_name);
25f53c39	155	kfree(event->desc->fields);
e0a7a7c4 MD	156	kfree(event->desc->name);
	157	kfree(event->desc);
	158	}
edeb3137	159	EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private);
e0a7a7c4	160
e3de3dde MD	161	int lttng_ftrace_init(void)
e3de3dde MD	162	{
16a9a591	163	wrapper_vmalloc_sync_all();
e3de3dde MD	164	return 0;
	165	}
	166	module_init(lttng_ftrace_init)
	167
1695dc9a MD	168	/*
	169	* Ftrace takes care of waiting for a grace period (RCU sched) at probe
	170	* unregistration, and disables preemption around probe call.
	171	*/
	172	void lttng_ftrace_exit(void)
	173	{
	174	}
	175	module_exit(lttng_ftrace_exit)
	176
e0a7a7c4 MD	177	MODULE_LICENSE("GPL and additional rights");
	178	MODULE_AUTHOR("Mathieu Desnoyers");
	179	MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");