X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=df834298a0dc24a624208da9eed020d66c1fc472;hb=31c02fb796462c07482101ab2845827f98df30d0;hp=0863484f5dd85a3f579198dcaceedb2546e1b4f5;hpb=b2bc0bc8dfef0380624d7d13764661a446cc809d;p=lttng-modules.git

diff --git a/src/lttng-events.c b/src/lttng-events.c
index 0863484f..df834298 100644
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -24,7 +24,6 @@
 #include <linux/file.h>
 #include <linux/anon_inodes.h>
 #include <wrapper/file.h>
-#include <linux/jhash.h>
 #include <linux/uaccess.h>
 #include <linux/vmalloc.h>
 #include <linux/dmi.h>
@@ -38,9 +37,11 @@
 #include <lttng/kernel-version.h>
 #include <lttng/events.h>
 #include <lttng/tracer.h>
+#include <lttng/event-notifier-notification.h>
 #include <lttng/abi-old.h>
 #include <lttng/endian.h>
 #include <lttng/string-utils.h>
+#include <lttng/utils.h>
 #include <ringbuffer/backend.h>
 #include <ringbuffer/frontend.h>
 #include <wrapper/time.h>
@@ -48,20 +49,25 @@
 #define METADATA_CACHE_DEFAULT_SIZE 4096
 
 static LIST_HEAD(sessions);
+static LIST_HEAD(event_notifier_groups);
 static LIST_HEAD(lttng_transport_list);
 /*
  * Protect the sessions and metadata caches.
  */
 static DEFINE_MUTEX(sessions_mutex);
 static struct kmem_cache *event_cache;
+static struct kmem_cache *event_notifier_cache;
 
 static void lttng_session_lazy_sync_event_enablers(struct lttng_session *session);
 static void lttng_session_sync_event_enablers(struct lttng_session *session);
 static void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler);
+static void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler);
 
 static void _lttng_event_destroy(struct lttng_event *event);
+static void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier);
 static void _lttng_channel_destroy(struct lttng_channel *chan);
 static int _lttng_event_unregister(struct lttng_event *event);
+static int _lttng_event_notifier_unregister(struct lttng_event_notifier *event_notifier);
 static
 int _lttng_event_metadata_statedump(struct lttng_session *session,
 				  struct lttng_channel *chan,
@@ -108,6 +114,17 @@ void lttng_unlock_sessions(void)
 	mutex_unlock(&sessions_mutex);
 }
 
+static struct lttng_transport *lttng_transport_find(const char *name)
+{
+	struct lttng_transport *transport;
+
+	list_for_each_entry(transport, &lttng_transport_list, node) {
+		if (!strcmp(transport->name, name))
+			return transport;
+	}
+	return NULL;
+}
+
 /*
  * Called with sessions lock held.
  */
@@ -178,6 +195,71 @@ err:
 	return NULL;
 }
 
+struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
+{
+	struct lttng_transport *transport = NULL;
+	struct lttng_event_notifier_group *event_notifier_group;
+	const char *transport_name = "relay-event-notifier";
+	size_t subbuf_size = 4096;	//TODO
+	size_t num_subbuf = 16;		//TODO
+	unsigned int switch_timer_interval = 0;
+	unsigned int read_timer_interval = 0;
+	int i;
+
+	mutex_lock(&sessions_mutex);
+
+	transport = lttng_transport_find(transport_name);
+	if (!transport) {
+		printk(KERN_WARNING "LTTng: transport %s not found\n",
+		       transport_name);
+		goto notransport;
+	}
+	if (!try_module_get(transport->owner)) {
+		printk(KERN_WARNING "LTTng: Can't lock transport %s module.\n",
+		       transport_name);
+		goto notransport;
+	}
+
+	event_notifier_group = lttng_kvzalloc(sizeof(struct lttng_event_notifier_group),
+				       GFP_KERNEL);
+	if (!event_notifier_group)
+		goto nomem;
+
+	/*
+	 * Initialize the ring buffer used to store event notifier
+	 * notifications.
+	 */
+	event_notifier_group->ops = &transport->ops;
+	event_notifier_group->chan = transport->ops.channel_create(
+			transport_name, event_notifier_group, NULL,
+			subbuf_size, num_subbuf, switch_timer_interval,
+			read_timer_interval);
+	if (!event_notifier_group->chan)
+		goto create_error;
+
+	event_notifier_group->transport = transport;
+
+	INIT_LIST_HEAD(&event_notifier_group->enablers_head);
+	INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
+	for (i = 0; i < LTTNG_EVENT_NOTIFIER_HT_SIZE; i++)
+		INIT_HLIST_HEAD(&event_notifier_group->event_notifiers_ht.table[i]);
+
+	list_add(&event_notifier_group->node, &event_notifier_groups);
+
+	mutex_unlock(&sessions_mutex);
+
+	return event_notifier_group;
+
+create_error:
+	lttng_kvfree(event_notifier_group);
+nomem:
+	if (transport)
+		module_put(transport->owner);
+notransport:
+	mutex_unlock(&sessions_mutex);
+	return NULL;
+}
+
 void metadata_cache_destroy(struct kref *kref)
 {
 	struct lttng_metadata_cache *cache =
@@ -234,6 +316,42 @@ void lttng_session_destroy(struct lttng_session *session)
 	lttng_kvfree(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_notifier *event_notifier, *tmpevent_notifier;
+	int ret;
+
+	if (!event_notifier_group)
+		return;
+
+	mutex_lock(&sessions_mutex);
+
+	list_for_each_entry_safe(event_notifier, tmpevent_notifier,
+			&event_notifier_group->event_notifiers_head, list) {
+		ret = _lttng_event_notifier_unregister(event_notifier);
+		WARN_ON(ret);
+	}
+
+	irq_work_sync(&event_notifier_group->wakeup_pending);
+
+	list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler,
+			&event_notifier_group->enablers_head, node)
+		lttng_event_notifier_enabler_destroy(event_notifier_enabler);
+
+	list_for_each_entry_safe(event_notifier, tmpevent_notifier,
+			&event_notifier_group->event_notifiers_head, list)
+		_lttng_event_notifier_destroy(event_notifier);
+
+	event_notifier_group->ops->channel_destroy(event_notifier_group->chan);
+	module_put(event_notifier_group->transport->owner);
+	list_del(&event_notifier_group->node);
+
+	mutex_unlock(&sessions_mutex);
+	lttng_kvfree(event_notifier_group);
+}
+
 int lttng_session_statedump(struct lttng_session *session)
 {
 	int ret;
@@ -479,15 +597,56 @@ end:
 	return ret;
 }
 
-static struct lttng_transport *lttng_transport_find(const char *name)
+int lttng_event_notifier_enable(struct lttng_event_notifier *event_notifier)
 {
-	struct lttng_transport *transport;
+	int ret = 0;
 
-	list_for_each_entry(transport, &lttng_transport_list, node) {
-		if (!strcmp(transport->name, name))
-			return transport;
+	mutex_lock(&sessions_mutex);
+	if (event_notifier->enabled) {
+		ret = -EEXIST;
+		goto end;
 	}
-	return NULL;
+	switch (event_notifier->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_SYSCALL:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_KRETPROBE:
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+	}
+end:
+	mutex_unlock(&sessions_mutex);
+	return ret;
+}
+
+int lttng_event_notifier_disable(struct lttng_event_notifier *event_notifier)
+{
+	int ret = 0;
+
+	mutex_lock(&sessions_mutex);
+	if (!event_notifier->enabled) {
+		ret = -EEXIST;
+		goto end;
+	}
+	switch (event_notifier->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_SYSCALL:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_KRETPROBE:
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+	}
+end:
+	mutex_unlock(&sessions_mutex);
+	return ret;
 }
 
 struct lttng_channel *lttng_channel_create(struct lttng_session *session,
@@ -596,8 +755,6 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 	struct lttng_event *event;
 	const char *event_name;
 	struct hlist_head *head;
-	size_t name_len;
-	uint32_t hash;
 	int ret;
 
 	if (chan->free_event_id == -1U) {
@@ -622,9 +779,9 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		ret = -EINVAL;
 		goto type_error;
 	}
-	name_len = strlen(event_name);
-	hash = jhash(event_name, name_len, 0);
-	head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
+
+	head = utils_borrow_hash_table_bucket(session->events_ht.table,
+		LTTNG_EVENT_HT_SIZE, event_name);
 	lttng_hlist_for_each_entry(event, head, hlist) {
 		WARN_ON_ONCE(!event->desc);
 		if (!strncmp(event->desc->name, event_name,
@@ -653,7 +810,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		/* Event will be enabled by enabler sync. */
 		event->enabled = 0;
 		event->registered = 0;
-		event->desc = lttng_event_get(event_name);
+		event->desc = lttng_event_desc_get(event_name);
 		if (!event->desc) {
 			ret = -ENOENT;
 			goto register_error;
@@ -823,6 +980,96 @@ full:
 	return ERR_PTR(ret);
 }
 
+struct lttng_event_notifier *_lttng_event_notifier_create(
+		const struct lttng_event_desc *event_desc,
+		uint64_t token, struct lttng_event_notifier_group *event_notifier_group,
+		struct lttng_kernel_event_notifier *event_notifier_param,
+		void *filter, enum lttng_kernel_instrumentation itype)
+{
+	struct lttng_event_notifier *event_notifier;
+	const char *event_name;
+	struct hlist_head *head;
+	int ret;
+
+	switch (itype) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_KRETPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_SYSCALL:
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+		goto type_error;
+	}
+
+	head = utils_borrow_hash_table_bucket(event_notifier_group->event_notifiers_ht.table,
+		LTTNG_EVENT_NOTIFIER_HT_SIZE, event_name);
+	lttng_hlist_for_each_entry(event_notifier, head, hlist) {
+		WARN_ON_ONCE(!event_notifier->desc);
+		if (!strncmp(event_notifier->desc->name, event_name,
+					LTTNG_KERNEL_SYM_NAME_LEN - 1)
+				&& event_notifier_group == event_notifier->group
+				&& token == event_notifier->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->group = event_notifier_group;
+	event_notifier->user_token = token;
+	event_notifier->filter = filter;
+	event_notifier->instrumentation = itype;
+	event_notifier->evtype = LTTNG_TYPE_EVENT;
+	event_notifier->send_notification = lttng_event_notifier_notification_send;
+	INIT_LIST_HEAD(&event_notifier->bytecode_runtime_head);
+	INIT_LIST_HEAD(&event_notifier->enablers_ref_head);
+
+	switch (itype) {
+	case LTTNG_KERNEL_TRACEPOINT:
+		/* Event will be enabled by enabler sync. */
+		event_notifier->enabled = 0;
+		event_notifier->registered = 0;
+		event_notifier->desc = lttng_event_desc_get(event_name);
+		if (!event_notifier->desc) {
+			ret = -ENOENT;
+			goto register_error;
+		}
+		/* Populate lttng_event_notifier structure before event registration. */
+		smp_wmb();
+		break;
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_KRETPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_SYSCALL:
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+		goto register_error;
+	}
+
+	list_add(&event_notifier->list, &event_notifier_group->event_notifiers_head);
+	hlist_add_head(&event_notifier->hlist, head);
+	return event_notifier;
+
+register_error:
+	kmem_cache_free(event_notifier_cache, event_notifier);
+cache_error:
+exist:
+type_error:
+	return ERR_PTR(ret);
+}
+
 struct lttng_event *lttng_event_create(struct lttng_channel *chan,
 				struct lttng_kernel_event *event_param,
 				void *filter,
@@ -838,6 +1085,21 @@ struct lttng_event *lttng_event_create(struct lttng_channel *chan,
 	return event;
 }
 
+struct lttng_event_notifier *lttng_event_notifier_create(
+		const struct lttng_event_desc *event_desc,
+		uint64_t id, struct lttng_event_notifier_group *event_notifier_group,
+		struct lttng_kernel_event_notifier *event_notifier_param,
+		void *filter, enum lttng_kernel_instrumentation itype)
+{
+	struct lttng_event_notifier *event_notifier;
+
+	mutex_lock(&sessions_mutex);
+	event_notifier = _lttng_event_notifier_create(event_desc, id,
+		event_notifier_group, event_notifier_param, filter, itype);
+	mutex_unlock(&sessions_mutex);
+	return event_notifier;
+}
+
 /* Only used for tracepoints for now. */
 static
 void register_event(struct lttng_event *event)
@@ -917,6 +1179,60 @@ int _lttng_event_unregister(struct lttng_event *event)
 	return ret;
 }
 
+/* Only used for tracepoints for now. */
+static
+void __always_unused register_event_notifier(
+		struct lttng_event_notifier *event_notifier)
+{
+	const struct lttng_event_desc *desc;
+	int ret = -EINVAL;
+
+	if (event_notifier->registered)
+		return;
+
+	desc = event_notifier->desc;
+	switch (event_notifier->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_SYSCALL:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_KRETPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_NOOP:
+	default:
+		WARN_ON_ONCE(1);
+	}
+	if (!ret)
+		event_notifier->registered = 1;
+}
+
+static
+int _lttng_event_notifier_unregister(
+		struct lttng_event_notifier *event_notifier)
+{
+	const struct lttng_event_desc *desc;
+	int ret = -EINVAL;
+
+	if (!event_notifier->registered)
+		return 0;
+
+	desc = event_notifier->desc;
+	switch (event_notifier->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_KRETPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_SYSCALL:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_UPROBE:
+	default:
+		WARN_ON_ONCE(1);
+	}
+	if (!ret)
+		event_notifier->registered = 0;
+	return ret;
+}
+
 /*
  * Only used internally at session destruction.
  */
@@ -925,7 +1241,7 @@ void _lttng_event_destroy(struct lttng_event *event)
 {
 	switch (event->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		lttng_event_put(event->desc);
+		lttng_event_desc_put(event->desc);
 		break;
 	case LTTNG_KERNEL_KPROBE:
 		module_put(event->desc->owner);
@@ -951,6 +1267,27 @@ void _lttng_event_destroy(struct lttng_event *event)
 	kmem_cache_free(event_cache, event);
 }
 
+/*
+ * Only used internally at session destruction.
+ */
+static
+void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier)
+{
+	switch (event_notifier->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_KRETPROBE:
+	case LTTNG_KERNEL_FUNCTION:
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_SYSCALL:
+	case LTTNG_KERNEL_UPROBE:
+	default:
+		WARN_ON_ONCE(1);
+	}
+	list_del(&event_notifier->list);
+	kmem_cache_free(event_notifier_cache, event_notifier);
+}
+
 struct lttng_id_tracker *get_tracker(struct lttng_session *session,
 		enum tracker_type tracker_type)
 {
@@ -1345,7 +1682,7 @@ struct lttng_enabler_ref *lttng_enabler_ref(
 }
 
 static
-void lttng_create_tracepoint_if_missing(struct lttng_event_enabler *event_enabler)
+void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_enabler)
 {
 	struct lttng_session *session = event_enabler->chan->session;
 	struct lttng_probe_desc *probe_desc;
@@ -1363,23 +1700,19 @@ void lttng_create_tracepoint_if_missing(struct lttng_event_enabler *event_enable
 		for (i = 0; i < probe_desc->nr_events; i++) {
 			int found = 0;
 			struct hlist_head *head;
-			const char *event_name;
-			size_t name_len;
-			uint32_t hash;
 			struct lttng_event *event;
 
 			desc = probe_desc->event_desc[i];
 			if (!lttng_desc_match_enabler(desc,
 					lttng_event_enabler_as_enabler(event_enabler)))
 				continue;
-			event_name = desc->name;
-			name_len = strlen(event_name);
 
 			/*
 			 * Check if already created.
 			 */
-			hash = jhash(event_name, name_len, 0);
-			head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
+			head = utils_borrow_hash_table_bucket(
+				session->events_ht.table, LTTNG_EVENT_HT_SIZE,
+				desc->name);
 			lttng_hlist_for_each_entry(event, head, hlist) {
 				if (event->desc == desc
 						&& event->chan == event_enabler->chan)
@@ -1404,7 +1737,7 @@ void lttng_create_tracepoint_if_missing(struct lttng_event_enabler *event_enable
 }
 
 static
-void lttng_create_syscall_if_missing(struct lttng_event_enabler *event_enabler)
+void lttng_create_syscall_event_if_missing(struct lttng_event_enabler *event_enabler)
 {
 	int ret;
 
@@ -1422,10 +1755,10 @@ void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
 {
 	switch (event_enabler->base.event_param.instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
-		lttng_create_tracepoint_if_missing(event_enabler);
+		lttng_create_tracepoint_event_if_missing(event_enabler);
 		break;
 	case LTTNG_KERNEL_SYSCALL:
-		lttng_create_syscall_if_missing(event_enabler);
+		lttng_create_syscall_event_if_missing(event_enabler);
 		break;
 	default:
 		WARN_ON_ONCE(1);
@@ -1484,7 +1817,10 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
 		/*
 		 * Link filter bytecodes if not linked yet.
 		 */
-		lttng_event_enabler_link_bytecode(event, event_enabler);
+		lttng_enabler_link_bytecode(event->desc,
+			lttng_static_ctx,
+			&event->bytecode_runtime_head,
+			lttng_event_enabler_as_enabler(event_enabler));
 
 		/* TODO: merge event context. */
 	}
@@ -1638,6 +1974,94 @@ void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
 	kfree(event_enabler);
 }
 
+struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
+		struct lttng_event_notifier_group *event_notifier_group,
+		enum lttng_enabler_format_type format_type,
+		struct lttng_kernel_event_notifier *event_notifier_param)
+{
+	struct lttng_event_notifier_enabler *event_notifier_enabler;
+
+	event_notifier_enabler = kzalloc(sizeof(*event_notifier_enabler), GFP_KERNEL);
+	if (!event_notifier_enabler)
+		return NULL;
+
+	event_notifier_enabler->base.format_type = format_type;
+	INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head);
+
+	memcpy(&event_notifier_enabler->base.event_param.name, event_notifier_param->event.name,
+		sizeof(event_notifier_enabler->base.event_param.name));
+	event_notifier_enabler->base.event_param.instrumentation = event_notifier_param->event.instrumentation;
+	event_notifier_enabler->base.evtype = LTTNG_TYPE_ENABLER;
+
+	event_notifier_enabler->base.enabled = 0;
+	event_notifier_enabler->base.user_token = event_notifier_param->event.token;
+	event_notifier_enabler->group = event_notifier_group;
+
+	mutex_lock(&sessions_mutex);
+	list_add(&event_notifier_enabler->node, &event_notifier_enabler->group->enablers_head);
+
+	mutex_unlock(&sessions_mutex);
+
+	return event_notifier_enabler;
+}
+
+int lttng_event_notifier_enabler_enable(
+		struct lttng_event_notifier_enabler *event_notifier_enabler)
+{
+	mutex_lock(&sessions_mutex);
+	lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1;
+	mutex_unlock(&sessions_mutex);
+	return 0;
+}
+
+int lttng_event_notifier_enabler_disable(
+		struct lttng_event_notifier_enabler *event_notifier_enabler)
+{
+	mutex_lock(&sessions_mutex);
+	lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0;
+	mutex_unlock(&sessions_mutex);
+	return 0;
+}
+
+int lttng_event_notifier_enabler_attach_bytecode(
+		struct lttng_event_notifier_enabler *event_notifier_enabler,
+		struct lttng_kernel_filter_bytecode __user *bytecode)
+{
+	int ret;
+
+	ret = lttng_enabler_attach_bytecode(
+		lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
+		bytecode);
+	if (ret)
+		goto error;
+
+	return 0;
+
+error:
+	return ret;
+}
+
+int lttng_event_notifier_enabler_attach_context(
+		struct lttng_event_notifier_enabler *event_notifier_enabler,
+		struct lttng_kernel_context *context_param)
+{
+	return -ENOSYS;
+}
+
+static
+void lttng_event_notifier_enabler_destroy(
+		struct lttng_event_notifier_enabler *event_notifier_enabler)
+{
+	if (!event_notifier_enabler) {
+		return;
+	}
+
+	list_del(&event_notifier_enabler->node);
+
+	lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
+	kfree(event_notifier_enabler);
+}
+
 /*
  * lttng_session_sync_event_enablers should be called just before starting a
  * session.
@@ -3133,7 +3557,12 @@ static int __init lttng_events_init(void)
 	event_cache = KMEM_CACHE(lttng_event, 0);
 	if (!event_cache) {
 		ret = -ENOMEM;
-		goto error_kmem;
+		goto error_kmem_event;
+	}
+	event_notifier_cache = KMEM_CACHE(lttng_event_notifier, 0);
+	if (!event_notifier_cache) {
+		ret = -ENOMEM;
+		goto error_kmem_event_notifier;
 	}
 	ret = lttng_abi_init();
 	if (ret)
@@ -3167,8 +3596,10 @@ error_hotplug:
 error_logger:
 	lttng_abi_exit();
 error_abi:
+	kmem_cache_destroy(event_notifier_cache);
+error_kmem_event_notifier:
 	kmem_cache_destroy(event_cache);
-error_kmem:
+error_kmem_event:
 	lttng_tracepoint_exit();
 error_tp:
 	lttng_context_exit();
@@ -3203,6 +3634,7 @@ static void __exit lttng_events_exit(void)
 	list_for_each_entry_safe(session, tmpsession, &sessions, list)
 		lttng_session_destroy(session);
 	kmem_cache_destroy(event_cache);
+	kmem_cache_destroy(event_notifier_cache);
 	lttng_tracepoint_exit();
 	lttng_context_exit();
 	printk(KERN_NOTICE "LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",