X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=probes%2Flttng-events.h;h=f6f7ef1c3bebb1a6b953d7f44f94164d9018b53b;hb=c782f1f3e8c799b7ba531ba940209014b66d4564;hp=a05c29d56771b89807ffef035b7cd6df34a0b97f;hpb=52fc2e1ff4b6e6a1050bc211ff32a6ccb977d7a4;p=lttng-modules.git

diff --git a/probes/lttng-events.h b/probes/lttng-events.h
index a05c29d5..f6f7ef1c 100644
--- a/probes/lttng-events.h
+++ b/probes/lttng-events.h
@@ -1,59 +1,227 @@
-#include <lttng.h>
-#include <lttng-types.h>
+/*
+ * lttng-events.h
+ *
+ * Copyright (C) 2009 Steven Rostedt <rostedt@goodmis.org>
+ * Copyright (C) 2009-2012 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; only
+ * 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 <linux/uaccess.h>
 #include <linux/debugfs.h>
-#include <linux/ringbuffer/frontend_types.h>
-#include "../ltt-events.h"
-#include "../ltt-tracer-core.h"
-
-struct lttng_event_field {
-	const char *name;
-	const struct lttng_type type;
-};
-
-struct lttng_event_desc {
-	const struct lttng_event_field *fields;
-	const char *name;
-	unsigned int nr_fields;
-};
+#include "lttng.h"
+#include "lttng-types.h"
+#include "lttng-probe-user.h"
+#include "../wrapper/vmalloc.h"	/* for wrapper_vmalloc_sync_all() */
+#include "../wrapper/ringbuffer/frontend_types.h"
+#include "../lttng-events.h"
+#include "../lttng-tracer-core.h"
 
 /*
  * Macro declarations used for all stages.
  */
 
 /*
- * DECLARE_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 DEFINE_EVENT and that
- * will map the DECLARE_EVENT_CLASS to the tracepoint.
- *
- * TRACE_EVENT is a one to one mapping between tracepoint and template.
+ * LTTng name mapping macros. LTTng remaps some of the kernel events to
+ * enforce name-spacing.
  */
+#undef LTTNG_TRACEPOINT_EVENT_MAP
+#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS(map,				\
+			     PARAMS(proto),				\
+			     PARAMS(args),				\
+			     PARAMS(tstruct),				\
+			     PARAMS(assign),				\
+			     PARAMS(print))				\
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args))
+
+#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(map,			\
+			     PARAMS(tstruct),				\
+			     PARAMS(assign),				\
+			     PARAMS(print))				\
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(map, name, map)
+
+#undef LTTNG_TRACEPOINT_EVENT_CODE
+#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_CODE(name,				\
+			     PARAMS(proto),				\
+			     PARAMS(args),				\
+			     PARAMS(_locvar),				\
+			     PARAMS(_code),				\
+			     PARAMS(tstruct),				\
+			     PARAMS(assign),				\
+			     PARAMS(print))				\
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(name, name, name, PARAMS(proto), PARAMS(args))
+
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, map, proto, args, print) \
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, PARAMS(proto), PARAMS(args))
 
-#undef TRACE_EVENT
-#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
-	DECLARE_EVENT_CLASS(name,			       \
-			     PARAMS(proto),		       \
-			     PARAMS(args),		       \
-			     PARAMS(tstruct),		       \
-			     PARAMS(assign),		       \
-			     PARAMS(print))		       \
-	DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args))
+/* Callbacks are meaningless to LTTng. */
+#undef LTTNG_TRACEPOINT_EVENT_FN_MAP
+#define LTTNG_TRACEPOINT_EVENT_FN_MAP(name, map, proto, args, tstruct,	\
+		assign, print, reg, unreg)				\
+	LTTNG_TRACEPOINT_EVENT_MAP(name, map, PARAMS(proto), PARAMS(args), \
+		PARAMS(tstruct), PARAMS(assign), PARAMS(print))
+
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION_MAP
+#define LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_MAP(name, map,				\
+		PARAMS(proto),						\
+		PARAMS(args),						\
+		PARAMS(tstruct),					\
+		PARAMS(assign),						\
+		PARAMS(print))
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP(template, name, map, proto, args, cond) \
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, PARAMS(proto), PARAMS(args))
 
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)	\
-	DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
+/*
+ * LTTNG_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 LTTNG_TRACEPOINT_EVENT_INSTANCE and that will map the
+ * LTTNG_TRACEPOINT_EVENT_CLASS to the tracepoint.
+ *
+ * LTTNG_TRACEPOINT_EVENT is a one to one mapping between tracepoint and
+ * template.
+ */
 
-/* Callbacks are meaningless to LTTng. */
-#undef TRACE_EVENT_FN
-#define TRACE_EVENT_FN(name, proto, args, tstruct,			\
+#undef LTTNG_TRACEPOINT_EVENT
+#define LTTNG_TRACEPOINT_EVENT(name, proto, args, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_MAP(name, name,				\
+			PARAMS(proto),					\
+			PARAMS(args),					\
+			PARAMS(tstruct),				\
+			PARAMS(assign),					\
+			PARAMS(print))
+
+#undef LTTNG_TRACEPOINT_EVENT_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_NOARGS(name, tstruct, assign, print)	\
+	LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, name,			\
+			PARAMS(tstruct),				\
+			PARAMS(assign),					\
+			PARAMS(print))
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT(template, name, proto, args, print) \
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, name,	\
+			PARAMS(proto), PARAMS(args), PARAMS(print_))
+
+#undef LTTNG_TRACEPOINT_EVENT_FN
+#define LTTNG_TRACEPOINT_EVENT_FN(name, proto, args, tstruct,		\
 		assign, print, reg, unreg)				\
-	TRACE_EVENT(name, PARAMS(proto), PARAMS(args),			\
-		PARAMS(tstruct), PARAMS(assign), PARAMS(print))		\
+	LTTNG_TRACEPOINT_EVENT_FN_MAP(name, name, PARAMS(proto), PARAMS(args), \
+		PARAMS(tstruct), PARAMS(assign), PARAMS(print),		\
+		PARAMS(reg), PARAMS(unreg))				\
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args)	\
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, name, PARAMS(proto), PARAMS(args))
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name)	\
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, name)
+
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION
+#define LTTNG_TRACEPOINT_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
+	LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(name, name,		\
+		PARAMS(proto),						\
+		PARAMS(args),						\
+		PARAMS(cond),						\
+		PARAMS(tstruct),					\
+		PARAMS(assign),						\
+		PARAMS(print))
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS
+#define LTTNG_TRACEPOINT_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, PARAMS(_proto), PARAMS(_args), , , \
+		PARAMS(_tstruct), PARAMS(_assign), PARAMS(_print))
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, , , PARAMS(_tstruct), \
+		PARAMS(_assign), PARAMS(_print))
+
 
 /*
  * Stage 1 of the trace events.
  *
+ * Create dummy trace calls for each events, verifying that the LTTng module
+ * instrumentation headers match the kernel arguments. Will be optimized
+ * out by the compiler.
+ */
+
+#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */
+
+#undef TP_PROTO
+#define TP_PROTO(args...) args
+
+#undef TP_ARGS
+#define TP_ARGS(args...) args
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \
+void trace_##_name(_proto);
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \
+void trace_##_name(void);
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Stage 1.1 of the trace events.
+ *
+ * Create dummy trace prototypes for each event class, and for each used
+ * template. This will allow checking whether the prototypes from the
+ * class and the instance using the class actually match.
+ */
+
+#include "lttng-events-reset.h"        /* Reset all macros within TRACE_EVENT */
+
+#undef TP_PROTO
+#define TP_PROTO(args...) args
+
+#undef TP_ARGS
+#define TP_ARGS(args...) args
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \
+void __event_template_proto___##_template(_proto);
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \
+void __event_template_proto___##_template(void);
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+void __event_template_proto___##_name(_proto);
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+void __event_template_proto___##_name(void);
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Stage 2 of the trace events.
+ *
  * Create event field type metadata section.
  * Each event produce an array of fields.
  */
@@ -62,202 +230,240 @@ struct lttng_event_desc {
 
 /* Named field types must be defined in lttng-types.h */
 
+#undef __field_full
+#define __field_full(_type, _item, _order, _base)		\
+	{							\
+	  .name = #_item,					\
+	  .type = __type_integer(_type, _order, _base, none),	\
+	},
+
 #undef __field
 #define __field(_type, _item)					\
-	{ .name = #_item, .type = { .atype = atype_integer, .name = #_type} },
+	__field_full(_type, _item, __BYTE_ORDER, 10)
 
 #undef __field_ext
-#define __field_ext(_type, _item, _filter_type)		__field(_type, _item)
+#define __field_ext(_type, _item, _filter_type)			\
+	__field(_type, _item)
 
-#undef __array
-#define __array(_type, _item, _length)				\
+#undef __field_hex
+#define __field_hex(_type, _item)				\
+	__field_full(_type, _item, __BYTE_ORDER, 16)
+
+#undef __field_oct
+#define __field_oct(_type, _item)				\
+	__field_full(_type, _item, __BYTE_ORDER, 8)
+
+#undef __field_network
+#define __field_network(_type, _item)				\
+	__field_full(_type, _item, __BIG_ENDIAN, 10)
+
+#undef __field_network_hex
+#define __field_network_hex(_type, _item)				\
+	__field_full(_type, _item, __BIG_ENDIAN, 16)
+
+#undef __array_enc_ext
+#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
 	{							\
-		.name = #_item,					\
-		.type = {					\
+	  .name = #_item,					\
+	  .type =						\
+		{						\
 		  .atype = atype_array,				\
-		  .name = NULL,					\
-		  .u.array.elem_type = #_type,			\
-		  .u.array.length = _length,			\
+		  .u.array =					\
+			{					\
+			    .length = _length,			\
+			    .elem_type = __type_integer(_type, _order, _base, _encoding), \
+			},					\
 		},						\
 	},
 
-#undef __dynamic_array
-#define __dynamic_array(_type, _item, _length)			\
+#undef __array
+#define __array(_type, _item, _length)				\
+	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none)
+
+#undef __array_text
+#define __array_text(_type, _item, _length)			\
+	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8)
+
+#undef __array_hex
+#define __array_hex(_type, _item, _length)			\
+	__array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none)
+
+#undef __dynamic_array_enc_ext
+#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding) \
 	{							\
-		.name = #_item,					\
-		.type = {					\
+	  .name = #_item,					\
+	  .type =						\
+		{						\
 		  .atype = atype_sequence,			\
-		  .name = NULL,					\
-		  .u.sequence.elem_type = #_type,		\
-		  .u.sequence.length_type = "u32",		\
+		  .u.sequence =					\
+			{					\
+			    .length_type = __type_integer(u32, __BYTE_ORDER, 10, none), \
+			    .elem_type = __type_integer(_type, _order, _base, _encoding), \
+			},					\
 		},						\
 	},
 
+#undef __dynamic_array_enc_ext_2
+#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding) \
+	__dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding)
+
+#undef __dynamic_array
+#define __dynamic_array(_type, _item, _length)			\
+	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none)
+
+#undef __dynamic_array_text
+#define __dynamic_array_text(_type, _item, _length)		\
+	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8)
+
+#undef __dynamic_array_hex
+#define __dynamic_array_hex(_type, _item, _length)		\
+	__dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none)
+
+#undef __dynamic_array_network_hex
+#define __dynamic_array_network_hex(_type, _item, _length)		\
+	__dynamic_array_enc_ext(_type, _item, _length, __BIG_ENDIAN, 16, none)
+
+#undef __dynamic_array_network
+#define __dynamic_array_network(_type, _item, _length)		\
+	__dynamic_array_enc_ext(_type, _item, _length, __BIG_ENDIAN, 10, none)
+
+#undef __dynamic_array_text_2
+#define __dynamic_array_text_2(_type, _item, _length1, _length2)	\
+	__dynamic_array_enc_ext_2(_type, _item, _length1, _length2, __BYTE_ORDER, 10, UTF8)
+
 #undef __string
 #define __string(_item, _src)					\
 	{							\
-		.name = #_item,					\
-		.type = {					\
+	  .name = #_item,					\
+	  .type =						\
+		{						\
 		  .atype = atype_string,			\
-		  .name = NULL,					\
-		  .u.string.encoding = lttng_encode_UTF8,	\
+		  .u.basic.string.encoding = lttng_encode_UTF8,	\
 		},						\
 	},
 
+#undef __string_from_user
+#define __string_from_user(_item, _src)				\
+	__string(_item, _src)
+
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args	/* Only one used in this phase */
 
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
 	static const struct lttng_event_field __event_fields___##_name[] = { \
 		_tstruct						     \
 	};
 
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, PARAMS(_tstruct), PARAMS(_assign), \
+			PARAMS(_print))
+
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 /*
- * Stage 2 of the trace events.
+ * Stage 3 of the trace events.
  *
- * Create an array of events.
+ * Create probe callback prototypes.
+ */
+
+#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */
+
+#undef TP_PROTO
+#define TP_PROTO(args...) args
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+static void __event_probe__##_name(void *__data, _proto);
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+static void __event_probe__##_name(void *__data);
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Stage 3.9 of the trace events.
+ *
+ * Create event descriptions.
  */
 
 /* Named field types must be defined in lttng-types.h */
 
 #include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */
 
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(_template, _name, _proto, _args)			       \
-		{							       \
-			.fields = __event_fields___##_template,		       \
-			.name = #_name,					       \
-			.nr_fields = ARRAY_SIZE(__event_fields___##_template), \
-		},
+#ifndef TP_PROBE_CB
+#define TP_PROBE_CB(_template)	&__event_probe__##_template
+#endif
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map)	\
+static const struct lttng_event_desc __event_desc___##_map = {		\
+	.fields = __event_fields___##_template,		     		\
+	.name = #_map,					     		\
+	.kname = #_name,				     		\
+	.probe_callback = (void *) TP_PROBE_CB(_template),   		\
+	.nr_fields = ARRAY_SIZE(__event_fields___##_template),		\
+	.owner = THIS_MODULE,				     		\
+};
 
-#define TP_ID1(_token, _system)	_token##_system
-#define TP_ID(_token, _system)	TP_ID1(_token, _system)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map)
 
-static const struct lttng_event_desc TP_ID(__event_desc___, TRACE_SYSTEM)[] = {
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-};
 
-#undef TP_ID1
-#undef TP_ID
 
 /*
- * Stage 3 of the trace events.
+ * Stage 4 of the trace events.
  *
- * Create seq file metadata output.
+ * Create an array of event description pointers.
  */
 
-#define TP_ID1(_token, _system)	_token##_system
-#define TP_ID(_token, _system)	TP_ID1(_token, _system)
-
-static void *TP_ID(__lttng_seq_start__, TRACE_SYSTEM)(struct seq_file *m,
-						      loff_t *pos)
-{
-	const struct lttng_event_desc *desc =
-		&TP_ID(__event_desc___, TRACE_SYSTEM)[*pos];
-
-	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
-			[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
-		return NULL;
-	return (void *) desc;
-}
+/* Named field types must be defined in lttng-types.h */
 
-static void *TP_ID(__lttng_seq_next__, TRACE_SYSTEM)(struct seq_file *m,
-						     void *p, loff_t *ppos)
-{
-	const struct lttng_event_desc *desc =
-		&TP_ID(__event_desc___, TRACE_SYSTEM)[++(*ppos)];
+#include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */
 
-	if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM)
-			[ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1])
-		return NULL;
-	return (void *) desc;
-}
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \
+		&__event_desc___##_map,
 
-static void TP_ID(__lttng_seq_stop__, TRACE_SYSTEM)(struct seq_file *m,
-						    void *p)
-{
-}
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \
+	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map)
 
-static int TP_ID(__lttng_seq_show__, TRACE_SYSTEM)(struct seq_file *m,
-						   void *p)
-{
-	const struct lttng_event_desc *desc = p;
-	int i;
-
-	seq_printf(m,	"event {\n"
-			"\tname = %s;\n"
-			"\tid = UNKNOWN;\n"
-			"\tstream = UNKNOWN;\n"
-			"\tfields = {\n",
-			desc->name);
-	for (i = 0; i < desc->nr_fields; i++) {
-		if (desc->fields[i].type.name)	/* Named type */
-			seq_printf(m,	"\t\t%s",
-					desc->fields[i].type.name);
-		else				/* Nameless type */
-			lttng_print_event_type(m, 2, &desc->fields[i].type);
-		seq_printf(m,	" %s;\n", desc->fields[i].name);
-	}
-	seq_printf(m,	"\t};\n");
-	seq_printf(m,	"};\n");
-	return 0;
-}
+#define TP_ID1(_token, _system)	_token##_system
+#define TP_ID(_token, _system)	TP_ID1(_token, _system)
 
-static const
-struct seq_operations TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM) = {
-	.start = TP_ID(__lttng_seq_start__, TRACE_SYSTEM),
-	.next = TP_ID(__lttng_seq_next__, TRACE_SYSTEM),
-	.stop = TP_ID(__lttng_seq_stop__, TRACE_SYSTEM),
-	.show = TP_ID(__lttng_seq_show__, TRACE_SYSTEM),
+static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = {
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 };
 
-static int
-TP_ID(__lttng_types_open__, TRACE_SYSTEM)(struct inode *inode, struct file *file)
-{
-	return seq_open(file, &TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM));
-}
+#undef TP_ID1
+#undef TP_ID
 
-static const
-struct file_operations TP_ID(__lttng_types_fops__, TRACE_SYSTEM) = {
-        .open = TP_ID(__lttng_types_open__, TRACE_SYSTEM),
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release_private,
-};
 
-static struct dentry *TP_ID(__lttng_types_dentry__, TRACE_SYSTEM);
+/*
+ * Stage 5 of the trace events.
+ *
+ * Create a toplevel descriptor for the whole probe.
+ */
 
-static int TP_ID(__lttng_types_init__, TRACE_SYSTEM)(void)
-{
-	int ret = 0;
-
-	TP_ID(__lttng_types_dentry__, TRACE_SYSTEM) =
-		debugfs_create_file("lttng-events-" __stringify(TRACE_SYSTEM),
-				    S_IWUSR, NULL, NULL,
-				    &TP_ID(__lttng_types_fops__, TRACE_SYSTEM));
-	if (IS_ERR(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM))
-	    || !TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)) {
-		printk(KERN_ERR "Error creating LTTng type export file\n");
-		ret = -ENOMEM;
-		goto error;
-	}
-error:
-	return ret;
-}
+#define TP_ID1(_token, _system)	_token##_system
+#define TP_ID(_token, _system)	TP_ID1(_token, _system)
 
-static void TP_ID(__lttng_types_exit__, TRACE_SYSTEM)(void)
-{
-	debugfs_remove(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM));
-}
+/* non-const because list head will be modified when registered. */
+static __used struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = {
+	.event_desc = TP_ID(__event_desc___, TRACE_SYSTEM),
+	.nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)),
+};
 
 #undef TP_ID1
 #undef TP_ID
 
 /*
- * Stage 4 of the trace events.
+ * Stage 6 of the trace events.
  *
  * Create static inline function that calculates event size.
  */
@@ -266,55 +472,89 @@ static void TP_ID(__lttng_types_exit__, TRACE_SYSTEM)(void)
 
 /* Named field types must be defined in lttng-types.h */
 
-#undef __field
-#define __field(_type, _item)						       \
-	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
+#undef __field_full
+#define __field_full(_type, _item, _order, _base)			       \
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 	__event_len += sizeof(_type);
 
-#undef __field_ext
-#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)
-
-#undef __array
-#define __array(_type, _item, _length)					       \
-	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
+#undef __array_enc_ext
+#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)       \
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
 	__event_len += sizeof(_type) * (_length);
 
-#undef __dynamic_array
-#define __dynamic_array(_type, _item, _length)				       \
-	__event_len += lib_ring_buffer_align(__event_len, __alignof__(u32));   \
+#undef __dynamic_array_enc_ext
+#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(u32)); \
 	__event_len += sizeof(u32);					       \
-	__event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \
-	__event_len += sizeof(_type) * (_length);
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
+	__dynamic_len[__dynamic_len_idx] = (_length);			       \
+	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
+	__dynamic_len_idx++;
+
+#undef __dynamic_array_enc_ext_2
+#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(u32)); \
+	__event_len += sizeof(u32);					       \
+	__event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \
+	__dynamic_len[__dynamic_len_idx] = (_length1);			       \
+	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
+	__dynamic_len_idx++;						       \
+	__dynamic_len[__dynamic_len_idx] = (_length2);			       \
+	__event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx];       \
+	__dynamic_len_idx++;
 
 #undef __string
 #define __string(_item, _src)						       \
 	__event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1;
 
+/*
+ * strlen_user includes \0. If returns 0, it faulted, so we set size to
+ * 1 (\0 only).
+ */
+#undef __string_from_user
+#define __string_from_user(_item, _src)					       \
+	__event_len += __dynamic_len[__dynamic_len_idx++] =		       \
+		max_t(size_t, lttng_strlen_user_inatomic(_src), 1);
+
 #undef TP_PROTO
 #define TP_PROTO(args...) args
 
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args
 
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
-static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
+#undef TP_locvar
+#define TP_locvar(...)	__VA_ARGS__
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+static inline size_t __event_get_size__##_name(size_t *__dynamic_len,	      \
+		void *__tp_locvar, _proto)				      \
 {									      \
 	size_t __event_len = 0;						      \
-	unsigned int __dynamic_len_idx = 0;				      \
+	unsigned int __dynamic_len_idx __attribute__((unused)) = 0;	      \
+	struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar;  \
 									      \
-	if (0)								      \
-		(void) __dynamic_len_idx;	/* don't warn if unused */    \
 	_tstruct							      \
 	return __event_len;						      \
 }
 
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+static inline size_t __event_get_size__##_name(size_t *__dynamic_len,	      \
+		void *__tp_locvar)					      \
+{									      \
+	size_t __event_len = 0;						      \
+	unsigned int __dynamic_len_idx __attribute__((unused)) = 0;	      \
+	struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar;  \
+									      \
+	_tstruct							      \
+	return __event_len;						      \
+}
 
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 /*
- * Stage 5 of the trace events.
+ * Stage 7 of the trace events.
  *
  * Create static inline function that calculates event payload alignment.
  */
@@ -323,45 +563,64 @@ static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \
 
 /* Named field types must be defined in lttng-types.h */
 
-#undef __field
-#define __field(_type, _item)						  \
-	__event_align = max_t(size_t, __event_align, __alignof__(_type));
+#undef __field_full
+#define __field_full(_type, _item, _order, _base)			  \
+	__event_align = max_t(size_t, __event_align, lttng_alignof(_type));
 
-#undef __field_ext
-#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)
+#undef __array_enc_ext
+#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)  \
+	__event_align = max_t(size_t, __event_align, lttng_alignof(_type));
 
-#undef __array
-#define __array(_type, _item, _length)					  \
-	__event_align = max_t(size_t, __event_align, __alignof__(_type));
+#undef __dynamic_array_enc_ext
+#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
+	__event_align = max_t(size_t, __event_align, lttng_alignof(u32)); \
+	__event_align = max_t(size_t, __event_align, lttng_alignof(_type));
 
-#undef __dynamic_array
-#define __dynamic_array(_type, _item, _length)				  \
-	__event_align = max_t(size_t, __event_align, __alignof__(u32));	  \
-	__event_align = max_t(size_t, __event_align, __alignof__(_type));
+#undef __dynamic_array_enc_ext_2
+#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\
+	__dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding)
 
 #undef __string
 #define __string(_item, _src)
 
+#undef __string_from_user
+#define __string_from_user(_item, _src)
+
 #undef TP_PROTO
 #define TP_PROTO(args...) args
 
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args
 
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
-static inline size_t __event_get_align__##_name(_proto)			      \
+#undef TP_locvar
+#define TP_locvar(...)	__VA_ARGS__
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+static inline size_t __event_get_align__##_name(void *__tp_locvar, _proto)    \
 {									      \
 	size_t __event_align = 1;					      \
+	struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar;  \
+									      \
 	_tstruct							      \
 	return __event_align;						      \
 }
 
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+static inline size_t __event_get_align__##_name(void *__tp_locvar)	      \
+{									      \
+	size_t __event_align = 1;					      \
+	struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar;  \
+									      \
+	_tstruct							      \
+	return __event_align;						      \
+}
 
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 /*
- * Stage 6 of the trace events.
+ * Stage 8 of the trace events.
  *
  * Create structure declaration that allows the "assign" macros to access the
  * field types.
@@ -371,35 +630,46 @@ static inline size_t __event_get_align__##_name(_proto)			      \
 
 /* Named field types must be defined in lttng-types.h */
 
-#undef __field
-#define __field(_type, _item)	_type	_item;
+#undef __field_full
+#define __field_full(_type, _item, _order, _base)	_type	_item;
 
-#undef __field_ext
-#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)
+#undef __array_enc_ext
+#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)  \
+	_type	_item;
 
-#undef __array
-#define __array(_type, _item, _length)	_type	_item;
+#undef __dynamic_array_enc_ext
+#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
+	_type	_item;
 
-#undef __dynamic_array
-#define __dynamic_array(_type, _item, _length)	_type	_item;
+#undef __dynamic_array_enc_ext_2
+#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\
+	__dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding)
 
 #undef __string
-#define __string(_item, _src)	char _item;
+#define __string(_item, _src)			char _item;
+
+#undef __string_from_user
+#define __string_from_user(_item, _src)		\
+	__string(_item, _src)
 
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args
 
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
 struct __event_typemap__##_name {					      \
 	_tstruct							      \
 };
 
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+	LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
+
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 
 /*
- * Stage 7 of the trace events.
+ * Stage 9 of the trace events.
  *
  * Create the probe function : call even size calculation and write event data
  * into the buffer.
@@ -411,31 +681,41 @@ struct __event_typemap__##_name {					      \
 
 #include "lttng-events-reset.h"	/* Reset all macros within TRACE_EVENT */
 
-#undef __field
-#define __field(_type, _item)						\
+#undef __field_full
+#define __field_full(_type, _item, _order, _base)			\
 	goto __assign_##_item;						\
 __end_field_##_item:
 
-#undef __field_ext
-#define __field_ext(_type, _item, _filter_type)	__field(_type, _item)
-
-#undef __array
-#define __array(_type, _item, _length)					\
+#undef __array_enc_ext
+#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
 	goto __assign_##_item;						\
 __end_field_##_item:
 
-#undef __dynamic_array
-#define __dynamic_array(_type, _item, _length)				\
+#undef __dynamic_array_enc_ext
+#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\
 	goto __assign_##_item##_1;					\
 __end_field_##_item##_1:						\
 	goto __assign_##_item##_2;					\
 __end_field_##_item##_2:
 
+#undef __dynamic_array_enc_ext_2
+#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\
+	goto __assign_##_item##_1;					\
+__end_field_##_item##_1:						\
+	goto __assign_##_item##_2;					\
+__end_field_##_item##_2:						\
+	goto __assign_##_item##_3;					\
+__end_field_##_item##_3:
+
 #undef __string
 #define __string(_item, _src)						\
 	goto __assign_##_item;						\
 __end_field_##_item:
 
+#undef __string_from_user
+#define __string_from_user(_item, _src)					\
+	__string(_item, _src)
+
 /*
  * Macros mapping tp_assign() to "=", tp_memcpy() to memcpy() and tp_strcpy() to
  * strcpy().
@@ -445,35 +725,98 @@ __end_field_##_item:
 __assign_##dest:							\
 	{								\
 		__typeof__(__typemap.dest) __tmp = (src);		\
-		lib_ring_buffer_align_ctx(&ctx, __alignof__(__tmp));	\
-		__chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp));	\
+		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));	\
+		__chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\
 	}								\
 	goto __end_field_##dest;
 
-#undef tp_memcpy
-#define tp_memcpy(dest, src, len)					\
+/* fixed length array memcpy */
+#undef tp_memcpy_gen
+#define tp_memcpy_gen(write_ops, dest, src, len)			\
 __assign_##dest:							\
-	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest));	\
-	__chan->ops->event_write(&ctx, src, len);			\
+	if (0)								\
+		(void) __typemap.dest;					\
+	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__typemap.dest));	\
+	__chan->ops->write_ops(&__ctx, src, len);			\
 	goto __end_field_##dest;
 
-#undef tp_memcpy_dyn
-#define tp_memcpy_dyn(dest, src, len)					\
+#undef tp_memcpy
+#define tp_memcpy(dest, src, len)					\
+	tp_memcpy_gen(event_write, dest, src, len)
+
+#undef tp_memcpy_from_user
+#define tp_memcpy_from_user(dest, src, len)				\
+	tp_memcpy_gen(event_write_from_user, dest, src, len)
+
+/* variable length sequence memcpy */
+#undef tp_memcpy_dyn_gen
+#define tp_memcpy_dyn_gen(write_ops, dest, src)				\
 __assign_##dest##_1:							\
 	{								\
-		u32 __tmpl = (len);					\
-		lib_ring_buffer_align_ctx(&ctx, __alignof__(u32));	\
-		__chan->ops->event_write(&ctx, &__tmpl, sizeof(u32));	\
+		u32 __tmpl = __dynamic_len[__dynamic_len_idx];		\
+		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(u32));	\
+		__chan->ops->event_write(&__ctx, &__tmpl, sizeof(u32));	\
 	}								\
 	goto __end_field_##dest##_1;					\
 __assign_##dest##_2:							\
-	lib_ring_buffer_align_ctx(&ctx, __alignof__(__typemap.dest));	\
-	__chan->ops->event_write(&ctx, src, len);			\
+	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__typemap.dest));	\
+	__chan->ops->write_ops(&__ctx, src,				\
+		sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\
 	goto __end_field_##dest##_2;
 
+#undef tp_memcpy_dyn_gen_2
+#define tp_memcpy_dyn_gen_2(write_ops, dest, src1, src2)		\
+__assign_##dest##_1:							\
+	{								\
+		u32 __tmpl = __dynamic_len[__dynamic_len_idx]		\
+			+ __dynamic_len[__dynamic_len_idx + 1];		\
+		lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(u32));	\
+		__chan->ops->event_write(&__ctx, &__tmpl, sizeof(u32));	\
+	}								\
+	goto __end_field_##dest##_1;					\
+__assign_##dest##_2:							\
+	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__typemap.dest));	\
+	__chan->ops->write_ops(&__ctx, src1,				\
+		sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\
+	goto __end_field_##dest##_2;					\
+__assign_##dest##_3:							\
+	__chan->ops->write_ops(&__ctx, src2,				\
+		sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\
+	goto __end_field_##dest##_3;
+
+#undef tp_memcpy_dyn
+#define tp_memcpy_dyn(dest, src)					\
+	tp_memcpy_dyn_gen(event_write, dest, src)
+
+#undef tp_memcpy_dyn_2
+#define tp_memcpy_dyn_2(dest, src1, src2)				\
+	tp_memcpy_dyn_gen_2(event_write, dest, src1, src2)
+
+#undef tp_memcpy_dyn_from_user
+#define tp_memcpy_dyn_from_user(dest, src)				\
+	tp_memcpy_dyn_gen(event_write_from_user, dest, src)
+
+/*
+ * The string length including the final \0.
+ */
+#undef tp_copy_string_from_user
+#define tp_copy_string_from_user(dest, src)				\
+__assign_##dest:							\
+	if (0)								\
+		(void) __typemap.dest;					\
+	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__typemap.dest)); \
+	__chan->ops->event_strcpy_from_user(&__ctx, src,		\
+		__get_dynamic_array_len(dest));				\
+	goto __end_field_##dest;
+
 #undef tp_strcpy
 #define tp_strcpy(dest, src)						\
-	tp_memcpy(dest, src, __get_dynamic_array_len(dest))
+__assign_##dest:							\
+	if (0)								\
+		(void) __typemap.dest;					\
+	lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__typemap.dest)); \
+	__chan->ops->event_strcpy(&__ctx, src, __get_dynamic_array_len(dest)); \
+	goto __end_field_##dest;
 
 /* Named field types must be defined in lttng-types.h */
 
@@ -499,33 +842,106 @@ __assign_##dest##_2:							\
 #undef TP_fast_assign
 #define TP_fast_assign(args...) args
 
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print)  \
+#undef TP_locvar
+#define TP_locvar(...)	__VA_ARGS__
+
+#undef TP_code
+#define TP_code(...)	__VA_ARGS__
+
+/*
+ * For state dump, check that "session" argument (mandatory) matches the
+ * session this event belongs to. Ensures that we write state dump data only
+ * into the started session, not into all sessions.
+ */
+#ifdef TP_SESSION_CHECK
+#define _TP_SESSION_CHECK(session, csession)	(session == csession)
+#else /* TP_SESSION_CHECK */
+#define _TP_SESSION_CHECK(session, csession)	1
+#endif /* TP_SESSION_CHECK */
+
+/*
+ * __dynamic_len array length is twice the number of fields due to
+ * __dynamic_array_enc_ext_2() and tp_memcpy_dyn_2(), which are the
+ * worse case, needing 2 entries per field.
+ */
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
 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;					      \
+	struct probe_local_vars { _locvar };				      \
+	struct lttng_event *__event = __data;				      \
+	struct lttng_channel *__chan = __event->chan;			      \
+	struct lib_ring_buffer_ctx __ctx;				      \
+	size_t __event_len, __event_align;				      \
+	size_t __dynamic_len_idx __attribute__((unused)) = 0;		      \
+	size_t __dynamic_len[2 * ARRAY_SIZE(__event_fields___##_name)] __attribute__((unused)); \
+	struct __event_typemap__##_name __typemap __attribute__((unused));    \
+	int __ret;							      \
+	struct probe_local_vars __tp_locvar;				      \
+	struct probe_local_vars *tp_locvar __attribute__((unused)) =	      \
+			&__tp_locvar;					      \
+									      \
+	if (!_TP_SESSION_CHECK(session, __chan->session))		      \
+		return;							      \
+	if (unlikely(!ACCESS_ONCE(__chan->session->active)))		      \
+		return;							      \
+	if (unlikely(!ACCESS_ONCE(__chan->enabled)))			      \
+		return;							      \
+	if (unlikely(!ACCESS_ONCE(__event->enabled)))			      \
+		return;							      \
+	_code								      \
+	__event_len = __event_get_size__##_name(__dynamic_len, tp_locvar,     \
+				_args);					      \
+	__event_align = __event_get_align__##_name(tp_locvar, _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;							      \
+	/* Control code (field ordering) */				      \
+	_tstruct							      \
+	__chan->ops->event_commit(&__ctx);				      \
+	return;								      \
+	/* Copy code, steered by control code */			      \
+	_assign								      \
+}
+
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+static void __event_probe__##_name(void *__data)			      \
+{									      \
+	struct probe_local_vars { _locvar };				      \
+	struct lttng_event *__event = __data;				      \
+	struct lttng_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[ARRAY_SIZE(__event_fields___##_name)];	      \
-	struct __event_typemap__##_name __typemap;			      \
+	size_t __dynamic_len_idx __attribute__((unused)) = 0;		      \
+	size_t __dynamic_len[2 * ARRAY_SIZE(__event_fields___##_name)] __attribute__((unused)); \
+	struct __event_typemap__##_name __typemap __attribute__((unused));    \
 	int __ret;							      \
+	struct probe_local_vars __tp_locvar;				      \
+	struct probe_local_vars *tp_locvar __attribute__((unused)) =	      \
+			&__tp_locvar;					      \
 									      \
-	if (0)								      \
-		(void) __dynamic_len_idx;	/* don't warn if unused */    \
-	if (!ACCESS_ONCE(__chan->session->active))			      \
+	if (!_TP_SESSION_CHECK(session, __chan->session))		      \
+		return;							      \
+	if (unlikely(!ACCESS_ONCE(__chan->session->active)))		      \
 		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, NULL, __event_len,	      \
+	if (unlikely(!ACCESS_ONCE(__chan->enabled)))			      \
+		return;							      \
+	if (unlikely(!ACCESS_ONCE(__event->enabled)))			      \
+		return;							      \
+	_code								      \
+	__event_len = __event_get_size__##_name(__dynamic_len, tp_locvar);    \
+	__event_align = __event_get_align__##_name(tp_locvar);		      \
+	lib_ring_buffer_ctx_init(&__ctx, __chan->chan, __event, __event_len,  \
 				 __event_align, -1);			      \
-	__ret = __chan->ops->event_reserve(&ctx);			      \
+	__ret = __chan->ops->event_reserve(&__ctx, __event->id);	      \
 	if (__ret < 0)							      \
 		return;							      \
 	/* Control code (field ordering) */				      \
 	_tstruct							      \
-	__chan->ops->event_commit(&ctx);				      \
+	__chan->ops->event_commit(&__ctx);				      \
 	return;								      \
 	/* Copy code, steered by control code */			      \
 	_assign								      \
@@ -533,9 +949,8 @@ static void __event_probe__##_name(void *__data, _proto)		      \
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-
 /*
- * Stage 8 of the trace events.
+ * Stage 10 of the trace events.
  *
  * Register/unregister probes at module load/unload.
  */
@@ -549,37 +964,29 @@ static void __event_probe__##_name(void *__data, _proto)		      \
 #define module_exit_eval1(_token, _system)	module_exit(_token##_system)
 #define module_exit_eval(_token, _system)	module_exit_eval1(_token, _system)
 
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(_template, _name, _proto, _args)			       \
-	ret = ltt_probe_register(#_name, (void *) __event_probe__##_template); \
-	WARN_ON_ONCE(ret);
-
+#ifndef TP_MODULE_NOINIT
 static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void)
 {
-	int ret = 0;
-
-	ret = TP_ID(__lttng_types_init__, TRACE_SYSTEM)();
-	if (ret)
-		return ret;
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-	return ret;
+	wrapper_vmalloc_sync_all();
+	return lttng_probe_register(&TP_ID(__probe_desc___, TRACE_SYSTEM));
 }
 
-module_init_eval(__lttng_events_init__, TRACE_SYSTEM);
-
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(_template, _name, _proto, _args)			       \
-	ltt_probe_unregister(#_name);
-
 static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void)
 {
-#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
-	TP_ID(__lttng_types_exit__, TRACE_SYSTEM)();
+	lttng_probe_unregister(&TP_ID(__probe_desc___, TRACE_SYSTEM));
 }
 
+#ifndef TP_MODULE_NOAUTOLOAD
+module_init_eval(__lttng_events_init__, TRACE_SYSTEM);
 module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM);
+#endif
+
+#endif
 
 #undef module_init_eval
 #undef module_exit_eval
 #undef TP_ID1
 #undef TP_ID
+
+#undef TP_PROTO
+#undef TP_ARGS