X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=21653efd242cf414042ded43afb5ae226ded8286;hb=437d5aa59380583ce1cd14d394a53b398be1275d;hp=3f9d0f9a91fdf7b50b7a647d1aea55413d8412b0;hpb=3b82c4e1b18900cc7ad4045b9173cabfaa498852;p=lttng-modules.git

diff --git a/src/lttng-events.c b/src/lttng-events.c
index 3f9d0f9a..21653efd 100644
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -36,6 +36,7 @@
 #include <wrapper/types.h>
 #include <lttng/kernel-version.h>
 #include <lttng/events.h>
+#include <lttng/events-internal.h>
 #include <lttng/lttng-bytecode.h>
 #include <lttng/tracer.h>
 #include <lttng/event-notifier-notification.h>
@@ -81,30 +82,31 @@ static
 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream);
 static
 int _lttng_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_common *type,
+		enum lttng_kernel_string_encoding parent_encoding,
 		size_t nesting);
 static
 int _lttng_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting);
 
 void synchronize_trace(void)
 {
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0))
 	synchronize_rcu();
 #else
 	synchronize_sched();
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
 #ifdef CONFIG_PREEMPT_RT_FULL
 	synchronize_rcu();
 #endif
-#else /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
+#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
 #ifdef CONFIG_PREEMPT_RT
 	synchronize_rcu();
 #endif
-#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
+#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
 }
 
 void lttng_lock_sessions(void)
@@ -412,6 +414,7 @@ void lttng_event_notifier_group_destroy(
 
 	if (event_notifier_group->error_counter) {
 		struct lttng_counter *error_counter = event_notifier_group->error_counter;
+
 		error_counter->ops->counter_destroy(error_counter->counter);
 		module_put(error_counter->transport->owner);
 		lttng_kvfree(error_counter);
@@ -613,19 +616,22 @@ int lttng_event_enable(struct lttng_event *event)
 		goto end;
 	}
 	switch (event->instrumentation) {
-	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		ret = -EINVAL;
 		break;
-	case LTTNG_KERNEL_KPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_UPROBE:
-	case LTTNG_KERNEL_NOOP:
 		WRITE_ONCE(event->enabled, 1);
 		break;
+
 	case LTTNG_KERNEL_KRETPROBE:
 		ret = lttng_kretprobes_event_enable_state(event, 1);
 		break;
-	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
+
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -649,19 +655,23 @@ int lttng_event_disable(struct lttng_event *event)
 		goto end;
 	}
 	switch (event->instrumentation) {
-	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		ret = -EINVAL;
 		break;
-	case LTTNG_KERNEL_KPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_UPROBE:
-	case LTTNG_KERNEL_NOOP:
 		WRITE_ONCE(event->enabled, 0);
 		break;
+
 	case LTTNG_KERNEL_KRETPROBE:
+
 		ret = lttng_kretprobes_event_enable_state(event, 0);
 		break;
-	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
+
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -681,17 +691,19 @@ int lttng_event_notifier_enable(struct lttng_event_notifier *event_notifier)
 		goto end;
 	}
 	switch (event_notifier->instrumentation) {
-	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		ret = -EINVAL;
 		break;
-	case LTTNG_KERNEL_KPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_UPROBE:
 		WRITE_ONCE(event_notifier->enabled, 1);
 		break;
-	case LTTNG_KERNEL_FUNCTION:
-	case LTTNG_KERNEL_NOOP:
-	case LTTNG_KERNEL_KRETPROBE:
+
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -711,17 +723,19 @@ int lttng_event_notifier_disable(struct lttng_event_notifier *event_notifier)
 		goto end;
 	}
 	switch (event_notifier->instrumentation) {
-	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		ret = -EINVAL;
 		break;
-	case LTTNG_KERNEL_KPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_UPROBE:
 		WRITE_ONCE(event_notifier->enabled, 0);
 		break;
-	case LTTNG_KERNEL_FUNCTION:
-	case LTTNG_KERNEL_NOOP:
-	case LTTNG_KERNEL_KRETPROBE:
+
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -801,7 +815,7 @@ void _lttng_channel_destroy(struct lttng_channel *chan)
 	chan->ops->channel_destroy(chan->chan);
 	module_put(chan->transport->owner);
 	list_del(&chan->list);
-	lttng_destroy_context(chan->ctx);
+	lttng_kernel_destroy_context(chan->ctx);
 	kfree(chan);
 }
 
@@ -831,7 +845,7 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
 struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 				struct lttng_kernel_event *event_param,
 				void *filter,
-				const struct lttng_event_desc *event_desc,
+				const struct lttng_kernel_event_desc *event_desc,
 				enum lttng_kernel_instrumentation itype)
 {
 	struct lttng_session *session = chan->session;
@@ -847,16 +861,18 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 
 	switch (itype) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		event_name = event_desc->name;
+		event_name = event_desc->event_name;
 		break;
-	case LTTNG_KERNEL_KPROBE:
-	case LTTNG_KERNEL_UPROBE:
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_NOOP:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_UPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		event_name = event_param->name;
 		break;
-	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
+
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -867,7 +883,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		LTTNG_EVENT_HT_SIZE, event_name);
 	lttng_hlist_for_each_entry(event, head, hlist) {
 		WARN_ON_ONCE(!event->desc);
-		if (!strncmp(event->desc->name, event_name,
+		if (!strncmp(event->desc->event_name, event_name,
 					LTTNG_KERNEL_SYM_NAME_LEN - 1)
 				&& chan == event->chan) {
 			ret = -EEXIST;
@@ -901,6 +917,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		/* Populate lttng_event structure before event registration. */
 		smp_wmb();
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -925,6 +942,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		ret = try_module_get(event->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
+
 	case LTTNG_KERNEL_KRETPROBE:
 	{
 		struct lttng_event *event_return;
@@ -948,6 +966,8 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		event_return->enabled = 0;
 		event_return->registered = 1;
 		event_return->instrumentation = itype;
+		INIT_LIST_HEAD(&event_return->filter_bytecode_runtime_head);
+		INIT_LIST_HEAD(&event_return->enablers_ref_head);
 		/*
 		 * Populate lttng_event structure before kretprobe registration.
 		 */
@@ -979,7 +999,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		list_add(&event_return->list, &chan->session->events);
 		break;
 	}
-	case LTTNG_KERNEL_NOOP:
+
 	case LTTNG_KERNEL_SYSCALL:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -1015,6 +1035,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 			goto register_error;
 		}
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -1037,7 +1058,9 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		ret = try_module_get(event->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
+
 	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -1064,29 +1087,32 @@ full:
 }
 
 struct lttng_event_notifier *_lttng_event_notifier_create(
-		const struct lttng_event_desc *event_desc,
+		const struct lttng_kernel_event_desc *event_desc,
 		uint64_t token, uint64_t error_counter_index,
 		struct lttng_event_notifier_group *event_notifier_group,
 		struct lttng_kernel_event_notifier *event_notifier_param,
 		void *filter, enum lttng_kernel_instrumentation itype)
 {
 	struct lttng_event_notifier *event_notifier;
+	struct lttng_counter *error_counter;
 	const char *event_name;
 	struct hlist_head *head;
 	int ret;
 
 	switch (itype) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		event_name = event_desc->name;
+		event_name = event_desc->event_name;
 		break;
-	case LTTNG_KERNEL_KPROBE:
-	case LTTNG_KERNEL_UPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_UPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_SYSCALL:
 		event_name = event_notifier_param->event.name;
 		break;
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
-	case LTTNG_KERNEL_NOOP:
+
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -1097,7 +1123,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 		LTTNG_EVENT_NOTIFIER_HT_SIZE, event_name);
 	lttng_hlist_for_each_entry(event_notifier, head, hlist) {
 		WARN_ON_ONCE(!event_notifier->desc);
-		if (!strncmp(event_notifier->desc->name, event_name,
+		if (!strncmp(event_notifier->desc->event_name, event_name,
 					LTTNG_KERNEL_SYM_NAME_LEN - 1)
 				&& event_notifier_group == event_notifier->group
 				&& token == event_notifier->user_token) {
@@ -1137,6 +1163,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 		/* Populate lttng_event_notifier structure before event registration. */
 		smp_wmb();
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -1161,7 +1188,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 		ret = try_module_get(event_notifier->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
-	case LTTNG_KERNEL_NOOP:
+
 	case LTTNG_KERNEL_SYSCALL:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -1198,6 +1225,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 			goto register_error;
 		}
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		/*
 		 * Needs to be explicitly enabled after creation, since
@@ -1221,8 +1249,10 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 		ret = try_module_get(event_notifier->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
+
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -1234,9 +1264,12 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 
 	/*
 	 * Clear the error counter bucket. The sessiond keeps track of which
-	 * bucket is currently in use. We trust it.
+	 * bucket is currently in use. We trust it. The session lock
+	 * synchronizes against concurrent creation of the error
+	 * counter.
 	 */
-	if (event_notifier_group->error_counter) {
+	error_counter = event_notifier_group->error_counter;
+	if (error_counter) {
 		size_t dimension_index[1];
 
 		/*
@@ -1250,9 +1283,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create(
 		}
 
 		dimension_index[0] = event_notifier->error_counter_index;
-		ret = event_notifier_group->error_counter->ops->counter_clear(
-				event_notifier_group->error_counter->counter,
-				dimension_index);
+		ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
 		if (ret) {
 			printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
 				event_notifier->error_counter_index);
@@ -1295,7 +1326,7 @@ int lttng_kernel_counter_clear(struct lttng_counter *counter,
 struct lttng_event *lttng_event_create(struct lttng_channel *chan,
 				struct lttng_kernel_event *event_param,
 				void *filter,
-				const struct lttng_event_desc *event_desc,
+				const struct lttng_kernel_event_desc *event_desc,
 				enum lttng_kernel_instrumentation itype)
 {
 	struct lttng_event *event;
@@ -1308,7 +1339,7 @@ struct lttng_event *lttng_event_create(struct lttng_channel *chan,
 }
 
 struct lttng_event_notifier *lttng_event_notifier_create(
-		const struct lttng_event_desc *event_desc,
+		const struct lttng_kernel_event_desc *event_desc,
 		uint64_t id, uint64_t error_counter_index,
 		struct lttng_event_notifier_group *event_notifier_group,
 		struct lttng_kernel_event_notifier *event_notifier_param,
@@ -1328,7 +1359,7 @@ struct lttng_event_notifier *lttng_event_notifier_create(
 static
 void register_event(struct lttng_event *event)
 {
-	const struct lttng_event_desc *desc;
+	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
 	if (event->registered)
@@ -1337,20 +1368,23 @@ void register_event(struct lttng_event *event)
 	desc = event->desc;
 	switch (event->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_register(desc->kname,
+		ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
 						  desc->probe_callback,
 						  event);
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		ret = lttng_syscall_filter_enable_event(event->chan, event);
 		break;
-	case LTTNG_KERNEL_KPROBE:
-	case LTTNG_KERNEL_UPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_UPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_NOOP:
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -1363,7 +1397,7 @@ void register_event(struct lttng_event *event)
  */
 int _lttng_event_unregister(struct lttng_event *event)
 {
-	const struct lttng_event_desc *desc;
+	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
 	if (!event->registered)
@@ -1372,28 +1406,34 @@ int _lttng_event_unregister(struct lttng_event *event)
 	desc = event->desc;
 	switch (event->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_unregister(event->desc->kname,
+		ret = lttng_wrapper_tracepoint_probe_unregister(event->desc->event_kname,
 						  event->desc->probe_callback,
 						  event);
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		lttng_kprobes_unregister_event(event);
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_KRETPROBE:
 		lttng_kretprobes_unregister(event);
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		ret = lttng_syscall_filter_disable_event(event->chan, event);
 		break;
+
 	case LTTNG_KERNEL_NOOP:
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		lttng_uprobes_unregister_event(event);
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
@@ -1407,7 +1447,7 @@ int _lttng_event_unregister(struct lttng_event *event)
 static
 void register_event_notifier(struct lttng_event_notifier *event_notifier)
 {
-	const struct lttng_event_desc *desc;
+	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
 	if (event_notifier->registered)
@@ -1416,20 +1456,23 @@ void register_event_notifier(struct lttng_event_notifier *event_notifier)
 	desc = event_notifier->desc;
 	switch (event_notifier->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_register(desc->kname,
+		ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
 						  desc->event_notifier_callback,
 						  event_notifier);
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		ret = lttng_syscall_filter_enable_event_notifier(event_notifier);
 		break;
-	case LTTNG_KERNEL_KPROBE:
+
+	case LTTNG_KERNEL_KPROBE:	/* Fall-through */
 	case LTTNG_KERNEL_UPROBE:
 		ret = 0;
 		break;
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
-	case LTTNG_KERNEL_NOOP:
+
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -1441,7 +1484,7 @@ static
 int _lttng_event_notifier_unregister(
 		struct lttng_event_notifier *event_notifier)
 {
-	const struct lttng_event_desc *desc;
+	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
 	if (!event_notifier->registered)
@@ -1450,24 +1493,28 @@ int _lttng_event_notifier_unregister(
 	desc = event_notifier->desc;
 	switch (event_notifier->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->desc->kname,
+		ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->desc->event_kname,
 						  event_notifier->desc->event_notifier_callback,
 						  event_notifier);
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		lttng_kprobes_unregister_event_notifier(event_notifier);
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		lttng_uprobes_unregister_event_notifier(event_notifier);
 		ret = 0;
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		ret = lttng_syscall_filter_disable_event_notifier(event_notifier);
 		break;
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
-	case LTTNG_KERNEL_NOOP:
+
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -1482,31 +1529,43 @@ int _lttng_event_notifier_unregister(
 static
 void _lttng_event_destroy(struct lttng_event *event)
 {
+	struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
+
 	switch (event->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
 		lttng_event_desc_put(event->desc);
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		module_put(event->desc->owner);
 		lttng_kprobes_destroy_event_private(event);
 		break;
+
 	case LTTNG_KERNEL_KRETPROBE:
 		module_put(event->desc->owner);
 		lttng_kretprobes_destroy_private(event);
 		break;
-	case LTTNG_KERNEL_NOOP:
+
 	case LTTNG_KERNEL_SYSCALL:
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		module_put(event->desc->owner);
 		lttng_uprobes_destroy_event_private(event);
 		break;
+
 	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
 	list_del(&event->list);
-	lttng_destroy_context(event->ctx);
+	lttng_kernel_destroy_context(event->ctx);
+	lttng_free_event_filter_runtime(event);
+	/* Free event enabler refs */
+	list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
+				 &event->enablers_ref_head, node)
+		kfree(enabler_ref);
 	kmem_cache_free(event_cache, event);
 }
 
@@ -1516,27 +1575,38 @@ void _lttng_event_destroy(struct lttng_event *event)
 static
 void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier)
 {
+	struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
+
 	switch (event_notifier->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
 		lttng_event_desc_put(event_notifier->desc);
 		break;
+
 	case LTTNG_KERNEL_KPROBE:
 		module_put(event_notifier->desc->owner);
 		lttng_kprobes_destroy_event_notifier_private(event_notifier);
 		break;
-	case LTTNG_KERNEL_NOOP:
+
 	case LTTNG_KERNEL_SYSCALL:
 		break;
+
 	case LTTNG_KERNEL_UPROBE:
 		module_put(event_notifier->desc->owner);
 		lttng_uprobes_destroy_event_notifier_private(event_notifier);
 		break;
-	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
+
+	case LTTNG_KERNEL_KRETPROBE:	/* Fall-through */
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
+	case LTTNG_KERNEL_NOOP:		/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
 	list_del(&event_notifier->list);
+	lttng_free_event_notifier_filter_runtime(event_notifier);
+	/* Free event enabler refs */
+	list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
+				 &event_notifier->enablers_ref_head, node)
+		kfree(enabler_ref);
 	kmem_cache_free(event_notifier_cache, event_notifier);
 }
 
@@ -1815,7 +1885,7 @@ int lttng_match_enabler_name(const char *desc_name,
 	return 1;
 }
 
-int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
+int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc,
 		struct lttng_enabler *enabler)
 {
 	const char *desc_name, *enabler_name;
@@ -1824,7 +1894,7 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 	enabler_name = enabler->event_param.name;
 	switch (enabler->event_param.instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		desc_name = desc->name;
+		desc_name = desc->event_name;
 		switch (enabler->format_type) {
 		case LTTNG_ENABLER_FORMAT_STAR_GLOB:
 			return lttng_match_enabler_star_glob(desc_name, enabler_name);
@@ -1834,8 +1904,9 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 			return -EINVAL;
 		}
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
-		desc_name = desc->name;
+		desc_name = desc->event_name;
 		if (!strncmp(desc_name, "compat_", strlen("compat_"))) {
 			desc_name += strlen("compat_");
 			compat = true;
@@ -1896,6 +1967,7 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 			return -EINVAL;
 		}
 		break;
+
 	default:
 		WARN_ON_ONCE(1);
 		return -EINVAL;
@@ -1953,8 +2025,8 @@ static
 void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_enabler)
 {
 	struct lttng_session *session = event_enabler->chan->session;
-	struct lttng_probe_desc *probe_desc;
-	const struct lttng_event_desc *desc;
+	struct lttng_kernel_probe_desc *probe_desc;
+	const struct lttng_kernel_event_desc *desc;
 	int i;
 	struct list_head *probe_list;
 
@@ -1980,7 +2052,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_
 			 */
 			head = utils_borrow_hash_table_bucket(
 				session->events_ht.table, LTTNG_EVENT_HT_SIZE,
-				desc->name);
+				desc->event_name);
 			lttng_hlist_for_each_entry(event, head, hlist) {
 				if (event->desc == desc
 						&& event->chan == event_enabler->chan)
@@ -1998,7 +2070,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_
 					LTTNG_KERNEL_TRACEPOINT);
 			if (!event) {
 				printk(KERN_INFO "LTTng: Unable to create event %s\n",
-					probe_desc->event_desc[i]->name);
+					probe_desc->event_desc[i]->event_name);
 			}
 		}
 	}
@@ -2008,8 +2080,8 @@ static
 void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
 {
 	struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
-	struct lttng_probe_desc *probe_desc;
-	const struct lttng_event_desc *desc;
+	struct lttng_kernel_probe_desc *probe_desc;
+	const struct lttng_kernel_event_desc *desc;
 	int i;
 	struct list_head *probe_list;
 
@@ -2035,7 +2107,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi
 			 */
 			head = utils_borrow_hash_table_bucket(
 				event_notifier_group->event_notifiers_ht.table,
-				LTTNG_EVENT_NOTIFIER_HT_SIZE, desc->name);
+				LTTNG_EVENT_NOTIFIER_HT_SIZE, desc->event_name);
 			lttng_hlist_for_each_entry(event_notifier, head, hlist) {
 				if (event_notifier->desc == desc
 						&& event_notifier->user_token == event_notifier_enabler->base.user_token)
@@ -2054,7 +2126,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi
 				LTTNG_KERNEL_TRACEPOINT);
 			if (IS_ERR(event_notifier)) {
 				printk(KERN_INFO "Unable to create event_notifier %s\n",
-					probe_desc->event_desc[i]->name);
+					probe_desc->event_desc[i]->event_name);
 			}
 		}
 	}
@@ -2092,9 +2164,11 @@ void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
 	case LTTNG_KERNEL_TRACEPOINT:
 		lttng_create_tracepoint_event_if_missing(event_enabler);
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		lttng_create_syscall_event_if_missing(event_enabler);
 		break;
+
 	default:
 		WARN_ON_ONCE(1);
 		break;
@@ -2177,9 +2251,11 @@ void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler
 	case LTTNG_KERNEL_TRACEPOINT:
 		lttng_create_tracepoint_event_notifier_if_missing(event_notifier_enabler);
 		break;
+
 	case LTTNG_KERNEL_SYSCALL:
 		lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler);
 		break;
+
 	default:
 		WARN_ON_ONCE(1);
 		break;
@@ -2432,7 +2508,7 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
 	lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler));
 
 	/* Destroy contexts */
-	lttng_destroy_context(event_enabler->ctx);
+	lttng_kernel_destroy_context(event_enabler->ctx);
 
 	list_del(&event_enabler->node);
 	kfree(event_enabler);
@@ -2612,7 +2688,7 @@ void lttng_session_sync_event_enablers(struct lttng_session *session)
 		int enabled = 0, has_enablers_without_bytecode = 0;
 
 		switch (event->instrumentation) {
-		case LTTNG_KERNEL_TRACEPOINT:
+		case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 		case LTTNG_KERNEL_SYSCALL:
 			/* Enable events */
 			list_for_each_entry(enabler_ref,
@@ -2623,6 +2699,7 @@ void lttng_session_sync_event_enablers(struct lttng_session *session)
 				}
 			}
 			break;
+
 		default:
 			/* Not handled with lazy sync. */
 			continue;
@@ -2699,7 +2776,7 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
 		int enabled = 0, has_enablers_without_bytecode = 0;
 
 		switch (event_notifier->instrumentation) {
-		case LTTNG_KERNEL_TRACEPOINT:
+		case LTTNG_KERNEL_TRACEPOINT:	/* Fall-through */
 		case LTTNG_KERNEL_SYSCALL:
 			/* Enable event_notifiers */
 			list_for_each_entry(enabler_ref,
@@ -2710,6 +2787,7 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
 				}
 			}
 			break;
+
 		default:
 			/* Not handled with sync. */
 			continue;
@@ -2749,6 +2827,8 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
 		list_for_each_entry(runtime,
 				&event_notifier->capture_bytecode_runtime_head, node)
 			lttng_bytecode_capture_sync_state(runtime);
+
+		WRITE_ONCE(event_notifier->eval_capture, !!event_notifier->num_captures);
 	}
 }
 
@@ -2922,7 +3002,7 @@ int print_tabs(struct lttng_session *session, size_t nesting)
 
 static
 int lttng_field_name_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	return lttng_metadata_printf(session, " _%s;\n", field->name);
@@ -2930,30 +3010,30 @@ int lttng_field_name_statedump(struct lttng_session *session,
 
 static
 int _lttng_integer_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_integer *type,
+		enum lttng_kernel_string_encoding parent_encoding,
 		size_t nesting)
 {
 	int ret;
 
-	WARN_ON_ONCE(type->atype != atype_integer);
 	ret = print_tabs(session, nesting);
 	if (ret)
 		return ret;
 	ret = lttng_metadata_printf(session,
 		"integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s }",
-		type->u.integer.size,
-		type->u.integer.alignment,
-		type->u.integer.signedness,
-		(type->u.integer.encoding == lttng_encode_none)
+		type->size,
+		type->alignment,
+		type->signedness,
+		(parent_encoding == lttng_kernel_string_encoding_none)
 			? "none"
-			: (type->u.integer.encoding == lttng_encode_UTF8)
+			: (parent_encoding == lttng_kernel_string_encoding_UTF8)
 				? "UTF8"
 				: "ASCII",
-		type->u.integer.base,
+		type->base,
 #if __BYTE_ORDER == __BIG_ENDIAN
-		type->u.integer.reverse_byte_order ? " byte_order = le;" : ""
+		type->reverse_byte_order ? " byte_order = le;" : ""
 #else
-		type->u.integer.reverse_byte_order ? " byte_order = be;" : ""
+		type->reverse_byte_order ? " byte_order = be;" : ""
 #endif
 	);
 	return ret;
@@ -2964,15 +3044,13 @@ int _lttng_integer_type_statedump(struct lttng_session *session,
  */
 static
 int _lttng_struct_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_struct *type,
 		size_t nesting)
 {
 	int ret;
 	uint32_t i, nr_fields;
 	unsigned int alignment;
 
-	WARN_ON_ONCE(type->atype != atype_struct_nestable);
-
 	ret = print_tabs(session, nesting);
 	if (ret)
 		return ret;
@@ -2980,11 +3058,11 @@ int _lttng_struct_type_statedump(struct lttng_session *session,
 		"struct {\n");
 	if (ret)
 		return ret;
-	nr_fields = type->u.struct_nestable.nr_fields;
+	nr_fields = type->nr_fields;
 	for (i = 0; i < nr_fields; i++) {
-		const struct lttng_event_field *iter_field;
+		const struct lttng_kernel_event_field *iter_field;
 
-		iter_field = &type->u.struct_nestable.fields[i];
+		iter_field = type->fields[i];
 		ret = _lttng_field_statedump(session, iter_field, nesting + 1);
 		if (ret)
 			return ret;
@@ -2992,7 +3070,7 @@ int _lttng_struct_type_statedump(struct lttng_session *session,
 	ret = print_tabs(session, nesting);
 	if (ret)
 		return ret;
-	alignment = type->u.struct_nestable.alignment;
+	alignment = type->alignment;
 	if (alignment) {
 		ret = lttng_metadata_printf(session,
 			"} align(%u)",
@@ -3009,13 +3087,13 @@ int _lttng_struct_type_statedump(struct lttng_session *session,
  */
 static
 int _lttng_struct_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
 
 	ret = _lttng_struct_type_statedump(session,
-			&field->type, nesting);
+			lttng_kernel_get_type_struct(field->type), nesting);
 	if (ret)
 		return ret;
 	return lttng_field_name_statedump(session, field, nesting);
@@ -3026,31 +3104,30 @@ int _lttng_struct_field_statedump(struct lttng_session *session,
  */
 static
 int _lttng_variant_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_variant *type,
 		size_t nesting)
 {
 	int ret;
 	uint32_t i, nr_choices;
 
-	WARN_ON_ONCE(type->atype != atype_variant_nestable);
 	/*
 	 * CTF 1.8 does not allow expressing nonzero variant alignment in a nestable way.
 	 */
-	if (type->u.variant_nestable.alignment != 0)
+	if (type->alignment != 0)
 		return -EINVAL;
 	ret = print_tabs(session, nesting);
 	if (ret)
 		return ret;
 	ret = lttng_metadata_printf(session,
 		"variant <_%s> {\n",
-		type->u.variant_nestable.tag_name);
+		type->tag_name);
 	if (ret)
 		return ret;
-	nr_choices = type->u.variant_nestable.nr_choices;
+	nr_choices = type->nr_choices;
 	for (i = 0; i < nr_choices; i++) {
-		const struct lttng_event_field *iter_field;
+		const struct lttng_kernel_event_field *iter_field;
 
-		iter_field = &type->u.variant_nestable.choices[i];
+		iter_field = type->choices[i];
 		ret = _lttng_field_statedump(session, iter_field, nesting + 1);
 		if (ret)
 			return ret;
@@ -3068,13 +3145,13 @@ int _lttng_variant_type_statedump(struct lttng_session *session,
  */
 static
 int _lttng_variant_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
 
 	ret = _lttng_variant_type_statedump(session,
-			&field->type, nesting);
+			lttng_kernel_get_type_variant(field->type), nesting);
 	if (ret)
 		return ret;
 	return lttng_field_name_statedump(session, field, nesting);
@@ -3085,21 +3162,23 @@ int _lttng_variant_field_statedump(struct lttng_session *session,
  */
 static
 int _lttng_array_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
-	const struct lttng_type *elem_type;
+	const struct lttng_kernel_type_array *array_type;
+	const struct lttng_kernel_type_common *elem_type;
 
-	WARN_ON_ONCE(field->type.atype != atype_array_nestable);
+	array_type = lttng_kernel_get_type_array(field->type);
+	WARN_ON_ONCE(!array_type);
 
-	if (field->type.u.array_nestable.alignment) {
+	if (array_type->alignment) {
 		ret = print_tabs(session, nesting);
 		if (ret)
 			return ret;
 		ret = lttng_metadata_printf(session,
 		"struct { } align(%u) _%s_padding;\n",
-				field->type.u.array_nestable.alignment * CHAR_BIT,
+				array_type->alignment * CHAR_BIT,
 				field->name);
 		if (ret)
 			return ret;
@@ -3108,12 +3187,13 @@ int _lttng_array_field_statedump(struct lttng_session *session,
 	 * Nested compound types: Only array of structures and variants are
 	 * currently supported.
 	 */
-	elem_type = field->type.u.array_nestable.elem_type;
-	switch (elem_type->atype) {
-	case atype_integer:
-	case atype_struct_nestable:
-	case atype_variant_nestable:
-		ret = _lttng_type_statedump(session, elem_type, nesting);
+	elem_type = array_type->elem_type;
+	switch (elem_type->type) {
+	case lttng_kernel_type_integer:
+	case lttng_kernel_type_struct:
+	case lttng_kernel_type_variant:
+		ret = _lttng_type_statedump(session, elem_type,
+				array_type->encoding, nesting);
 		if (ret)
 			return ret;
 		break;
@@ -3124,7 +3204,7 @@ int _lttng_array_field_statedump(struct lttng_session *session,
 	ret = lttng_metadata_printf(session,
 		" _%s[%u];\n",
 		field->name,
-		field->type.u.array_nestable.length);
+		array_type->length);
 	return ret;
 }
 
@@ -3133,24 +3213,26 @@ int _lttng_array_field_statedump(struct lttng_session *session,
  */
 static
 int _lttng_sequence_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
 	const char *length_name;
-	const struct lttng_type *elem_type;
+	const struct lttng_kernel_type_sequence *sequence_type;
+	const struct lttng_kernel_type_common *elem_type;
 
-	WARN_ON_ONCE(field->type.atype != atype_sequence_nestable);
+	sequence_type = lttng_kernel_get_type_sequence(field->type);
+	WARN_ON_ONCE(!sequence_type);
 
-	length_name = field->type.u.sequence_nestable.length_name;
+	length_name = sequence_type->length_name;
 
-	if (field->type.u.sequence_nestable.alignment) {
+	if (sequence_type->alignment) {
 		ret = print_tabs(session, nesting);
 		if (ret)
 			return ret;
 		ret = lttng_metadata_printf(session,
 		"struct { } align(%u) _%s_padding;\n",
-				field->type.u.sequence_nestable.alignment * CHAR_BIT,
+				sequence_type->alignment * CHAR_BIT,
 				field->name);
 		if (ret)
 			return ret;
@@ -3160,12 +3242,13 @@ int _lttng_sequence_field_statedump(struct lttng_session *session,
 	 * Nested compound types: Only array of structures and variants are
 	 * currently supported.
 	 */
-	elem_type = field->type.u.sequence_nestable.elem_type;
-	switch (elem_type->atype) {
-	case atype_integer:
-	case atype_struct_nestable:
-	case atype_variant_nestable:
-		ret = _lttng_type_statedump(session, elem_type, nesting);
+	elem_type = sequence_type->elem_type;
+	switch (elem_type->type) {
+	case lttng_kernel_type_integer:
+	case lttng_kernel_type_struct:
+	case lttng_kernel_type_variant:
+		ret = _lttng_type_statedump(session, elem_type,
+				sequence_type->encoding, nesting);
 		if (ret)
 			return ret;
 		break;
@@ -3176,7 +3259,7 @@ int _lttng_sequence_field_statedump(struct lttng_session *session,
 	ret = lttng_metadata_printf(session,
 		" _%s[ _%s ];\n",
 		field->name,
-		field->type.u.sequence_nestable.length_name);
+		sequence_type->length_name);
 	return ret;
 }
 
@@ -3185,20 +3268,20 @@ int _lttng_sequence_field_statedump(struct lttng_session *session,
  */
 static
 int _lttng_enum_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_enum *type,
 		size_t nesting)
 {
-	const struct lttng_enum_desc *enum_desc;
-	const struct lttng_type *container_type;
+	const struct lttng_kernel_enum_desc *enum_desc;
+	const struct lttng_kernel_type_common *container_type;
 	int ret;
 	unsigned int i, nr_entries;
 
-	container_type = type->u.enum_nestable.container_type;
-	if (container_type->atype != atype_integer) {
+	container_type = type->container_type;
+	if (container_type->type != lttng_kernel_type_integer) {
 		ret = -EINVAL;
 		goto end;
 	}
-	enum_desc = type->u.enum_nestable.desc;
+	enum_desc = type->desc;
 	nr_entries = enum_desc->nr_entries;
 
 	ret = print_tabs(session, nesting);
@@ -3207,7 +3290,8 @@ int _lttng_enum_type_statedump(struct lttng_session *session,
 	ret = lttng_metadata_printf(session, "enum : ");
 	if (ret)
 		goto end;
-	ret = _lttng_integer_type_statedump(session, container_type, 0);
+	ret = _lttng_integer_type_statedump(session, lttng_kernel_get_type_integer(container_type),
+			lttng_kernel_string_encoding_none, 0);
 	if (ret)
 		goto end;
 	ret = lttng_metadata_printf(session, " {\n");
@@ -3215,7 +3299,7 @@ int _lttng_enum_type_statedump(struct lttng_session *session,
 		goto end;
 	/* Dump all entries */
 	for (i = 0; i < nr_entries; i++) {
-		const struct lttng_enum_entry *entry = &enum_desc->entries[i];
+		const struct lttng_kernel_enum_entry *entry = enum_desc->entries[i];
 		int j, len;
 
 		ret = print_tabs(session, nesting + 1);
@@ -3301,12 +3385,15 @@ end:
  */
 static
 int _lttng_enum_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
+	const struct lttng_kernel_type_enum *enum_type;
 
-	ret = _lttng_enum_type_statedump(session, &field->type, nesting);
+	enum_type = lttng_kernel_get_type_enum(field->type);
+	WARN_ON_ONCE(!enum_type);
+	ret = _lttng_enum_type_statedump(session, enum_type, nesting);
 	if (ret)
 		return ret;
 	return lttng_field_name_statedump(session, field, nesting);
@@ -3314,12 +3401,13 @@ int _lttng_enum_field_statedump(struct lttng_session *session,
 
 static
 int _lttng_integer_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret;
 
-	ret = _lttng_integer_type_statedump(session, &field->type, nesting);
+	ret = _lttng_integer_type_statedump(session, lttng_kernel_get_type_integer(field->type),
+			lttng_kernel_string_encoding_none, nesting);
 	if (ret)
 		return ret;
 	return lttng_field_name_statedump(session, field, nesting);
@@ -3327,32 +3415,33 @@ int _lttng_integer_field_statedump(struct lttng_session *session,
 
 static
 int _lttng_string_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_string *type,
 		size_t nesting)
 {
 	int ret;
 
-	WARN_ON_ONCE(type->atype != atype_string);
 	/* Default encoding is UTF8 */
 	ret = print_tabs(session, nesting);
 	if (ret)
 		return ret;
 	ret = lttng_metadata_printf(session,
 		"string%s",
-		type->u.string.encoding == lttng_encode_ASCII ?
+		type->encoding == lttng_kernel_string_encoding_ASCII ?
 			" { encoding = ASCII; }" : "");
 	return ret;
 }
 
 static
 int _lttng_string_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
+	const struct lttng_kernel_type_string *string_type;
 	int ret;
 
-	WARN_ON_ONCE(field->type.atype != atype_string);
-	ret = _lttng_string_type_statedump(session, &field->type, nesting);
+	string_type = lttng_kernel_get_type_string(field->type);
+	WARN_ON_ONCE(!string_type);
+	ret = _lttng_string_type_statedump(session, string_type, nesting);
 	if (ret)
 		return ret;
 	return lttng_field_name_statedump(session, field, nesting);
@@ -3363,31 +3452,42 @@ int _lttng_string_field_statedump(struct lttng_session *session,
  */
 static
 int _lttng_type_statedump(struct lttng_session *session,
-		const struct lttng_type *type,
+		const struct lttng_kernel_type_common *type,
+		enum lttng_kernel_string_encoding parent_encoding,
 		size_t nesting)
 {
 	int ret = 0;
 
-	switch (type->atype) {
-	case atype_integer:
-		ret = _lttng_integer_type_statedump(session, type, nesting);
+	switch (type->type) {
+	case lttng_kernel_type_integer:
+		ret = _lttng_integer_type_statedump(session,
+				lttng_kernel_get_type_integer(type),
+				parent_encoding, nesting);
 		break;
-	case atype_enum_nestable:
-		ret = _lttng_enum_type_statedump(session, type, nesting);
+	case lttng_kernel_type_enum:
+		ret = _lttng_enum_type_statedump(session,
+				lttng_kernel_get_type_enum(type),
+				nesting);
 		break;
-	case atype_string:
-		ret = _lttng_string_type_statedump(session, type, nesting);
+	case lttng_kernel_type_string:
+		ret = _lttng_string_type_statedump(session,
+				lttng_kernel_get_type_string(type),
+				nesting);
 		break;
-	case atype_struct_nestable:
-		ret = _lttng_struct_type_statedump(session, type, nesting);
+	case lttng_kernel_type_struct:
+		ret = _lttng_struct_type_statedump(session,
+				lttng_kernel_get_type_struct(type),
+				nesting);
 		break;
-	case atype_variant_nestable:
-		ret = _lttng_variant_type_statedump(session, type, nesting);
+	case lttng_kernel_type_variant:
+		ret = _lttng_variant_type_statedump(session,
+				lttng_kernel_get_type_variant(type),
+				nesting);
 		break;
 
 	/* Nested arrays and sequences are not supported yet. */
-	case atype_array_nestable:
-	case atype_sequence_nestable:
+	case lttng_kernel_type_array:
+	case lttng_kernel_type_sequence:
 	default:
 		WARN_ON_ONCE(1);
 		return -EINVAL;
@@ -3400,31 +3500,31 @@ int _lttng_type_statedump(struct lttng_session *session,
  */
 static
 int _lttng_field_statedump(struct lttng_session *session,
-		const struct lttng_event_field *field,
+		const struct lttng_kernel_event_field *field,
 		size_t nesting)
 {
 	int ret = 0;
 
-	switch (field->type.atype) {
-	case atype_integer:
+	switch (field->type->type) {
+	case lttng_kernel_type_integer:
 		ret = _lttng_integer_field_statedump(session, field, nesting);
 		break;
-	case atype_enum_nestable:
+	case lttng_kernel_type_enum:
 		ret = _lttng_enum_field_statedump(session, field, nesting);
 		break;
-	case atype_string:
+	case lttng_kernel_type_string:
 		ret = _lttng_string_field_statedump(session, field, nesting);
 		break;
-	case atype_struct_nestable:
+	case lttng_kernel_type_struct:
 		ret = _lttng_struct_field_statedump(session, field, nesting);
 		break;
-	case atype_array_nestable:
+	case lttng_kernel_type_array:
 		ret = _lttng_array_field_statedump(session, field, nesting);
 		break;
-	case atype_sequence_nestable:
+	case lttng_kernel_type_sequence:
 		ret = _lttng_sequence_field_statedump(session, field, nesting);
 		break;
-	case atype_variant_nestable:
+	case lttng_kernel_type_variant:
 		ret = _lttng_variant_field_statedump(session, field, nesting);
 		break;
 
@@ -3437,7 +3537,7 @@ int _lttng_field_statedump(struct lttng_session *session,
 
 static
 int _lttng_context_metadata_statedump(struct lttng_session *session,
-				    struct lttng_ctx *ctx)
+				    struct lttng_kernel_ctx *ctx)
 {
 	int ret = 0;
 	int i;
@@ -3445,9 +3545,9 @@ int _lttng_context_metadata_statedump(struct lttng_session *session,
 	if (!ctx)
 		return 0;
 	for (i = 0; i < ctx->nr_fields; i++) {
-		const struct lttng_ctx_field *field = &ctx->fields[i];
+		const struct lttng_kernel_ctx_field *field = &ctx->fields[i];
 
-		ret = _lttng_field_statedump(session, &field->event_field, 2);
+		ret = _lttng_field_statedump(session, field->event_field, 2);
 		if (ret)
 			return ret;
 	}
@@ -3458,12 +3558,12 @@ static
 int _lttng_fields_metadata_statedump(struct lttng_session *session,
 				   struct lttng_event *event)
 {
-	const struct lttng_event_desc *desc = event->desc;
+	const struct lttng_kernel_event_desc *desc = event->desc;
 	int ret = 0;
 	int i;
 
 	for (i = 0; i < desc->nr_fields; i++) {
-		const struct lttng_event_field *field = &desc->fields[i];
+		const struct lttng_kernel_event_field *field = desc->fields[i];
 
 		ret = _lttng_field_statedump(session, field, 2);
 		if (ret)
@@ -3496,7 +3596,7 @@ int _lttng_event_metadata_statedump(struct lttng_session *session,
 		"	name = \"%s\";\n"
 		"	id = %u;\n"
 		"	stream_id = %u;\n",
-		event->desc->name,
+		event->desc->event_name,
 		event->id,
 		event->chan->id);
 	if (ret)
@@ -4026,7 +4126,7 @@ void lttng_counter_transport_unregister(struct lttng_counter_transport *transpor
 }
 EXPORT_SYMBOL_GPL(lttng_counter_transport_unregister);
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
 
 enum cpuhp_state lttng_hp_prepare;
 enum cpuhp_state lttng_hp_online;
@@ -4142,7 +4242,7 @@ static void __exit lttng_exit_cpu_hotplug(void)
 	cpuhp_remove_multi_state(lttng_hp_prepare);
 }
 
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
 static int lttng_init_cpu_hotplug(void)
 {
 	return 0;
@@ -4150,7 +4250,7 @@ static int lttng_init_cpu_hotplug(void)
 static void lttng_exit_cpu_hotplug(void)
 {
 }
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
 
 
 static int __init lttng_events_init(void)