[deliverable/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 "../ltt-tracer.h"

static
int 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 0;
	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 0;
	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 0;
}

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