[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 <stdlib.h>
#include <urcu/compiler.h>
#include <lttng/ust-events.h>
#include <lttng/ringbuffer-config.h>
#include <string.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 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 inline
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>

#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(...) __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>

#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(...) __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 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>

#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(...) __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>

#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(...) __VA_ARGS__

#undef TP_FIELDS
#define TP_FIELDS(...) __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))\
{									      \
	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;					      \
	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_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;

	/*
	 * __tracepoint_provider_check_ ## TRACEPOINT_PROVIDER() is a
	 * static inline function that ensures every probe PROVIDER
	 * argument match the provider within which they appear. It
	 * calls empty static inline functions, and therefore has no
	 * runtime effect. However, if it detects an error, a linker
	 * error will appear.
	 */
	_TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)();
	ret = ltt_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER));
	if (ret) {
		fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe. Duplicate registration of tracepoint probes having the same name is not allowed.\n", ret);
		abort();
	}
}

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