[lttng-ust.git] / include / ust / lttng-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 <ust/lttng-events.h>
#include <ust/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)

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

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

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

/*
 * 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 <ust/lttng-tracepoint-event-reset.h>

/* Named field types must be defined in lttng-types.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(_name, _fields)		   	     \
	static const struct lttng_event_field __event_fields___##_name[] = { \
		_fields							     \
	};

#undef TRACEPOINT_EVENT_CLASS
#define TRACEPOINT_EVENT_CLASS(_name, _proto, _args, _fields)		     \
	TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields)

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

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

#undef TP_PROTO
#define TP_PROTO(args...) args

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

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

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

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

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

#undef TRACEPOINT_EVENT_INSTANCE_NOARGS
#define TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name)		       \
		{							       \
			.fields = __event_fields___##_template,		       \
			.name = #_name,					       \
			.probe_callback = (void *) &__event_probe__##_template,\
			.nr_fields = _TP_ARRAY_SIZE(__event_fields___##_template), \
		},

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

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

static const struct lttng_event_desc TP_ID(__event_desc___, TRACEPOINT_SYSTEM)[] = {
#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, _system)	_token##_system
#define TP_ID(_token, _system)	TP_ID1(_token, _system)

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

#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 <ust/lttng-tracepoint-event-reset.h>

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

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

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

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length)			       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_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, ltt_alignof(_length_type));   \
	__event_len += sizeof(_length_type);				       \
	__event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \
	__dynamic_len[__dynamic_len_idx] = (_length);			       \
	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
	__dynamic_len_idx++;

#undef 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(_name, _proto, _args, _fields)		      \
static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
{									      \
	size_t __event_len = 0;						      \
	unsigned int __dynamic_len_idx = 0;				      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	_fields								      \
	return __event_len;						      \
}

#undef TRACEPOINT_EVENT_CLASS_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields)			      \
static inline size_t __event_get_size__##_name(size_t *__dynamic_len)	      \
{									      \
	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 <ust/lttng-tracepoint-event-reset.h>

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

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

#undef ctf_float
#define ctf_float(_type, _item, _src)					       \
	__event_align = max_t(size_t, __event_align, ltt_alignof(_type));

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length)			       \
	__event_align = max_t(size_t, __event_align, ltt_alignof(_type));

#undef ctf_sequence_encoded
#define ctf_sequence_encoded(_type, _item, _src, _length_type,	\
			_src_length, _encoding)			\
	__event_align = max_t(size_t, __event_align, ltt_alignof(_length_type));	  \
	__event_align = max_t(size_t, __event_align, ltt_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(_name, _proto, _args, _fields)		      \
static inline size_t __event_get_align__##_name(_proto)			      \
{									      \
	size_t __event_align = 1;					      \
	_fields								      \
	return __event_align;						      \
}

#undef TRACEPOINT_EVENT_CLASS_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields)			      \
static inline size_t __event_get_align__##_name(void)			      \
{									      \
	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 <ust/lttng-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, ltt_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, ltt_alignof(__tmp));	\
		__chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp));	\
	}

#undef ctf_array_encoded
#define ctf_array_encoded(_type, _item, _src, _length)		        \
	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(_type));		\
	__chan->ops->event_write(&ctx, _src, _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, ltt_alignof(_length_type));    \
		__chan->ops->event_write(&ctx, &__tmpl, sizeof(_length_type)); \
	}								\
	lib_ring_buffer_align_ctx(&ctx, ltt_alignof(_type));		\
	__chan->ops->event_write(&ctx, _src,				\
		sizeof(_type) * __get_sequence_len(dest));

#undef ctf_string
#define ctf_string(_item, _src)					        \
	tp_memcpy(dest, _src, __get_sequence_len(dest))

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

#undef TP_PROTO
#define TP_PROTO(args...) args

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

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

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

#undef TRACEPOINT_EVENT_CLASS_NOARGS
#define TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields)			      \
static void __event_probe__##_name(void *__data)			      \
{									      \
	struct ltt_event *__event = __data;				      \
	struct ltt_channel *__chan = __event->chan;			      \
	struct lib_ring_buffer_ctx ctx;					      \
	size_t __event_len, __event_align;				      \
	size_t __dynamic_len_idx = 0;					      \
	size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_name)];	      \
	int __ret;							      \
									      \
	if (0)								      \
		(void) __dynamic_len_idx;	/* don't warn if unused */    \
	if (unlikely(!CMM_ACCESS_ONCE(__chan->session->active)))	      \
		return;							      \
	if (unlikely(!CMM_ACCESS_ONCE(__chan->enabled)))		      \
		return;							      \
	if (unlikely(!CMM_ACCESS_ONCE(__event->enabled)))		      \
		return;							      \
	__event_len = __event_get_size__##_name(__dynamic_len);		      \
	__event_align = __event_get_align__##_name();			      \
	lib_ring_buffer_ctx_init(&ctx, __chan->chan, __event, __event_len,    \
				 __event_align, -1);			      \
	__ret = __chan->ops->event_reserve(&ctx, __event->id);		      \
	if (__ret < 0)							      \
		return;							      \
	_fields								      \
	__chan->ops->event_commit(&ctx);				      \
}

#include TRACEPOINT_INCLUDE(TRACEPOINT_INCLUDE_FILE)

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

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

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

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

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

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

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