X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=08cb66dc49a3fcd00856a5ec3132f2b9c38c034c;hb=7cd0f6963147383a8ed0129a7c327582ae2aaf47;hp=7f7748dc54b2e0de50294dabac9577d6c6272fed;hpb=f237aef8019a982e3577e64895e5b4ae5cb5a968;p=lttng-modules.git

diff --git a/src/lttng-events.c b/src/lttng-events.c
index 7f7748dc..08cb66dc 100644
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -353,7 +353,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
 	struct lttng_kernel_channel_buffer_private *chan_priv, *tmpchan_priv;
 	struct lttng_kernel_event_recorder_private *event_recorder_priv, *tmpevent_recorder_priv;
 	struct lttng_metadata_stream *metadata_stream;
-	struct lttng_event_recorder_enabler *event_recorder_enabler, *tmp_event_recorder_enabler;
+	struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler;
 	int ret;
 
 	mutex_lock(&sessions_mutex);
@@ -371,9 +371,8 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
 		ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table);
 		WARN_ON(ret);
 	}
-	list_for_each_entry_safe(event_recorder_enabler, tmp_event_recorder_enabler,
-			&session->priv->enablers_head, node)
-		lttng_event_enabler_destroy(&event_recorder_enabler->parent);
+	list_for_each_entry_safe(event_enabler, tmp_event_enabler, &session->priv->enablers_head, node)
+		lttng_event_enabler_destroy(event_enabler);
 	list_for_each_entry_safe(event_recorder_priv, tmpevent_recorder_priv, &session->priv->events, parent.node)
 		_lttng_event_destroy(&event_recorder_priv->pub->parent);
 	list_for_each_entry_safe(chan_priv, tmpchan_priv, &session->priv->chan, node) {
@@ -400,7 +399,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
 void lttng_event_notifier_group_destroy(
 		struct lttng_event_notifier_group *event_notifier_group)
 {
-	struct lttng_event_notifier_enabler *event_notifier_enabler, *tmp_event_notifier_enabler;
+	struct lttng_event_enabler_common *event_enabler, *tmp_event_enabler;
 	struct lttng_kernel_event_notifier_private *event_notifier_priv, *tmpevent_notifier_priv;
 	int ret;
 
@@ -426,9 +425,9 @@ void lttng_event_notifier_group_destroy(
 	ret = lttng_syscalls_destroy_syscall_table(&event_notifier_group->syscall_table);
 	WARN_ON(ret);
 
-	list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler,
+	list_for_each_entry_safe(event_enabler, tmp_event_enabler,
 			&event_notifier_group->enablers_head, node)
-		lttng_event_enabler_destroy(&event_notifier_enabler->parent);
+		lttng_event_enabler_destroy(event_enabler);
 
 	list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv,
 			&event_notifier_group->event_notifiers_head, parent.node)
@@ -867,6 +866,109 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
 	wake_up_interruptible(&stream->read_wait);
 }
 
+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);
+	}
+}
 
 /*
  * Supports event creation while tracing session is active.
@@ -880,9 +982,10 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 	struct lttng_kernel_channel_buffer *chan = event_enabler->chan;
 	struct lttng_kernel_abi_event *event_param = &event_enabler->parent.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;
+	struct lttng_kernel_event_recorder_private *event_recorder_priv;
+	struct lttng_kernel_event_recorder *event_recorder;
 	const char *event_name;
 	struct hlist_head *head;
 	int ret;
@@ -930,36 +1033,20 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 		}
 	}
 
-	event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
-	if (!event_recorder) {
+	event = lttng_kernel_event_alloc(&event_enabler->parent);
+	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);
+	event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent);
 
 	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;
 		}
@@ -972,8 +1059,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.
@@ -983,53 +1070,38 @@ 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_common *event_return;
 		struct lttng_kernel_event_recorder *event_recorder_return;
-		struct lttng_kernel_event_recorder_private *event_recorder_return_priv;
 
 		/* 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->parent);
+		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_recorder_return = container_of(event_return, struct lttng_kernel_event_recorder, parent);
+
+		event_return->enabled = 0;
+		event_return->priv->registered = 1;
+
 		/*
 		 * Populate lttng_event structure before kretprobe registration.
 		 */
@@ -1038,29 +1110,26 @@ 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_metadata_statedump(chan->parent.session, chan, event_recorder_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);
+			lttng_kernel_event_free(event_return);
+			module_put(event_return->priv->desc->owner);
+			module_put(event->priv->desc->owner);
 			goto statedump_error;
 		}
-		list_add(&event_recorder_return->priv->parent.node, &chan->parent.session->priv->events);
+		list_add(&event_return->priv->node, &chan->parent.session->priv->events);
 		break;
 	}
 
@@ -1069,18 +1138,18 @@ 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 = 0;
-		event_recorder->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_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
+			event->priv->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
 			break;
 		case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
-			event_recorder->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
+			event->priv->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
 			break;
 		}
 		switch (event_param->u.syscall.abi) {
@@ -1088,13 +1157,13 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 			ret = -EINVAL;
 			goto register_error;
 		case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
-			event_recorder->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_recorder->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
+			event->priv->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
 			break;
 		}
-		if (!event_recorder->priv->parent.desc) {
+		if (!event->priv->desc) {
 			ret = -EINVAL;
 			goto register_error;
 		}
@@ -1105,8 +1174,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
@@ -1116,10 +1185,10 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 
 		ret = lttng_uprobes_register_event(event_param->name,
 				event_param->u.uprobe.fd,
-				&event_recorder->parent);
+				event);
 		if (ret)
 			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;
 
@@ -1137,17 +1206,15 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 	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);
+	hlist_add_head(&event->priv->hlist_node, head);
+	list_add(&event->priv->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:
+	lttng_kernel_event_free(event);
+alloc_error:
 exist:
 type_error:
 full:
@@ -1163,9 +1230,10 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 	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_kernel_event_common *event;
+	struct lttng_kernel_event_notifier_private *event_notifier_priv;
+	struct lttng_kernel_event_notifier *event_notifier;
 	struct lttng_counter *error_counter;
 	const char *event_name;
 	struct hlist_head *head;
@@ -1210,40 +1278,20 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 		}
 	}
 
-	event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL);
-	if (!event_notifier) {
+	event = lttng_kernel_event_alloc(&event_enabler->parent);
+	if (!event) {
 		ret = -ENOMEM;
-		goto cache_error;
+		goto alloc_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;
+	event_notifier = container_of(event, struct lttng_kernel_event_notifier, parent);
 
 	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) {
+		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;
 		}
@@ -1256,8 +1304,8 @@ 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
 		 * registration.
@@ -1267,12 +1315,12 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 				event_param->u.kprobe.symbol_name,
 				event_param->u.kprobe.offset,
 				event_param->u.kprobe.addr,
-				&event_notifier->parent);
+				event);
 		if (ret) {
 			ret = -EINVAL;
 			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;
 
@@ -1281,18 +1329,18 @@ 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 = 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) {
@@ -1300,14 +1348,14 @@ 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;
 		}
@@ -1318,8 +1366,8 @@ 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
@@ -1329,10 +1377,10 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 
 		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;
 
@@ -1348,8 +1396,8 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 		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);
+	list_add(&event->priv->node, &event_notifier_group->event_notifiers_head);
+	hlist_add_head(&event->priv->hlist_node, head);
 
 	/*
 	 * Clear the error counter bucket. The sessiond keeps track of which
@@ -1383,10 +1431,8 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 	return event_notifier;
 
 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:
 	return ERR_PTR(ret);
@@ -2222,109 +2268,66 @@ void lttng_create_event_if_missing(struct lttng_event_enabler_common *event_enab
 	}
 }
 
-/*
- * Create events associated with an event_enabler (if not already present),
- * and add backward reference from the event to the enabler.
- * Should be called with sessions mutex held.
- */
 static
-int lttng_event_enabler_ref_events(struct lttng_event_recorder_enabler *event_enabler)
+void lttng_event_enabler_init_event_filter(struct lttng_event_enabler_common *event_enabler,
+		struct lttng_kernel_event_common *event)
 {
-	struct lttng_kernel_channel_buffer *chan = event_enabler->chan;
-	struct lttng_kernel_session *session = event_enabler->chan->parent.session;
-	struct lttng_event_enabler_common *base_enabler = lttng_event_recorder_enabler_as_enabler(event_enabler);
-	struct lttng_kernel_event_recorder_private *event_recorder_priv;
-
-	if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_ABI_SYSCALL &&
-			base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL &&
-			base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME &&
-			!strcmp(base_enabler->event_param.name, "*")) {
-		int enabled = base_enabler->enabled;
-		enum lttng_kernel_abi_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit;
+	/* Link filter bytecodes if not linked yet. */
+	lttng_enabler_link_bytecode(event->priv->desc, lttng_static_ctx,
+		&event->priv->filter_bytecode_runtime_head, &event_enabler->filter_bytecode_head);
+}
 
-		if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
-			WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_entry, enabled);
+static
+void lttng_event_enabler_init_event_capture(struct lttng_event_enabler_common *event_enabler,
+		struct lttng_kernel_event_common *event)
+{
+	switch (event_enabler->enabler_type) {
+	case LTTNG_EVENT_ENABLER_TYPE_RECORDER:
+		break;
+	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 (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
-			WRITE_ONCE(chan->priv->parent.syscall_table.syscall_all_exit, enabled);
+		/* Link capture bytecodes if not linked yet. */
+		lttng_enabler_link_bytecode(event->priv->desc,
+			lttng_static_ctx, &event_notifier->priv->capture_bytecode_runtime_head,
+			&event_notifier_enabler->capture_bytecode_head);
+		event_notifier->priv->num_captures = event_notifier_enabler->num_captures;
+		break;
 	}
-
-	/* First ensure that probe events are created for this enabler. */
-	lttng_create_event_if_missing(&event_enabler->parent);
-
-	/* For each event matching event_enabler in session event list. */
-	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;
-
-		if (!lttng_event_enabler_match_event(&event_enabler->parent, &event_recorder->parent))
-			continue;
-		enabler_ref = lttng_enabler_ref(&event_recorder_priv->parent.enablers_ref_head,
-			lttng_event_recorder_enabler_as_enabler(event_enabler));
-		if (!enabler_ref) {
-			/*
-			 * If no backward ref, create it.
-			 * Add backward ref from event to event_enabler.
-			 */
-			enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
-			if (!enabler_ref)
-				return -ENOMEM;
-			enabler_ref->ref = lttng_event_recorder_enabler_as_enabler(event_enabler);
-			list_add(&enabler_ref->node,
-				&event_recorder_priv->parent.enablers_ref_head);
-		}
-
-		/*
-		 * Link filter bytecodes if not linked yet.
-		 */
-		lttng_enabler_link_bytecode(event_recorder_priv->parent.desc,
-			lttng_static_ctx,
-			&event_recorder_priv->parent.filter_bytecode_runtime_head,
-			&lttng_event_recorder_enabler_as_enabler(event_enabler)->filter_bytecode_head);
+	default:
+		WARN_ON_ONCE(1);
 	}
-	return 0;
 }
 
 /*
- * Create event_notifiers associated with a event_notifier enabler (if not already present).
+ * Create events associated with an event_enabler (if not already present),
+ * and add backward reference from the event to the enabler.
+ * Should be called with sessions mutex held.
  */
 static
-int lttng_event_notifier_enabler_ref_event_notifiers(
-		struct lttng_event_notifier_enabler *event_notifier_enabler)
+int lttng_event_enabler_ref_events(struct lttng_event_enabler_common *event_enabler)
 {
-	struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
-	struct lttng_event_enabler_common *base_enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler);
-	struct lttng_kernel_event_notifier_private *event_notifier_priv;
-
-	if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_ABI_SYSCALL &&
-			base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL &&
-			base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME &&
-			!strcmp(base_enabler->event_param.name, "*")) {
-
-		int enabled = base_enabler->enabled;
-		enum lttng_kernel_abi_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit;
-
-		if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
-			WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_entry, enabled);
-
-		if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT)
-			WRITE_ONCE(event_notifier_group->syscall_table.syscall_all_exit, enabled);
+	struct list_head *event_list_head = lttng_get_event_list_head_from_enabler(event_enabler);
+	struct lttng_kernel_event_common_private *event_priv;
 
-	}
+	lttng_syscall_table_set_wildcard_all(event_enabler);
 
-	/* First ensure that probe event_notifiers are created for this enabler. */
-	lttng_create_event_if_missing(&event_notifier_enabler->parent);
+	/* First ensure that probe events are created for this enabler. */
+	lttng_create_event_if_missing(event_enabler);
 
-	/* Link the created event_notifier with its associated enabler. */
-	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;
+	/* Link the created event with its associated enabler. */
+	list_for_each_entry(event_priv, event_list_head, node) {
+		struct lttng_kernel_event_common *event = event_priv->pub;
 		struct lttng_enabler_ref *enabler_ref;
 
-		if (!lttng_event_enabler_match_event(&event_notifier_enabler->parent, &event_notifier->parent))
+		if (!lttng_event_enabler_match_event(event_enabler, event))
 			continue;
 
-		enabler_ref = lttng_enabler_ref(&event_notifier_priv->parent.enablers_ref_head,
-			lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
+		enabler_ref = lttng_enabler_ref(&event_priv->enablers_ref_head, event_enabler);
 		if (!enabler_ref) {
 			/*
 			 * If no backward ref, create it.
@@ -2334,25 +2337,12 @@ int lttng_event_notifier_enabler_ref_event_notifiers(
 			if (!enabler_ref)
 				return -ENOMEM;
 
-			enabler_ref->ref = lttng_event_notifier_enabler_as_enabler(
-				event_notifier_enabler);
-			list_add(&enabler_ref->node,
-				&event_notifier_priv->parent.enablers_ref_head);
+			enabler_ref->ref = event_enabler;
+			list_add(&enabler_ref->node, &event_priv->enablers_ref_head);
 		}
 
-		/*
-		 * Link filter bytecodes if not linked yet.
-		 */
-		lttng_enabler_link_bytecode(event_notifier_priv->parent.desc,
-			lttng_static_ctx, &event_notifier_priv->parent.filter_bytecode_runtime_head,
-			&lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
-
-		/* Link capture bytecodes if not linked yet. */
-		lttng_enabler_link_bytecode(event_notifier_priv->parent.desc,
-			lttng_static_ctx, &event_notifier_priv->capture_bytecode_runtime_head,
-			&event_notifier_enabler->capture_bytecode_head);
-
-		event_notifier_priv->num_captures = event_notifier_enabler->num_captures;
+		lttng_event_enabler_init_event_filter(event_enabler, event);
+		lttng_event_enabler_init_event_capture(event_enabler, event);
 	}
 	return 0;
 }
@@ -2374,11 +2364,10 @@ int lttng_fix_pending_events(void)
 static bool lttng_event_notifier_group_has_active_event_notifiers(
 		struct lttng_event_notifier_group *event_notifier_group)
 {
-	struct lttng_event_notifier_enabler *event_notifier_enabler;
+	struct lttng_event_enabler_common *event_enabler;
 
-	list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head,
-			node) {
-		if (event_notifier_enabler->parent.enabled)
+	list_for_each_entry(event_enabler, &event_notifier_group->enablers_head, node) {
+		if (event_enabler->enabled)
 			return true;
 	}
 	return false;
@@ -2429,8 +2418,8 @@ void lttng_event_enabler_session_add(struct lttng_kernel_session *session,
 		struct lttng_event_recorder_enabler *event_enabler)
 {
 	mutex_lock(&sessions_mutex);
-	list_add(&event_enabler->node, &session->priv->enablers_head);
-	event_enabler->published = true;
+	list_add(&event_enabler->parent.node, &session->priv->enablers_head);
+	event_enabler->parent.published = true;
 	lttng_session_lazy_sync_event_enablers(session);
 	mutex_unlock(&sessions_mutex);
 }
@@ -2526,15 +2515,16 @@ void lttng_enabler_destroy(struct lttng_event_enabler_common *enabler)
 
 void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enabler)
 {
+	lttng_enabler_destroy(event_enabler);
+	if (event_enabler->published)
+		list_del(&event_enabler->node);
+
 	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);
 
-		lttng_enabler_destroy(event_enabler);
-		if (event_recorder_enabler->published)
-			list_del(&event_recorder_enabler->node);
 		kfree(event_recorder_enabler);
 		break;
 	}
@@ -2543,9 +2533,6 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler_common *event_enable
 		struct lttng_event_notifier_enabler *event_notifier_enabler =
 			container_of(event_enabler, struct lttng_event_notifier_enabler, parent);
 
-		lttng_enabler_destroy(event_enabler);
-		if (event_notifier_enabler->published)
-			list_del(&event_notifier_enabler->node);
 		kfree(event_notifier_enabler);
 		break;
 	}
@@ -2586,8 +2573,8 @@ void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group *e
 		struct lttng_event_notifier_enabler *event_notifier_enabler)
 {
 	mutex_lock(&sessions_mutex);
-	list_add(&event_notifier_enabler->node, &event_notifier_enabler->group->enablers_head);
-	event_notifier_enabler->published = true;
+	list_add(&event_notifier_enabler->parent.node, &event_notifier_enabler->group->enablers_head);
+	event_notifier_enabler->parent.published = true;
 	lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
 	mutex_unlock(&sessions_mutex);
 }
@@ -2654,90 +2641,167 @@ end:
 	return ret;
 }
 
+static
+void lttng_event_sync_filter_state(struct lttng_kernel_event_common *event)
+{
+	int has_enablers_without_filter_bytecode = 0, nr_filters = 0;
+	struct lttng_kernel_bytecode_runtime *runtime;
+	struct lttng_enabler_ref *enabler_ref;
+
+	/* Check if has enablers without bytecode enabled */
+	list_for_each_entry(enabler_ref, &event->priv->enablers_ref_head, node) {
+		if (enabler_ref->ref->enabled
+				&& list_empty(&enabler_ref->ref->filter_bytecode_head)) {
+			has_enablers_without_filter_bytecode = 1;
+			break;
+		}
+	}
+	event->priv->has_enablers_without_filter_bytecode = has_enablers_without_filter_bytecode;
+
+	/* Enable filters */
+	list_for_each_entry(runtime, &event->priv->filter_bytecode_runtime_head, node) {
+		lttng_bytecode_sync_state(runtime);
+		nr_filters++;
+	}
+	WRITE_ONCE(event->eval_filter, !(has_enablers_without_filter_bytecode || !nr_filters));
+}
+
+static
+void lttng_event_sync_capture_state(struct lttng_kernel_event_common *event)
+{
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+		break;
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+	{
+		struct lttng_kernel_event_notifier *event_notifier =
+			container_of(event, struct lttng_kernel_event_notifier, parent);
+		struct lttng_kernel_bytecode_runtime *runtime;
+		int nr_captures = 0;
+
+		/* Enable captures */
+		list_for_each_entry(runtime, &event_notifier->priv->capture_bytecode_runtime_head, node) {
+			lttng_bytecode_sync_state(runtime);
+			nr_captures++;
+		}
+		WRITE_ONCE(event_notifier->eval_capture, !!nr_captures);
+		break;
+	}
+	default:
+		WARN_ON_ONCE(1);
+	}
+}
+
+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_event_recorder_enabler *event_enabler;
-	struct lttng_kernel_event_recorder_private *event_recorder_priv;
+	struct lttng_kernel_event_common_private *event_priv;
+	struct lttng_event_enabler_common *event_enabler;
 
-	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;
-		struct lttng_kernel_bytecode_runtime *runtime;
-		int enabled = 0, has_enablers_without_filter_bytecode = 0;
-		int nr_filters = 0;
+	list_for_each_entry(event_priv, event_list, node) {
+		struct lttng_kernel_event_common *event = event_priv->pub;
+		bool enabled;
 
-		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;
-
-		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);
+			register_event(event);
 		} else {
-			_lttng_event_unregister(&event_recorder->parent);
-		}
-
-		/* Check if has enablers without bytecode enabled */
-		list_for_each_entry(enabler_ref,
-				&event_recorder_priv->parent.enablers_ref_head, node) {
-			if (enabler_ref->ref->enabled
-					&& list_empty(&enabler_ref->ref->filter_bytecode_head)) {
-				has_enablers_without_filter_bytecode = 1;
-				break;
-			}
+			_lttng_event_unregister(event);
 		}
-		event_recorder_priv->parent.has_enablers_without_filter_bytecode =
-			has_enablers_without_filter_bytecode;
 
-		/* Enable filters */
-		list_for_each_entry(runtime,
-				&event_recorder_priv->parent.filter_bytecode_runtime_head, node) {
-			lttng_bytecode_sync_state(runtime);
-			nr_filters++;
-		}
-		WRITE_ONCE(event_recorder_priv->parent.pub->eval_filter,
-			!(has_enablers_without_filter_bytecode || !nr_filters));
+		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
@@ -2757,84 +2821,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_notifier_enabler *event_notifier_enabler;
-	struct lttng_kernel_event_notifier_private *event_notifier_priv;
-
-	list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node)
-		lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_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;
-		struct lttng_kernel_bytecode_runtime *runtime;
-		int enabled = 0, has_enablers_without_filter_bytecode = 0;
-		int nr_filters = 0, nr_captures = 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);
-		}
-
-		/* Check if has enablers without bytecode enabled */
-		list_for_each_entry(enabler_ref,
-				&event_notifier_priv->parent.enablers_ref_head, node) {
-			if (enabler_ref->ref->enabled
-					&& list_empty(&enabler_ref->ref->filter_bytecode_head)) {
-				has_enablers_without_filter_bytecode = 1;
-				break;
-			}
-		}
-		event_notifier_priv->parent.has_enablers_without_filter_bytecode =
-			has_enablers_without_filter_bytecode;
-
-		/* Enable filters */
-		list_for_each_entry(runtime,
-				&event_notifier_priv->parent.filter_bytecode_runtime_head, node) {
-			lttng_bytecode_sync_state(runtime);
-			nr_filters++;
-		}
-		WRITE_ONCE(event_notifier_priv->parent.pub->eval_filter,
-			!(has_enablers_without_filter_bytecode || !nr_filters));
-
-		/* Enable captures */
-		list_for_each_entry(runtime,
-				&event_notifier_priv->capture_bytecode_runtime_head, node) {
-			lttng_bytecode_sync_state(runtime);
-			nr_captures++;
-		}
-		WRITE_ONCE(event_notifier->eval_capture, !!nr_captures);
-	}
+	lttng_sync_event_list(&event_notifier_group->enablers_head, &event_notifier_group->event_notifiers_head);
 }
 
 static