X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=828cb18460477a2f13f5fc724abe2669c3ed96ba;hb=51d248b5aae42e872ba2b8eac38df6cae381c078;hp=795286329690b9a3866852b8faa4225c626e7362;hpb=a0c6ad2e91bfd5feaa5d6e2ef2a9dff83b0db43c;p=lttng-modules.git

diff --git a/src/lttng-events.c b/src/lttng-events.c
index 79528632..828cb184 100644
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -73,9 +73,7 @@ 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
-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
@@ -866,6 +864,198 @@ 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.
@@ -876,17 +1066,17 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 				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 list_head *event_list_head = lttng_get_event_list_head_from_enabler(&event_enabler->parent);
 	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 *event_recorder;
 	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->parent)) {
 		ret = -EMFILE;
 		goto full;
 	}
@@ -918,47 +1108,26 @@ 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->parent, event_name, event_priv->pub)) {
 			ret = -EEXIST;
 			goto exist;
 		}
 	}
 
-	event_recorder = kmem_cache_zalloc(event_recorder_cache, GFP_KERNEL);
-	if (!event_recorder) {
-		ret = -ENOMEM;
-		goto cache_error;
-	}
-	event_recorder_priv = kmem_cache_zalloc(event_recorder_private_cache, GFP_KERNEL);
-	if (!event_recorder_priv) {
+	event = lttng_kernel_event_alloc(&event_enabler->parent);
+	if (!event) {
 		ret = -ENOMEM;
-		goto cache_private_error;
+		goto alloc_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;
 		}
@@ -971,8 +1140,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 +1151,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->parent);
+		if (!event) {
 			ret = -ENOMEM;
-			goto register_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;
+			goto alloc_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,29 +1189,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_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);
+			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, event_list_head);
 		break;
 	}
 
@@ -1068,18 +1217,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) {
@@ -1087,13 +1236,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;
 		}
@@ -1104,8 +1253,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
@@ -1115,10 +1264,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;
 
@@ -1131,22 +1280,20 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 		ret = -EINVAL;
 		goto register_error;
 	}
-	ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder);
+	ret = _lttng_event_recorder_metadata_statedump(event);
 	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);
+	hlist_add_head(&event->priv->hlist_node, head);
+	list_add(&event->priv->node, event_list_head);
 	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:
@@ -1158,14 +1305,12 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 		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 list_head *event_list_head = lttng_get_event_list_head_from_enabler(&event_enabler->parent);
 	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;
+	struct lttng_kernel_event_common *event;
+	struct lttng_kernel_event_notifier *event_notifier;
 	const char *event_name;
 	struct hlist_head *head;
 	int ret;
@@ -1197,52 +1342,26 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_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_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) {
+		if (lttng_event_enabler_event_name_match_event(&event_enabler->parent, event_name, event_priv->pub)) {
 			ret = -EEXIST;
 			goto exist;
 		}
 	}
 
-	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;
 		}
@@ -1255,8 +1374,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.
@@ -1266,12 +1385,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;
 
@@ -1280,18 +1399,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) {
@@ -1299,14 +1418,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;
 		}
@@ -1317,8 +1436,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
@@ -1328,10 +1447,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;
 
@@ -1347,45 +1466,17 @@ 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);
-
-	/*
-	 * 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];
-
-		/*
-		 * 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;
-		}
-
-		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;
-		}
-	}
+	list_add(&event->priv->node, event_list_head);
+	hlist_add_head(&event->priv->hlist_node, head);
 
+	ret = lttng_kernel_event_notifier_clear_error_counter(event);
+	if (ret)
+		goto register_error;
 	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);
@@ -2127,6 +2218,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,
@@ -3569,12 +3701,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)
@@ -4029,8 +4168,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;
 	}