Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1e8ab70d authored by Mathieu Desnoyers's avatar Mathieu Desnoyers Committed by Greg Kroah-Hartman
Browse files

lttng: probe callbacks 



Implement the LTTng probe callbacks. One notable file here is
lttng-events.h, which is the core implementation of the LTTng
TRACE_EVENT macros for generation of probes and tracepoint decription
from the TRACE_EVENT declarations.

Signed-off-by: default avatarMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 97104e24

drivers/staging/lttng/probes/Makefile

0 → 100644
+37 −0
Original line number Diff line number Diff line 
#

# Makefile for the LTT probes.

#



ccflags-y += -I$(PWD)/probes

obj-m += lttng-types.o



obj-m += lttng-probe-lttng.o



obj-m += lttng-probe-sched.o

obj-m += lttng-probe-irq.o



ifneq ($(CONFIG_KVM),)

obj-m += lttng-probe-kvm.o

endif



ifneq ($(CONFIG_BLOCK),)

ifneq ($(CONFIG_EVENT_TRACING),)	# need blk_cmd_buf_len

obj-m +=  $(shell \

	if [ $(VERSION) -ge 3 \

		-o \( $(VERSION) -eq 2 -a $(PATCHLEVEL) -ge 6 -a $(SUBLEVEL) -ge 38 \) ] ; then \

		echo "lttng-probe-block.o" ; fi;)

endif

endif



ifneq ($(CONFIG_KPROBES),)

obj-m += lttng-kprobes.o

endif





ifneq ($(CONFIG_KRETPROBES),)

obj-m += lttng-kretprobes.o

endif



ifneq ($(CONFIG_DYNAMIC_FTRACE),)

obj-m += lttng-ftrace.o

endif

drivers/staging/lttng/probes/define_trace.h

0 → 100644
+132 −0
Original line number Diff line number Diff line 
/*

 * define_trace.h

 *

 * Copyright (C) 2009 Steven Rostedt <rostedt@goodmis.org>

 * Copyright (C) 2010-2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

 *

 * Dual LGPL v2.1/GPL v2 license.

 */



/*

 * Trace files that want to automate creationg of all tracepoints defined

 * in their file should include this file. The following are macros that the

 * trace file may define:

 *

 * TRACE_SYSTEM defines the system the tracepoint is for

 *

 * TRACE_INCLUDE_FILE if the file name is something other than TRACE_SYSTEM.h

 *     This macro may be defined to tell define_trace.h what file to include.

 *     Note, leave off the ".h".

 *

 * TRACE_INCLUDE_PATH if the path is something other than core kernel include/trace

 *     then this macro can define the path to use. Note, the path is relative to

 *     define_trace.h, not the file including it. Full path names for out of tree

 *     modules must be used.

 */



#ifdef CREATE_TRACE_POINTS



/* Prevent recursion */

#undef CREATE_TRACE_POINTS



#include <linux/stringify.h>

/*

 * module.h includes tracepoints, and because ftrace.h

 * pulls in module.h:

 *  trace/ftrace.h -> linux/ftrace_event.h -> linux/perf_event.h ->

 *  linux/ftrace.h -> linux/module.h

 * we must include module.h here before we play with any of

 * the TRACE_EVENT() macros, otherwise the tracepoints included

 * by module.h may break the build.

 */

#include <linux/module.h>



#undef TRACE_EVENT

#define TRACE_EVENT(name, proto, args, tstruct, assign, print)	\

	DEFINE_TRACE(name)



#undef TRACE_EVENT_CONDITION

#define TRACE_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \

	TRACE_EVENT(name,						\

		PARAMS(proto),						\

		PARAMS(args),						\

		PARAMS(tstruct),					\

		PARAMS(assign),						\

		PARAMS(print))



#undef TRACE_EVENT_FN

#define TRACE_EVENT_FN(name, proto, args, tstruct,		\

		assign, print, reg, unreg)			\

	DEFINE_TRACE_FN(name, reg, unreg)



#undef DEFINE_EVENT

#define DEFINE_EVENT(template, name, proto, args) \

	DEFINE_TRACE(name)



#undef DEFINE_EVENT_PRINT

#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\

	DEFINE_TRACE(name)



#undef DEFINE_EVENT_CONDITION

#define DEFINE_EVENT_CONDITION(template, name, proto, args, cond) \

	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))



#undef DECLARE_TRACE

#define DECLARE_TRACE(name, proto, args)	\

	DEFINE_TRACE(name)



#undef TRACE_INCLUDE

#undef __TRACE_INCLUDE



#ifndef TRACE_INCLUDE_FILE

# define TRACE_INCLUDE_FILE TRACE_SYSTEM

# define UNDEF_TRACE_INCLUDE_FILE

#endif



#ifndef TRACE_INCLUDE_PATH

# define __TRACE_INCLUDE(system) <trace/events/system.h>

# define UNDEF_TRACE_INCLUDE_PATH

#else

# define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h)

#endif



# define TRACE_INCLUDE(system) __TRACE_INCLUDE(system)



/* Let the trace headers be reread */

#define TRACE_HEADER_MULTI_READ



#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)



/* Make all open coded DECLARE_TRACE nops */

#undef DECLARE_TRACE

#define DECLARE_TRACE(name, proto, args)



#ifdef LTTNG_PACKAGE_BUILD

#include "lttng-events.h"

#endif



#undef TRACE_EVENT

#undef TRACE_EVENT_FN

#undef TRACE_EVENT_CONDITION

#undef DECLARE_EVENT_CLASS

#undef DEFINE_EVENT

#undef DEFINE_EVENT_PRINT

#undef DEFINE_EVENT_CONDITION

#undef TRACE_HEADER_MULTI_READ

#undef DECLARE_TRACE



/* Only undef what we defined in this file */

#ifdef UNDEF_TRACE_INCLUDE_FILE

# undef TRACE_INCLUDE_FILE

# undef UNDEF_TRACE_INCLUDE_FILE

#endif



#ifdef UNDEF_TRACE_INCLUDE_PATH

# undef TRACE_INCLUDE_PATH

# undef UNDEF_TRACE_INCLUDE_PATH

#endif



/* We may be processing more files */

#define CREATE_TRACE_POINTS



#endif /* CREATE_TRACE_POINTS */

drivers/staging/lttng/probes/lttng-events-reset.h

0 → 100644
+84 −0
Original line number Diff line number Diff line 
/*

 * lttng-events-reset.h

 *

 * Copyright (C) 2010-2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

 *

 * Dual LGPL v2.1/GPL v2 license.

 */



/* Reset macros used within TRACE_EVENT to "nothing" */



#undef __field_full

#define __field_full(_type, _item, _order, _base)



#undef __array_enc_ext

#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)



#undef __dynamic_array_enc_ext

#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)



#undef __dynamic_array_len

#define __dynamic_array_len(_type, _item, _length)



#undef __string

#define __string(_item, _src)



#undef tp_assign

#define tp_assign(dest, src)



#undef tp_memcpy

#define tp_memcpy(dest, src, len)



#undef tp_memcpy_dyn

#define tp_memcpy_dyn(dest, src, len)



#undef tp_strcpy

#define tp_strcpy(dest, src)



#undef __get_str

#define __get_str(field)



#undef __get_dynamic_array

#define __get_dynamic_array(field)



#undef __get_dynamic_array_len

#define __get_dynamic_array_len(field)



#undef TP_PROTO

#define TP_PROTO(args...)



#undef TP_ARGS

#define TP_ARGS(args...)



#undef TP_STRUCT__entry

#define TP_STRUCT__entry(args...)



#undef TP_fast_assign

#define TP_fast_assign(args...)



#undef __perf_count

#define __perf_count(args...)



#undef __perf_addr

#define __perf_addr(args...)



#undef TP_perf_assign

#define TP_perf_assign(args...)



#undef TP_printk

#define TP_printk(args...)



#undef DECLARE_EVENT_CLASS

#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)



#undef DECLARE_EVENT_CLASS_NOARGS

#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print)



#undef DEFINE_EVENT

#define DEFINE_EVENT(_template, _name, _proto, _args)



#undef DEFINE_EVENT_NOARGS

#define DEFINE_EVENT_NOARGS(_template, _name)



#undef TRACE_EVENT_FLAGS

#define TRACE_EVENT_FLAGS(name, value)

drivers/staging/lttng/probes/lttng-events.h

0 → 100644
+703 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/lttng/probes/lttng-ftrace.c

0 → 100644
+188 −0
Original line number Diff line number Diff line 
/*

 * (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).

 *

 * 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 "../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 (unlikely(!ACCESS_ONCE(chan->session->active)))

		return;

	if (unlikely(!ACCESS_ONCE(chan->enabled)))

		return;

	if (unlikely(!ACCESS_ONCE(event->enabled)))

		return;



	lib_ring_buffer_ctx_init(&ctx, chan->chan, event,

				 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 = 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 = ltt_alignof(unsigned long) * CHAR_BIT;

	fields[1].type.u.basic.integer.signedness = 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 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");