[lttng-ust.git] / include / lttng / ust-tracepoint-event.h

/*
 * Copyright (C) 2009     Steven Rostedt <srostedt@redhat.com>
 * Copyright (C) 2011     Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include <stdio.h>
#include <urcu/compiler.h>
#include <lttng/ust-events.h>
#include <lttng/usterr-signal-safe.h>
#include <lttng/ringbuffer-config.h>

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

#undef ctf_integer
#define ctf_integer(_type, _item, _src)				\
	ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10)

#undef ctf_integer_hex
#define ctf_integer_hex(_type, _item, _src)			\
	ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 16)

#undef ctf_integer_network
#define ctf_integer_network(_type, _item, _src)			\
	ctf_integer_ext(_type, _item, _src, BIG_ENDIAN, 10)

#undef ctf_integer_network_hex
#define ctf_integer_network_hex(_type, _item, _src)		\
	ctf_integer_ext(_type, _item, _src, BIG_ENDIAN, 16)

/* ctf_float is redefined at each step */

#undef ctf_array
#define ctf_array(_type, _item, _src, _length)			\
	ctf_array_encoded(_type, _item, _src, _length, none)

#undef ctf_array_text
#define ctf_array_text(_type, _item, _src, _length)		\
	ctf_array_encoded(_type, _item, _src, _length, UTF8)

#undef ctf_sequence
#define ctf_sequence(_type, _item, _src, _length_type, _src_length)	\
	ctf_sequence_encoded(_type, _item, _src,			\
			_length_type, _src_length, none)

#undef ctf_sequence_text
#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) \
	ctf_sequence_encoded(_type, _item, _src,			 \
			_length_type, _src_length, UTF8)

/* ctf_string is redefined at each step */

/*
 * TRACEPOINT_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
 * TRACEPOINT_EVENT_INSTANCE and that will map the
 * TRACEPOINT_EVENT_CLASS to the tracepoint.
 *
 * TRACEPOINT_EVENT is a one to one mapping between tracepoint and
 * template.
 */

#undef TRACEPOINT_EVENT
#define TRACEPOINT_EVENT(provider, name, args, fields)	\
	TRACEPOINT_EVENT_CLASS(provider, name,		\
			     TP_PARAMS(args),		\
			     TP_PARAMS(fields))		\
	TRACEPOINT_EVENT_INSTANCE(provider, name, name, TP_PARAMS(args))

/* Helpers */
#define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

#define _tp_max_t(type, x, y)				\
	({						\
		type __max1 = (x);              	\
		type __max2 = (y);              	\
		__max1 > __max2 ? __max1: __max2;	\
	})

/*
 * Stage 0 of the trace events.
 *
 * Check that each TRACEPOINT_EVENT provider argument match the
 * TRACEPOINT_PROVIDER by creating dummy callbacks.
 */

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

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

static inline
void TP_ID(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void)
{
}

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) 	\
	__tracepoint_provider_mismatch_##_provider();

#undef TRACEPOINT_EVENT_INSTANCE
#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)	\
	__tracepoint_provider_mismatch_##_provider();

static __attribute__((unused))
void TP_ID(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
{
#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
}

#undef TP_ID1
#undef TP_ID

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

#undef ctf_integer_ext
#define ctf_integer_ext(_type, _item, _src, _byte_order, _base)	\
	{							\
	  .name = #_item,					\
	  .type = __type_integer(_type, _byte_order, _base, none),\
	},

#undef ctf_float
#define ctf_float(_type, _item, _src)				\
	{							\
	  .name = #_item,					\
	  .type = __type_float(_type),				\
	},

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

#undef ctf_sequence_encoded
#define ctf_sequence_encoded(_type, _item, _src,	\
			_length_type, _src_length, _encoding)	\
	{							\
	  .name = #_item,					\
	  .type =						\
		{						\
		  .atype = atype_sequence,			\
		  .u.sequence =					\
			{					\
			    .length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
			    .elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
			},					\
		},						\
	},

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

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

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)		   	     \
	static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
		_fields									     \
	};

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

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

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)		\
static void __event_probe__##_provider##___##_name(_TP_ARGS_PROTO_DATA(_args));

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

#undef TRACEPOINT_EVENT_INSTANCE
#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args)	       \
		{							       \
			.fields = __event_fields___##_provider##___##_template,\
			.name = #_provider ":" #_name,			       \
			.probe_callback = (void *) &__event_probe__##_provider##___##_template,\
			.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
		},

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

static const struct lttng_event_desc TP_ID(__event_desc___, TRACEPOINT_PROVIDER)[] = {
#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
};

#undef TP_ID1
#undef TP_ID


/*
 * Stage 4 of the trace events.
 *
 * Create a toplevel descriptor for the whole probe.
 */

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

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

#undef TP_ID1
#undef TP_ID

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

#undef ctf_integer_ext
#define ctf_integer_ext(_type, _item, _src, _byte_order, _base)		       \
	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	__event_len += sizeof(_type);

#undef ctf_float
#define ctf_float(_type, _item, _src)		      			       \
	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	__event_len += sizeof(_type);

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length, _encoding)	       \
	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	__event_len += sizeof(_type) * (_length);

#undef ctf_sequence_encoded
#define ctf_sequence_encoded(_type, _item, _src, _length_type,	\
			_src_length, _encoding)			\
	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type));   \
	__event_len += sizeof(_length_type);				       \
	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	__dynamic_len[__dynamic_len_idx] = (_src_length);		       \
	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
	__dynamic_len_idx++;

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

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

#undef TP_FIELDS
#define TP_FIELDS(args...) args

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)      \
static inline size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_PROTO_DATA(_args)) \
{									      \
	size_t __event_len = 0;						      \
	unsigned int __dynamic_len_idx = 0;				      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	_fields								      \
	return __event_len;						      \
}

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

#undef ctf_integer_ext
#define ctf_integer_ext(_type, _item, _src, _byte_order, _base)		       \
	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));

#undef ctf_float
#define ctf_float(_type, _item, _src)					       \
	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length, _encoding)	       \
	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));

#undef ctf_sequence_encoded
#define ctf_sequence_encoded(_type, _item, _src, _length_type,	\
			_src_length, _encoding)			\
	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type));	  \
	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));

#undef ctf_string
#define ctf_string(_item, _src)

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

#undef TP_FIELDS
#define TP_FIELDS(args...) args

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)	      \
static inline								      \
size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args))      \
{									      \
	size_t __event_align = 1;					      \
	_fields								      \
	return __event_align;						      \
}

#include TRACEPOINT_INCLUDE(TRACEPOINT_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.
 */

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

#undef ctf_integer_ext
#define ctf_integer_ext(_type, _item, _src, _byte_order, _base)	        \
	{								\
		_type __tmp = (_src);					\
		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
		__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	}

#undef ctf_float
#define ctf_float(_type, _item, _src)				        \
	{								\
		_type __tmp = (_src);					\
		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
		__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	}

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length, _encoding)       \
	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));	\
	__chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));

#undef ctf_sequence_encoded
#define ctf_sequence_encoded(_type, _item, _src, _length_type,		\
			_src_length, _encoding)			\
	{								\
		_length_type __tmpl = __dynamic_len[__dynamic_len_idx];	\
		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
		__chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
	}								\
	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type));	\
	__chan->ops->event_write(&__ctx, _src,				\
		sizeof(_type) * __get_dynamic_len(dest));

#undef ctf_string
#define ctf_string(_item, _src)					        \
	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src)));	\
	__chan->ops->event_write(&__ctx, _src, __get_dynamic_len(dest));

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

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

#undef TP_FIELDS
#define TP_FIELDS(args...) args

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)	      \
static void __event_probe__##_provider##___##_name(_TP_ARGS_PROTO_DATA(_args))\
{									      \
	struct ltt_event *__event = __tp_cb_data;			      \
	struct ltt_channel *__chan = __event->chan;			      \
	struct lttng_ust_lib_ring_buffer_ctx __ctx;				      \
	size_t __event_len, __event_align;				      \
	size_t __dynamic_len_idx = 0;					      \
	size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)];	      \
	int __ret;							      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active)))	      \
		return;							      \
	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled)))		      \
		return;							      \
	if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled)))		      \
		return;							      \
	__event_len = __event_get_size__##_provider##___##_name(__dynamic_len,\
		 _TP_ARGS_VARS_DATA(_args));				      \
	__event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VARS(_args)); \
	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len,  \
				 __event_align, -1, __chan->handle);	      \
	__ret = __chan->ops->event_reserve(&__ctx, __event->id);	      \
	if (__ret < 0)							      \
		return;							      \
	_fields								      \
	__chan->ops->event_commit(&__ctx);				      \
}

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

#undef __get_dynamic_len

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

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>

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

static void __attribute__((constructor))
TP_ID(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
{
	int ret;

	ret = ltt_probe_register(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
	assert(!ret);
}

static void __attribute__((destructor))
TP_ID(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
{
	ltt_probe_unregister(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
}

#undef TP_ID1
#undef TP_ID
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com>
	3	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation;
	8	* version 2.1 of the License.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19
	20	#include <stdio.h>
	21	#include <urcu/compiler.h>
	22	#include <lttng/ust-events.h>
	23	#include <lttng/usterr-signal-safe.h>
	24	#include <lttng/ringbuffer-config.h>
	25
	26	/*
	27	* Macro declarations used for all stages.
	28	*/
	29
	30	#undef ctf_integer
	31	#define ctf_integer(_type, _item, _src) \
	32	ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 10)
	33
	34	#undef ctf_integer_hex
	35	#define ctf_integer_hex(_type, _item, _src) \
	36	ctf_integer_ext(_type, _item, _src, BYTE_ORDER, 16)
	37
	38	#undef ctf_integer_network
	39	#define ctf_integer_network(_type, _item, _src) \
	40	ctf_integer_ext(_type, _item, _src, BIG_ENDIAN, 10)
	41
	42	#undef ctf_integer_network_hex
	43	#define ctf_integer_network_hex(_type, _item, _src) \
	44	ctf_integer_ext(_type, _item, _src, BIG_ENDIAN, 16)
	45
	46	/* ctf_float is redefined at each step */
	47
	48	#undef ctf_array
	49	#define ctf_array(_type, _item, _src, _length) \
	50	ctf_array_encoded(_type, _item, _src, _length, none)
	51
	52	#undef ctf_array_text
	53	#define ctf_array_text(_type, _item, _src, _length) \
	54	ctf_array_encoded(_type, _item, _src, _length, UTF8)
	55
	56	#undef ctf_sequence
	57	#define ctf_sequence(_type, _item, _src, _length_type, _src_length) \
	58	ctf_sequence_encoded(_type, _item, _src, \
	59	_length_type, _src_length, none)
	60
	61	#undef ctf_sequence_text
	62	#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) \
	63	ctf_sequence_encoded(_type, _item, _src, \
	64	_length_type, _src_length, UTF8)
	65
	66	/* ctf_string is redefined at each step */
	67
	68	/*
	69	* TRACEPOINT_EVENT_CLASS can be used to add a generic function handlers
	70	* for events. That is, if all events have the same parameters and just
	71	* have distinct trace points. Each tracepoint can be defined with
	72	* TRACEPOINT_EVENT_INSTANCE and that will map the
	73	* TRACEPOINT_EVENT_CLASS to the tracepoint.
	74	*
	75	* TRACEPOINT_EVENT is a one to one mapping between tracepoint and
	76	* template.
	77	*/
	78
	79	#undef TRACEPOINT_EVENT
	80	#define TRACEPOINT_EVENT(provider, name, args, fields) \
	81	TRACEPOINT_EVENT_CLASS(provider, name, \
	82	TP_PARAMS(args), \
	83	TP_PARAMS(fields)) \
	84	TRACEPOINT_EVENT_INSTANCE(provider, name, name, TP_PARAMS(args))
	85
	86	/* Helpers */
	87	#define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	88
	89	#define _tp_max_t(type, x, y) \
	90	({ \
	91	type __max1 = (x); \
	92	type __max2 = (y); \
	93	__max1 > __max2 ? __max1: __max2; \
	94	})
	95
	96	/*
	97	* Stage 0 of the trace events.
	98	*
	99	* Check that each TRACEPOINT_EVENT provider argument match the
	100	* TRACEPOINT_PROVIDER by creating dummy callbacks.
	101	*/
	102
	103	/* Reset all macros within TRACEPOINT_EVENT */
	104	#include <lttng/ust-tracepoint-event-reset.h>
	105
	106	#define TP_ID1(_token, _provider) _token##_provider
	107	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
	108
	109	static inline
	110	void TP_ID(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void)
	111	{
	112	}
	113
	114	#undef TRACEPOINT_EVENT_CLASS
	115	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	116	__tracepoint_provider_mismatch_##_provider();
	117
	118	#undef TRACEPOINT_EVENT_INSTANCE
	119	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	120	__tracepoint_provider_mismatch_##_provider();
	121
	122	static __attribute__((unused))
	123	void TP_ID(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
	124	{
	125	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	126	}
	127
	128	#undef TP_ID1
	129	#undef TP_ID
	130
	131	/*
	132	* Stage 1 of the trace events.
	133	*
	134	* Create event field type metadata section.
	135	* Each event produce an array of fields.
	136	*/
	137
	138	/* Reset all macros within TRACEPOINT_EVENT */
	139	#include <lttng/ust-tracepoint-event-reset.h>
	140
	141	#undef ctf_integer_ext
	142	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	143	{ \
	144	.name = #_item, \
	145	.type = __type_integer(_type, _byte_order, _base, none),\
	146	},
	147
	148	#undef ctf_float
	149	#define ctf_float(_type, _item, _src) \
	150	{ \
	151	.name = #_item, \
	152	.type = __type_float(_type), \
	153	},
	154
	155	#undef ctf_array_encoded
	156	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
	157	{ \
	158	.name = #_item, \
	159	.type = \
	160	{ \
	161	.atype = atype_array, \
	162	.u.array = \
	163	{ \
	164	.length = _length, \
	165	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	166	}, \
	167	}, \
	168	},
	169
	170	#undef ctf_sequence_encoded
	171	#define ctf_sequence_encoded(_type, _item, _src, \
	172	_length_type, _src_length, _encoding) \
	173	{ \
	174	.name = #_item, \
	175	.type = \
	176	{ \
	177	.atype = atype_sequence, \
	178	.u.sequence = \
	179	{ \
	180	.length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
	181	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	182	}, \
	183	}, \
	184	},
	185
	186	#undef ctf_string
	187	#define ctf_string(_item, _src) \
	188	{ \
	189	.name = #_item, \
	190	.type = \
	191	{ \
	192	.atype = atype_string, \
	193	.u.basic.string.encoding = lttng_encode_UTF8, \
	194	}, \
	195	},
	196
	197	#undef TP_FIELDS
	198	#define TP_FIELDS(args...) args /* Only one used in this phase */
	199
	200	#undef TRACEPOINT_EVENT_CLASS
	201	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	202	static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
	203	_fields \
	204	};
	205
	206	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	207
	208	/*
	209	* Stage 2 of the trace events.
	210	*
	211	* Create probe callback prototypes.
	212	*/
	213
	214	/* Reset all macros within TRACEPOINT_EVENT */
	215	#include <lttng/ust-tracepoint-event-reset.h>
	216
	217	#undef TP_ARGS
	218	#define TP_ARGS(args...) args
	219
	220	#undef TRACEPOINT_EVENT_CLASS
	221	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	222	static void __event_probe__##_provider##___##_name(_TP_ARGS_PROTO_DATA(_args));
	223
	224	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	225
	226	/*
	227	* Stage 3 of the trace events.
	228	*
	229	* Create an array of events.
	230	*/
	231
	232	/* Reset all macros within TRACEPOINT_EVENT */
	233	#include <lttng/ust-tracepoint-event-reset.h>
	234
	235	#undef TRACEPOINT_EVENT_INSTANCE
	236	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	237	{ \
	238	.fields = __event_fields___##_provider##___##_template,\
	239	.name = #_provider ":" #_name, \
	240	.probe_callback = (void *) &__event_probe__##_provider##___##_template,\
	241	.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
	242	},
	243
	244	#define TP_ID1(_token, _provider) _token##_provider
	245	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
	246
	247	static const struct lttng_event_desc TP_ID(__event_desc___, TRACEPOINT_PROVIDER)[] = {
	248	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	249	};
	250
	251	#undef TP_ID1
	252	#undef TP_ID
	253
	254
	255	/*
	256	* Stage 4 of the trace events.
	257	*
	258	* Create a toplevel descriptor for the whole probe.
	259	*/
	260
	261	#define TP_ID1(_token, _provider) _token##_provider
	262	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
	263
	264	/* non-const because list head will be modified when registered. */
	265	static struct lttng_probe_desc TP_ID(__probe_desc___, TRACEPOINT_PROVIDER) = {
	266	.event_desc = TP_ID(__event_desc___, TRACEPOINT_PROVIDER),
	267	.nr_events = _TP_ARRAY_SIZE(TP_ID(__event_desc___, TRACEPOINT_PROVIDER)),
	268	};
	269
	270	#undef TP_ID1
	271	#undef TP_ID
	272
	273	/*
	274	* Stage 5 of the trace events.
	275	*
	276	* Create static inline function that calculates event size.
	277	*/
	278
	279	/* Reset all macros within TRACEPOINT_EVENT */
	280	#include <lttng/ust-tracepoint-event-reset.h>
	281
	282	#undef ctf_integer_ext
	283	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	284	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	285	__event_len += sizeof(_type);
	286
	287	#undef ctf_float
	288	#define ctf_float(_type, _item, _src) \
	289	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	290	__event_len += sizeof(_type);
	291
	292	#undef ctf_array_encoded
	293	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
	294	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	295	__event_len += sizeof(_type) * (_length);
	296
	297	#undef ctf_sequence_encoded
	298	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	299	_src_length, _encoding) \
	300	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \
	301	__event_len += sizeof(_length_type); \
	302	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	303	__dynamic_len[__dynamic_len_idx] = (_src_length); \
	304	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \
	305	__dynamic_len_idx++;
	306
	307	#undef ctf_string
	308	#define ctf_string(_item, _src) \
	309	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
	310
	311	#undef TP_ARGS
	312	#define TP_ARGS(args...) args
	313
	314	#undef TP_FIELDS
	315	#define TP_FIELDS(args...) args
	316
	317	#undef TRACEPOINT_EVENT_CLASS
	318	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	319	static inline size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_PROTO_DATA(_args)) \
	320	{ \
	321	size_t __event_len = 0; \
	322	unsigned int __dynamic_len_idx = 0; \
	323	\
	324	if (0) \
	325	(void) __dynamic_len_idx; /* don't warn if unused */ \
	326	_fields \
	327	return __event_len; \
	328	}
	329
	330	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	331
	332	/*
	333	* Stage 6 of the trace events.
	334	*
	335	* Create static inline function that calculates event payload alignment.
	336	*/
	337
	338	/* Reset all macros within TRACEPOINT_EVENT */
	339	#include <lttng/ust-tracepoint-event-reset.h>
	340
	341	#undef ctf_integer_ext
	342	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	343	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	344
	345	#undef ctf_float
	346	#define ctf_float(_type, _item, _src) \
	347	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	348
	349	#undef ctf_array_encoded
	350	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
	351	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	352
	353	#undef ctf_sequence_encoded
	354	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	355	_src_length, _encoding) \
	356	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type)); \
	357	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	358
	359	#undef ctf_string
	360	#define ctf_string(_item, _src)
	361
	362	#undef TP_ARGS
	363	#define TP_ARGS(args...) args
	364
	365	#undef TP_FIELDS
	366	#define TP_FIELDS(args...) args
	367
	368	#undef TRACEPOINT_EVENT_CLASS
	369	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	370	static inline \
	371	size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \
	372	{ \
	373	size_t __event_align = 1; \
	374	_fields \
	375	return __event_align; \
	376	}
	377
	378	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	379
	380
	381	/*
	382	* Stage 7 of the trace events.
	383	*
	384	* Create the probe function : call even size calculation and write event data
	385	* into the buffer.
	386	*
	387	* We use both the field and assignment macros to write the fields in the order
	388	* defined in the field declaration. The field declarations control the
	389	* execution order, jumping to the appropriate assignment block.
	390	*/
	391
	392	/* Reset all macros within TRACEPOINT_EVENT */
	393	#include <lttng/ust-tracepoint-event-reset.h>
	394
	395	#undef ctf_integer_ext
	396	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	397	{ \
	398	_type __tmp = (_src); \
	399	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
	400	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	401	}
	402
	403	#undef ctf_float
	404	#define ctf_float(_type, _item, _src) \
	405	{ \
	406	_type __tmp = (_src); \
	407	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
	408	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	409	}
	410
	411	#undef ctf_array_encoded
	412	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
	413	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
	414	__chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
	415
	416	#undef ctf_sequence_encoded
	417	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	418	_src_length, _encoding) \
	419	{ \
	420	_length_type __tmpl = __dynamic_len[__dynamic_len_idx]; \
	421	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
	422	__chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
	423	} \
	424	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
	425	__chan->ops->event_write(&__ctx, _src, \
	426	sizeof(_type) * __get_dynamic_len(dest));
	427
	428	#undef ctf_string
	429	#define ctf_string(_item, _src) \
	430	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src))); \
	431	__chan->ops->event_write(&__ctx, _src, __get_dynamic_len(dest));
	432
	433	/* Beware: this get len actually consumes the len value */
	434	#undef __get_dynamic_len
	435	#define __get_dynamic_len(field) __dynamic_len[__dynamic_len_idx++]
	436
	437	#undef TP_ARGS
	438	#define TP_ARGS(args...) args
	439
	440	#undef TP_FIELDS
	441	#define TP_FIELDS(args...) args
	442
	443	#undef TRACEPOINT_EVENT_CLASS
	444	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	445	static void __event_probe__##_provider##___##_name(_TP_ARGS_PROTO_DATA(_args))\
	446	{ \
	447	struct ltt_event *__event = __tp_cb_data; \
	448	struct ltt_channel *__chan = __event->chan; \
	449	struct lttng_ust_lib_ring_buffer_ctx __ctx; \
	450	size_t __event_len, __event_align; \
	451	size_t __dynamic_len_idx = 0; \
	452	size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
	453	int __ret; \
	454	\
	455	if (0) \
	456	(void) __dynamic_len_idx; /* don't warn if unused */ \
	457	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active))) \
	458	return; \
	459	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled))) \
	460	return; \
	461	if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled))) \
	462	return; \
	463	__event_len = __event_get_size__##_provider##___##_name(__dynamic_len,\
	464	_TP_ARGS_VARS_DATA(_args)); \
	465	__event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VARS(_args)); \
	466	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len, \
	467	__event_align, -1, __chan->handle); \
	468	__ret = __chan->ops->event_reserve(&__ctx, __event->id); \
	469	if (__ret < 0) \
	470	return; \
	471	_fields \
	472	__chan->ops->event_commit(&__ctx); \
	473	}
	474
	475	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	476
	477	#undef __get_dynamic_len
	478
	479	/*
	480	* Stage 8 of the trace events.
	481	*
	482	* Register/unregister probes at module load/unload.
	483	*/
	484
	485	/* Reset all macros within TRACEPOINT_EVENT */
	486	#include <lttng/ust-tracepoint-event-reset.h>
	487
	488	#define TP_ID1(_token, _provider) _token##_provider
	489	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
	490
	491	static void __attribute__((constructor))
	492	TP_ID(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
	493	{
	494	int ret;
	495
	496	ret = ltt_probe_register(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
	497	assert(!ret);
	498	}
	499
	500	static void __attribute__((destructor))
	501	TP_ID(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
	502	{
	503	ltt_probe_unregister(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
	504	}
	505
	506	#undef TP_ID1
	507	#undef TP_ID