X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=a0bd232228c8dd6a3120134bce7cd16d2c5db33e;hb=ff024e6646f0d75935e8eb277cce508c593a23ad;hp=6d3e3f1a2c64089e4a5761e13088da07e747e49a;hpb=09710b830767f6cc69fc68ea7e1903a1122d1045;p=lttng-modules.git

diff --git a/src/lttng-events.c b/src/lttng-events.c
index 6d3e3f1a..a0bd2322 100644
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -23,7 +23,6 @@
 #include <linux/seq_file.h>
 #include <linux/file.h>
 #include <linux/anon_inodes.h>
-#include <wrapper/file.h>
 #include <linux/uaccess.h>
 #include <linux/vmalloc.h>
 #include <linux/dmi.h>
@@ -47,7 +46,13 @@
 #include <lttng/utils.h>
 #include <ringbuffer/backend.h>
 #include <ringbuffer/frontend.h>
-#include <wrapper/time.h>
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,16,0) \
+	|| LTTNG_RHEL_KERNEL_RANGE(5,14,0,162,0,0, 5,15,0,0,0,0))
+#include <linux/stdarg.h>
+#else
+#include <stdarg.h>
+#endif
 
 #define METADATA_CACHE_DEFAULT_SIZE 4096
 
@@ -71,11 +76,9 @@ static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_en
 
 static void _lttng_event_destroy(struct lttng_kernel_event_common *event);
 static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan);
-static int _lttng_event_unregister(struct lttng_kernel_event_common *event);
+static void _lttng_event_unregister(struct lttng_kernel_event_common *event);
 static
-int _lttng_event_metadata_statedump(struct lttng_kernel_session *session,
-				  struct lttng_kernel_channel_buffer *chan,
-				  struct lttng_kernel_event_recorder *event);
+int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event);
 static
 int _lttng_session_metadata_statedump(struct lttng_kernel_session *session);
 static
@@ -99,15 +102,9 @@ void synchronize_trace(void)
 	synchronize_sched();
 #endif
 
-#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
 #ifdef CONFIG_PREEMPT_RT_FULL
 	synchronize_rcu();
 #endif
-#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
-#ifdef CONFIG_PREEMPT_RT
-	synchronize_rcu();
-#endif
-#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
 }
 
 void lttng_lock_sessions(void)
@@ -362,10 +359,8 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
 		ret = lttng_syscalls_unregister_syscall_table(&chan_priv->parent.syscall_table);
 		WARN_ON(ret);
 	}
-	list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
-		ret = _lttng_event_unregister(&event_recorder_priv->pub->parent);
-		WARN_ON(ret);
-	}
+	list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node)
+		_lttng_event_unregister(&event_recorder_priv->pub->parent);
 	synchronize_trace();	/* Wait for in-flight events to complete */
 	list_for_each_entry(chan_priv, &session->priv->chan, node) {
 		ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table);
@@ -412,10 +407,8 @@ void lttng_event_notifier_group_destroy(
 	WARN_ON(ret);
 
 	list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv,
-			&event_notifier_group->event_notifiers_head, parent.node) {
-		ret = _lttng_event_unregister(&event_notifier_priv->pub->parent);
-		WARN_ON(ret);
-	}
+			&event_notifier_group->event_notifiers_head, parent.node)
+		_lttng_event_unregister(&event_notifier_priv->pub->parent);
 
 	/* Wait for in-flight event notifier to complete */
 	synchronize_trace();
@@ -866,27 +859,217 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
 	wake_up_interruptible(&stream->read_wait);
 }
 
+static
+bool lttng_kernel_event_id_available(struct lttng_event_enabler_common *event_enabler)
+{
+	struct lttng_kernel_abi_event *event_param = &event_enabler->event_param;
+        enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
+
+	switch (event_enabler->enabler_type) {
+	case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+	{
+		struct lttng_event_recorder_enabler *event_recorder_enabler =
+			container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+		struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan;
+
+		switch (itype) {
+		case LTTNG_KERNEL_ABI_TRACEPOINT:
+			lttng_fallthrough;
+		case LTTNG_KERNEL_ABI_KPROBE:
+			lttng_fallthrough;
+		case LTTNG_KERNEL_ABI_SYSCALL:
+			lttng_fallthrough;
+		case LTTNG_KERNEL_ABI_UPROBE:
+			if (chan->priv->free_event_id == -1U)
+				return false;
+			return true;
+		case LTTNG_KERNEL_ABI_KRETPROBE:
+			/* kretprobes require 2 event IDs. */
+			if (chan->priv->free_event_id >= -2U)
+				return false;
+			return true;
+		default:
+			WARN_ON_ONCE(1);
+			return false;
+		}
+	}
+	case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
+		return true;
+	default:
+		WARN_ON_ONCE(1);
+		return false;
+	}
+}
+
+static
+struct lttng_kernel_event_common *lttng_kernel_event_alloc(struct lttng_event_enabler_common *event_enabler)
+{
+	struct lttng_kernel_abi_event *event_param = &event_enabler->event_param;
+        enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
+
+	switch (event_enabler->enabler_type) {
+	case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+	{
+		struct lttng_event_recorder_enabler *event_recorder_enabler =
+			container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+		struct lttng_kernel_event_recorder *event_recorder;
+		struct lttng_kernel_event_recorder_private *event_recorder_priv;
+		struct lttng_kernel_channel_buffer *chan = event_recorder_enabler->chan;
+
+		event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
+		if (!event_recorder)
+			return NULL;
+		event_recorder_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL);
+		if (!event_recorder_priv) {
+			kmem_cache_free(event_recorder_private_cache, event_recorder);
+			return NULL;
+		}
+		event_recorder_priv->pub = event_recorder;
+		event_recorder_priv->parent.pub = &event_recorder->parent;
+		event_recorder->priv = event_recorder_priv;
+		event_recorder->parent.priv = &event_recorder_priv->parent;
+
+		event_recorder->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER;
+		event_recorder->parent.run_filter = lttng_kernel_interpret_event_filter;
+		event_recorder->priv->parent.instrumentation = itype;
+		INIT_LIST_HEAD(&event_recorder->priv->parent.filter_bytecode_runtime_head);
+		INIT_LIST_HEAD(&event_recorder->priv->parent.enablers_ref_head);
+
+		event_recorder->chan = chan;
+		event_recorder->priv->id = chan->priv->free_event_id++;
+		return &event_recorder->parent;
+	}
+	case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
+	{
+		struct lttng_event_notifier_enabler *event_notifier_enabler =
+			container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
+		struct lttng_kernel_event_notifier *event_notifier;
+		struct lttng_kernel_event_notifier_private *event_notifier_priv;
+
+		event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL);
+		if (!event_notifier)
+			return NULL;
+		event_notifier_priv = kmem_cache_zalloc(event_notifier_private_cache, GFP_KERNEL);
+		if (!event_notifier_priv) {
+			kmem_cache_free(event_notifier_private_cache, event_notifier);
+			return NULL;
+		}
+		event_notifier_priv->pub = event_notifier;
+		event_notifier_priv->parent.pub = &event_notifier->parent;
+		event_notifier->priv = event_notifier_priv;
+		event_notifier->parent.priv = &event_notifier_priv->parent;
+
+		event_notifier->parent.type = LTTNG_KERNEL_EVENT_TYPE_NOTIFIER;
+		event_notifier->parent.run_filter = lttng_kernel_interpret_event_filter;
+		event_notifier->priv->parent.instrumentation = itype;
+		event_notifier->priv->parent.user_token = event_enabler->user_token;
+		INIT_LIST_HEAD(&event_notifier->priv->parent.filter_bytecode_runtime_head);
+		INIT_LIST_HEAD(&event_notifier->priv->parent.enablers_ref_head);
+
+		event_notifier->priv->group = event_notifier_enabler->group;
+		event_notifier->priv->error_counter_index = event_notifier_enabler->error_counter_index;
+		event_notifier->priv->num_captures = 0;
+		event_notifier->notification_send = lttng_event_notifier_notification_send;
+		INIT_LIST_HEAD(&event_notifier->priv->capture_bytecode_runtime_head);
+		return &event_notifier->parent;
+	}
+	default:
+		return NULL;
+	}
+}
+
+static
+void lttng_kernel_event_free(struct lttng_kernel_event_common *event)
+{
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+	{
+		struct lttng_kernel_event_recorder *event_recorder =
+			container_of(event, struct lttng_kernel_event_recorder, parent);
+
+		kmem_cache_free(event_recorder_private_cache, event_recorder->priv);
+		kmem_cache_free(event_recorder_cache, event_recorder);
+		break;
+	}
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+	{
+		struct lttng_kernel_event_notifier *event_notifier =
+			container_of(event, struct lttng_kernel_event_notifier, parent);
+
+		kmem_cache_free(event_notifier_private_cache, event_notifier->priv);
+		kmem_cache_free(event_notifier_cache, event_notifier);
+		break;
+	}
+	default:
+		WARN_ON_ONCE(1);
+	}
+}
+
+static
+int lttng_kernel_event_notifier_clear_error_counter(struct lttng_kernel_event_common *event)
+{
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+		return 0;
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+	{
+		struct lttng_kernel_event_notifier *event_notifier =
+			container_of(event, struct lttng_kernel_event_notifier, parent);
+		struct lttng_counter *error_counter;
+		struct lttng_event_notifier_group *event_notifier_group = event_notifier->priv->group;
+		size_t dimension_index[1];
+		int ret;
+
+		/*
+		 * Clear the error counter bucket. The sessiond keeps track of which
+		 * bucket is currently in use. We trust it. The session lock
+		 * synchronizes against concurrent creation of the error
+		 * counter.
+		 */
+		error_counter = event_notifier_group->error_counter;
+		if (!error_counter)
+			return 0;
+		/*
+		 * Check that the index is within the boundary of the counter.
+		 */
+		if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) {
+			printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
+				event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index);
+			return -EINVAL;
+		}
+
+		dimension_index[0] = event_notifier->priv->error_counter_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->priv->error_counter_index);
+			return -EINVAL;
+		}
+		return 0;
+	}
+	default:
+		return -EINVAL;
+	}
+}
 
 /*
  * Supports event creation while tracing session is active.
  * Needs to be called with sessions mutex held.
  */
-static
-struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler,
+struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler,
 				const struct lttng_kernel_event_desc *event_desc)
 {
-	struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent);
-	struct lttng_kernel_channel_buffer *chan = event_enabler->chan;
-	struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param;
+	struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler);
+	struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler);
+	struct lttng_kernel_abi_event *event_param = &event_enabler->event_param;
 	enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
-	struct lttng_kernel_event_recorder *event_recorder;
-	struct lttng_kernel_event_recorder_private *event_recorder_priv;
 	struct lttng_kernel_event_common_private *event_priv;
+	struct lttng_kernel_event_common *event;
 	const char *event_name;
 	struct hlist_head *head;
 	int ret;
 
-	if (chan->priv->free_event_id == -1U) {
+	if (!lttng_kernel_event_id_available(event_enabler)) {
 		ret = -EMFILE;
 		goto full;
 	}
@@ -918,47 +1101,25 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 
 	head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name);
 	lttng_hlist_for_each_entry(event_priv, head, hlist_node) {
-		event_recorder_priv = container_of(event_priv, struct lttng_kernel_event_recorder_private, parent);
-
-		WARN_ON_ONCE(!event_priv->desc);
-		if (!strncmp(event_priv->desc->event_name, event_name,
-					LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
-				&& chan == event_recorder_priv->pub->chan) {
+		if (lttng_event_enabler_event_name_match_event(event_enabler, event_name, event_priv->pub)) {
 			ret = -EEXIST;
 			goto exist;
 		}
 	}
 
-	event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
-	if (!event_recorder) {
+	event = lttng_kernel_event_alloc(event_enabler);
+	if (!event) {
 		ret = -ENOMEM;
-		goto cache_error;
+		goto alloc_error;
 	}
-	event_recorder_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL);
-	if (!event_recorder_priv) {
-		ret = -ENOMEM;
-		goto cache_private_error;
-	}
-	event_recorder_priv->pub = event_recorder;
-	event_recorder_priv->parent.pub = &event_recorder->parent;
-	event_recorder->priv = event_recorder_priv;
-	event_recorder->parent.priv = &event_recorder_priv->parent;
-	event_recorder->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER;
-
-	event_recorder->parent.run_filter = lttng_kernel_interpret_event_filter;
-	event_recorder->chan = chan;
-	event_recorder->priv->id = chan->priv->free_event_id++;
-	event_recorder->priv->parent.instrumentation = itype;
-	INIT_LIST_HEAD(&event_recorder->priv->parent.filter_bytecode_runtime_head);
-	INIT_LIST_HEAD(&event_recorder->priv->parent.enablers_ref_head);
 
 	switch (itype) {
 	case LTTNG_KERNEL_ABI_TRACEPOINT:
 		/* Event will be enabled by enabler sync. */
-		event_recorder->parent.enabled = 0;
-		event_recorder->priv->parent.registered = 0;
-		event_recorder->priv->parent.desc = lttng_event_desc_get(event_name);
-		if (!event_recorder->priv->parent.desc) {
+		event->enabled = 0;
+		event->priv->registered = 0;
+		event->priv->desc = lttng_event_desc_get(event_name);
+		if (!event->priv->desc) {
 			ret = -ENOENT;
 			goto register_error;
 		}
@@ -971,8 +1132,8 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 		 * Needs to be explicitly enabled after creation, since
 		 * we may want to apply filters.
 		 */
-		event_recorder->parent.enabled = 0;
-		event_recorder->priv->parent.registered = 1;
+		event->enabled = 0;
+		event->priv->registered = 1;
 		/*
 		 * Populate lttng_event structure before event
 		 * registration.
@@ -982,53 +1143,36 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 				event_param->u.kprobe.symbol_name,
 				event_param->u.kprobe.offset,
 				event_param->u.kprobe.addr,
-				&event_recorder->parent);
+				event);
 		if (ret) {
 			ret = -EINVAL;
 			goto register_error;
 		}
-		ret = try_module_get(event_recorder->priv->parent.desc->owner);
+		ret = try_module_get(event->priv->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
 
 	case LTTNG_KERNEL_ABI_KRETPROBE:
 	{
-		struct lttng_kernel_event_recorder *event_recorder_return;
-		struct lttng_kernel_event_recorder_private *event_recorder_return_priv;
+		struct lttng_kernel_event_common *event_return;
 
 		/* kretprobe defines 2 events */
 		/*
 		 * Needs to be explicitly enabled after creation, since
 		 * we may want to apply filters.
 		 */
-		event_recorder->parent.enabled = 0;
-		event_recorder->priv->parent.registered = 1;
+		event->enabled = 0;
+		event->priv->registered = 1;
 
-		event_recorder_return = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
-		if (!event_recorder_return) {
+		event_return = lttng_kernel_event_alloc(event_enabler);
+		if (!event) {
 			ret = -ENOMEM;
-			goto register_error;
+			goto alloc_error;
 		}
-		event_recorder_return_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL);
-		if (!event_recorder_return_priv) {
-			kmem_cache_free(event_recorder_cache, event_recorder_return);
-			ret = -ENOMEM;
-			goto register_error;
-		}
-		event_recorder_return_priv->pub = event_recorder_return;
-		event_recorder_return_priv->parent.pub = &event_recorder_return->parent;
-		event_recorder_return->priv = event_recorder_return_priv;
-		event_recorder_return->parent.priv = &event_recorder_return_priv->parent;
-		event_recorder_return->parent.type = LTTNG_KERNEL_EVENT_TYPE_RECORDER;
-
-		event_recorder_return->parent.run_filter = lttng_kernel_interpret_event_filter;
-		event_recorder_return->chan = chan;
-		event_recorder_return->priv->id = chan->priv->free_event_id++;
-		event_recorder_return->priv->parent.instrumentation = itype;
-		event_recorder_return->parent.enabled = 0;
-		event_recorder_return->priv->parent.registered = 1;
-		INIT_LIST_HEAD(&event_recorder_return->priv->parent.filter_bytecode_runtime_head);
-		INIT_LIST_HEAD(&event_recorder_return->priv->parent.enablers_ref_head);
+
+		event_return->enabled = 0;
+		event_return->priv->registered = 1;
+
 		/*
 		 * Populate lttng_event structure before kretprobe registration.
 		 */
@@ -1037,261 +1181,46 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 				event_param->u.kretprobe.symbol_name,
 				event_param->u.kretprobe.offset,
 				event_param->u.kretprobe.addr,
-				&event_recorder->parent, &event_recorder_return->parent);
+				event, event_return);
 		if (ret) {
-			kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv);
-			kmem_cache_free(event_recorder_cache, event_recorder_return);
+			lttng_kernel_event_free(event_return);
 			ret = -EINVAL;
 			goto register_error;
 		}
 		/* Take 2 refs on the module: one per event. */
-		ret = try_module_get(event_recorder->priv->parent.desc->owner);
+		ret = try_module_get(event->priv->desc->owner);
 		WARN_ON_ONCE(!ret);
-		ret = try_module_get(event_recorder_return->priv->parent.desc->owner);
+		ret = try_module_get(event_return->priv->desc->owner);
 		WARN_ON_ONCE(!ret);
-		ret = _lttng_event_metadata_statedump(chan->parent.session, chan,
-						    event_recorder_return);
+		ret = _lttng_event_recorder_metadata_statedump(event_return);
 		WARN_ON_ONCE(ret > 0);
-		if (ret) {
-			kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv);
-			kmem_cache_free(event_recorder_cache, event_recorder_return);
-			module_put(event_recorder_return->priv->parent.desc->owner);
-			module_put(event_recorder->priv->parent.desc->owner);
-			goto statedump_error;
-		}
-		list_add(&event_recorder_return->priv->parent.node, &chan->parent.session->priv->events);
-		break;
-	}
-
-	case LTTNG_KERNEL_ABI_SYSCALL:
-		/*
-		 * Needs to be explicitly enabled after creation, since
-		 * we may want to apply filters.
-		 */
-		event_recorder->parent.enabled = 0;
-		event_recorder->priv->parent.registered = 0;
-		event_recorder->priv->parent.desc = event_desc;
-		switch (event_param->u.syscall.entryexit) {
-		case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT:
-			ret = -EINVAL;
-			goto register_error;
-		case LTTNG_KERNEL_ABI_SYSCALL_ENTRY:
-			event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
-			break;
-		case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
-			event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
-			break;
-		}
-		switch (event_param->u.syscall.abi) {
-		case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
-			ret = -EINVAL;
-			goto register_error;
-		case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
-			event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
-			break;
-		case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT:
-			event_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
-			break;
-		}
-		if (!event_recorder->priv->parent.desc) {
-			ret = -EINVAL;
-			goto register_error;
-		}
-		break;
-
-	case LTTNG_KERNEL_ABI_UPROBE:
-		/*
-		 * Needs to be explicitly enabled after creation, since
-		 * we may want to apply filters.
-		 */
-		event_recorder->parent.enabled = 0;
-		event_recorder->priv->parent.registered = 1;
-
-		/*
-		 * Populate lttng_event structure before event
-		 * registration.
-		 */
-		smp_wmb();
-
-		ret = lttng_uprobes_register_event(event_param->name,
-				event_param->u.uprobe.fd,
-				&event_recorder->parent);
-		if (ret)
-			goto register_error;
-		ret = try_module_get(event_recorder->priv->parent.desc->owner);
-		WARN_ON_ONCE(!ret);
-		break;
-
-	case LTTNG_KERNEL_ABI_FUNCTION:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_NOOP:
-		lttng_fallthrough;
-	default:
-		WARN_ON_ONCE(1);
-		ret = -EINVAL;
-		goto register_error;
-	}
-	ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder);
-	WARN_ON_ONCE(ret > 0);
-	if (ret) {
-		goto statedump_error;
-	}
-	hlist_add_head(&event_recorder->priv->parent.hlist_node, head);
-	list_add(&event_recorder->priv->parent.node, &chan->parent.session->priv->events);
-	return event_recorder;
-
-statedump_error:
-	/* If a statedump error occurs, events will not be readable. */
-register_error:
-	kmem_cache_free(event_recorder_private_cache, event_recorder_priv);
-cache_private_error:
-	kmem_cache_free(event_recorder_cache, event_recorder);
-cache_error:
-exist:
-type_error:
-full:
-	return ERR_PTR(ret);
-}
-
-static
-struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler,
-		const struct lttng_kernel_event_desc *event_desc)
-{
-	struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent);
-	struct lttng_event_notifier_group *event_notifier_group = event_enabler->group;
-	struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param;
-	uint64_t token = event_enabler->parent.user_token;
-	enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
-	struct lttng_kernel_event_notifier *event_notifier;
-	struct lttng_kernel_event_notifier_private *event_notifier_priv;
-	struct lttng_kernel_event_common_private *event_priv;
-	struct lttng_counter *error_counter;
-	const char *event_name;
-	struct hlist_head *head;
-	int ret;
-
-	switch (itype) {
-	case LTTNG_KERNEL_ABI_TRACEPOINT:
-		event_name = event_desc->event_name;
-		break;
-
-	case LTTNG_KERNEL_ABI_KPROBE:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_UPROBE:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_SYSCALL:
-		event_name = event_param->name;
-		break;
-
-	case LTTNG_KERNEL_ABI_KRETPROBE:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_FUNCTION:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_NOOP:
-		lttng_fallthrough;
-	default:
-		WARN_ON_ONCE(1);
-		ret = -EINVAL;
-		goto type_error;
-	}
-
-	head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name);
-	lttng_hlist_for_each_entry(event_priv, head, hlist_node) {
-		event_notifier_priv = container_of(event_priv, struct lttng_kernel_event_notifier_private, parent);
-
-		WARN_ON_ONCE(!event_priv->desc);
-		if (!strncmp(event_priv->desc->event_name, event_name,
-					LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
-				&& event_notifier_group == event_notifier_priv->group
-				&& token == event_priv->user_token) {
-			ret = -EEXIST;
-			goto exist;
-		}
-	}
-
-	event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL);
-	if (!event_notifier) {
-		ret = -ENOMEM;
-		goto cache_error;
-	}
-	event_notifier_priv = kmem_cache_zalloc(event_notifier_private_cache, GFP_KERNEL);
-	if (!event_notifier_priv) {
-		ret = -ENOMEM;
-		goto cache_private_error;
-	}
-	event_notifier_priv->pub = event_notifier;
-	event_notifier_priv->parent.pub = &event_notifier->parent;
-	event_notifier->priv = event_notifier_priv;
-	event_notifier->parent.priv = &event_notifier_priv->parent;
-	event_notifier->parent.type = LTTNG_KERNEL_EVENT_TYPE_NOTIFIER;
-
-	event_notifier->priv->group = event_notifier_group;
-	event_notifier->priv->parent.user_token = event_enabler->parent.user_token;
-	event_notifier->priv->error_counter_index = event_enabler->error_counter_index;
-	event_notifier->priv->num_captures = 0;
-	event_notifier->priv->parent.instrumentation = itype;
-	event_notifier->notification_send = lttng_event_notifier_notification_send;
-	INIT_LIST_HEAD(&event_notifier->priv->parent.filter_bytecode_runtime_head);
-	INIT_LIST_HEAD(&event_notifier->priv->parent.enablers_ref_head);
-	INIT_LIST_HEAD(&event_notifier->priv->capture_bytecode_runtime_head);
-	event_notifier->parent.run_filter = lttng_kernel_interpret_event_filter;
-
-	switch (itype) {
-	case LTTNG_KERNEL_ABI_TRACEPOINT:
-		/* Event will be enabled by enabler sync. */
-		event_notifier->parent.enabled = 0;
-		event_notifier->priv->parent.registered = 0;
-		event_notifier->priv->parent.desc = lttng_event_desc_get(event_name);
-		if (!event_notifier->priv->parent.desc) {
-			ret = -ENOENT;
-			goto register_error;
-		}
-		/* Populate lttng_event_notifier structure before event registration. */
-		smp_wmb();
-		break;
-
-	case LTTNG_KERNEL_ABI_KPROBE:
-		/*
-		 * Needs to be explicitly enabled after creation, since
-		 * we may want to apply filters.
-		 */
-		event_notifier->parent.enabled = 0;
-		event_notifier->priv->parent.registered = 1;
-		/*
-		 * Populate lttng_event_notifier structure before event
-		 * registration.
-		 */
-		smp_wmb();
-		ret = lttng_kprobes_register_event(event_param->u.kprobe.symbol_name,
-				event_param->u.kprobe.symbol_name,
-				event_param->u.kprobe.offset,
-				event_param->u.kprobe.addr,
-				&event_notifier->parent);
-		if (ret) {
-			ret = -EINVAL;
-			goto register_error;
+		if (ret) {
+			lttng_kernel_event_free(event_return);
+			module_put(event_return->priv->desc->owner);
+			module_put(event->priv->desc->owner);
+			goto statedump_error;
 		}
-		ret = try_module_get(event_notifier->priv->parent.desc->owner);
-		WARN_ON_ONCE(!ret);
+		list_add(&event_return->priv->node, event_list_head);
 		break;
+	}
 
 	case LTTNG_KERNEL_ABI_SYSCALL:
 		/*
 		 * Needs to be explicitly enabled after creation, since
 		 * we may want to apply filters.
 		 */
-		event_notifier->parent.enabled = 0;
-		event_notifier->priv->parent.registered = 0;
-		event_notifier->priv->parent.desc = event_desc;
+		event->enabled = 0;
+		event->priv->registered = 0;
+		event->priv->desc = event_desc;
 		switch (event_param->u.syscall.entryexit) {
 		case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT:
 			ret = -EINVAL;
 			goto register_error;
 		case LTTNG_KERNEL_ABI_SYSCALL_ENTRY:
-			event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
+			event->priv->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
 			break;
 		case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
-			event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
+			event->priv->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
 			break;
 		}
 		switch (event_param->u.syscall.abi) {
@@ -1299,14 +1228,13 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 			ret = -EINVAL;
 			goto register_error;
 		case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
-			event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
+			event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
 			break;
 		case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT:
-			event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
+			event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
 			break;
 		}
-
-		if (!event_notifier->priv->parent.desc) {
+		if (!event->priv->desc) {
 			ret = -EINVAL;
 			goto register_error;
 		}
@@ -1317,111 +1245,56 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 		 * Needs to be explicitly enabled after creation, since
 		 * we may want to apply filters.
 		 */
-		event_notifier->parent.enabled = 0;
-		event_notifier->priv->parent.registered = 1;
+		event->enabled = 0;
+		event->priv->registered = 1;
 
 		/*
-		 * Populate lttng_event_notifier structure before
-		 * event_notifier registration.
+		 * Populate lttng_event structure before event
+		 * registration.
 		 */
 		smp_wmb();
 
 		ret = lttng_uprobes_register_event(event_param->name,
 				event_param->u.uprobe.fd,
-				&event_notifier->parent);
+				event);
 		if (ret)
 			goto register_error;
-		ret = try_module_get(event_notifier->priv->parent.desc->owner);
+		ret = try_module_get(event->priv->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
 
-	case LTTNG_KERNEL_ABI_KRETPROBE:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_FUNCTION:
-		lttng_fallthrough;
-	case LTTNG_KERNEL_ABI_NOOP:
-		lttng_fallthrough;
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
 		goto register_error;
 	}
 
-	list_add(&event_notifier->priv->parent.node, &event_notifier_group->event_notifiers_head);
-	hlist_add_head(&event_notifier->priv->parent.hlist_node, head);
-
-	/*
-	 * Clear the error counter bucket. The sessiond keeps track of which
-	 * bucket is currently in use. We trust it. The session lock
-	 * synchronizes against concurrent creation of the error
-	 * counter.
-	 */
-	error_counter = event_notifier_group->error_counter;
-	if (error_counter) {
-		size_t dimension_index[1];
+	ret = _lttng_event_recorder_metadata_statedump(event);
+	WARN_ON_ONCE(ret > 0);
+	if (ret) {
+		goto statedump_error;
+	}
 
-		/*
-		 * Check that the index is within the boundary of the counter.
-		 */
-		if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) {
-			printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
-				event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index);
-			ret = -EINVAL;
-			goto register_error;
-		}
+	ret = lttng_kernel_event_notifier_clear_error_counter(event);
+	if (ret)
+		goto register_error;
 
-		dimension_index[0] = event_notifier->priv->error_counter_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->priv->error_counter_index);
-			goto register_error;
-		}
-	}
+	hlist_add_head(&event->priv->hlist_node, head);
+	list_add(&event->priv->node, event_list_head);
 
-	return event_notifier;
+	return event;
 
+statedump_error:
+	/* If a statedump error occurs, events will not be readable. */
 register_error:
-	kmem_cache_free(event_notifier_private_cache, event_notifier_priv);
-cache_private_error:
-	kmem_cache_free(event_notifier_cache, event_notifier);
-cache_error:
+	lttng_kernel_event_free(event);
+alloc_error:
 exist:
 type_error:
+full:
 	return ERR_PTR(ret);
 }
 
-struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler,
-				const struct lttng_kernel_event_desc *event_desc)
-{
-	switch (event_enabler->enabler_type) {
-	case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
-	{
-		struct lttng_event_recorder_enabler *event_recorder_enabler =
-			container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
-		struct lttng_kernel_event_recorder *event_recorder;
-
-		event_recorder = _lttng_kernel_event_recorder_create(event_recorder_enabler, event_desc);
-		if (!event_recorder)
-			return NULL;
-		return &event_recorder->parent;
-	}
-	case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
-	{
-		struct lttng_event_notifier_enabler *event_notifier_enabler =
-			container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
-		struct lttng_kernel_event_notifier *event_notifier;
-
-		event_notifier = _lttng_kernel_event_notifier_create(event_notifier_enabler, event_desc);
-		if (!event_notifier)
-			return NULL;
-		return &event_notifier->parent;
-	}
-	default:
-		return NULL;
-	}
-}
-
 struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler,
 				const struct lttng_kernel_event_desc *event_desc)
 {
@@ -1433,8 +1306,6 @@ struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_e
 	return event;
 }
 
-
-
 int lttng_kernel_counter_read(struct lttng_counter *counter,
 		const size_t *dim_indexes, int32_t cpu,
 		int64_t *val, bool *overflow, bool *underflow)
@@ -1457,20 +1328,19 @@ int lttng_kernel_counter_clear(struct lttng_counter *counter,
 	return counter->ops->counter_clear(counter->counter, dim_indexes);
 }
 
-/* Only used for tracepoints for now. */
+/* Only used for tracepoints and system calls for now. */
 static
 void register_event(struct lttng_kernel_event_common *event)
 {
 	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
-	if (event->priv->registered)
-		return;
+	WARN_ON_ONCE(event->priv->registered);
 
 	desc = event->priv->desc;
 	switch (event->priv->instrumentation) {
 	case LTTNG_KERNEL_ABI_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
+		ret = lttng_tracepoint_probe_register(desc->event_kname,
 						  desc->tp_class->probe_callback,
 						  event);
 		break;
@@ -1503,23 +1373,24 @@ void register_event(struct lttng_kernel_event_common *event)
 	default:
 		WARN_ON_ONCE(1);
 	}
+	WARN_ON_ONCE(ret);
 	if (!ret)
 		event->priv->registered = 1;
 }
 
-int _lttng_event_unregister(struct lttng_kernel_event_common *event)
+static
+void unregister_event(struct lttng_kernel_event_common *event)
 {
 	struct lttng_kernel_event_common_private *event_priv = event->priv;
 	const struct lttng_kernel_event_desc *desc;
 	int ret = -EINVAL;
 
-	if (!event_priv->registered)
-		return 0;
+	WARN_ON_ONCE(!event->priv->registered);
 
 	desc = event_priv->desc;
 	switch (event_priv->instrumentation) {
 	case LTTNG_KERNEL_ABI_TRACEPOINT:
-		ret = lttng_wrapper_tracepoint_probe_unregister(event_priv->desc->event_kname,
+		ret = lttng_tracepoint_probe_unregister(event_priv->desc->event_kname,
 						  event_priv->desc->tp_class->probe_callback,
 						  event);
 		break;
@@ -1566,9 +1437,16 @@ int _lttng_event_unregister(struct lttng_kernel_event_common *event)
 	default:
 		WARN_ON_ONCE(1);
 	}
+	WARN_ON_ONCE(ret);
 	if (!ret)
 		event_priv->registered = 0;
-	return ret;
+}
+
+static
+void _lttng_event_unregister(struct lttng_kernel_event_common *event)
+{
+	if (event->priv->registered)
+		unregister_event(event);
 }
 
 /*
@@ -1884,7 +1762,7 @@ int lttng_session_list_tracker_ids(struct lttng_kernel_session *session,
 	struct seq_file *m;
 	int file_fd, ret;
 
-	file_fd = lttng_get_unused_fd();
+	file_fd = get_unused_fd_flags(0);
 	if (file_fd < 0) {
 		ret = file_fd;
 		goto fd_error;
@@ -2127,6 +2005,47 @@ bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common *eve
 	}
 }
 
+bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common *event_enabler,
+		const char *event_name,
+		struct lttng_kernel_event_common *event)
+{
+	if (event_enabler->event_param.instrumentation != event->priv->instrumentation)
+		return false;
+
+	switch (event_enabler->enabler_type) {
+	case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+	{
+		struct lttng_event_recorder_enabler *event_recorder_enabler =
+			container_of(event_enabler, struct lttng_event_recorder_enabler, parent);
+		struct lttng_kernel_event_recorder *event_recorder =
+			container_of(event, struct lttng_kernel_event_recorder, parent);
+
+		if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
+				&& event_recorder->chan == event_recorder_enabler->chan)
+			return true;
+		else
+			return false;
+	}
+	case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER:
+	{
+		struct lttng_event_notifier_enabler *event_notifier_enabler =
+			container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
+		struct lttng_kernel_event_notifier *event_notifier =
+			container_of(event, struct lttng_kernel_event_notifier, parent);
+
+		if (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
+				&& event_notifier->priv->group == event_notifier_enabler->group
+				&& event->priv->user_token == event_enabler->user_token)
+			return true;
+		else
+			return false;
+	}
+	default:
+		WARN_ON_ONCE(1);
+		return false;
+	}
+}
+
 static
 struct lttng_enabler_ref *lttng_enabler_ref(
 		struct list_head *enablers_ref_list,
@@ -2142,7 +2061,7 @@ struct lttng_enabler_ref *lttng_enabler_ref(
 }
 
 static
-void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common *event_enabler)
+void lttng_event_enabler_create_tracepoint_events_if_missing(struct lttng_event_enabler_common *event_enabler)
 {
 	struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler);
 	struct lttng_kernel_probe_desc *probe_desc;
@@ -2158,7 +2077,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common
 	 */
 	list_for_each_entry(probe_desc, probe_list, head) {
 		for (i = 0; i < probe_desc->nr_events; i++) {
-			int found = 0;
+			bool found = false;
 			struct hlist_head *head;
 			struct lttng_kernel_event_common *event;
 			struct lttng_kernel_event_common_private *event_priv;
@@ -2172,8 +2091,10 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common
 			 */
 			head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, desc->event_name);
 			lttng_hlist_for_each_entry(event_priv, head, hlist_node) {
-				if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub))
-					found = 1;
+				if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) {
+					found = true;
+					break;
+				}
 			}
 			if (found)
 				continue;
@@ -2182,7 +2103,7 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common
 			 * We need to create an event for this event probe.
 			 */
 			event = _lttng_kernel_event_create(event_enabler, desc);
-			if (!event) {
+			if (IS_ERR(event)) {
 				printk(KERN_INFO "LTTng: Unable to create event %s\n",
 					probe_desc->event_desc[i]->event_name);
 			}
@@ -2190,29 +2111,23 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common
 	}
 }
 
-static
-void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler)
-{
-	int ret;
-
-	ret = lttng_syscalls_register_event(event_enabler);
-	WARN_ON_ONCE(ret);
-}
-
 /*
  * Create event if it is missing and present in the list of tracepoint probes.
  * Should be called with sessions mutex held.
  */
 static
-void lttng_create_event_if_missing(struct lttng_event_enabler_common *event_enabler)
+void lttng_event_enabler_create_events_if_missing(struct lttng_event_enabler_common *event_enabler)
 {
+	int ret;
+
 	switch (event_enabler->event_param.instrumentation) {
 	case LTTNG_KERNEL_ABI_TRACEPOINT:
-		lttng_create_tracepoint_event_if_missing(event_enabler);
+		lttng_event_enabler_create_tracepoint_events_if_missing(event_enabler);
 		break;
 
 	case LTTNG_KERNEL_ABI_SYSCALL:
-		lttng_create_syscall_event_if_missing(event_enabler);
+		ret = lttng_event_enabler_create_syscall_events_if_missing(event_enabler);
+		WARN_ON_ONCE(ret);
 		break;
 
 	default:
@@ -2270,7 +2185,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler_common *event_enab
 	lttng_syscall_table_set_wildcard_all(event_enabler);
 
 	/* First ensure that probe events are created for this enabler. */
-	lttng_create_event_if_missing(event_enabler);
+	lttng_event_enabler_create_events_if_missing(event_enabler);
 
 	/* Link the created event with its associated enabler. */
 	list_for_each_entry(event_priv, event_list_head, node) {
@@ -2645,69 +2560,118 @@ void lttng_event_sync_capture_state(struct lttng_kernel_event_common *event)
 	}
 }
 
+static
+bool lttng_get_event_enabled_state(struct lttng_kernel_event_common *event)
+{
+	struct lttng_enabler_ref *enabler_ref;
+	bool enabled = false;
+
+	switch (event->priv->instrumentation) {
+	case LTTNG_KERNEL_ABI_TRACEPOINT:
+		lttng_fallthrough;
+	case LTTNG_KERNEL_ABI_SYSCALL:
+		/* Enable events */
+		list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) {
+			if (enabler_ref->ref->enabled) {
+				enabled = true;
+				break;
+			}
+		}
+		break;
+	default:
+		WARN_ON_ONCE(1);
+		return false;
+	}
+
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+	{
+		struct lttng_kernel_event_recorder *event_recorder =
+			container_of(event, struct lttng_kernel_event_recorder, parent);
+
+		/*
+		 * Enabled state is based on union of enablers, with
+		 * intersection of session and channel transient enable
+		 * states.
+		 */
+		return enabled && event_recorder->chan->parent.session->priv->tstate && event_recorder->chan->priv->parent.tstate;
+	}
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+		return enabled;
+	default:
+		WARN_ON_ONCE(1);
+		return false;
+	}
+}
+
+static
+bool lttng_event_is_lazy_sync(struct lttng_kernel_event_common *event)
+{
+	switch (event->priv->instrumentation) {
+	case LTTNG_KERNEL_ABI_TRACEPOINT:
+		lttng_fallthrough;
+	case LTTNG_KERNEL_ABI_SYSCALL:
+		return true;
+
+	default:
+		/* Not handled with lazy sync. */
+		return false;
+	}
+}
+
 /*
- * lttng_session_sync_event_enablers should be called just before starting a
- * session.
  * Should be called with sessions mutex held.
  */
 static
-void lttng_session_sync_event_enablers(struct lttng_kernel_session *session)
+void lttng_sync_event_list(struct list_head *event_enabler_list,
+		struct list_head *event_list)
 {
+	struct lttng_kernel_event_common_private *event_priv;
 	struct lttng_event_enabler_common *event_enabler;
-	struct lttng_kernel_event_recorder_private *event_recorder_priv;
 
-	list_for_each_entry(event_enabler, &session->priv->enablers_head, node)
+	list_for_each_entry(event_enabler, event_enabler_list, node)
 		lttng_event_enabler_ref_events(event_enabler);
+
 	/*
 	 * For each event, if at least one of its enablers is enabled,
 	 * and its channel and session transient states are enabled, we
 	 * enable the event, else we disable it.
 	 */
-	list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
-		struct lttng_kernel_event_recorder *event_recorder = event_recorder_priv->pub;
-		struct lttng_enabler_ref *enabler_ref;
-		int enabled = 0;
-
-		switch (event_recorder_priv->parent.instrumentation) {
-		case LTTNG_KERNEL_ABI_TRACEPOINT:
-			lttng_fallthrough;
-		case LTTNG_KERNEL_ABI_SYSCALL:
-			/* Enable events */
-			list_for_each_entry(enabler_ref,
-					&event_recorder_priv->parent.enablers_ref_head, node) {
-				if (enabler_ref->ref->enabled) {
-					enabled = 1;
-					break;
-				}
-			}
-			break;
+	list_for_each_entry(event_priv, event_list, node) {
+		struct lttng_kernel_event_common *event = event_priv->pub;
+		bool enabled;
 
-		default:
-			/* Not handled with lazy sync. */
+		if (!lttng_event_is_lazy_sync(event))
 			continue;
-		}
-		/*
-		 * Enabled state is based on union of enablers, with
-		 * intesection of session and channel transient enable
-		 * states.
-		 */
-		enabled = enabled && session->priv->tstate && event_recorder->chan->priv->parent.tstate;
 
-		WRITE_ONCE(event_recorder->parent.enabled, enabled);
+		enabled = lttng_get_event_enabled_state(event);
+		WRITE_ONCE(event->enabled, enabled);
 		/*
-		 * Sync tracepoint registration with event enabled
-		 * state.
+		 * Sync tracepoint registration with event enabled state.
 		 */
 		if (enabled) {
-			register_event(&event_recorder->parent);
+			if (!event_priv->registered)
+				register_event(event);
 		} else {
-			_lttng_event_unregister(&event_recorder->parent);
+			if (event_priv->registered)
+				unregister_event(event);
 		}
 
-		lttng_event_sync_filter_state(&event_recorder_priv->pub->parent);
+		lttng_event_sync_filter_state(event);
+		lttng_event_sync_capture_state(event);
 	}
 }
 
+/*
+ * lttng_session_sync_event_enablers should be called just before starting a
+ * session.
+ */
+static
+void lttng_session_sync_event_enablers(struct lttng_kernel_session *session)
+{
+	lttng_sync_event_list(&session->priv->enablers_head, &session->priv->events);
+}
+
 /*
  * Apply enablers to session events, adding events to session if need
  * be. It is required after each modification applied to an active
@@ -2727,56 +2691,7 @@ void lttng_session_lazy_sync_event_enablers(struct lttng_kernel_session *session
 static
 void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group)
 {
-	struct lttng_event_enabler_common *event_enabler;
-	struct lttng_kernel_event_notifier_private *event_notifier_priv;
-
-	list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node)
-		lttng_event_enabler_ref_events(event_enabler);
-
-	/*
-	 * For each event_notifier, if at least one of its enablers is enabled,
-	 * we enable the event_notifier, else we disable it.
-	 */
-	list_for_each_entry(event_notifier_priv, &event_notifier_group->event_notifiers_head, parent.node) {
-		struct lttng_kernel_event_notifier *event_notifier = event_notifier_priv->pub;
-		struct lttng_enabler_ref *enabler_ref;
-		int enabled = 0;
-
-		switch (event_notifier_priv->parent.instrumentation) {
-		case LTTNG_KERNEL_ABI_TRACEPOINT:
-			lttng_fallthrough;
-		case LTTNG_KERNEL_ABI_SYSCALL:
-			/* Enable event_notifiers */
-			list_for_each_entry(enabler_ref,
-					&event_notifier_priv->parent.enablers_ref_head, node) {
-				if (enabler_ref->ref->enabled) {
-					enabled = 1;
-					break;
-				}
-			}
-			break;
-
-		default:
-			/* Not handled with sync. */
-			continue;
-		}
-
-		WRITE_ONCE(event_notifier->parent.enabled, enabled);
-		/*
-		 * Sync tracepoint registration with event_notifier enabled
-		 * state.
-		 */
-		if (enabled) {
-			if (!event_notifier_priv->parent.registered)
-				register_event(&event_notifier->parent);
-		} else {
-			if (event_notifier_priv->parent.registered)
-				_lttng_event_unregister(&event_notifier->parent);
-		}
-
-		lttng_event_sync_filter_state(&event_notifier_priv->pub->parent);
-		lttng_event_sync_capture_state(&event_notifier_priv->pub->parent);
-	}
+	lttng_sync_event_list(&event_notifier_group->enablers_head, &event_notifier_group->event_notifiers_head);
 }
 
 static
@@ -3571,12 +3486,19 @@ int _lttng_fields_metadata_statedump(struct lttng_kernel_session *session,
  * transaction.
  */
 static
-int _lttng_event_metadata_statedump(struct lttng_kernel_session *session,
-				  struct lttng_kernel_channel_buffer *chan,
-				  struct lttng_kernel_event_recorder *event_recorder)
+int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event)
 {
+	struct lttng_kernel_event_recorder *event_recorder;
+	struct lttng_kernel_channel_buffer *chan;
+	struct lttng_kernel_session *session;
 	int ret = 0;
 
+	if (event->type != LTTNG_KERNEL_EVENT_TYPE_RECORDER)
+		return 0;
+	event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent);
+	chan = event_recorder->chan;
+	session = chan->parent.session;
+
 	if (event_recorder->priv->metadata_dumped || !LTTNG_READ_ONCE(session->active))
 		return 0;
 	if (chan->priv->channel_type == METADATA_CHANNEL)
@@ -3760,20 +3682,12 @@ int64_t measure_clock_offset(void)
 	uint64_t tcf = trace_clock_freq();
 	int64_t offset;
 	unsigned long flags;
-#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
 	struct timespec64 rts = { 0, 0 };
-#else
-	struct timespec rts = { 0, 0 };
-#endif
 
 	/* Disable interrupts to increase correlation precision. */
 	local_irq_save(flags);
 	monotonic[0] = trace_clock_read64();
-#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
 	ktime_get_real_ts64(&rts);
-#else
-	getnstimeofday(&rts);
-#endif
 	monotonic[1] = trace_clock_read64();
 	local_irq_restore(flags);
 
@@ -4031,8 +3945,7 @@ skip_session:
 	}
 
 	list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
-		ret = _lttng_event_metadata_statedump(session, event_recorder_priv->pub->chan,
-				event_recorder_priv->pub);
+		ret = _lttng_event_recorder_metadata_statedump(&event_recorder_priv->pub->parent);
 		if (ret)
 			goto end;
 	}
@@ -4234,13 +4147,7 @@ static int __init lttng_events_init(void)
 {
 	int ret;
 
-	ret = wrapper_lttng_fixup_sig(THIS_MODULE);
-	if (ret)
-		return ret;
 	ret = wrapper_get_pfnblock_flags_mask_init();
-	if (ret)
-		return ret;
-	ret = wrapper_get_pageblock_flags_mask_init();
 	if (ret)
 		return ret;
 	ret = lttng_probes_init();