[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 "../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);
	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);
	fields[0].name = "ip";
	fields[0].type.atype = atype_integer;
	fields[0].type.u.basic.integer.size = sizeof(unsigned long);
	fields[0].type.u.basic.integer.alignment = ltt_alignof(unsigned long);
	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);
	fields[1].type.u.basic.integer.alignment = ltt_alignof(unsigned long);
	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;

	event->desc = desc;

	return 0;

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(name, GFP_KERNEL);
	if (!event->u.ftrace.symbol_name)
		goto name_error;

	ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
			&lttng_ftrace_ops, event);
	if (ret)
		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);
	kfree(event->u.ftrace.symbol_name);
	kfree(event->desc->name);
	kfree(event->desc);
}
EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);

/* This module is permanent. */
int lttng_ftrace_init(void)
{
	return 0;
}
module_init(lttng_ftrace_init)

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"
e0a7a7c4 MD	22	#include "../ltt-tracer.h"
	23
	24	static
5a9479dc	25	void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
e0a7a7c4 MD	26	{
	27	struct ltt_event event = data;
	28	struct ltt_channel *chan = event->chan;
	29	struct lib_ring_buffer_ctx ctx;
	30	struct {
	31	unsigned long ip;
	32	unsigned long parent_ip;
	33	} payload;
	34	int ret;
	35
	36	if (!ACCESS_ONCE(chan->session->active))
5a9479dc	37	return;
e0a7a7c4 MD	38	lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL,
	39	sizeof(payload), ltt_alignof(payload), -1);
	40	ret = chan->ops->event_reserve(&ctx);
	41	if (ret < 0)
5a9479dc	42	return;
e0a7a7c4 MD	43	payload.ip = ip;
	44	payload.parent_ip = parent_ip;
	45	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(payload));
	46	chan->ops->event_write(&ctx, &payload, sizeof(payload));
	47	chan->ops->event_commit(&ctx);
5a9479dc	48	return;
e0a7a7c4 MD	49	}
	50
	51	/*
	52	* Create event description
	53	*/
	54	static
	55	int lttng_create_ftrace_event(const char name, struct ltt_event event)
	56	{
	57	struct lttng_event_field *fields;
	58	struct lttng_event_desc *desc;
	59	int ret;
	60
	61	desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
	62	if (!desc)
	63	return -ENOMEM;
	64	desc->name = kstrdup(name, GFP_KERNEL);
	65	if (!desc->name) {
	66	ret = -ENOMEM;
	67	goto error_str;
	68	}
	69	desc->nr_fields = 2;
	70	desc->fields = fields =
	71	kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
	72	fields[0].name = "ip";
	73	fields[0].type.atype = atype_integer;
	74	fields[0].type.u.basic.integer.size = sizeof(unsigned long);
	75	fields[0].type.u.basic.integer.alignment = ltt_alignof(unsigned long);
	76	fields[0].type.u.basic.integer.signedness = 0;
	77	fields[0].type.u.basic.integer.reverse_byte_order = 0;
	78	fields[0].type.u.basic.integer.base = 16;
	79	fields[0].type.u.basic.integer.encoding = lttng_encode_none;
	80
	81	fields[1].name = "parent_ip";
	82	fields[1].type.atype = atype_integer;
	83	fields[1].type.u.basic.integer.size = sizeof(unsigned long);
	84	fields[1].type.u.basic.integer.alignment = ltt_alignof(unsigned long);
	85	fields[1].type.u.basic.integer.signedness = 0;
	86	fields[1].type.u.basic.integer.reverse_byte_order = 0;
	87	fields[1].type.u.basic.integer.base = 16;
	88	fields[1].type.u.basic.integer.encoding = lttng_encode_none;
	89
	90	event->desc = desc;
	91
	92	return 0;
	93
	94	error_str:
	95	kfree(desc);
	96	return ret;
	97	}
	98
	99	static
	100	struct ftrace_probe_ops lttng_ftrace_ops = {
	101	.func = lttng_ftrace_handler,
	102	};
	103
	104	int lttng_ftrace_register(const char *name,
	105	const char *symbol_name,
	106	struct ltt_event *event)
	107	{
	108	int ret;
	109
	110	ret = lttng_create_ftrace_event(name, event);
	111	if (ret)
	112	goto error;
113
114	event->u.ftrace.symbol_name = kstrdup(name, GFP_KERNEL);
115	if (!event->u.ftrace.symbol_name)
116	goto name_error;
117
5a9479dc	118	ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
e0a7a7c4 MD	119	&lttng_ftrace_ops, event);
	120	if (ret)
	121	goto register_error;
	122	return 0;
	123
	124	register_error:
	125	kfree(event->u.ftrace.symbol_name);
	126	name_error:
	127	kfree(event->desc->name);
	128	kfree(event->desc);
	129	error:
	130	return ret;
	131	}
	132	EXPORT_SYMBOL_GPL(lttng_ftrace_register);
	133
	134	void lttng_ftrace_unregister(struct ltt_event *event)
	135	{
5a9479dc	136	wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
e0a7a7c4 MD	137	&lttng_ftrace_ops, event);
	138	kfree(event->u.ftrace.symbol_name);
	139	kfree(event->desc->name);
	140	kfree(event->desc);
	141	}
	142	EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);
	143
e3de3dde MD	144	/* This module is permanent. */
	145	int lttng_ftrace_init(void)
	146	{
	147	return 0;
	148	}
	149	module_init(lttng_ftrace_init)
	150
e0a7a7c4 MD	151	MODULE_LICENSE("GPL and additional rights");
	152	MODULE_AUTHOR("Mathieu Desnoyers");
	153	MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");