[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.
 */

#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);

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