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

/*
 * Copyright (c) 2011-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

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

/*
 * TRACEPOINT_EVENT_CLASS declares a class of tracepoints receiving the
 * same arguments and having the same field layout.
 *
 * TRACEPOINT_EVENT_INSTANCE declares an instance of a tracepoint, with
 * its own provider and name. It refers to a class (template).
 *
 * TRACEPOINT_EVENT declared both a class and an instance and does a
 * direct mapping from the instance to the class.
 */

#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 tracepoint event generation.
 *
 * 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>

static inline
void _TP_COMBINE_TOKENS(__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_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
{
#include TRACEPOINT_INCLUDE
}

/*
 * Stage 0.1 of tracepoint event generation.
 *
 * Check that each TRACEPOINT_EVENT provider:name does not exceed the
 * tracepoint name length limit.
 */

/* 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)	\
static const char							\
	__tp_name_len_check##_provider##___##_name[LTTNG_UST_SYM_NAME_LEN] \
	__attribute__((unused)) =					\
		#_provider ":" #_name;

#include TRACEPOINT_INCLUDE

/*
 * Stage 1 of tracepoint event generation.
 *
 * 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>
#include <lttng/ust-tracepoint-event-write.h>
#include <lttng/ust-tracepoint-event-nowrite.h>

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

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

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

#undef _ctf_sequence_encoded
#define _ctf_sequence_encoded(_type, _item, _src,	\
			_length_type, _src_length, _encoding, _written)	\
	{							\
	  .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), \
			},					\
		},						\
	  .written = _written,					\
	},

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

#undef TP_FIELDS
#define TP_FIELDS(...) __VA_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

/*
 * Stage 2 of tracepoint event generation.
 *
 * Create probe callback prototypes.
 */

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

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

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

#include TRACEPOINT_INCLUDE

/*
 * Stage 3 of tracepoint event generation.
 *
 * Create static inline function that calculates event size.
 */

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

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

#undef _ctf_float
#define _ctf_float(_type, _item, _src, _written)				 \
	__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, _written)     \
	__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, _written)	\
	__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, _written)				       \
	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

#undef TP_FIELDS
#define TP_FIELDS(...) __VA_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_DATA_PROTO(_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

/*
 * Stage 3.1 of tracepoint event generation.
 *
 * Create static inline function that layout the filter stack data.
 * We make both write and nowrite data available to the filter.
 */

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

#undef _ctf_integer_ext
#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written)     \
	if (lttng_is_signed_type(_type))				       \
		*(int64_t *) __stack_data = (int64_t) (_type) (_src);	       \
	else								       \
		*(uint64_t *) __stack_data = (uint64_t) (_type) (_src);	       \
	__stack_data += sizeof(int64_t);

#undef _ctf_float
#define _ctf_float(_type, _item, _src, _written)			       \
	*(double *) __stack_data = (double) (_type) (_src);		       \
	__stack_data += sizeof(double);

#undef _ctf_array_encoded
#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written)   \
	*(unsigned long *) __stack_data = (unsigned long) (_length);	       \
	__stack_data += sizeof(unsigned long);				       \
	*(const void **) __stack_data = (_src);				       \
	__stack_data += sizeof(void *);

#undef _ctf_sequence_encoded
#define _ctf_sequence_encoded(_type, _item, _src, _length_type,		       \
			_src_length, _encoding, _written)		       \
	*(unsigned long *) __stack_data = (unsigned long) (_src_length);       \
	__stack_data += sizeof(unsigned long);				       \
	*(const void **) __stack_data = (_src);				       \
	__stack_data += sizeof(void *);

#undef _ctf_string
#define _ctf_string(_item, _src, _written)				       \
	*(const void **) __stack_data = (_src);				       \
	__stack_data += sizeof(void *);

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

#undef TP_FIELDS
#define TP_FIELDS(...) __VA_ARGS__

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)	      \
static inline								      \
void __event_prepare_filter_stack__##_provider##___##_name(char *__stack_data,\
						 _TP_ARGS_DATA_PROTO(_args))  \
{									      \
	_fields								      \
}

#include TRACEPOINT_INCLUDE


/*
 * Stage 4 of tracepoint event generation.
 *
 * Create static inline function that calculates event payload alignment.
 */

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

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

#undef _ctf_float
#define _ctf_float(_type, _item, _src, _written)			       \
	__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, _written)   \
	__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, _written)	\
	__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, _written)

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

#undef TP_FIELDS
#define TP_FIELDS(...) __VA_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


/*
 * Stage 5 of tracepoint event generation.
 *
 * Create the probe function. This function calls event size calculation
 * and writes event data into the buffer.
 */

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

#undef _ctf_integer_ext
#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	{								\
		_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, _written)		        \
	{								\
		_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, _written) \
	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, _written)		\
	{								\
		_length_type __tmpl = __stackvar.__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, _written)			        \
	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)	__stackvar.__dynamic_len[__dynamic_len_idx++]

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

#undef TP_FIELDS
#define TP_FIELDS(...) __VA_ARGS__

/*
 * Using twice size for filter stack data to hold size and pointer for
 * each field (worse case). For integers, max size required is 64-bit.
 * Same for double-precision floats. Those fit within
 * 2*sizeof(unsigned long) for all supported architectures.
 */
#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)	      \
static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args))\
{									      \
	struct ltt_event *__event = __tp_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;					      \
	union {								      \
		size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
		char __filter_stack_data[2 * sizeof(unsigned long) * _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
	} __stackvar;							      \
	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;							      \
	if (caa_unlikely(__event->filter)) {				      \
		__event_prepare_filter_stack__##_provider##___##_name(__stackvar.__filter_stack_data, \
			_TP_ARGS_DATA_VAR(_args));				      \
		if (caa_likely(!__event->filter(__event->filter_data, __stackvar.__filter_stack_data))) \
			return;						      \
	}								      \
	__event_len = __event_get_size__##_provider##___##_name(__stackvar.__dynamic_len, \
		 _TP_ARGS_DATA_VAR(_args));				      \
	__event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_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

#undef __get_dynamic_len

/*
 * Stage 5.1 of tracepoint event generation.
 *
 * Create probe signature
 */

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

#undef TP_ARGS
#define TP_ARGS(...) __VA_ARGS__

#define _TP_EXTRACT_STRING2(...)	#__VA_ARGS__

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields)	\
const char __tp_event_signature___##_provider##___##_name[] = 		\
		_TP_EXTRACT_STRING2(_args);

#include TRACEPOINT_INCLUDE

#undef _TP_EXTRACT_STRING2

/*
 * Stage 6 of tracepoint event generation.
 *
 * Tracepoint loglevel mapping definition generation. We generate a
 * symbol for each mapping for a provider/event to ensure at most a 1 to
 * 1 mapping between events and loglevels. If the symbol is repeated,
 * the compiler will complain.
 */

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

#undef TRACEPOINT_LOGLEVEL
#define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel)		   \
static const int _loglevel_value___##__provider##___##__name = __loglevel; \
static const int *_loglevel___##__provider##___##__name =		   \
		&_loglevel_value___##__provider##___##__name;

#include TRACEPOINT_INCLUDE

/*
 * Stage 7.1 of tracepoint event generation.
 *
 * Create events description structures. We use a weakref because
 * loglevels are optional. If not declared, the event will point to the
 * a loglevel that contains NULL.
 */

/* 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)	       \
static const int *							       \
	__ref_loglevel___##_provider##___##_name			       \
	__attribute__((weakref ("_loglevel___" #_provider "___" #_name)));     \
const struct lttng_event_desc __event_desc___##_provider##_##_name = {	       \
	.fields = __event_fields___##_provider##___##_template,		       \
	.name = #_provider ":" #_name,					       \
	.probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template,\
	.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
	.loglevel = &__ref_loglevel___##_provider##___##_name,		       \
	.signature = __tp_event_signature___##_provider##___##_template,       \
};

#include TRACEPOINT_INCLUDE

/*
 * Stage 7.2 of tracepoint event generation.
 *
 * Create 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)	       \
	&__event_desc___##_provider##_##_name,

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


/*
 * Stage 8 of tracepoint event generation.
 *
 * Create a toplevel descriptor for the whole probe.
 */

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

/*
 * Stage 9 of tracepoint event generation.
 *
 * Register/unregister probes at module load/unload.
 *
 * Generate the constructor as an externally visible symbol for use when
 * linking the probe statically.
 */

/* Reset all macros within TRACEPOINT_EVENT */
#include <lttng/ust-tracepoint-event-reset.h>
static void __attribute__((constructor))
_TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
{
	int ret;

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

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

int _TP_COMBINE_TOKENS(__tracepoint_provider_, TRACEPOINT_PROVIDER);
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2011-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*/
	14
	15	#include <stdio.h>
	16	#include <urcu/compiler.h>
	17	#include <lttng/ust-events.h>
	18	#include <lttng/ringbuffer-config.h>
	19	#include <string.h>
	20
	21	/*
	22	* TRACEPOINT_EVENT_CLASS declares a class of tracepoints receiving the
	23	* same arguments and having the same field layout.
	24	*
	25	* TRACEPOINT_EVENT_INSTANCE declares an instance of a tracepoint, with
	26	* its own provider and name. It refers to a class (template).
	27	*
	28	* TRACEPOINT_EVENT declared both a class and an instance and does a
	29	* direct mapping from the instance to the class.
	30	*/
	31
	32	#undef TRACEPOINT_EVENT
	33	#define TRACEPOINT_EVENT(_provider, _name, _args, _fields) \
	34	TRACEPOINT_EVENT_CLASS(_provider, _name, \
	35	_TP_PARAMS(_args), \
	36	_TP_PARAMS(_fields)) \
	37	TRACEPOINT_EVENT_INSTANCE(_provider, _name, _name, \
	38	_TP_PARAMS(_args))
	39
	40	/* Helpers */
	41	#define _TP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	42
	43	#define _tp_max_t(type, x, y) \
	44	({ \
	45	type __max1 = (x); \
	46	type __max2 = (y); \
	47	__max1 > __max2 ? __max1: __max2; \
	48	})
	49
	50	/*
	51	* Stage 0 of tracepoint event generation.
	52	*
	53	* Check that each TRACEPOINT_EVENT provider argument match the
	54	* TRACEPOINT_PROVIDER by creating dummy callbacks.
	55	*/
	56
	57	/* Reset all macros within TRACEPOINT_EVENT */
	58	#include <lttng/ust-tracepoint-event-reset.h>
	59
	60	static inline
	61	void _TP_COMBINE_TOKENS(__tracepoint_provider_mismatch_, TRACEPOINT_PROVIDER)(void)
	62	{
	63	}
	64
	65	#undef TRACEPOINT_EVENT_CLASS
	66	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	67	__tracepoint_provider_mismatch_##_provider();
	68
	69	#undef TRACEPOINT_EVENT_INSTANCE
	70	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	71	__tracepoint_provider_mismatch_##_provider();
	72
	73	static __attribute__((unused))
	74	void _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(void)
	75	{
	76	#include TRACEPOINT_INCLUDE
	77	}
	78
	79	/*
	80	* Stage 0.1 of tracepoint event generation.
	81	*
	82	* Check that each TRACEPOINT_EVENT provider:name does not exceed the
	83	* tracepoint name length limit.
	84	*/
	85
	86	/* Reset all macros within TRACEPOINT_EVENT */
	87	#include <lttng/ust-tracepoint-event-reset.h>
	88
	89	#undef TRACEPOINT_EVENT_INSTANCE
	90	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	91	static const char \
	92	__tp_name_len_check##_provider##___##_name[LTTNG_UST_SYM_NAME_LEN] \
	93	__attribute__((unused)) = \
	94	#_provider ":" #_name;
	95
	96	#include TRACEPOINT_INCLUDE
	97
	98	/*
	99	* Stage 1 of tracepoint event generation.
	100	*
	101	* Create event field type metadata section.
	102	* Each event produce an array of fields.
	103	*/
	104
	105	/* Reset all macros within TRACEPOINT_EVENT */
	106	#include <lttng/ust-tracepoint-event-reset.h>
	107	#include <lttng/ust-tracepoint-event-write.h>
	108	#include <lttng/ust-tracepoint-event-nowrite.h>
	109
	110	#undef _ctf_integer_ext
	111	#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	112	{ \
	113	.name = #_item, \
	114	.type = __type_integer(_type, _byte_order, _base, none),\
	115	.written = _written, \
	116	},
	117
	118	#undef _ctf_float
	119	#define _ctf_float(_type, _item, _src, _written) \
	120	{ \
	121	.name = #_item, \
	122	.type = __type_float(_type), \
	123	.written = _written, \
	124	},
	125
	126	#undef _ctf_array_encoded
	127	#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written) \
	128	{ \
	129	.name = #_item, \
	130	.type = \
	131	{ \
	132	.atype = atype_array, \
	133	.u.array = \
	134	{ \
	135	.length = _length, \
	136	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	137	}, \
	138	}, \
	139	.written = _written, \
	140	},
	141
	142	#undef _ctf_sequence_encoded
	143	#define _ctf_sequence_encoded(_type, _item, _src, \
	144	_length_type, _src_length, _encoding, _written) \
	145	{ \
	146	.name = #_item, \
	147	.type = \
	148	{ \
	149	.atype = atype_sequence, \
	150	.u.sequence = \
	151	{ \
	152	.length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \
	153	.elem_type = __type_integer(_type, BYTE_ORDER, 10, _encoding), \
	154	}, \
	155	}, \
	156	.written = _written, \
	157	},
	158
	159	#undef _ctf_string
	160	#define _ctf_string(_item, _src, _written) \
	161	{ \
	162	.name = #_item, \
	163	.type = \
	164	{ \
	165	.atype = atype_string, \
	166	.u.basic.string.encoding = lttng_encode_UTF8, \
	167	}, \
	168	.written = _written, \
	169	},
	170
	171	#undef TP_FIELDS
	172	#define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */
	173
	174	#undef TRACEPOINT_EVENT_CLASS
	175	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	176	static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \
	177	_fields \
	178	};
	179
	180	#include TRACEPOINT_INCLUDE
	181
	182	/*
	183	* Stage 2 of tracepoint event generation.
	184	*
	185	* Create probe callback prototypes.
	186	*/
	187
	188	/* Reset all macros within TRACEPOINT_EVENT */
	189	#include <lttng/ust-tracepoint-event-reset.h>
	190
	191	#undef TP_ARGS
	192	#define TP_ARGS(...) __VA_ARGS__
	193
	194	#undef TRACEPOINT_EVENT_CLASS
	195	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	196	static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args));
	197
	198	#include TRACEPOINT_INCLUDE
	199
	200	/*
	201	* Stage 3 of tracepoint event generation.
	202	*
	203	* Create static inline function that calculates event size.
	204	*/
	205
	206	/* Reset all macros within TRACEPOINT_EVENT */
	207	#include <lttng/ust-tracepoint-event-reset.h>
	208	#include <lttng/ust-tracepoint-event-write.h>
	209
	210	#undef _ctf_integer_ext
	211	#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	212	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	213	__event_len += sizeof(_type);
	214
	215	#undef _ctf_float
	216	#define _ctf_float(_type, _item, _src, _written) \
	217	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	218	__event_len += sizeof(_type);
	219
	220	#undef _ctf_array_encoded
	221	#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written) \
	222	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	223	__event_len += sizeof(_type) * (_length);
	224
	225	#undef _ctf_sequence_encoded
	226	#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
	227	_src_length, _encoding, _written) \
	228	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \
	229	__event_len += sizeof(_length_type); \
	230	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
	231	__dynamic_len[__dynamic_len_idx] = (_src_length); \
	232	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \
	233	__dynamic_len_idx++;
	234
	235	#undef _ctf_string
	236	#define _ctf_string(_item, _src, _written) \
	237	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
	238
	239	#undef TP_ARGS
	240	#define TP_ARGS(...) __VA_ARGS__
	241
	242	#undef TP_FIELDS
	243	#define TP_FIELDS(...) __VA_ARGS__
	244
	245	#undef TRACEPOINT_EVENT_CLASS
	246	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	247	static inline size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS_DATA_PROTO(_args)) \
	248	{ \
	249	size_t __event_len = 0; \
	250	unsigned int __dynamic_len_idx = 0; \
	251	\
	252	if (0) \
	253	(void) __dynamic_len_idx; /* don't warn if unused */ \
	254	_fields \
	255	return __event_len; \
	256	}
	257
	258	#include TRACEPOINT_INCLUDE
	259
	260	/*
	261	* Stage 3.1 of tracepoint event generation.
	262	*
	263	* Create static inline function that layout the filter stack data.
	264	* We make both write and nowrite data available to the filter.
	265	*/
	266
	267	/* Reset all macros within TRACEPOINT_EVENT */
	268	#include <lttng/ust-tracepoint-event-reset.h>
	269	#include <lttng/ust-tracepoint-event-write.h>
	270	#include <lttng/ust-tracepoint-event-nowrite.h>
	271
	272	#undef _ctf_integer_ext
	273	#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	274	if (lttng_is_signed_type(_type)) \
	275	(int64_t ) __stack_data = (int64_t) (_type) (_src); \
	276	else \
	277	(uint64_t ) __stack_data = (uint64_t) (_type) (_src); \
	278	__stack_data += sizeof(int64_t);
	279
	280	#undef _ctf_float
	281	#define _ctf_float(_type, _item, _src, _written) \
	282	(double ) __stack_data = (double) (_type) (_src); \
	283	__stack_data += sizeof(double);
	284
	285	#undef _ctf_array_encoded
	286	#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written) \
	287	(unsigned long ) __stack_data = (unsigned long) (_length); \
	288	__stack_data += sizeof(unsigned long); \
	289	(const void *) __stack_data = (_src); \
	290	__stack_data += sizeof(void *);
	291
	292	#undef _ctf_sequence_encoded
	293	#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
	294	_src_length, _encoding, _written) \
	295	(unsigned long ) __stack_data = (unsigned long) (_src_length); \
	296	__stack_data += sizeof(unsigned long); \
	297	(const void *) __stack_data = (_src); \
	298	__stack_data += sizeof(void *);
	299
	300	#undef _ctf_string
	301	#define _ctf_string(_item, _src, _written) \
	302	(const void *) __stack_data = (_src); \
	303	__stack_data += sizeof(void *);
	304
	305	#undef TP_ARGS
	306	#define TP_ARGS(...) __VA_ARGS__
	307
	308	#undef TP_FIELDS
	309	#define TP_FIELDS(...) __VA_ARGS__
	310
	311	#undef TRACEPOINT_EVENT_CLASS
	312	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	313	static inline \
	314	void __event_prepare_filter_stack__##_provider##___##_name(char *__stack_data,\
	315	_TP_ARGS_DATA_PROTO(_args)) \
	316	{ \
	317	_fields \
	318	}
	319
	320	#include TRACEPOINT_INCLUDE
	321
	322
	323
	324	/*
	325	* Stage 4 of tracepoint event generation.
	326	*
	327	* Create static inline function that calculates event payload alignment.
	328	*/
	329
	330	/* Reset all macros within TRACEPOINT_EVENT */
	331	#include <lttng/ust-tracepoint-event-reset.h>
	332	#include <lttng/ust-tracepoint-event-write.h>
	333
	334	#undef _ctf_integer_ext
	335	#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	336	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	337
	338	#undef _ctf_float
	339	#define _ctf_float(_type, _item, _src, _written) \
	340	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	341
	342	#undef _ctf_array_encoded
	343	#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written) \
	344	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	345
	346	#undef _ctf_sequence_encoded
	347	#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
	348	_src_length, _encoding, _written) \
	349	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_length_type)); \
	350	__event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type));
	351
	352	#undef _ctf_string
	353	#define _ctf_string(_item, _src, _written)
	354
	355	#undef TP_ARGS
	356	#define TP_ARGS(...) __VA_ARGS__
	357
	358	#undef TP_FIELDS
	359	#define TP_FIELDS(...) __VA_ARGS__
	360
	361	#undef TRACEPOINT_EVENT_CLASS
	362	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	363	static inline \
	364	size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \
	365	{ \
	366	size_t __event_align = 1; \
	367	_fields \
	368	return __event_align; \
	369	}
	370
	371	#include TRACEPOINT_INCLUDE
	372
	373
	374	/*
	375	* Stage 5 of tracepoint event generation.
	376	*
	377	* Create the probe function. This function calls event size calculation
	378	* and writes event data into the buffer.
	379	*/
	380
	381	/* Reset all macros within TRACEPOINT_EVENT */
	382	#include <lttng/ust-tracepoint-event-reset.h>
	383	#include <lttng/ust-tracepoint-event-write.h>
	384
	385	#undef _ctf_integer_ext
	386	#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _written) \
	387	{ \
	388	_type __tmp = (_src); \
	389	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
	390	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	391	}
	392
	393	#undef _ctf_float
	394	#define _ctf_float(_type, _item, _src, _written) \
	395	{ \
	396	_type __tmp = (_src); \
	397	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\
	398	__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
	399	}
	400
	401	#undef _ctf_array_encoded
	402	#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _written) \
	403	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
	404	__chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length));
	405
	406	#undef _ctf_sequence_encoded
	407	#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \
	408	_src_length, _encoding, _written) \
	409	{ \
	410	_length_type __tmpl = __stackvar.__dynamic_len[__dynamic_len_idx]; \
	411	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\
	412	__chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\
	413	} \
	414	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \
	415	__chan->ops->event_write(&__ctx, _src, \
	416	sizeof(_type) * __get_dynamic_len(dest));
	417
	418	#undef _ctf_string
	419	#define _ctf_string(_item, _src, _written) \
	420	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src))); \
	421	__chan->ops->event_write(&__ctx, _src, __get_dynamic_len(dest));
	422
	423	/* Beware: this get len actually consumes the len value */
	424	#undef __get_dynamic_len
	425	#define __get_dynamic_len(field) __stackvar.__dynamic_len[__dynamic_len_idx++]
	426
	427	#undef TP_ARGS
	428	#define TP_ARGS(...) __VA_ARGS__
	429
	430	#undef TP_FIELDS
	431	#define TP_FIELDS(...) __VA_ARGS__
	432
	433	/*
	434	* Using twice size for filter stack data to hold size and pointer for
	435	* each field (worse case). For integers, max size required is 64-bit.
	436	* Same for double-precision floats. Those fit within
	437	* 2*sizeof(unsigned long) for all supported architectures.
	438	*/
	439	#undef TRACEPOINT_EVENT_CLASS
	440	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	441	static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args))\
	442	{ \
	443	struct ltt_event *__event = __tp_data; \
	444	struct ltt_channel *__chan = __event->chan; \
	445	struct lttng_ust_lib_ring_buffer_ctx __ctx; \
	446	size_t __event_len, __event_align; \
	447	size_t __dynamic_len_idx = 0; \
	448	union { \
	449	size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
	450	char __filter_stack_data[2 * sizeof(unsigned long) * _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \
	451	} __stackvar; \
	452	int __ret; \
	453	\
	454	if (0) \
	455	(void) __dynamic_len_idx; /* don't warn if unused */ \
	456	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->session->active))) \
	457	return; \
	458	if (caa_unlikely(!CMM_ACCESS_ONCE(__chan->enabled))) \
	459	return; \
	460	if (caa_unlikely(!CMM_ACCESS_ONCE(__event->enabled))) \
	461	return; \
	462	if (caa_unlikely(__event->filter)) { \
	463	__event_prepare_filter_stack__##_provider##___##_name(__stackvar.__filter_stack_data, \
	464	_TP_ARGS_DATA_VAR(_args)); \
	465	if (caa_likely(!__event->filter(__event->filter_data, __stackvar.__filter_stack_data))) \
	466	return; \
	467	} \
	468	__event_len = __event_get_size__##_provider##___##_name(__stackvar.__dynamic_len, \
	469	_TP_ARGS_DATA_VAR(_args)); \
	470	__event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_args)); \
	471	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len, \
	472	__event_align, -1, __chan->handle); \
	473	__ret = __chan->ops->event_reserve(&__ctx, __event->id); \
	474	if (__ret < 0) \
	475	return; \
	476	_fields \
	477	__chan->ops->event_commit(&__ctx); \
	478	}
	479
	480	#include TRACEPOINT_INCLUDE
	481
	482	#undef __get_dynamic_len
	483
	484	/*
	485	* Stage 5.1 of tracepoint event generation.
	486	*
	487	* Create probe signature
	488	*/
	489
	490	/* Reset all macros within TRACEPOINT_EVENT */
	491	#include <lttng/ust-tracepoint-event-reset.h>
	492
	493	#undef TP_ARGS
	494	#define TP_ARGS(...) __VA_ARGS__
	495
	496	#define _TP_EXTRACT_STRING2(...) #__VA_ARGS__
	497
	498	#undef TRACEPOINT_EVENT_CLASS
	499	#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \
	500	const char __tp_event_signature___##_provider##___##_name[] = \
	501	_TP_EXTRACT_STRING2(_args);
	502
	503	#include TRACEPOINT_INCLUDE
	504
	505	#undef _TP_EXTRACT_STRING2
	506
	507	/*
	508	* Stage 6 of tracepoint event generation.
	509	*
	510	* Tracepoint loglevel mapping definition generation. We generate a
	511	* symbol for each mapping for a provider/event to ensure at most a 1 to
	512	* 1 mapping between events and loglevels. If the symbol is repeated,
	513	* the compiler will complain.
	514	*/
	515
	516	/* Reset all macros within TRACEPOINT_EVENT */
	517	#include <lttng/ust-tracepoint-event-reset.h>
	518
	519	#undef TRACEPOINT_LOGLEVEL
	520	#define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel) \
	521	static const int _loglevel_value___##__provider##___##__name = __loglevel; \
	522	static const int *_loglevel___##__provider##___##__name = \
	523	&_loglevel_value___##__provider##___##__name;
	524
	525	#include TRACEPOINT_INCLUDE
	526
	527	/*
	528	* Stage 7.1 of tracepoint event generation.
	529	*
	530	* Create events description structures. We use a weakref because
	531	* loglevels are optional. If not declared, the event will point to the
	532	* a loglevel that contains NULL.
	533	*/
	534
	535	/* Reset all macros within TRACEPOINT_EVENT */
	536	#include <lttng/ust-tracepoint-event-reset.h>
	537
	538	#undef TRACEPOINT_EVENT_INSTANCE
	539	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	540	static const int * \
	541	__ref_loglevel___##_provider##___##_name \
	542	__attribute__((weakref ("_loglevel___" #_provider "___" #_name))); \
	543	const struct lttng_event_desc __event_desc___##_provider##_##_name = { \
	544	.fields = __event_fields___##_provider##___##_template, \
	545	.name = #_provider ":" #_name, \
	546	.probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template,\
	547	.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \
	548	.loglevel = &__ref_loglevel___##_provider##___##_name, \
	549	.signature = __tp_event_signature___##_provider##___##_template, \
	550	};
	551
	552	#include TRACEPOINT_INCLUDE
	553
	554	/*
	555	* Stage 7.2 of tracepoint event generation.
	556	*
	557	* Create array of events.
	558	*/
	559
	560	/* Reset all macros within TRACEPOINT_EVENT */
	561	#include <lttng/ust-tracepoint-event-reset.h>
	562
	563	#undef TRACEPOINT_EVENT_INSTANCE
	564	#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \
	565	&__event_desc___##_provider##_##_name,
	566
	567	static const struct lttng_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)[] = {
	568	#include TRACEPOINT_INCLUDE
	569	};
	570
	571
	572	/*
	573	* Stage 8 of tracepoint event generation.
	574	*
	575	* Create a toplevel descriptor for the whole probe.
	576	*/
	577
	578	/* non-const because list head will be modified when registered. */
	579	static struct lttng_probe_desc _TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER) = {
	580	.provider = __tp_stringify(TRACEPOINT_PROVIDER),
	581	.event_desc = _TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER),
	582	.nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)),
	583	};
	584
	585	/*
	586	* Stage 9 of tracepoint event generation.
	587	*
	588	* Register/unregister probes at module load/unload.
	589	*
	590	* Generate the constructor as an externally visible symbol for use when
	591	* linking the probe statically.
	592	*/
	593
	594	/* Reset all macros within TRACEPOINT_EVENT */
	595	#include <lttng/ust-tracepoint-event-reset.h>
	596	static void __attribute__((constructor))
	597	_TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void)
	598	{
	599	int ret;
	600
	601	ret = ltt_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
	602	assert(!ret);
	603	}
	604
	605	static void __attribute__((destructor))
	606	_TP_COMBINE_TOKENS(__lttng_events_exit__, TRACEPOINT_PROVIDER)(void)
	607	{
	608	ltt_probe_unregister(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
	609	}
	610
	611	int _TP_COMBINE_TOKENS(__tracepoint_provider_, TRACEPOINT_PROVIDER);