[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 TRACE_EVENT_NOARGS
#define TRACE_EVENT_NOARGS(name, tstruct, assign, print)       \
	DECLARE_EVENT_CLASS_NOARGS(name,		       \
			     PARAMS(tstruct),		       \
			     PARAMS(assign),		       \
			     PARAMS(print))		       \
	DEFINE_EVENT_NOARGS(name, name)


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

#undef DEFINE_EVENT_NOARGS
#define DEFINE_EVENT_NOARGS(_template, _name)				\
void trace_##_name(void *__data);

#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_full
#define __field_full(_type, _item, _order, _base)		\
	{							\
	  .name = #_item,					\
	  .type = __type_integer(_type, _order, _base, none),	\
	},

#undef __field
#define __field(_type, _item)					\
	__field_full(_type, _item, __BYTE_ORDER, 10)

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

#undef __field_hex
#define __field_hex(_type, _item)				\
	__field_full(_type, _item, __BYTE_ORDER, 16)

#undef __field_network
#define __field_network(_type, _item)				\
	__field_full(_type, _item, __BIG_ENDIAN, 10)

#undef __field_network_hex
#define __field_network_hex(_type, _item)				\
	__field_full(_type, _item, __BIG_ENDIAN, 16)

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

#undef __array
#define __array(_type, _item, _length)				\
	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none)

#undef __array_text
#define __array_text(_type, _item, _length)			\
	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8)

#undef __array_hex
#define __array_hex(_type, _item, _length)			\
	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none)

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

#undef __dynamic_array
#define __dynamic_array(_type, _item, _length)			\
	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none)

#undef __dynamic_array_text
#define __dynamic_array_text(_type, _item, _length)		\
	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8)

#undef __dynamic_array_hex
#define __dynamic_array_hex(_type, _item, _length)		\
	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none)

#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_NOARGS
#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \
	static const struct lttng_event_field __event_fields___##_name[] = { \
		_tstruct						     \
	};

#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
	DECLARE_EVENT_CLASS_NOARGS(_name, PARAMS(_tstruct), PARAMS(_assign), \
			PARAMS(_print))

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * 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);

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

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)

/*
 * Stage 3.9 of the trace events.
 *
 * Create event descriptions.
 */

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

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

#ifndef TP_PROBE_CB
#define TP_PROBE_CB(_template)	&__event_probe__##_template
#endif

#undef DEFINE_EVENT_NOARGS
#define DEFINE_EVENT_NOARGS(_template, _name)				\
static const struct lttng_event_desc __event_desc___##_name = {		\
	.fields = __event_fields___##_template,		     		\
	.name = #_name,					     		\
	.probe_callback = (void *) TP_PROBE_CB(_template),   		\
	.nr_fields = ARRAY_SIZE(__event_fields___##_template),		\
	.owner = THIS_MODULE,				     		\
};

#undef DEFINE_EVENT
#define DEFINE_EVENT(_template, _name, _proto, _args)			\
	DEFINE_EVENT_NOARGS(_template, _name)

#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)


/*
 * Stage 4 of the trace events.
 *
 * Create an array of event description pointers.
 */

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

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

#undef DEFINE_EVENT_NOARGS
#define DEFINE_EVENT_NOARGS(_template, _name)				       \
		&__event_desc___##_name,

#undef DEFINE_EVENT
#define DEFINE_EVENT(_template, _name, _proto, _args)			       \
	DEFINE_EVENT_NOARGS(_template, _name)

#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 __used 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_full
#define __field_full(_type, _item, _order, _base)			       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
	__event_len += sizeof(_type);

#undef __array_enc_ext
#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
	__event_len += sizeof(_type) * (_length);

#undef __dynamic_array_enc_ext
#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
	__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 __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_full
#define __field_full(_type, _item, _order, _base)			  \
	__event_align = max_t(size_t, __event_align, ltt_alignof(_type));

#undef __array_enc_ext
#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)  \
	__event_align = max_t(size_t, __event_align, ltt_alignof(_type));

#undef __dynamic_array_enc_ext
#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
	__event_align = max_t(size_t, __event_align, ltt_alignof(u32));	  \
	__event_align = max_t(size_t, __event_align, ltt_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 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_full
#define __field_full(_type, _item, _order, _base)	_type	_item;

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

#undef __dynamic_array_enc_ext
#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
	_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 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_full
#define __field_full(_type, _item, _order, _base)			\
	goto __assign_##_item;						\
__end_field_##_item:

#undef __array_enc_ext
#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
	goto __assign_##_item;						\
__end_field_##_item:

#undef __dynamic_array_enc_ext
#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
	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, 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_memcpy_from_user
#define tp_memcpy_from_user(dest, src, len)				\
	__assign_##dest:						\
	if (0)								\
		(void) __typemap.dest;					\
	lib_ring_buffer_align_ctx(&__ctx, ltt_alignof(__typemap.dest));	\
	__chan->ops->event_write_from_user(&__ctx, src, len);		\
	goto __end_field_##dest;

#undef tp_copy_string_from_user
#define tp_copy_string_from_user(dest, src)				\
	__assign_##dest:						\
	if (0)								\
		(void) __typemap.dest;					\
	lib_ring_buffer_align_ctx(&__ctx, ltt_alignof(__typemap.dest));	\
	__chan->ops->event_write_from_user(&__ctx, src,			\
		__get_dynamic_array_len(dest) - 1);			\
	__chan->ops->event_memset(&__ctx, 0, 1);			\
	goto __end_field_##dest;

#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								      \
}

#undef DECLARE_EVENT_CLASS_NOARGS
#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print)	      \
static void __event_probe__##_name(void *__data)			      \
{									      \
	struct ltt_event *__event = __data;				      \
	struct ltt_channel *__chan = __event->chan;			      \
	struct lib_ring_buffer_ctx __ctx;				      \
	size_t __event_len, __event_align;				      \
	int __ret;							      \
									      \
	if (unlikely(!ACCESS_ONCE(__chan->session->active)))		      \
		return;							      \
	if (unlikely(!ACCESS_ONCE(__chan->enabled)))			      \
		return;							      \
	if (unlikely(!ACCESS_ONCE(__event->enabled)))			      \
		return;							      \
	__event_len = 0;						      \
	__event_align = 1;						      \
	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)

#ifndef TP_MODULE_OVERRIDE
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);
#endif

#undef module_init_eval
#undef module_exit_eval
#undef TP_ID1
#undef TP_ID

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