[lttng-modules.git] / probes / lttng-events.h

#include <lttng.h>
#include <lttng-types.h>
#include <linux/debugfs.h>
#include "../wrapper/vmalloc.h"	/* for wrapper_vmalloc_sync_all() */
#include "../wrapper/ringbuffer/frontend_types.h"
#include "../ltt-events.h"
#include "../ltt-tracer-core.h"

struct lttng_event_field {
	const char *name;
	const struct lttng_type type;
};

struct lttng_event_desc {
	const struct lttng_event_field *fields;
	const char *name;
	void *probe_callback;
	unsigned int nr_fields;
};

/*
 * Macro declarations used for all stages.
 */

/*
 * DECLARE_EVENT_CLASS can be used to add a generic function
 * handlers for events. That is, if all events have the same
 * parameters and just have distinct trace points.
 * Each tracepoint can be defined with DEFINE_EVENT and that
 * will map the DECLARE_EVENT_CLASS to the tracepoint.
 *
 * TRACE_EVENT is a one to one mapping between tracepoint and template.
 */

#undef TRACE_EVENT
#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
	DECLARE_EVENT_CLASS(name,			       \
			     PARAMS(proto),		       \
			     PARAMS(args),		       \
			     PARAMS(tstruct),		       \
			     PARAMS(assign),		       \
			     PARAMS(print))		       \
	DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args))

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

/* Callbacks are meaningless to LTTng. */
#undef TRACE_EVENT_FN
#define TRACE_EVENT_FN(name, proto, args, tstruct,			\
		assign, print, reg, unreg)				\
	TRACE_EVENT(name, PARAMS(proto), PARAMS(args),			\
		PARAMS(tstruct), PARAMS(assign), PARAMS(print))		\

/*
 * Stage 0.1 of the trace events.
 *
 * Create dummy trace calls for each events, verifying that the LTTng module
 * TRACE_EVENT headers match the kernel arguments. Will be optimized out by the
 * compiler.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

#undef TP_PROTO
#define TP_PROTO(args...) args

#undef TP_ARGS
#define TP_ARGS(args...) args

#undef DEFINE_EVENT
#define DEFINE_EVENT(_template, _name, _proto, _args)			\
void trace_##_name(proto);

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 1 of the trace events.
 *
 * Create event field type metadata section.
 * Each event produce an array of fields.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

/* Named field types must be defined in lttng-types.h */

#undef __field
#define __field(_type, _item)					\
	{ .name = #_item, .type = { .atype = atype_integer, .name = #_type} },

#undef __field_ext
#define __field_ext(_type, _item, _filter_type)		__field(_type, _item)

#undef __array
#define __array(_type, _item, _length)				\
	{							\
		.name = #_item,					\
		.type = {					\
		  .atype = atype_array,				\
		  .name = NULL,					\
		  .u.array.elem_type = #_type,			\
		  .u.array.length = _length,			\
		},						\
	},

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)			\
	{							\
		.name = #_item,					\
		.type = {					\
		  .atype = atype_sequence,			\
		  .name = NULL,					\
		  .u.sequence.elem_type = #_type,		\
		  .u.sequence.length_type = "u32",		\
		},						\
	},

#undef __string
#define __string(_item, _src)					\
	{							\
		.name = #_item,					\
		.type = {					\
		  .atype = atype_string,			\
		  .name = NULL,					\
		  .u.string.encoding = lttng_encode_UTF8,	\
		},						\
	},

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args	/* Only one used in this phase */

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	static const struct lttng_event_field __event_fields___##_name[] = { \
		_tstruct						     \
	};

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 1.1 of the trace events.
 *
 * Create probe callback prototypes.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

#undef TP_PROTO
#define TP_PROTO(args...) args

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
static void __event_probe__##_name(void *__data, _proto);

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 2 of the trace events.
 *
 * Create an array of events.
 */

/* Named field types must be defined in lttng-types.h */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

#undef DEFINE_EVENT
#define DEFINE_EVENT(_template, _name, _proto, _args)			       \
		{							       \
			.fields = __event_fields___##_template,		       \
			.name = #_name,					       \
			.probe_callback = (void *) &__event_probe__##_template,\
			.nr_fields = ARRAY_SIZE(__event_fields___##_template), \
		},

#define TP_ID1(_token, _system)	_token##_system
#define TP_ID(_token, _system)	TP_ID1(_token, _system)

static const struct lttng_event_desc TP_ID(__event_desc___, TRACE_SYSTEM)[] = {
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
};

#undef TP_ID1
#undef TP_ID

/*
 * Stage 3 of the trace events.
 *
 * Create seq file metadata output.
 */

#define TP_ID1(_token, _system)	_token##_system
#define TP_ID(_token, _system)	TP_ID1(_token, _system)

static void *TP_ID(__lttng_seq_start__, TRACE_SYSTEM)(struct seq_file *m,
						      loff_t *pos)
{
	const struct lttng_event_desc *desc =
		&TP_ID(__event_desc___, TRACE_SYSTEM)[*pos];

	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
			[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
		return NULL;
	return (void *) desc;
}

static void *TP_ID(__lttng_seq_next__, TRACE_SYSTEM)(struct seq_file *m,
						     void *p, loff_t *ppos)
{
	const struct lttng_event_desc *desc =
		&TP_ID(__event_desc___, TRACE_SYSTEM)[++(*ppos)];

	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
			[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
		return NULL;
	return (void *) desc;
}

static void TP_ID(__lttng_seq_stop__, TRACE_SYSTEM)(struct seq_file *m,
						    void *p)
{
}

static int TP_ID(__lttng_seq_show__, TRACE_SYSTEM)(struct seq_file *m,
						   void *p)
{
	const struct lttng_event_desc *desc = p;
	int i;

	seq_printf(m,	"event {\n"
			"\tname = %s;\n"
			"\tid = UNKNOWN;\n"
			"\tstream = UNKNOWN;\n"
			"\tfields = {\n",
			desc->name);
	for (i = 0; i < desc->nr_fields; i++) {
		if (desc->fields[i].type.name)	/* Named type */
			seq_printf(m,	"\t\t%s",
					desc->fields[i].type.name);
		else				/* Nameless type */
			lttng_print_event_type(m, 2, &desc->fields[i].type);
		seq_printf(m,	" %s;\n", desc->fields[i].name);
	}
	seq_printf(m,	"\t};\n");
	seq_printf(m,	"};\n");
	return 0;
}

static const
struct seq_operations TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM) = {
	.start = TP_ID(__lttng_seq_start__, TRACE_SYSTEM),
	.next = TP_ID(__lttng_seq_next__, TRACE_SYSTEM),
	.stop = TP_ID(__lttng_seq_stop__, TRACE_SYSTEM),
	.show = TP_ID(__lttng_seq_show__, TRACE_SYSTEM),
};

static int
TP_ID(__lttng_types_open__, TRACE_SYSTEM)(struct inode *inode, struct file *file)
{
	return seq_open(file, &TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM));
}

static const
struct file_operations TP_ID(__lttng_types_fops__, TRACE_SYSTEM) = {
        .open = TP_ID(__lttng_types_open__, TRACE_SYSTEM),
        .read = seq_read,
        .llseek = seq_lseek,
        .release = seq_release_private,
};

static struct dentry *TP_ID(__lttng_types_dentry__, TRACE_SYSTEM);

static int TP_ID(__lttng_types_init__, TRACE_SYSTEM)(void)
{
	int ret = 0;

	TP_ID(__lttng_types_dentry__, TRACE_SYSTEM) =
		debugfs_create_file("lttng-events-" __stringify(TRACE_SYSTEM),
				    S_IWUSR, NULL, NULL,
				    &TP_ID(__lttng_types_fops__, TRACE_SYSTEM));
	if (IS_ERR(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM))
	    || !TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)) {
		printk(KERN_ERR "Error creating LTTng type export file\n");
		ret = -ENOMEM;
		goto error;
	}
error:
	return ret;
}

static void TP_ID(__lttng_types_exit__, TRACE_SYSTEM)(void)
{
	debugfs_remove(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM));
}

#undef TP_ID1
#undef TP_ID

/*
 * Stage 4 of the trace events.
 *
 * Create static inline function that calculates event size.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

/* Named field types must be defined in lttng-types.h */

#undef __field
#define __field(_type, _item)						       \
	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	__event_len += sizeof(_type);

#undef __field_ext
#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)

#undef __array
#define __array(_type, _item, _length)					       \
	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	__event_len += sizeof(_type) * (_length);

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)				       \
	__event_len += lib_ring_buffer_align(__event_len, __alignof__(u32));   \
	__event_len += sizeof(u32);					       \
	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	__event_len += sizeof(_type) * (_length);

#undef __string
#define __string(_item, _src)						       \
	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;

#undef TP_PROTO
#define TP_PROTO(args...) args

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
{									      \
	size_t __event_len = 0;						      \
	unsigned int __dynamic_len_idx = 0;				      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	_tstruct							      \
	return __event_len;						      \
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)


/*
 * Stage 5 of the trace events.
 *
 * Create static inline function that calculates event payload alignment.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

/* Named field types must be defined in lttng-types.h */

#undef __field
#define __field(_type, _item)						  \
	__event_align = max_t(size_t, __event_align, __alignof__(_type));

#undef __field_ext
#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)

#undef __array
#define __array(_type, _item, _length)					  \
	__event_align = max_t(size_t, __event_align, __alignof__(_type));

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)				  \
	__event_align = max_t(size_t, __event_align, __alignof__(u32));	  \
	__event_align = max_t(size_t, __event_align, __alignof__(_type));

#undef __string
#define __string(_item, _src)

#undef TP_PROTO
#define TP_PROTO(args...) args

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
static inline size_t __event_get_align__##_name(_proto)			      \
{									      \
	size_t __event_align = 1;					      \
	_tstruct							      \
	return __event_align;						      \
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)


/*
 * Stage 6 of the trace events.
 *
 * Create structure declaration that allows the "assign" macros to access the
 * field types.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

/* Named field types must be defined in lttng-types.h */

#undef __field
#define __field(_type, _item)	_type	_item;

#undef __field_ext
#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)

#undef __array
#define __array(_type, _item, _length)	_type	_item;

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)	_type	_item;

#undef __string
#define __string(_item, _src)	char _item;

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
struct __event_typemap__##_name {					      \
	_tstruct							      \
};

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)


/*
 * Stage 7 of the trace events.
 *
 * Create the probe function : call even size calculation and write event data
 * into the buffer.
 *
 * We use both the field and assignment macros to write the fields in the order
 * defined in the field declaration. The field declarations control the
 * execution order, jumping to the appropriate assignment block.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

#undef __field
#define __field(_type, _item)						\
	goto __assign_##_item;						\
__end_field_##_item:

#undef __field_ext
#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)

#undef __array
#define __array(_type, _item, _length)					\
	goto __assign_##_item;						\
__end_field_##_item:

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)				\
	goto __assign_##_item##_1;					\
__end_field_##_item##_1:						\
	goto __assign_##_item##_2;					\
__end_field_##_item##_2:

#undef __string
#define __string(_item, _src)						\
	goto __assign_##_item;						\
__end_field_##_item:

/*
 * Macros mapping tp_assign() to "=", tp_memcpy() to memcpy() and tp_strcpy() to
 * strcpy().
 */
#undef tp_assign
#define tp_assign(dest, src)						\
__assign_##dest:							\
	{								\
		__typeof__(__typemap.dest) __tmp = (src);		\
		lib_ring_buffer_align_ctx(&ctx, __alignof__(__tmp));	\
		__chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp));	\
	}								\
	goto __end_field_##dest;

#undef tp_memcpy
#define tp_memcpy(dest, src, len)					\
__assign_##dest:							\
	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest));	\
	__chan->ops->event_write(&ctx, src, len);			\
	goto __end_field_##dest;

#undef tp_memcpy_dyn
#define tp_memcpy_dyn(dest, src, len)					\
__assign_##dest##_1:							\
	{								\
		u32 __tmpl = (len);					\
		lib_ring_buffer_align_ctx(&ctx, __alignof__(u32));	\
		__chan->ops->event_write(&ctx, &__tmpl, sizeof(u32));	\
	}								\
	goto __end_field_##dest##_1;					\
__assign_##dest##_2:							\
	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest));	\
	__chan->ops->event_write(&ctx, src, len);			\
	goto __end_field_##dest##_2;

#undef tp_strcpy
#define tp_strcpy(dest, src)						\
	tp_memcpy(dest, src, __get_dynamic_array_len(dest))

/* Named field types must be defined in lttng-types.h */

#undef __get_str
#define __get_str(field)		field

#undef __get_dynamic_array
#define __get_dynamic_array(field)	field

/* Beware: this get len actually consumes the len value */
#undef __get_dynamic_array_len
#define __get_dynamic_array_len(field)	__dynamic_len[__dynamic_len_idx++]

#undef TP_PROTO
#define TP_PROTO(args...) args

#undef TP_ARGS
#define TP_ARGS(args...) args

#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args

#undef TP_fast_assign
#define TP_fast_assign(args...) args

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
static void __event_probe__##_name(void *__data, _proto)		      \
{									      \
	struct ltt_event *__event = __data;				      \
	struct ltt_channel *__chan = __event->chan;			      \
	struct lib_ring_buffer_ctx ctx;					      \
	size_t __event_len, __event_align;				      \
	size_t __dynamic_len_idx = 0;					      \
	size_t __dynamic_len[ARRAY_SIZE(__event_fields___##_name)];	      \
	struct __event_typemap__##_name __typemap;			      \
	int __ret;							      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	if (!ACCESS_ONCE(__chan->session->active))			      \
		return;							      \
	__event_len = __event_get_size__##_name(__dynamic_len, _args);	      \
	__event_align = __event_get_align__##_name(_args);		      \
	lib_ring_buffer_ctx_init(&ctx, __chan->chan, NULL, __event_len,	      \
				 __event_align, -1);			      \
	__ret = __chan->ops->event_reserve(&ctx);			      \
	if (__ret < 0)							      \
		return;							      \
	/* Control code (field ordering) */				      \
	_tstruct							      \
	__chan->ops->event_commit(&ctx);				      \
	return;								      \
	/* Copy code, steered by control code */			      \
	_assign								      \
}

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 8 of the trace events.
 *
 * Register/unregister probes at module load/unload.
 */

#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */

#define TP_ID1(_token, _system)	_token##_system
#define TP_ID(_token, _system)	TP_ID1(_token, _system)
#define module_init_eval1(_token, _system)	module_init(_token##_system)
#define module_init_eval(_token, _system)	module_init_eval1(_token, _system)
#define module_exit_eval1(_token, _system)	module_exit(_token##_system)
#define module_exit_eval(_token, _system)	module_exit_eval1(_token, _system)

static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void)
{
	int ret;
	int i;

	wrapper_vmalloc_sync_all();
	ret = TP_ID(__lttng_types_init__, TRACE_SYSTEM)();
	if (ret)
		return ret;
	for (i = 0; i < ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)); i++) {
		const struct lttng_event_desc *event_desc;

		event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
		ret = ltt_probe_register(event_desc->name,
					 event_desc->probe_callback);
		if (ret)
			goto error;
	}
	return 0;

error:
	for (i--; i >= 0; i--) {
		const struct lttng_event_desc *event_desc;

		event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
		ltt_probe_unregister(event_desc->name);
	}
	return ret;
}

module_init_eval(__lttng_events_init__, TRACE_SYSTEM);

static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)); i++) {
		const struct lttng_event_desc *event_desc;

		event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
		ltt_probe_unregister(event_desc->name);
	}
	TP_ID(__lttng_types_exit__, TRACE_SYSTEM)();
}

module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM);

#undef module_init_eval
#undef module_exit_eval
#undef TP_ID1
#undef TP_ID
Commit	Line	Data
	1	#include <lttng.h>
	2	#include <lttng-types.h>
	3	#include <linux/debugfs.h>
	4	#include "../wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
	5	#include "../wrapper/ringbuffer/frontend_types.h"
	6	#include "../ltt-events.h"
	7	#include "../ltt-tracer-core.h"
	8
	9	struct lttng_event_field {
	10	const char *name;
	11	const struct lttng_type type;
	12	};
	13
	14	struct lttng_event_desc {
	15	const struct lttng_event_field *fields;
	16	const char *name;
	17	void *probe_callback;
	18	unsigned int nr_fields;
	19	};
	20
	21	/*
	22	* Macro declarations used for all stages.
	23	*/
	24
	25	/*
	26	* DECLARE_EVENT_CLASS can be used to add a generic function
	27	* handlers for events. That is, if all events have the same
	28	* parameters and just have distinct trace points.
	29	* Each tracepoint can be defined with DEFINE_EVENT and that
	30	* will map the DECLARE_EVENT_CLASS to the tracepoint.
	31	*
	32	* TRACE_EVENT is a one to one mapping between tracepoint and template.
	33	*/
	34
	35	#undef TRACE_EVENT
	36	#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
	37	DECLARE_EVENT_CLASS(name, \
	38	PARAMS(proto), \
	39	PARAMS(args), \
	40	PARAMS(tstruct), \
	41	PARAMS(assign), \
	42	PARAMS(print)) \
	43	DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args))
	44
	45	#undef DEFINE_EVENT_PRINT
	46	#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
	47	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
	48
	49	/* Callbacks are meaningless to LTTng. */
	50	#undef TRACE_EVENT_FN
	51	#define TRACE_EVENT_FN(name, proto, args, tstruct, \
	52	assign, print, reg, unreg) \
	53	TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \
	54	PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
	55
	56	/*
	57	* Stage 0.1 of the trace events.
	58	*
	59	* Create dummy trace calls for each events, verifying that the LTTng module
	60	* TRACE_EVENT headers match the kernel arguments. Will be optimized out by the
	61	* compiler.
	62	*/
	63
	64	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	65
	66	#undef TP_PROTO
	67	#define TP_PROTO(args...) args
	68
	69	#undef TP_ARGS
	70	#define TP_ARGS(args...) args
	71
	72	#undef DEFINE_EVENT
	73	#define DEFINE_EVENT(_template, _name, _proto, _args) \
	74	void trace_##_name(proto);
	75
	76	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	77
	78	/*
	79	* Stage 1 of the trace events.
	80	*
	81	* Create event field type metadata section.
	82	* Each event produce an array of fields.
	83	*/
	84
	85	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	86
	87	/* Named field types must be defined in lttng-types.h */
	88
	89	#undef __field
	90	#define __field(_type, _item) \
	91	{ .name = #_item, .type = { .atype = atype_integer, .name = #_type} },
	92
	93	#undef __field_ext
	94	#define __field_ext(_type, _item, _filter_type) __field(_type, _item)
	95
	96	#undef __array
	97	#define __array(_type, _item, _length) \
	98	{ \
	99	.name = #_item, \
	100	.type = { \
	101	.atype = atype_array, \
	102	.name = NULL, \
	103	.u.array.elem_type = #_type, \
	104	.u.array.length = _length, \
	105	}, \
	106	},
	107
	108	#undef __dynamic_array
	109	#define __dynamic_array(_type, _item, _length) \
	110	{ \
	111	.name = #_item, \
	112	.type = { \
	113	.atype = atype_sequence, \
	114	.name = NULL, \
	115	.u.sequence.elem_type = #_type, \
	116	.u.sequence.length_type = "u32", \
	117	}, \
	118	},
	119
	120	#undef __string
	121	#define __string(_item, _src) \
	122	{ \
	123	.name = #_item, \
	124	.type = { \
	125	.atype = atype_string, \
	126	.name = NULL, \
	127	.u.string.encoding = lttng_encode_UTF8, \
	128	}, \
	129	},
	130
	131	#undef TP_STRUCT__entry
	132	#define TP_STRUCT__entry(args...) args /* Only one used in this phase */
	133
	134	#undef DECLARE_EVENT_CLASS
	135	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	136	static const struct lttng_event_field __event_fields___##_name[] = { \
	137	_tstruct \
	138	};
	139
	140	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	141
	142	/*
	143	* Stage 1.1 of the trace events.
	144	*
	145	* Create probe callback prototypes.
	146	*/
	147
	148	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	149
	150	#undef TP_PROTO
	151	#define TP_PROTO(args...) args
	152
	153	#undef DECLARE_EVENT_CLASS
	154	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	155	static void __event_probe__##_name(void *__data, _proto);
	156
	157	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	158
	159	/*
	160	* Stage 2 of the trace events.
	161	*
	162	* Create an array of events.
	163	*/
	164
	165	/* Named field types must be defined in lttng-types.h */
	166
	167	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	168
	169	#undef DEFINE_EVENT
	170	#define DEFINE_EVENT(_template, _name, _proto, _args) \
	171	{ \
	172	.fields = __event_fields___##_template, \
	173	.name = #_name, \
	174	.probe_callback = (void *) &__event_probe__##_template,\
	175	.nr_fields = ARRAY_SIZE(__event_fields___##_template), \
	176	},
	177
	178	#define TP_ID1(_token, _system) _token##_system
	179	#define TP_ID(_token, _system) TP_ID1(_token, _system)
	180
	181	static const struct lttng_event_desc TP_ID(__event_desc___, TRACE_SYSTEM)[] = {
	182	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	183	};
	184
	185	#undef TP_ID1
	186	#undef TP_ID
	187
	188	/*
	189	* Stage 3 of the trace events.
	190	*
	191	* Create seq file metadata output.
	192	*/
	193
	194	#define TP_ID1(_token, _system) _token##_system
	195	#define TP_ID(_token, _system) TP_ID1(_token, _system)
	196
	197	static void TP_ID(__lttng_seq_start__, TRACE_SYSTEM)(struct seq_file m,
	198	loff_t *pos)
	199	{
	200	const struct lttng_event_desc *desc =
	201	&TP_ID(__event_desc___, TRACE_SYSTEM)[*pos];
	202
	203	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
	204	[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
	205	return NULL;
	206	return (void *) desc;
	207	}
	208
	209	static void TP_ID(__lttng_seq_next__, TRACE_SYSTEM)(struct seq_file m,
	210	void p, loff_t ppos)
	211	{
	212	const struct lttng_event_desc *desc =
	213	&TP_ID(__event_desc___, TRACE_SYSTEM)[++(*ppos)];
	214
	215	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
	216	[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
	217	return NULL;
	218	return (void *) desc;
	219	}
	220
	221	static void TP_ID(__lttng_seq_stop__, TRACE_SYSTEM)(struct seq_file *m,
	222	void *p)
	223	{
	224	}
	225
	226	static int TP_ID(__lttng_seq_show__, TRACE_SYSTEM)(struct seq_file *m,
	227	void *p)
	228	{
	229	const struct lttng_event_desc *desc = p;
	230	int i;
	231
	232	seq_printf(m, "event {\n"
	233	"\tname = %s;\n"
	234	"\tid = UNKNOWN;\n"
	235	"\tstream = UNKNOWN;\n"
	236	"\tfields = {\n",
	237	desc->name);
	238	for (i = 0; i < desc->nr_fields; i++) {
	239	if (desc->fields[i].type.name) /* Named type */
	240	seq_printf(m, "\t\t%s",
	241	desc->fields[i].type.name);
	242	else /* Nameless type */
	243	lttng_print_event_type(m, 2, &desc->fields[i].type);
	244	seq_printf(m, " %s;\n", desc->fields[i].name);
	245	}
	246	seq_printf(m, "\t};\n");
	247	seq_printf(m, "};\n");
	248	return 0;
	249	}
	250
	251	static const
	252	struct seq_operations TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM) = {
	253	.start = TP_ID(__lttng_seq_start__, TRACE_SYSTEM),
	254	.next = TP_ID(__lttng_seq_next__, TRACE_SYSTEM),
	255	.stop = TP_ID(__lttng_seq_stop__, TRACE_SYSTEM),
	256	.show = TP_ID(__lttng_seq_show__, TRACE_SYSTEM),
	257	};
	258
	259	static int
	260	TP_ID(__lttng_types_open__, TRACE_SYSTEM)(struct inode inode, struct file file)
	261	{
	262	return seq_open(file, &TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM));
	263	}
	264
	265	static const
	266	struct file_operations TP_ID(__lttng_types_fops__, TRACE_SYSTEM) = {
	267	.open = TP_ID(__lttng_types_open__, TRACE_SYSTEM),
	268	.read = seq_read,
	269	.llseek = seq_lseek,
	270	.release = seq_release_private,
	271	};
	272
	273	static struct dentry *TP_ID(__lttng_types_dentry__, TRACE_SYSTEM);
	274
	275	static int TP_ID(__lttng_types_init__, TRACE_SYSTEM)(void)
	276	{
	277	int ret = 0;
	278
	279	TP_ID(__lttng_types_dentry__, TRACE_SYSTEM) =
	280	debugfs_create_file("lttng-events-" __stringify(TRACE_SYSTEM),
	281	S_IWUSR, NULL, NULL,
	282	&TP_ID(__lttng_types_fops__, TRACE_SYSTEM));
	283	if (IS_ERR(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM))
	284	\|\| !TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)) {
	285	printk(KERN_ERR "Error creating LTTng type export file\n");
	286	ret = -ENOMEM;
	287	goto error;
	288	}
	289	error:
	290	return ret;
	291	}
	292
	293	static void TP_ID(__lttng_types_exit__, TRACE_SYSTEM)(void)
	294	{
	295	debugfs_remove(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM));
	296	}
	297
	298	#undef TP_ID1
	299	#undef TP_ID
	300
	301	/*
	302	* Stage 4 of the trace events.
	303	*
	304	* Create static inline function that calculates event size.
	305	*/
	306
	307	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	308
	309	/* Named field types must be defined in lttng-types.h */
	310
	311	#undef __field
	312	#define __field(_type, _item) \
	313	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	314	__event_len += sizeof(_type);
	315
	316	#undef __field_ext
	317	#define __field_ext(_type, _item, _filter_type) __field(_type, _item)
	318
	319	#undef __array
	320	#define __array(_type, _item, _length) \
	321	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	322	__event_len += sizeof(_type) * (_length);
	323
	324	#undef __dynamic_array
	325	#define __dynamic_array(_type, _item, _length) \
	326	__event_len += lib_ring_buffer_align(__event_len, __alignof__(u32)); \
	327	__event_len += sizeof(u32); \
	328	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
	329	__event_len += sizeof(_type) * (_length);
	330
	331	#undef __string
	332	#define __string(_item, _src) \
	333	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
	334
	335	#undef TP_PROTO
	336	#define TP_PROTO(args...) args
	337
	338	#undef TP_STRUCT__entry
	339	#define TP_STRUCT__entry(args...) args
	340
	341	#undef DECLARE_EVENT_CLASS
	342	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	343	static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
	344	{ \
	345	size_t __event_len = 0; \
	346	unsigned int __dynamic_len_idx = 0; \
	347	\
	348	if (0) \
	349	(void) __dynamic_len_idx; /* don't warn if unused */ \
	350	_tstruct \
	351	return __event_len; \
	352	}
	353
	354	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	355
	356
	357
	358	/*
	359	* Stage 5 of the trace events.
	360	*
	361	* Create static inline function that calculates event payload alignment.
	362	*/
	363
	364	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	365
	366	/* Named field types must be defined in lttng-types.h */
	367
	368	#undef __field
	369	#define __field(_type, _item) \
	370	__event_align = max_t(size_t, __event_align, __alignof__(_type));
	371
	372	#undef __field_ext
	373	#define __field_ext(_type, _item, _filter_type) __field(_type, _item)
	374
	375	#undef __array
	376	#define __array(_type, _item, _length) \
	377	__event_align = max_t(size_t, __event_align, __alignof__(_type));
	378
	379	#undef __dynamic_array
	380	#define __dynamic_array(_type, _item, _length) \
	381	__event_align = max_t(size_t, __event_align, __alignof__(u32)); \
	382	__event_align = max_t(size_t, __event_align, __alignof__(_type));
	383
	384	#undef __string
	385	#define __string(_item, _src)
	386
	387	#undef TP_PROTO
	388	#define TP_PROTO(args...) args
	389
	390	#undef TP_STRUCT__entry
	391	#define TP_STRUCT__entry(args...) args
	392
	393	#undef DECLARE_EVENT_CLASS
	394	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	395	static inline size_t __event_get_align__##_name(_proto) \
	396	{ \
	397	size_t __event_align = 1; \
	398	_tstruct \
	399	return __event_align; \
	400	}
	401
	402	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	403
	404
	405	/*
	406	* Stage 6 of the trace events.
	407	*
	408	* Create structure declaration that allows the "assign" macros to access the
	409	* field types.
	410	*/
	411
	412	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	413
	414	/* Named field types must be defined in lttng-types.h */
	415
	416	#undef __field
	417	#define __field(_type, _item) _type _item;
	418
	419	#undef __field_ext
	420	#define __field_ext(_type, _item, _filter_type) __field(_type, _item)
	421
	422	#undef __array
	423	#define __array(_type, _item, _length) _type _item;
	424
	425	#undef __dynamic_array
	426	#define __dynamic_array(_type, _item, _length) _type _item;
	427
	428	#undef __string
	429	#define __string(_item, _src) char _item;
	430
	431	#undef TP_STRUCT__entry
	432	#define TP_STRUCT__entry(args...) args
	433
	434	#undef DECLARE_EVENT_CLASS
	435	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	436	struct __event_typemap__##_name { \
	437	_tstruct \
	438	};
	439
	440	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	441
	442
	443	/*
	444	* Stage 7 of the trace events.
	445	*
	446	* Create the probe function : call even size calculation and write event data
	447	* into the buffer.
	448	*
	449	* We use both the field and assignment macros to write the fields in the order
	450	* defined in the field declaration. The field declarations control the
	451	* execution order, jumping to the appropriate assignment block.
	452	*/
	453
	454	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	455
	456	#undef __field
	457	#define __field(_type, _item) \
	458	goto __assign_##_item; \
	459	__end_field_##_item:
	460
	461	#undef __field_ext
	462	#define __field_ext(_type, _item, _filter_type) __field(_type, _item)
	463
	464	#undef __array
	465	#define __array(_type, _item, _length) \
	466	goto __assign_##_item; \
	467	__end_field_##_item:
	468
	469	#undef __dynamic_array
	470	#define __dynamic_array(_type, _item, _length) \
	471	goto __assign_##_item##_1; \
	472	__end_field_##_item##_1: \
	473	goto __assign_##_item##_2; \
	474	__end_field_##_item##_2:
	475
	476	#undef __string
	477	#define __string(_item, _src) \
	478	goto __assign_##_item; \
	479	__end_field_##_item:
	480
	481	/*
	482	* Macros mapping tp_assign() to "=", tp_memcpy() to memcpy() and tp_strcpy() to
	483	* strcpy().
	484	*/
	485	#undef tp_assign
	486	#define tp_assign(dest, src) \
	487	__assign_##dest: \
	488	{ \
	489	__typeof__(__typemap.dest) __tmp = (src); \
	490	lib_ring_buffer_align_ctx(&ctx, __alignof__(__tmp)); \
	491	__chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp)); \
	492	} \
	493	goto __end_field_##dest;
	494
	495	#undef tp_memcpy
	496	#define tp_memcpy(dest, src, len) \
	497	__assign_##dest: \
	498	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest)); \
	499	__chan->ops->event_write(&ctx, src, len); \
	500	goto __end_field_##dest;
	501
	502	#undef tp_memcpy_dyn
	503	#define tp_memcpy_dyn(dest, src, len) \
	504	__assign_##dest##_1: \
	505	{ \
	506	u32 __tmpl = (len); \
	507	lib_ring_buffer_align_ctx(&ctx, __alignof__(u32)); \
	508	__chan->ops->event_write(&ctx, &__tmpl, sizeof(u32)); \
	509	} \
	510	goto __end_field_##dest##_1; \
	511	__assign_##dest##_2: \
	512	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest)); \
	513	__chan->ops->event_write(&ctx, src, len); \
	514	goto __end_field_##dest##_2;
	515
	516	#undef tp_strcpy
	517	#define tp_strcpy(dest, src) \
	518	tp_memcpy(dest, src, __get_dynamic_array_len(dest))
	519
	520	/* Named field types must be defined in lttng-types.h */
	521
	522	#undef __get_str
	523	#define __get_str(field) field
	524
	525	#undef __get_dynamic_array
	526	#define __get_dynamic_array(field) field
	527
	528	/* Beware: this get len actually consumes the len value */
	529	#undef __get_dynamic_array_len
	530	#define __get_dynamic_array_len(field) __dynamic_len[__dynamic_len_idx++]
	531
	532	#undef TP_PROTO
	533	#define TP_PROTO(args...) args
	534
	535	#undef TP_ARGS
	536	#define TP_ARGS(args...) args
	537
	538	#undef TP_STRUCT__entry
	539	#define TP_STRUCT__entry(args...) args
	540
	541	#undef TP_fast_assign
	542	#define TP_fast_assign(args...) args
	543
	544	#undef DECLARE_EVENT_CLASS
	545	#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	546	static void __event_probe__##_name(void *__data, _proto) \
	547	{ \
	548	struct ltt_event *__event = __data; \
	549	struct ltt_channel *__chan = __event->chan; \
	550	struct lib_ring_buffer_ctx ctx; \
	551	size_t __event_len, __event_align; \
	552	size_t __dynamic_len_idx = 0; \
	553	size_t __dynamic_len[ARRAY_SIZE(__event_fields___##_name)]; \
	554	struct __event_typemap__##_name __typemap; \
	555	int __ret; \
	556	\
	557	if (0) \
	558	(void) __dynamic_len_idx; /* don't warn if unused */ \
	559	if (!ACCESS_ONCE(__chan->session->active)) \
	560	return; \
	561	__event_len = __event_get_size__##_name(__dynamic_len, _args); \
	562	__event_align = __event_get_align__##_name(_args); \
	563	lib_ring_buffer_ctx_init(&ctx, __chan->chan, NULL, __event_len, \
	564	__event_align, -1); \
	565	__ret = __chan->ops->event_reserve(&ctx); \
	566	if (__ret < 0) \
	567	return; \
	568	/* Control code (field ordering) */ \
	569	_tstruct \
	570	__chan->ops->event_commit(&ctx); \
	571	return; \
	572	/* Copy code, steered by control code */ \
	573	_assign \
	574	}
	575
	576	#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
	577
	578	/*
	579	* Stage 8 of the trace events.
	580	*
	581	* Register/unregister probes at module load/unload.
	582	*/
	583
	584	#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
	585
	586	#define TP_ID1(_token, _system) _token##_system
	587	#define TP_ID(_token, _system) TP_ID1(_token, _system)
	588	#define module_init_eval1(_token, _system) module_init(_token##_system)
	589	#define module_init_eval(_token, _system) module_init_eval1(_token, _system)
	590	#define module_exit_eval1(_token, _system) module_exit(_token##_system)
	591	#define module_exit_eval(_token, _system) module_exit_eval1(_token, _system)
	592
	593	static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void)
	594	{
	595	int ret;
	596	int i;
	597
	598	wrapper_vmalloc_sync_all();
	599	ret = TP_ID(__lttng_types_init__, TRACE_SYSTEM)();
	600	if (ret)
	601	return ret;
	602	for (i = 0; i < ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)); i++) {
	603	const struct lttng_event_desc *event_desc;
	604
	605	event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
	606	ret = ltt_probe_register(event_desc->name,
	607	event_desc->probe_callback);
	608	if (ret)
	609	goto error;
	610	}
	611	return 0;
	612
	613	error:
	614	for (i--; i >= 0; i--) {
	615	const struct lttng_event_desc *event_desc;
	616
	617	event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
	618	ltt_probe_unregister(event_desc->name);
	619	}
	620	return ret;
	621	}
	622
	623	module_init_eval(__lttng_events_init__, TRACE_SYSTEM);
	624
	625	static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void)
	626	{
	627	int i;
	628
	629	for (i = 0; i < ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)); i++) {
	630	const struct lttng_event_desc *event_desc;
	631
	632	event_desc = &TP_ID(__event_desc___, TRACE_SYSTEM)[i];
	633	ltt_probe_unregister(event_desc->name);
	634	}
	635	TP_ID(__lttng_types_exit__, TRACE_SYSTEM)();
	636	}
	637
	638	module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM);
	639
	640	#undef module_init_eval
	641	#undef module_exit_eval
	642	#undef TP_ID1
	643	#undef TP_ID