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

/*
 * lttng-events.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.
 */

#include <linux/debugfs.h>
#include "lttng.h"
#include "lttng-types.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"

/*
 * 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 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 2 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 = __type_integer(_type, __BYTE_ORDER, 10, none),\
	},

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

#undef __field_network
#define __field_network(_type, _item)				\
	{							\
	  .name = #_item,					\
	  .type = __type_integer(_type, __BIG_ENDIAN, 10, none),\
	},

#undef __array_enc
#define __array_enc(_type, _item, _length, _encoding)		\
	{							\
	  .name = #_item,					\
	  .type =						\
		{						\
		  .atype = atype_array,				\
		  .u.array =					\
			{					\
			    .length = _length,			\
			    .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \
			},					\
		},						\
	},

#undef __array
#define __array(_type, _item, _length)				\
	__array_enc(_type, _item, _length, none)

#undef __array_text
#define __array_text(_type, _item, _length)			\
	__array_enc(_type, _item, _length, UTF8)

#undef __dynamic_array_enc
#define __dynamic_array_enc(_type, _item, _length, _encoding)	\
	{							\
	  .name = #_item,					\
	  .type =						\
		{						\
		  .atype = atype_sequence,			\
		  .u.sequence =					\
			{					\
			    .length_type = __type_integer(u32, __BYTE_ORDER, 10, none), \
			    .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \
			},					\
		},						\
	},

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)			\
	__dynamic_array_enc(_type, _item, _length, none)

#undef __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)		\
	__dynamic_array_enc(_type, _item, _length, UTF8)

#undef __string
#define __string(_item, _src)					\
	{							\
	  .name = #_item,					\
	  .type =						\
		{						\
		  .atype = atype_string,			\
		  .u.basic.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)

#undef __type_integer

/*
 * Stage 3 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 4 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), \
			.owner = THIS_MODULE,				       \
		},

#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 5 of the trace events.
 *
 * Create a toplevel descriptor for the whole probe.
 */

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

/* non-const because list head will be modified when registered. */
static struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = {
	.event_desc = TP_ID(__event_desc___, TRACE_SYSTEM),
	.nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)),
};

#undef TP_ID1
#undef TP_ID

/*
 * Stage 6 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, ltt_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, ltt_alignof(_type)); \
	__event_len += sizeof(_type) * (_length);

#undef __array_text
#define __array_text(_type, _item, _length)				       \
	__array(_type, _item, _length)

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)				       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_alignof(u32));   \
	__event_len += sizeof(u32);					       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
	__dynamic_len[__dynamic_len_idx] = (_length);			       \
	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
	__dynamic_len_idx++;

#undef __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)			       \
	__dynamic_array(_type, _item, _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 7 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, ltt_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, ltt_alignof(_type));

#undef __array_text
#define __array_text(_type, _item, _length)				  \
	__array(_type, _item, _length)

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

#undef __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)			  \
	__dynamic_array(_type, _item, _length)

#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 8 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 __array_text
#define __array_text(_type, _item, _length)				  \
	__array(_type, _item, _length)

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

#undef __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)			  \
	__dynamic_array(_type, _item, _length)

#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 9 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 __array_text
#define __array_text(_type, _item, _length)				\
	__array(_type, _item, _length)

#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 __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)			\
	__dynamic_array(_type, _item, _length)

#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, ltt_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:							\
	if (0)								\
		(void) __typemap.dest;					\
	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest));	\
	__chan->ops->event_write(&ctx, src, len);			\
	goto __end_field_##dest;

#undef tp_memcpy_dyn
#define tp_memcpy_dyn(dest, src)					\
__assign_##dest##_1:							\
	{								\
		u32 __tmpl = __dynamic_len[__dynamic_len_idx];		\
		lib_ring_buffer_align_ctx(&ctx, ltt_alignof(u32));	\
		__chan->ops->event_write(&ctx, &__tmpl, sizeof(u32));	\
	}								\
	goto __end_field_##dest##_1;					\
__assign_##dest##_2:							\
	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest));	\
	__chan->ops->event_write(&ctx, src,				\
		sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\
	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 (unlikely(!ACCESS_ONCE(__chan->session->active)))		      \
		return;							      \
	if (unlikely(!ACCESS_ONCE(__chan->enabled)))			      \
		return;							      \
	if (unlikely(!ACCESS_ONCE(__event->enabled)))			      \
		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, __event, __event_len,    \
				 __event_align, -1);			      \
	__ret = __chan->ops->event_reserve(&ctx, __event->id);		      \
	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 10 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)
{
	wrapper_vmalloc_sync_all();
	return ltt_probe_register(&TP_ID(__probe_desc___, TRACE_SYSTEM));
}

module_init_eval(__lttng_events_init__, TRACE_SYSTEM);

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