[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, proto, args, fields)	\
	TRACEPOINT_EVENT_CLASS(provider, name,		\
			     TP_PARAMS(proto),		\
			     TP_PARAMS(args),		\
			     TP_PARAMS(fields))		\
	TRACEPOINT_EVENT_INSTANCE(provider, name, name, TP_PARAMS(proto), TP_PARAMS(args))

#undef TRACEPOINT_EVENT_NOARGS
#define TRACEPOINT_EVENT_NOARGS(provider, name, fields)	\
	TRACEPOINT_EVENT_CLASS_NOARGS(provider, name,	\
			     TP_PARAMS(fields))		\
	TRACEPOINT_EVENT_INSTANCE_NOARGS(provider, name, name)

/* 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, _proto, _args, _fields) \
	__tracepoint_provider_mismatch_##_provider();

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

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

#undef TRACEPOINT_EVENT_INSTANCE_NOARGS
#define TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name)	 \
	__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_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields)		   	     \
	static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
		_fields							     \
	};

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields)		     \
	TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, TP_PARAMS(_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_PROTO
#define TP_PROTO(args...) args

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

#undef TRACEPOINT_EVENT_CLASS_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields)			     \
static void __event_probe__##_provider##___##_name(void *__data);

#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_NOARGS
#define TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name)	       \
		{							       \
			.fields = __event_fields___##_provider##___##_template,\
			.name = #_provider ":" #_name,			       \
			.probe_callback = (void *) &__event_probe__##_provider##___##_template,\
			.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
		},

#undef TRACEPOINT_EVENT_INSTANCE
#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _proto, _args)	       \
	TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name)

#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_PROTO
#define TP_PROTO(args...) args

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

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields)      \
static inline size_t __event_get_size__##_provider##___##_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 */    \
	_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_PROTO
#define TP_PROTO(args...) args

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

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields)      \
static inline size_t __event_get_align__##_provider##___##_name(_proto)	      \
{									      \
	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_PROTO
#define TP_PROTO(args...) args

#undef TP_VARS
#define TP_VARS(args...) args

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

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields)      \
static void __event_probe__##_provider##___##_name(void *__data, _proto)      \
{									      \
	struct ltt_event *__event = __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, _args);	      \
	__event_align = __event_get_align__##_provider##___##_name(_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);				      \
}

#undef TRACEPOINT_EVENT_CLASS_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields)	      \
static void __event_probe__##_provider##___##_name(void *__data)	      \
{									      \
	struct ltt_event *__event = __data;				      \
	struct ltt_channel *__chan = __event->chan;			      \
	struct lttng_ust_lib_ring_buffer_ctx __ctx;				      \
	size_t __event_len, __event_align;				      \
	int __ret;							      \
									      \
	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 = 0;						      \
	__event_align = 1;						      \
	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
0a42beb6 MD	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>
8d8a24c8	21	#include <urcu/compiler.h>
4318ae1b MD	22	#include <lttng/ust-events.h>
	23	#include <lttng/usterr-signal-safe.h>
	24	#include <lttng/ringbuffer-config.h>
0a42beb6 MD	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
513fc97e MD	46	/* ctf_float is redefined at each step */
513fc97e MD	47
0a42beb6 MD	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
7083f0fe MD	80	#define TRACEPOINT_EVENT(provider, name, proto, args, fields) \
7083f0fe MD	81	TRACEPOINT_EVENT_CLASS(provider, name, \
0a42beb6 MD	82	TP_PARAMS(proto), \
	83	TP_PARAMS(args), \
	84	TP_PARAMS(fields)) \
7083f0fe	85	TRACEPOINT_EVENT_INSTANCE(provider, name, name, TP_PARAMS(proto), TP_PARAMS(args))
0a42beb6	86
8d8a24c8	87	#undef TRACEPOINT_EVENT_NOARGS
7083f0fe MD	88	#define TRACEPOINT_EVENT_NOARGS(provider, name, fields) \
7083f0fe MD	89	TRACEPOINT_EVENT_CLASS_NOARGS(provider, name, \
8d8a24c8	90	TP_PARAMS(fields)) \
7083f0fe	91	TRACEPOINT_EVENT_INSTANCE_NOARGS(provider, name, name)
8d8a24c8 MD	92
	93	/* Helpers */
	94	#define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	95
1dbfff0c MD	96	#define _tp_max_t(type, x, y) \
	97	({ \
	98	type __max1 = (x); \
	99	type __max2 = (y); \
	100	__max1 > __max2 ? __max1: __max2; \
	101	})
	102
34a4456d MD	103	/*
	104	* Stage 0 of the trace events.
	105	*
	106	* Check that each TRACEPOINT_EVENT provider argument match the
	107	* TRACEPOINT_PROVIDER by creating dummy callbacks.
	108	*/
	109
	110	/* Reset all macros within TRACEPOINT_EVENT */
	111	#include <lttng/ust-tracepoint-event-reset.h>
	112
	113	#define TP_ID1(_token, _provider) _token##_provider
	114	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
	115
	116	static inline
	117	void TP_ID(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void)
	118	{
	119	}
	120
	121	#undef TRACEPOINT_EVENT_CLASS
	122	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
	123	__tracepoint_provider_mismatch_##_provider();
	124
	125	#undef TRACEPOINT_EVENT_CLASS_NOARGS
	126	#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields) \
	127	__tracepoint_provider_mismatch_##_provider();
	128
	129	#undef TRACEPOINT_EVENT_INSTANCE
	130	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _proto, _args) \
	131	__tracepoint_provider_mismatch_##_provider();
	132
	133	#undef TRACEPOINT_EVENT_INSTANCE_NOARGS
	134	#define TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name) \
	135	__tracepoint_provider_mismatch_##_provider();
	136
	137	static __attribute__((unused))
	138	void TP_ID(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
	139	{
	140	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
	141	}
	142
	143	#undef TP_ID1
	144	#undef TP_ID
1dbfff0c	145
0a42beb6 MD	146	/*
	147	* Stage 1 of the trace events.
	148	*
	149	* Create event field type metadata section.
	150	* Each event produce an array of fields.
	151	*/
	152
8d8a24c8	153	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	154	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6 MD	155
	156	#undef ctf_integer_ext
	157	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	158	{ \
	159	.name = #_item, \
	160	.type = __type_integer(_type, _byte_order, _base, none),\
	161	},
	162
20f1eee7 MD	163	#undef ctf_float
	164	#define ctf_float(_type, _item, _src) \
	165	{ \
	166	.name = #_item, \
	167	.type = __type_float(_type), \
	168	},
	169
0a42beb6 MD	170	#undef ctf_array_encoded
	171	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
	172	{ \
	173	.name = #_item, \
	174	.type = \
	175	{ \
	176	.atype = atype_array, \
	177	.u.array = \
	178	{ \
	179	.length = _length, \
	180	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	181	}, \
	182	}, \
	183	},
	184
	185	#undef ctf_sequence_encoded
	186	#define ctf_sequence_encoded(_type, _item, _src, \
	187	_length_type, _src_length, _encoding) \
	188	{ \
	189	.name = #_item, \
	190	.type = \
	191	{ \
	192	.atype = atype_sequence, \
	193	.u.sequence = \
	194	{ \
	195	.length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
	196	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	197	}, \
	198	}, \
	199	},
	200
	201	#undef ctf_string
	202	#define ctf_string(_item, _src) \
	203	{ \
	204	.name = #_item, \
	205	.type = \
	206	{ \
	207	.atype = atype_string, \
	208	.u.basic.string.encoding = lttng_encode_UTF8, \
	209	}, \
	210	},
	211
	212	#undef TP_FIELDS
	213	#define TP_FIELDS(args...) args /* Only one used in this phase */
	214
8d8a24c8	215	#undef TRACEPOINT_EVENT_CLASS_NOARGS
7083f0fe MD	216	#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields) \
7083f0fe MD	217	static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
0a42beb6 MD	218	_fields \
	219	};
	220
8d8a24c8	221	#undef TRACEPOINT_EVENT_CLASS
7083f0fe MD	222	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
7083f0fe MD	223	TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, TP_PARAMS(_fields))
8d8a24c8 MD	224
8d8a24c8 MD	225	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6 MD	226
	227	/*
	228	* Stage 2 of the trace events.
	229	*
	230	* Create probe callback prototypes.
	231	*/
	232
8d8a24c8	233	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	234	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6 MD	235
	236	#undef TP_PROTO
	237	#define TP_PROTO(args...) args
	238
	239	#undef TRACEPOINT_EVENT_CLASS
7083f0fe MD	240	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
7083f0fe MD	241	static void __event_probe__##_provider##___##_name(void *__data, _proto);
0a42beb6	242
8d8a24c8	243	#undef TRACEPOINT_EVENT_CLASS_NOARGS
7083f0fe MD	244	#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields) \
7083f0fe MD	245	static void __event_probe__##_provider##___##_name(void *__data);
8d8a24c8 MD	246
8d8a24c8 MD	247	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6 MD	248
	249	/*
	250	* Stage 3 of the trace events.
	251	*
	252	* Create an array of events.
	253	*/
	254
8d8a24c8	255	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	256	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6	257
8d8a24c8	258	#undef TRACEPOINT_EVENT_INSTANCE_NOARGS
7083f0fe	259	#define TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name) \
0a42beb6	260	{ \
7083f0fe MD	261	.fields = __event_fields___##_provider##___##_template,\
	262	.name = #_provider ":" #_name, \
	263	.probe_callback = (void *) &__event_probe__##_provider##___##_template,\
	264	.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
0a42beb6 MD	265	},
0a42beb6 MD	266
8d8a24c8	267	#undef TRACEPOINT_EVENT_INSTANCE
7083f0fe MD	268	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _proto, _args) \
7083f0fe MD	269	TRACEPOINT_EVENT_INSTANCE_NOARGS(_provider, _template, _name)
8d8a24c8	270
a4ada9b8 MD	271	#define TP_ID1(_token, _provider) _token##_provider
a4ada9b8 MD	272	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
0a42beb6	273
a4ada9b8	274	static const struct lttng_event_desc TP_ID(__event_desc___, TRACEPOINT_PROVIDER)[] = {
8d8a24c8	275	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6 MD	276	};
	277
	278	#undef TP_ID1
	279	#undef TP_ID
	280
	281
	282	/*
	283	* Stage 4 of the trace events.
	284	*
	285	* Create a toplevel descriptor for the whole probe.
	286	*/
	287
a4ada9b8 MD	288	#define TP_ID1(_token, _provider) _token##_provider
a4ada9b8 MD	289	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
0a42beb6 MD	290
0a42beb6 MD	291	/* non-const because list head will be modified when registered. */
a4ada9b8 MD	292	static struct lttng_probe_desc TP_ID(__probe_desc___, TRACEPOINT_PROVIDER) = {
	293	.event_desc = TP_ID(__event_desc___, TRACEPOINT_PROVIDER),
	294	.nr_events = _TP_ARRAY_SIZE(TP_ID(__event_desc___, TRACEPOINT_PROVIDER)),
0a42beb6 MD	295	};
	296
	297	#undef TP_ID1
	298	#undef TP_ID
	299
	300	/*
	301	* Stage 5 of the trace events.
	302	*
	303	* Create static inline function that calculates event size.
	304	*/
	305
8d8a24c8	306	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	307	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6 MD	308
	309	#undef ctf_integer_ext
	310	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
1dbfff0c	311	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
0a42beb6 MD	312	__event_len += sizeof(_type);
0a42beb6 MD	313
20f1eee7 MD	314	#undef ctf_float
20f1eee7 MD	315	#define ctf_float(_type, _item, _src) \
1dbfff0c	316	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
20f1eee7 MD	317	__event_len += sizeof(_type);
20f1eee7 MD	318
0a42beb6	319	#undef ctf_array_encoded
41aaf8a5	320	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
1dbfff0c	321	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
0a42beb6 MD	322	__event_len += sizeof(_type) * (_length);
	323
	324	#undef ctf_sequence_encoded
	325	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	326	_src_length, _encoding) \
1dbfff0c	327	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \
0a42beb6	328	__event_len += sizeof(_length_type); \
1dbfff0c	329	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
5dba5937	330	__dynamic_len[__dynamic_len_idx] = (_src_length); \
0a42beb6 MD	331	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \
	332	__dynamic_len_idx++;
	333
	334	#undef ctf_string
	335	#define ctf_string(_item, _src) \
	336	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
	337
	338	#undef TP_PROTO
	339	#define TP_PROTO(args...) args
	340
	341	#undef TP_FIELDS
	342	#define TP_FIELDS(args...) args
	343
	344	#undef TRACEPOINT_EVENT_CLASS
7083f0fe MD	345	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
7083f0fe MD	346	static inline size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _proto) \
0a42beb6 MD	347	{ \
	348	size_t __event_len = 0; \
	349	unsigned int __dynamic_len_idx = 0; \
	350	\
	351	if (0) \
	352	(void) __dynamic_len_idx; /* don't warn if unused */ \
	353	_fields \
	354	return __event_len; \
	355	}
	356
8d8a24c8	357	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6 MD	358
	359	/*
	360	* Stage 6 of the trace events.
	361	*
	362	* Create static inline function that calculates event payload alignment.
	363	*/
	364
8d8a24c8	365	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	366	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6 MD	367
	368	#undef ctf_integer_ext
	369	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
1dbfff0c	370	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
0a42beb6	371
20f1eee7 MD	372	#undef ctf_float
20f1eee7 MD	373	#define ctf_float(_type, _item, _src) \
1dbfff0c	374	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
20f1eee7	375
0a42beb6	376	#undef ctf_array_encoded
41aaf8a5	377	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
1dbfff0c	378	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
0a42beb6 MD	379
	380	#undef ctf_sequence_encoded
	381	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	382	_src_length, _encoding) \
1dbfff0c MD	383	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type)); \
1dbfff0c MD	384	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
0a42beb6 MD	385
	386	#undef ctf_string
	387	#define ctf_string(_item, _src)
	388
	389	#undef TP_PROTO
	390	#define TP_PROTO(args...) args
	391
	392	#undef TP_FIELDS
	393	#define TP_FIELDS(args...) args
	394
	395	#undef TRACEPOINT_EVENT_CLASS
7083f0fe MD	396	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
7083f0fe MD	397	static inline size_t __event_get_align__##_provider##___##_name(_proto) \
0a42beb6 MD	398	{ \
	399	size_t __event_align = 1; \
	400	_fields \
	401	return __event_align; \
	402	}
	403
8d8a24c8	404	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6 MD	405
	406
	407	/*
	408	* Stage 7 of the trace events.
	409	*
	410	* Create the probe function : call even size calculation and write event data
	411	* into the buffer.
	412	*
	413	* We use both the field and assignment macros to write the fields in the order
	414	* defined in the field declaration. The field declarations control the
	415	* execution order, jumping to the appropriate assignment block.
	416	*/
	417
8d8a24c8	418	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	419	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6 MD	420
	421	#undef ctf_integer_ext
	422	#define ctf_integer_ext(_type, _item, _src, _byte_order, _base) \
	423	{ \
	424	_type __tmp = (_src); \
b8b77c00 MD	425	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
b8b77c00 MD	426	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
0a42beb6 MD	427	}
0a42beb6 MD	428
20f1eee7 MD	429	#undef ctf_float
	430	#define ctf_float(_type, _item, _src) \
	431	{ \
	432	_type __tmp = (_src); \
b8b77c00 MD	433	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
b8b77c00 MD	434	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
20f1eee7 MD	435	}
20f1eee7 MD	436
0a42beb6	437	#undef ctf_array_encoded
41aaf8a5	438	#define ctf_array_encoded(_type, _item, _src, _length, _encoding) \
b8b77c00 MD	439	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
b8b77c00 MD	440	__chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
0a42beb6 MD	441
	442	#undef ctf_sequence_encoded
	443	#define ctf_sequence_encoded(_type, _item, _src, _length_type, \
	444	_src_length, _encoding) \
	445	{ \
	446	_length_type __tmpl = __dynamic_len[__dynamic_len_idx]; \
b8b77c00 MD	447	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
b8b77c00 MD	448	__chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
0a42beb6	449	} \
b8b77c00 MD	450	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
b8b77c00 MD	451	__chan->ops->event_write(&__ctx, _src, \
5dba5937	452	sizeof(_type) * __get_dynamic_len(dest));
0a42beb6 MD	453
	454	#undef ctf_string
	455	#define ctf_string(_item, _src) \
b8b77c00 MD	456	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src))); \
b8b77c00 MD	457	__chan->ops->event_write(&__ctx, _src, __get_dynamic_len(dest));
0a42beb6 MD	458
0a42beb6 MD	459	/* Beware: this get len actually consumes the len value */
5dba5937 MD	460	#undef __get_dynamic_len
5dba5937 MD	461	#define __get_dynamic_len(field) __dynamic_len[__dynamic_len_idx++]
0a42beb6 MD	462
	463	#undef TP_PROTO
	464	#define TP_PROTO(args...) args
	465
11dfd4ee MD	466	#undef TP_VARS
11dfd4ee MD	467	#define TP_VARS(args...) args
0a42beb6 MD	468
	469	#undef TP_FIELDS
	470	#define TP_FIELDS(args...) args
	471
	472	#undef TRACEPOINT_EVENT_CLASS
7083f0fe MD	473	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _proto, _args, _fields) \
7083f0fe MD	474	static void __event_probe__##_provider##___##_name(void *__data, _proto) \
0a42beb6 MD	475	{ \
	476	struct ltt_event *__event = __data; \
	477	struct ltt_channel *__chan = __event->chan; \
4cfec15c	478	struct lttng_ust_lib_ring_buffer_ctx __ctx; \
0a42beb6 MD	479	size_t __event_len, __event_align; \
0a42beb6 MD	480	size_t __dynamic_len_idx = 0; \
7083f0fe	481	size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
0a42beb6 MD	482	int __ret; \
	483	\
	484	if (0) \
	485	(void) __dynamic_len_idx; /* don't warn if unused */ \
b5a3dfa5	486	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active))) \
0a42beb6	487	return; \
b5a3dfa5	488	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled))) \
0a42beb6	489	return; \
b5a3dfa5	490	if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled))) \
0a42beb6	491	return; \
7083f0fe MD	492	__event_len = __event_get_size__##_provider##___##_name(__dynamic_len, _args); \
7083f0fe MD	493	__event_align = __event_get_align__##_provider##___##_name(_args); \
b8b77c00	494	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len, \
1d498196	495	__event_align, -1, __chan->handle); \
b8b77c00	496	__ret = __chan->ops->event_reserve(&__ctx, __event->id); \
0a42beb6 MD	497	if (__ret < 0) \
	498	return; \
	499	_fields \
b8b77c00	500	__chan->ops->event_commit(&__ctx); \
0a42beb6 MD	501	}
0a42beb6 MD	502
8d8a24c8	503	#undef TRACEPOINT_EVENT_CLASS_NOARGS
7083f0fe MD	504	#define TRACEPOINT_EVENT_CLASS_NOARGS(_provider, _name, _fields) \
7083f0fe MD	505	static void __event_probe__##_provider##___##_name(void *__data) \
8d8a24c8 MD	506	{ \
	507	struct ltt_event *__event = __data; \
	508	struct ltt_channel *__chan = __event->chan; \
4cfec15c	509	struct lttng_ust_lib_ring_buffer_ctx __ctx; \
8d8a24c8	510	size_t __event_len, __event_align; \
8d8a24c8 MD	511	int __ret; \
8d8a24c8 MD	512	\
b5a3dfa5	513	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active))) \
8d8a24c8	514	return; \
b5a3dfa5	515	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled))) \
8d8a24c8	516	return; \
b5a3dfa5	517	if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled))) \
8d8a24c8	518	return; \
4f6ffb56 MD	519	__event_len = 0; \
4f6ffb56 MD	520	__event_align = 1; \
b8b77c00	521	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len, \
1d498196	522	__event_align, -1, __chan->handle); \
b8b77c00	523	__ret = __chan->ops->event_reserve(&__ctx, __event->id); \
8d8a24c8 MD	524	if (__ret < 0) \
	525	return; \
	526	_fields \
b8b77c00	527	__chan->ops->event_commit(&__ctx); \
8d8a24c8 MD	528	}
	529
	530	#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)
0a42beb6	531
5dba5937 MD	532	#undef __get_dynamic_len
5dba5937 MD	533
0a42beb6 MD	534	/*
	535	* Stage 8 of the trace events.
	536	*
	537	* Register/unregister probes at module load/unload.
	538	*/
	539
8d8a24c8	540	/* Reset all macros within TRACEPOINT_EVENT */
4318ae1b	541	#include <lttng/ust-tracepoint-event-reset.h>
0a42beb6	542
a4ada9b8 MD	543	#define TP_ID1(_token, _provider) _token##_provider
a4ada9b8 MD	544	#define TP_ID(_token, _provider) TP_ID1(_token, _provider)
0a42beb6 MD	545
0a42beb6 MD	546	static void __attribute__((constructor))
a4ada9b8	547	TP_ID(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
0a42beb6 MD	548	{
	549	int ret;
	550
a4ada9b8	551	ret = ltt_probe_register(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
0a42beb6 MD	552	assert(!ret);
	553	}
	554
	555	static void __attribute__((destructor))
a4ada9b8	556	TP_ID(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
0a42beb6	557	{
a4ada9b8	558	ltt_probe_unregister(&TP_ID(__probe_desc___, TRACEPOINT_PROVIDER));
0a42beb6 MD	559	}
	560
	561	#undef TP_ID1
	562	#undef TP_ID