X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=lttng-events.c;h=49a181b6a5d09aba4c5279ae8fb73c59d5f25049;hp=c213b719fa4802876a6605c43829d0ccaf0736fb;hb=263b6c88138c3354d63dba3c70a965de94becd22;hpb=5b3cf4f924befda843a7736daf84f8ecae5e86a4

diff --git a/lttng-events.c b/lttng-events.c
index c213b719..49a181b6 100644
--- a/lttng-events.c
+++ b/lttng-events.c
@@ -1,23 +1,10 @@
-/*
+/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
+ *
  * lttng-events.c
  *
  * Holds LTTng per-session event registry.
  *
  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*
@@ -36,20 +23,27 @@
 #include <linux/seq_file.h>
 #include <linux/file.h>
 #include <linux/anon_inodes.h>
-#include "wrapper/file.h"
+#include <wrapper/file.h>
 #include <linux/jhash.h>
 #include <linux/uaccess.h>
 #include <linux/vmalloc.h>
-
-#include "wrapper/uuid.h"
-#include "wrapper/vmalloc.h"	/* for wrapper_vmalloc_sync_all() */
-#include "wrapper/random.h"
-#include "wrapper/tracepoint.h"
-#include "wrapper/list.h"
-#include "lttng-kernel-version.h"
-#include "lttng-events.h"
-#include "lttng-tracer.h"
-#include "lttng-abi-old.h"
+#include <linux/dmi.h>
+
+#include <wrapper/uuid.h>
+#include <wrapper/vmalloc.h>	/* for wrapper_vmalloc_sync_mappings() */
+#include <wrapper/random.h>
+#include <wrapper/tracepoint.h>
+#include <wrapper/list.h>
+#include <wrapper/types.h>
+#include <lttng-kernel-version.h>
+#include <lttng-events.h>
+#include <lttng-tracer.h>
+#include <lttng-abi-old.h>
+#include <lttng-endian.h>
+#include <lttng-string-utils.h>
+#include <wrapper/ringbuffer/backend.h>
+#include <wrapper/ringbuffer/frontend.h>
+#include <wrapper/time.h>
 
 #define METADATA_CACHE_DEFAULT_SIZE 4096
 
@@ -76,10 +70,23 @@ static
 int _lttng_session_metadata_statedump(struct lttng_session *session);
 static
 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream);
+static
+int _lttng_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting);
+static
+int _lttng_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting);
 
 void synchronize_trace(void)
 {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
+	synchronize_rcu();
+#else
 	synchronize_sched();
+#endif
+
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
 #ifdef CONFIG_PREEMPT_RT_FULL
 	synchronize_rcu();
@@ -122,12 +129,12 @@ struct lttng_session *lttng_session_create(void)
 	int i;
 
 	mutex_lock(&sessions_mutex);
-	session = kzalloc(sizeof(struct lttng_session), GFP_KERNEL);
+	session = lttng_kvzalloc(sizeof(struct lttng_session), GFP_KERNEL);
 	if (!session)
 		goto err;
 	INIT_LIST_HEAD(&session->chan);
 	INIT_LIST_HEAD(&session->events);
-	uuid_le_gen(&session->uuid);
+	lttng_guid_gen(&session->uuid);
 
 	metadata_cache = kzalloc(sizeof(struct lttng_metadata_cache),
 			GFP_KERNEL);
@@ -147,13 +154,25 @@ struct lttng_session *lttng_session_create(void)
 	for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
 		INIT_HLIST_HEAD(&session->events_ht.table[i]);
 	list_add(&session->list, &sessions);
+	session->pid_tracker.session = session;
+	session->pid_tracker.tracker_type = TRACKER_PID;
+	session->vpid_tracker.session = session;
+	session->vpid_tracker.tracker_type = TRACKER_VPID;
+	session->uid_tracker.session = session;
+	session->uid_tracker.tracker_type = TRACKER_UID;
+	session->vuid_tracker.session = session;
+	session->vuid_tracker.tracker_type = TRACKER_VUID;
+	session->gid_tracker.session = session;
+	session->gid_tracker.tracker_type = TRACKER_GID;
+	session->vgid_tracker.session = session;
+	session->vgid_tracker.tracker_type = TRACKER_VGID;
 	mutex_unlock(&sessions_mutex);
 	return session;
 
 err_free_cache:
 	kfree(metadata_cache);
 err_free_session:
-	kfree(session);
+	lttng_kvfree(session);
 err:
 	mutex_unlock(&sessions_mutex);
 	return NULL;
@@ -176,7 +195,7 @@ void lttng_session_destroy(struct lttng_session *session)
 	int ret;
 
 	mutex_lock(&sessions_mutex);
-	ACCESS_ONCE(session->active) = 0;
+	WRITE_ONCE(session->active, 0);
 	list_for_each_entry(chan, &session->chan, list) {
 		ret = lttng_syscalls_unregister(chan);
 		WARN_ON(ret);
@@ -197,12 +216,26 @@ void lttng_session_destroy(struct lttng_session *session)
 	}
 	list_for_each_entry(metadata_stream, &session->metadata_cache->metadata_stream, list)
 		_lttng_metadata_channel_hangup(metadata_stream);
-	if (session->pid_tracker)
-		lttng_pid_tracker_destroy(session->pid_tracker);
+	lttng_id_tracker_destroy(&session->pid_tracker, false);
+	lttng_id_tracker_destroy(&session->vpid_tracker, false);
+	lttng_id_tracker_destroy(&session->uid_tracker, false);
+	lttng_id_tracker_destroy(&session->vuid_tracker, false);
+	lttng_id_tracker_destroy(&session->gid_tracker, false);
+	lttng_id_tracker_destroy(&session->vgid_tracker, false);
 	kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
 	list_del(&session->list);
 	mutex_unlock(&sessions_mutex);
-	kfree(session);
+	lttng_kvfree(session);
+}
+
+int lttng_session_statedump(struct lttng_session *session)
+{
+	int ret;
+
+	mutex_lock(&sessions_mutex);
+	ret = lttng_statedump_start(session);
+	mutex_unlock(&sessions_mutex);
+	return ret;
 }
 
 int lttng_session_enable(struct lttng_session *session)
@@ -219,6 +252,9 @@ int lttng_session_enable(struct lttng_session *session)
 	/* Set transient enabler state to "enabled" */
 	session->tstate = 1;
 
+	/* We need to sync enablers with session before activation. */
+	lttng_session_sync_enablers(session);
+
 	/*
 	 * Snapshot the number of events per channel to know the type of header
 	 * we need to use.
@@ -232,19 +268,22 @@ int lttng_session_enable(struct lttng_session *session)
 			chan->header_type = 2;	/* large */
 	}
 
-	/* We need to sync enablers with session before activation. */
-	lttng_session_sync_enablers(session);
+	/* Clear each stream's quiescent state. */
+	list_for_each_entry(chan, &session->chan, list) {
+		if (chan->channel_type != METADATA_CHANNEL)
+			lib_ring_buffer_clear_quiescent_channel(chan->chan);
+	}
 
-	ACCESS_ONCE(session->active) = 1;
-	ACCESS_ONCE(session->been_active) = 1;
+	WRITE_ONCE(session->active, 1);
+	WRITE_ONCE(session->been_active, 1);
 	ret = _lttng_session_metadata_statedump(session);
 	if (ret) {
-		ACCESS_ONCE(session->active) = 0;
+		WRITE_ONCE(session->active, 0);
 		goto end;
 	}
 	ret = lttng_statedump_start(session);
 	if (ret)
-		ACCESS_ONCE(session->active) = 0;
+		WRITE_ONCE(session->active, 0);
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -253,17 +292,64 @@ end:
 int lttng_session_disable(struct lttng_session *session)
 {
 	int ret = 0;
+	struct lttng_channel *chan;
 
 	mutex_lock(&sessions_mutex);
 	if (!session->active) {
 		ret = -EBUSY;
 		goto end;
 	}
-	ACCESS_ONCE(session->active) = 0;
+	WRITE_ONCE(session->active, 0);
 
 	/* Set transient enabler state to "disabled" */
 	session->tstate = 0;
 	lttng_session_sync_enablers(session);
+
+	/* Set each stream's quiescent state. */
+	list_for_each_entry(chan, &session->chan, list) {
+		if (chan->channel_type != METADATA_CHANNEL)
+			lib_ring_buffer_set_quiescent_channel(chan->chan);
+	}
+end:
+	mutex_unlock(&sessions_mutex);
+	return ret;
+}
+
+int lttng_session_metadata_regenerate(struct lttng_session *session)
+{
+	int ret = 0;
+	struct lttng_channel *chan;
+	struct lttng_event *event;
+	struct lttng_metadata_cache *cache = session->metadata_cache;
+	struct lttng_metadata_stream *stream;
+
+	mutex_lock(&sessions_mutex);
+	if (!session->active) {
+		ret = -EBUSY;
+		goto end;
+	}
+
+	mutex_lock(&cache->lock);
+	memset(cache->data, 0, cache->cache_alloc);
+	cache->metadata_written = 0;
+	cache->version++;
+	list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list) {
+		stream->metadata_out = 0;
+		stream->metadata_in = 0;
+	}
+	mutex_unlock(&cache->lock);
+
+	session->metadata_dumped = 0;
+	list_for_each_entry(chan, &session->chan, list) {
+		chan->metadata_dumped = 0;
+	}
+
+	list_for_each_entry(event, &session->events, list) {
+		event->metadata_dumped = 0;
+	}
+
+	ret = _lttng_session_metadata_statedump(session);
+
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -286,7 +372,7 @@ int lttng_channel_enable(struct lttng_channel *channel)
 	channel->tstate = 1;
 	lttng_session_sync_enablers(channel->session);
 	/* Set atomically the state to "enabled" */
-	ACCESS_ONCE(channel->enabled) = 1;
+	WRITE_ONCE(channel->enabled, 1);
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -306,7 +392,7 @@ int lttng_channel_disable(struct lttng_channel *channel)
 		goto end;
 	}
 	/* Set atomically the state to "disabled" */
-	ACCESS_ONCE(channel->enabled) = 0;
+	WRITE_ONCE(channel->enabled, 0);
 	/* Set transient enabler state to "enabled" */
 	channel->tstate = 0;
 	lttng_session_sync_enablers(channel->session);
@@ -328,8 +414,24 @@ int lttng_event_enable(struct lttng_event *event)
 		ret = -EEXIST;
 		goto end;
 	}
-	ACCESS_ONCE(event->enabled) = 1;
-	lttng_session_sync_enablers(event->chan->session);
+	switch (event->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_SYSCALL:
+		ret = -EINVAL;
+		break;
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_NOOP:
+		WRITE_ONCE(event->enabled, 1);
+		break;
+	case LTTNG_KERNEL_KRETPROBE:
+		ret = lttng_kretprobes_event_enable_state(event, 1);
+		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+	}
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -348,8 +450,24 @@ int lttng_event_disable(struct lttng_event *event)
 		ret = -EEXIST;
 		goto end;
 	}
-	ACCESS_ONCE(event->enabled) = 0;
-	lttng_session_sync_enablers(event->chan->session);
+	switch (event->instrumentation) {
+	case LTTNG_KERNEL_TRACEPOINT:
+	case LTTNG_KERNEL_SYSCALL:
+		ret = -EINVAL;
+		break;
+	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
+	case LTTNG_KERNEL_NOOP:
+		WRITE_ONCE(event->enabled, 0);
+		break;
+	case LTTNG_KERNEL_KRETPROBE:
+		ret = lttng_kretprobes_event_enable_state(event, 0);
+		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
+	default:
+		WARN_ON_ONCE(1);
+		ret = -EINVAL;
+	}
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -486,12 +604,13 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		event_name = event_desc->name;
 		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:
 		event_name = event_param->name;
 		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through. */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -537,7 +656,11 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		smp_wmb();
 		break;
 	case LTTNG_KERNEL_KPROBE:
-		event->enabled = 1;
+		/*
+		 * Needs to be explicitly enabled after creation, since
+		 * we may want to apply filters.
+		 */
+		event->enabled = 0;
 		event->registered = 1;
 		/*
 		 * Populate lttng_event structure before event
@@ -561,7 +684,11 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		struct lttng_event *event_return;
 
 		/* kretprobe defines 2 events */
-		event->enabled = 1;
+		/*
+		 * Needs to be explicitly enabled after creation, since
+		 * we may want to apply filters.
+		 */
+		event->enabled = 0;
 		event->registered = 1;
 		event_return =
 			kmem_cache_zalloc(event_cache, GFP_KERNEL);
@@ -572,7 +699,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		event_return->chan = chan;
 		event_return->filter = filter;
 		event_return->id = chan->free_event_id++;
-		event_return->enabled = 1;
+		event_return->enabled = 0;
 		event_return->registered = 1;
 		event_return->instrumentation = itype;
 		/*
@@ -606,33 +733,43 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		list_add(&event_return->list, &chan->session->events);
 		break;
 	}
-	case LTTNG_KERNEL_FUNCTION:
-		event->enabled = 1;
+	case LTTNG_KERNEL_NOOP:
+	case LTTNG_KERNEL_SYSCALL:
+		/*
+		 * Needs to be explicitly enabled after creation, since
+		 * we may want to apply filters.
+		 */
+		event->enabled = 0;
+		event->registered = 0;
+		event->desc = event_desc;
+		if (!event->desc) {
+			ret = -EINVAL;
+			goto register_error;
+		}
+		break;
+	case LTTNG_KERNEL_UPROBE:
+		/*
+		 * Needs to be explicitly enabled after creation, since
+		 * we may want to apply filters.
+		 */
+		event->enabled = 0;
 		event->registered = 1;
+
 		/*
 		 * Populate lttng_event structure before event
 		 * registration.
 		 */
 		smp_wmb();
-		ret = lttng_ftrace_register(event_name,
-				event_param->u.ftrace.symbol_name,
+
+		ret = lttng_uprobes_register(event_param->name,
+				event_param->u.uprobe.fd,
 				event);
-		if (ret) {
+		if (ret)
 			goto register_error;
-		}
 		ret = try_module_get(event->desc->owner);
 		WARN_ON_ONCE(!ret);
 		break;
-	case LTTNG_KERNEL_NOOP:
-	case LTTNG_KERNEL_SYSCALL:
-		event->enabled = 1;
-		event->registered = 0;
-		event->desc = event_desc;
-		if (!event->desc) {
-			ret = -EINVAL;
-			goto register_error;
-		}
-		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 		ret = -EINVAL;
@@ -695,11 +832,12 @@ void register_event(struct lttng_event *event)
 			desc->name);
 		break;
 	case LTTNG_KERNEL_KPROBE:
+	case LTTNG_KERNEL_UPROBE:
 	case LTTNG_KERNEL_KRETPROBE:
-	case LTTNG_KERNEL_FUNCTION:
 	case LTTNG_KERNEL_NOOP:
 		ret = 0;
 		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -733,10 +871,6 @@ int _lttng_event_unregister(struct lttng_event *event)
 		lttng_kretprobes_unregister(event);
 		ret = 0;
 		break;
-	case LTTNG_KERNEL_FUNCTION:
-		lttng_ftrace_unregister(event);
-		ret = 0;
-		break;
 	case LTTNG_KERNEL_SYSCALL:
 		ret = lttng_syscall_filter_disable(event->chan,
 			desc->name);
@@ -744,6 +878,11 @@ int _lttng_event_unregister(struct lttng_event *event)
 	case LTTNG_KERNEL_NOOP:
 		ret = 0;
 		break;
+	case LTTNG_KERNEL_UPROBE:
+		lttng_uprobes_unregister(event);
+		ret = 0;
+		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -770,13 +909,14 @@ void _lttng_event_destroy(struct lttng_event *event)
 		module_put(event->desc->owner);
 		lttng_kretprobes_destroy_private(event);
 		break;
-	case LTTNG_KERNEL_FUNCTION:
-		module_put(event->desc->owner);
-		lttng_ftrace_destroy_private(event);
-		break;
 	case LTTNG_KERNEL_NOOP:
 	case LTTNG_KERNEL_SYSCALL:
 		break;
+	case LTTNG_KERNEL_UPROBE:
+		module_put(event->desc->owner);
+		lttng_uprobes_destroy_private(event);
+		break;
+	case LTTNG_KERNEL_FUNCTION:	/* Fall-through */
 	default:
 		WARN_ON_ONCE(1);
 	}
@@ -785,91 +925,85 @@ void _lttng_event_destroy(struct lttng_event *event)
 	kmem_cache_free(event_cache, event);
 }
 
-int lttng_session_track_pid(struct lttng_session *session, int pid)
+struct lttng_id_tracker *get_tracker(struct lttng_session *session,
+		enum tracker_type tracker_type)
+{
+	switch (tracker_type) {
+	case TRACKER_PID:
+		return &session->pid_tracker;
+	case TRACKER_VPID:
+		return &session->vpid_tracker;
+	case TRACKER_UID:
+		return &session->uid_tracker;
+	case TRACKER_VUID:
+		return &session->vuid_tracker;
+	case TRACKER_GID:
+		return &session->gid_tracker;
+	case TRACKER_VGID:
+		return &session->vgid_tracker;
+	default:
+		WARN_ON_ONCE(1);
+		return NULL;
+	}
+}
+
+int lttng_session_track_id(struct lttng_session *session,
+		enum tracker_type tracker_type, int id)
 {
+	struct lttng_id_tracker *tracker;
 	int ret;
 
-	if (pid < -1)
+	tracker = get_tracker(session, tracker_type);
+	if (!tracker)
+		return -EINVAL;
+	if (id < -1)
 		return -EINVAL;
 	mutex_lock(&sessions_mutex);
-	if (pid == -1) {
-		/* track all pids: destroy tracker. */
-		if (session->pid_tracker) {
-			struct lttng_pid_tracker *lpf;
-
-			lpf = session->pid_tracker;
-			rcu_assign_pointer(session->pid_tracker, NULL);
-			synchronize_trace();
-			lttng_pid_tracker_destroy(lpf);
-		}
+	if (id == -1) {
+		/* track all ids: destroy tracker. */
+		lttng_id_tracker_destroy(tracker, true);
 		ret = 0;
 	} else {
-		if (!session->pid_tracker) {
-			struct lttng_pid_tracker *lpf;
-
-			lpf = lttng_pid_tracker_create();
-			if (!lpf) {
-				ret = -ENOMEM;
-				goto unlock;
-			}
-			ret = lttng_pid_tracker_add(lpf, pid);
-			rcu_assign_pointer(session->pid_tracker, lpf);
-		} else {
-			ret = lttng_pid_tracker_add(session->pid_tracker, pid);
-		}
+		ret = lttng_id_tracker_add(tracker, id);
 	}
-unlock:
 	mutex_unlock(&sessions_mutex);
 	return ret;
 }
 
-int lttng_session_untrack_pid(struct lttng_session *session, int pid)
+int lttng_session_untrack_id(struct lttng_session *session,
+		enum tracker_type tracker_type, int id)
 {
+	struct lttng_id_tracker *tracker;
 	int ret;
 
-	if (pid < -1)
+	tracker = get_tracker(session, tracker_type);
+	if (!tracker)
+		return -EINVAL;
+	if (id < -1)
 		return -EINVAL;
 	mutex_lock(&sessions_mutex);
-	if (pid == -1) {
-		/* untrack all pids: replace by empty tracker. */
-		struct lttng_pid_tracker *old_lpf = session->pid_tracker;
-		struct lttng_pid_tracker *lpf;
-
-		lpf = lttng_pid_tracker_create();
-		if (!lpf) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-		rcu_assign_pointer(session->pid_tracker, lpf);
-		synchronize_trace();
-		if (old_lpf)
-			lttng_pid_tracker_destroy(old_lpf);
-		ret = 0;
+	if (id == -1) {
+		/* untrack all ids: replace by empty tracker. */
+		ret = lttng_id_tracker_empty_set(tracker);
 	} else {
-		if (!session->pid_tracker) {
-			ret = -ENOENT;
-			goto unlock;
-		}
-		ret = lttng_pid_tracker_del(session->pid_tracker, pid);
+		ret = lttng_id_tracker_del(tracker, id);
 	}
-unlock:
 	mutex_unlock(&sessions_mutex);
 	return ret;
 }
 
 static
-void *pid_list_start(struct seq_file *m, loff_t *pos)
+void *id_list_start(struct seq_file *m, loff_t *pos)
 {
-	struct lttng_session *session = m->private;
-	struct lttng_pid_tracker *lpf;
-	struct lttng_pid_hash_node *e;
+	struct lttng_id_tracker *id_tracker = m->private;
+	struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
+	struct lttng_id_hash_node *e;
 	int iter = 0, i;
 
 	mutex_lock(&sessions_mutex);
-	lpf = session->pid_tracker;
-	if (lpf) {
-		for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) {
-			struct hlist_head *head = &lpf->pid_hash[i];
+	if (id_tracker_p) {
+		for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
+			struct hlist_head *head = &id_tracker_p->id_hash[i];
 
 			lttng_hlist_for_each_entry(e, head, hlist) {
 				if (iter++ >= *pos)
@@ -877,9 +1011,9 @@ void *pid_list_start(struct seq_file *m, loff_t *pos)
 			}
 		}
 	} else {
-		/* PID tracker disabled. */
+		/* ID tracker disabled. */
 		if (iter >= *pos && iter == 0) {
-			return session;	/* empty tracker */
+			return id_tracker_p;	/* empty tracker */
 		}
 		iter++;
 	}
@@ -889,18 +1023,17 @@ void *pid_list_start(struct seq_file *m, loff_t *pos)
 
 /* Called with sessions_mutex held. */
 static
-void *pid_list_next(struct seq_file *m, void *p, loff_t *ppos)
+void *id_list_next(struct seq_file *m, void *p, loff_t *ppos)
 {
-	struct lttng_session *session = m->private;
-	struct lttng_pid_tracker *lpf;
-	struct lttng_pid_hash_node *e;
+	struct lttng_id_tracker *id_tracker = m->private;
+	struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
+	struct lttng_id_hash_node *e;
 	int iter = 0, i;
 
 	(*ppos)++;
-	lpf = session->pid_tracker;
-	if (lpf) {
-		for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) {
-			struct hlist_head *head = &lpf->pid_hash[i];
+	if (id_tracker_p) {
+		for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
+			struct hlist_head *head = &id_tracker_p->id_hash[i];
 
 			lttng_hlist_for_each_entry(e, head, hlist) {
 				if (iter++ >= *ppos)
@@ -908,9 +1041,9 @@ void *pid_list_next(struct seq_file *m, void *p, loff_t *ppos)
 			}
 		}
 	} else {
-		/* PID tracker disabled. */
+		/* ID tracker disabled. */
 		if (iter >= *ppos && iter == 0)
-			return session;	/* empty tracker */
+			return p;	/* empty tracker */
 		iter++;
 	}
 
@@ -919,67 +1052,91 @@ void *pid_list_next(struct seq_file *m, void *p, loff_t *ppos)
 }
 
 static
-void pid_list_stop(struct seq_file *m, void *p)
+void id_list_stop(struct seq_file *m, void *p)
 {
 	mutex_unlock(&sessions_mutex);
 }
 
 static
-int pid_list_show(struct seq_file *m, void *p)
+int id_list_show(struct seq_file *m, void *p)
 {
-	int pid;
+	struct lttng_id_tracker *id_tracker = m->private;
+	struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
+	int id;
 
-	if (p == m->private) {
+	if (p == id_tracker_p) {
 		/* Tracker disabled. */
-		pid = -1;
+		id = -1;
 	} else {
-		const struct lttng_pid_hash_node *e = p;
+		const struct lttng_id_hash_node *e = p;
 
-		pid = lttng_pid_tracker_get_node_pid(e);
+		id = lttng_id_tracker_get_node_id(e);
+	}
+	switch (id_tracker->tracker_type) {
+	case TRACKER_PID:
+		seq_printf(m,	"process { pid = %d; };\n", id);
+		break;
+	case TRACKER_VPID:
+		seq_printf(m,	"process { vpid = %d; };\n", id);
+		break;
+	case TRACKER_UID:
+		seq_printf(m,	"user { uid = %d; };\n", id);
+		break;
+	case TRACKER_VUID:
+		seq_printf(m,	"user { vuid = %d; };\n", id);
+		break;
+	case TRACKER_GID:
+		seq_printf(m,	"group { gid = %d; };\n", id);
+		break;
+	case TRACKER_VGID:
+		seq_printf(m,	"group { vgid = %d; };\n", id);
+		break;
+	default:
+		seq_printf(m,	"UNKNOWN { field = %d };\n", id);
 	}
-	seq_printf(m,	"process { pid = %d; };\n", pid);
 	return 0;
 }
 
 static
-const struct seq_operations lttng_tracker_pids_list_seq_ops = {
-	.start = pid_list_start,
-	.next = pid_list_next,
-	.stop = pid_list_stop,
-	.show = pid_list_show,
+const struct seq_operations lttng_tracker_ids_list_seq_ops = {
+	.start = id_list_start,
+	.next = id_list_next,
+	.stop = id_list_stop,
+	.show = id_list_show,
 };
 
 static
-int lttng_tracker_pids_list_open(struct inode *inode, struct file *file)
+int lttng_tracker_ids_list_open(struct inode *inode, struct file *file)
 {
-	return seq_open(file, &lttng_tracker_pids_list_seq_ops);
+	return seq_open(file, &lttng_tracker_ids_list_seq_ops);
 }
 
 static
-int lttng_tracker_pids_list_release(struct inode *inode, struct file *file)
+int lttng_tracker_ids_list_release(struct inode *inode, struct file *file)
 {
 	struct seq_file *m = file->private_data;
-	struct lttng_session *session = m->private;
+	struct lttng_id_tracker *id_tracker = m->private;
 	int ret;
 
-	WARN_ON_ONCE(!session);
+	WARN_ON_ONCE(!id_tracker);
 	ret = seq_release(inode, file);
-	if (!ret && session)
-		fput(session->file);
+	if (!ret)
+		fput(id_tracker->session->file);
 	return ret;
 }
 
-const struct file_operations lttng_tracker_pids_list_fops = {
+const struct file_operations lttng_tracker_ids_list_fops = {
 	.owner = THIS_MODULE,
-	.open = lttng_tracker_pids_list_open,
+	.open = lttng_tracker_ids_list_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
-	.release = lttng_tracker_pids_list_release,
+	.release = lttng_tracker_ids_list_release,
 };
 
-int lttng_session_list_tracker_pids(struct lttng_session *session)
+int lttng_session_list_tracker_ids(struct lttng_session *session,
+		enum tracker_type tracker_type)
 {
-	struct file *tracker_pids_list_file;
+	struct file *tracker_ids_list_file;
 	struct seq_file *m;
 	int file_fd, ret;
 
@@ -989,25 +1146,32 @@ int lttng_session_list_tracker_pids(struct lttng_session *session)
 		goto fd_error;
 	}
 
-	tracker_pids_list_file = anon_inode_getfile("[lttng_tracker_pids_list]",
-					  &lttng_tracker_pids_list_fops,
+	tracker_ids_list_file = anon_inode_getfile("[lttng_tracker_ids_list]",
+					  &lttng_tracker_ids_list_fops,
 					  NULL, O_RDWR);
-	if (IS_ERR(tracker_pids_list_file)) {
-		ret = PTR_ERR(tracker_pids_list_file);
+	if (IS_ERR(tracker_ids_list_file)) {
+		ret = PTR_ERR(tracker_ids_list_file);
 		goto file_error;
 	}
-	ret = lttng_tracker_pids_list_fops.open(NULL, tracker_pids_list_file);
+	if (!atomic_long_add_unless(&session->file->f_count, 1, LONG_MAX)) {
+		ret = -EOVERFLOW;
+		goto refcount_error;
+	}
+	ret = lttng_tracker_ids_list_fops.open(NULL, tracker_ids_list_file);
 	if (ret < 0)
 		goto open_error;
-	m = tracker_pids_list_file->private_data;
-	m->private = session;
-	fd_install(file_fd, tracker_pids_list_file);
-	atomic_long_inc(&session->file->f_count);
+	m = tracker_ids_list_file->private_data;
+
+	m->private = get_tracker(session, tracker_type);
+	BUG_ON(!m->private);
+	fd_install(file_fd, tracker_ids_list_file);
 
 	return file_fd;
 
 open_error:
-	fput(tracker_pids_list_file);
+	atomic_long_dec(&session->file->f_count);
+refcount_error:
+	fput(tracker_ids_list_file);
 file_error:
 	put_unused_fd(file_fd);
 fd_error:
@@ -1018,11 +1182,11 @@ fd_error:
  * Enabler management.
  */
 static
-int lttng_match_enabler_wildcard(const char *desc_name,
-		const char *name)
+int lttng_match_enabler_star_glob(const char *desc_name,
+		const char *pattern)
 {
-	/* Compare excluding final '*' */
-	if (strncmp(desc_name, name, strlen(name) - 1))
+	if (!strutils_star_glob_match(pattern, LTTNG_SIZE_MAX,
+			desc_name, LTTNG_SIZE_MAX))
 		return 0;
 	return 1;
 }
@@ -1067,8 +1231,8 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 		return -EINVAL;
 	}
 	switch (enabler->type) {
-	case LTTNG_ENABLER_WILDCARD:
-		return lttng_match_enabler_wildcard(desc_name, enabler_name);
+	case LTTNG_ENABLER_STAR_GLOB:
+		return lttng_match_enabler_star_glob(desc_name, enabler_name);
 	case LTTNG_ENABLER_NAME:
 		return lttng_match_enabler_name(desc_name, enabler_name);
 	default:
@@ -1321,6 +1485,18 @@ error_free:
 	return ret;
 }
 
+int lttng_event_add_callsite(struct lttng_event *event,
+		struct lttng_kernel_event_callsite __user *callsite)
+{
+
+	switch (event->instrumentation) {
+	case LTTNG_KERNEL_UPROBE:
+		return lttng_uprobes_add_callsite(event, callsite);
+	default:
+		return -EINVAL;
+	}
+}
+
 int lttng_enabler_attach_context(struct lttng_enabler *enabler,
 		struct lttng_kernel_context *context_param)
 {
@@ -1391,7 +1567,7 @@ void lttng_session_sync_enablers(struct lttng_session *session)
 		 */
 		enabled = enabled && session->tstate && event->chan->tstate;
 
-		ACCESS_ONCE(event->enabled) = enabled;
+		WRITE_ONCE(event->enabled, enabled);
 		/*
 		 * Sync tracepoint registration with event enabled
 		 * state.
@@ -1470,6 +1646,10 @@ int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
 	if (stream->metadata_in != stream->metadata_out)
 		goto end;
 
+	/* Metadata regenerated, change the version. */
+	if (stream->metadata_cache->version != stream->version)
+		stream->version = stream->metadata_cache->version;
+
 	len = stream->metadata_cache->metadata_written -
 		stream->metadata_in;
 	if (!len)
@@ -1513,7 +1693,7 @@ int lttng_metadata_printf(struct lttng_session *session,
 	va_list ap;
 	struct lttng_metadata_stream *stream;
 
-	WARN_ON_ONCE(!ACCESS_ONCE(session->active));
+	WARN_ON_ONCE(!READ_ONCE(session->active));
 
 	va_start(ap, fmt);
 	str = kvasprintf(GFP_KERNEL, fmt, ap);
@@ -1562,162 +1742,58 @@ err:
 	return -ENOMEM;
 }
 
-/*
- * Must be called with sessions_mutex held.
- */
 static
-int _lttng_field_statedump(struct lttng_session *session,
-			 const struct lttng_event_field *field)
+int print_tabs(struct lttng_session *session, size_t nesting)
 {
-	int ret = 0;
+	size_t i;
 
-	switch (field->type.atype) {
-	case atype_integer:
-		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
-			field->type.u.basic.integer.size,
-			field->type.u.basic.integer.alignment,
-			field->type.u.basic.integer.signedness,
-			(field->type.u.basic.integer.encoding == lttng_encode_none)
-				? "none"
-				: (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
-					? "UTF8"
-					: "ASCII",
-			field->type.u.basic.integer.base,
-#ifdef __BIG_ENDIAN
-			field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
-#else
-			field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
-#endif
-			field->name);
-		break;
-	case atype_enum:
-		ret = lttng_metadata_printf(session,
-			"		%s _%s;\n",
-			field->type.u.basic.enumeration.name,
-			field->name);
-		break;
-	case atype_array:
-	{
-		const struct lttng_basic_type *elem_type;
-
-		elem_type = &field->type.u.array.elem_type;
-		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
-			elem_type->u.basic.integer.size,
-			elem_type->u.basic.integer.alignment,
-			elem_type->u.basic.integer.signedness,
-			(elem_type->u.basic.integer.encoding == lttng_encode_none)
-				? "none"
-				: (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
-					? "UTF8"
-					: "ASCII",
-			elem_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
-			elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
-#else
-			elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
-#endif
-			field->name, field->type.u.array.length);
-		break;
-	}
-	case atype_sequence:
-	{
-		const struct lttng_basic_type *elem_type;
-		const struct lttng_basic_type *length_type;
+	for (i = 0; i < nesting; i++) {
+		int ret;
 
-		elem_type = &field->type.u.sequence.elem_type;
-		length_type = &field->type.u.sequence.length_type;
-		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
-			length_type->u.basic.integer.size,
-			(unsigned int) length_type->u.basic.integer.alignment,
-			length_type->u.basic.integer.signedness,
-			(length_type->u.basic.integer.encoding == lttng_encode_none)
-				? "none"
-				: ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
-					? "UTF8"
-					: "ASCII"),
-			length_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
-			length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
-#else
-			length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
-#endif
-			field->name);
-		if (ret)
+		ret = lttng_metadata_printf(session, "	");
+		if (ret) {
 			return ret;
-
-		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
-			elem_type->u.basic.integer.size,
-			(unsigned int) elem_type->u.basic.integer.alignment,
-			elem_type->u.basic.integer.signedness,
-			(elem_type->u.basic.integer.encoding == lttng_encode_none)
-				? "none"
-				: ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
-					? "UTF8"
-					: "ASCII"),
-			elem_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
-			elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
-#else
-			elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
-#endif
-			field->name,
-			field->name);
-		break;
-	}
-
-	case atype_string:
-		/* Default encoding is UTF8 */
-		ret = lttng_metadata_printf(session,
-			"		string%s _%s;\n",
-			field->type.u.basic.string.encoding == lttng_encode_ASCII ?
-				" { encoding = ASCII; }" : "",
-			field->name);
-		break;
-	default:
-		WARN_ON_ONCE(1);
-		return -EINVAL;
+		}
 	}
-	return ret;
+	return 0;
 }
 
 static
-int _lttng_context_metadata_statedump(struct lttng_session *session,
-				    struct lttng_ctx *ctx)
+int lttng_field_name_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
 {
-	int ret = 0;
-	int i;
-
-	if (!ctx)
-		return 0;
-	for (i = 0; i < ctx->nr_fields; i++) {
-		const struct lttng_ctx_field *field = &ctx->fields[i];
-
-		ret = _lttng_field_statedump(session, &field->event_field);
-		if (ret)
-			return ret;
-	}
-	return ret;
+	return lttng_metadata_printf(session, " _%s;\n", field->name);
 }
 
 static
-int _lttng_fields_metadata_statedump(struct lttng_session *session,
-				   struct lttng_event *event)
+int _lttng_integer_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
 {
-	const struct lttng_event_desc *desc = event->desc;
-	int ret = 0;
-	int i;
-
-	for (i = 0; i < desc->nr_fields; i++) {
-		const struct lttng_event_field *field = &desc->fields[i];
+	int ret;
 
-		ret = _lttng_field_statedump(session, field);
-		if (ret)
-			return ret;
-	}
+	WARN_ON_ONCE(type->atype != atype_integer);
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
+	ret = lttng_metadata_printf(session,
+		"integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s }",
+		type->u.integer.size,
+		type->u.integer.alignment,
+		type->u.integer.signedness,
+		(type->u.integer.encoding == lttng_encode_none)
+			? "none"
+			: (type->u.integer.encoding == lttng_encode_UTF8)
+				? "UTF8"
+				: "ASCII",
+		type->u.integer.base,
+#if __BYTE_ORDER == __BIG_ENDIAN
+		type->u.integer.reverse_byte_order ? " byte_order = le;" : ""
+#else
+		type->u.integer.reverse_byte_order ? " byte_order = be;" : ""
+#endif
+	);
 	return ret;
 }
 
@@ -1725,19 +1801,532 @@ int _lttng_fields_metadata_statedump(struct lttng_session *session,
  * Must be called with sessions_mutex held.
  */
 static
-int _lttng_event_metadata_statedump(struct lttng_session *session,
-				  struct lttng_channel *chan,
-				  struct lttng_event *event)
+int _lttng_struct_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
 {
-	int ret = 0;
+	int ret;
+	uint32_t i, nr_fields;
+	unsigned int alignment;
 
-	if (event->metadata_dumped || !ACCESS_ONCE(session->active))
-		return 0;
-	if (chan->channel_type == METADATA_CHANNEL)
-		return 0;
+	WARN_ON_ONCE(type->atype != atype_struct_nestable);
 
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
 	ret = lttng_metadata_printf(session,
-		"event {\n"
+		"struct {\n");
+	if (ret)
+		return ret;
+	nr_fields = type->u.struct_nestable.nr_fields;
+	for (i = 0; i < nr_fields; i++) {
+		const struct lttng_event_field *iter_field;
+
+		iter_field = &type->u.struct_nestable.fields[i];
+		ret = _lttng_field_statedump(session, iter_field, nesting + 1);
+		if (ret)
+			return ret;
+	}
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
+	alignment = type->u.struct_nestable.alignment;
+	if (alignment) {
+		ret = lttng_metadata_printf(session,
+			"} align(%u)",
+			alignment);
+	} else {
+		ret = lttng_metadata_printf(session,
+			"}");
+	}
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_struct_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+
+	ret = _lttng_struct_type_statedump(session,
+			&field->type, nesting);
+	if (ret)
+		return ret;
+	return lttng_field_name_statedump(session, field, nesting);
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_variant_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
+{
+	int ret;
+	uint32_t i, nr_choices;
+
+	WARN_ON_ONCE(type->atype != atype_variant_nestable);
+	/*
+	 * CTF 1.8 does not allow expressing nonzero variant alignment in a nestable way.
+	 */
+	if (type->u.variant_nestable.alignment != 0)
+		return -EINVAL;
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
+	ret = lttng_metadata_printf(session,
+		"variant <_%s> {\n",
+		type->u.variant_nestable.tag_name);
+	if (ret)
+		return ret;
+	nr_choices = type->u.variant_nestable.nr_choices;
+	for (i = 0; i < nr_choices; i++) {
+		const struct lttng_event_field *iter_field;
+
+		iter_field = &type->u.variant_nestable.choices[i];
+		ret = _lttng_field_statedump(session, iter_field, nesting + 1);
+		if (ret)
+			return ret;
+	}
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
+	ret = lttng_metadata_printf(session,
+		"}");
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_variant_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+
+	ret = _lttng_variant_type_statedump(session,
+			&field->type, nesting);
+	if (ret)
+		return ret;
+	return lttng_field_name_statedump(session, field, nesting);
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_array_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+	const struct lttng_type *elem_type;
+
+	WARN_ON_ONCE(field->type.atype != atype_array_nestable);
+
+	if (field->type.u.array_nestable.alignment) {
+		ret = print_tabs(session, nesting);
+		if (ret)
+			return ret;
+		ret = lttng_metadata_printf(session,
+		"struct { } align(%u) _%s_padding;\n",
+				field->type.u.array_nestable.alignment * CHAR_BIT,
+				field->name);
+		if (ret)
+			return ret;
+	}
+	/*
+	 * Nested compound types: Only array of structures and variants are
+	 * currently supported.
+	 */
+	elem_type = field->type.u.array_nestable.elem_type;
+	switch (elem_type->atype) {
+	case atype_integer:
+	case atype_struct_nestable:
+	case atype_variant_nestable:
+		ret = _lttng_type_statedump(session, elem_type, nesting);
+		if (ret)
+			return ret;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+	ret = lttng_metadata_printf(session,
+		" _%s[%u];\n",
+		field->name,
+		field->type.u.array_nestable.length);
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_sequence_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+	const char *length_name;
+	const struct lttng_type *elem_type;
+
+	WARN_ON_ONCE(field->type.atype != atype_sequence_nestable);
+
+	length_name = field->type.u.sequence_nestable.length_name;
+
+	if (field->type.u.sequence_nestable.alignment) {
+		ret = print_tabs(session, nesting);
+		if (ret)
+			return ret;
+		ret = lttng_metadata_printf(session,
+		"struct { } align(%u) _%s_padding;\n",
+				field->type.u.sequence_nestable.alignment * CHAR_BIT,
+				field->name);
+		if (ret)
+			return ret;
+	}
+
+	/*
+	 * Nested compound types: Only array of structures and variants are
+	 * currently supported.
+	 */
+	elem_type = field->type.u.sequence_nestable.elem_type;
+	switch (elem_type->atype) {
+	case atype_integer:
+	case atype_struct_nestable:
+	case atype_variant_nestable:
+		ret = _lttng_type_statedump(session, elem_type, nesting);
+		if (ret)
+			return ret;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+	ret = lttng_metadata_printf(session,
+		" _%s[ _%s ];\n",
+		field->name,
+		field->type.u.sequence_nestable.length_name);
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_enum_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
+{
+	const struct lttng_enum_desc *enum_desc;
+	const struct lttng_type *container_type;
+	int ret;
+	unsigned int i, nr_entries;
+
+	container_type = type->u.enum_nestable.container_type;
+	if (container_type->atype != atype_integer) {
+		ret = -EINVAL;
+		goto end;
+	}
+	enum_desc = type->u.enum_nestable.desc;
+	nr_entries = enum_desc->nr_entries;
+
+	ret = print_tabs(session, nesting);
+	if (ret)
+		goto end;
+	ret = lttng_metadata_printf(session, "enum : ");
+	if (ret)
+		goto end;
+	ret = _lttng_integer_type_statedump(session, container_type, 0);
+	if (ret)
+		goto end;
+	ret = lttng_metadata_printf(session, " {\n");
+	if (ret)
+		goto end;
+	/* Dump all entries */
+	for (i = 0; i < nr_entries; i++) {
+		const struct lttng_enum_entry *entry = &enum_desc->entries[i];
+		int j, len;
+
+		ret = print_tabs(session, nesting + 1);
+		if (ret)
+			goto end;
+		ret = lttng_metadata_printf(session,
+				"\"");
+		if (ret)
+			goto end;
+		len = strlen(entry->string);
+		/* Escape the character '"' */
+		for (j = 0; j < len; j++) {
+			char c = entry->string[j];
+
+			switch (c) {
+			case '"':
+				ret = lttng_metadata_printf(session,
+						"\\\"");
+				break;
+			case '\\':
+				ret = lttng_metadata_printf(session,
+						"\\\\");
+				break;
+			default:
+				ret = lttng_metadata_printf(session,
+						"%c", c);
+				break;
+			}
+			if (ret)
+				goto end;
+		}
+		ret = lttng_metadata_printf(session, "\"");
+		if (ret)
+			goto end;
+
+		if (entry->options.is_auto) {
+			ret = lttng_metadata_printf(session, ",\n");
+			if (ret)
+				goto end;
+		} else {
+			ret = lttng_metadata_printf(session,
+					" = ");
+			if (ret)
+				goto end;
+			if (entry->start.signedness)
+				ret = lttng_metadata_printf(session,
+					"%lld", (long long) entry->start.value);
+			else
+				ret = lttng_metadata_printf(session,
+					"%llu", entry->start.value);
+			if (ret)
+				goto end;
+			if (entry->start.signedness == entry->end.signedness &&
+					entry->start.value
+						== entry->end.value) {
+				ret = lttng_metadata_printf(session,
+					",\n");
+			} else {
+				if (entry->end.signedness) {
+					ret = lttng_metadata_printf(session,
+						" ... %lld,\n",
+						(long long) entry->end.value);
+				} else {
+					ret = lttng_metadata_printf(session,
+						" ... %llu,\n",
+						entry->end.value);
+				}
+			}
+			if (ret)
+				goto end;
+		}
+	}
+	ret = print_tabs(session, nesting);
+	if (ret)
+		goto end;
+	ret = lttng_metadata_printf(session, "}");
+end:
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_enum_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+
+	ret = _lttng_enum_type_statedump(session, &field->type, nesting);
+	if (ret)
+		return ret;
+	return lttng_field_name_statedump(session, field, nesting);
+}
+
+static
+int _lttng_integer_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+
+	ret = _lttng_integer_type_statedump(session, &field->type, nesting);
+	if (ret)
+		return ret;
+	return lttng_field_name_statedump(session, field, nesting);
+}
+
+static
+int _lttng_string_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
+{
+	int ret;
+
+	WARN_ON_ONCE(type->atype != atype_string);
+	/* Default encoding is UTF8 */
+	ret = print_tabs(session, nesting);
+	if (ret)
+		return ret;
+	ret = lttng_metadata_printf(session,
+		"string%s",
+		type->u.string.encoding == lttng_encode_ASCII ?
+			" { encoding = ASCII; }" : "");
+	return ret;
+}
+
+static
+int _lttng_string_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret;
+
+	WARN_ON_ONCE(field->type.atype != atype_string);
+	ret = _lttng_string_type_statedump(session, &field->type, nesting);
+	if (ret)
+		return ret;
+	return lttng_field_name_statedump(session, field, nesting);
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_type_statedump(struct lttng_session *session,
+		const struct lttng_type *type,
+		size_t nesting)
+{
+	int ret = 0;
+
+	switch (type->atype) {
+	case atype_integer:
+		ret = _lttng_integer_type_statedump(session, type, nesting);
+		break;
+	case atype_enum_nestable:
+		ret = _lttng_enum_type_statedump(session, type, nesting);
+		break;
+	case atype_string:
+		ret = _lttng_string_type_statedump(session, type, nesting);
+		break;
+	case atype_struct_nestable:
+		ret = _lttng_struct_type_statedump(session, type, nesting);
+		break;
+	case atype_variant_nestable:
+		ret = _lttng_variant_type_statedump(session, type, nesting);
+		break;
+
+	/* Nested arrays and sequences are not supported yet. */
+	case atype_array_nestable:
+	case atype_sequence_nestable:
+	default:
+		WARN_ON_ONCE(1);
+		return -EINVAL;
+	}
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_field_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	int ret = 0;
+
+	switch (field->type.atype) {
+	case atype_integer:
+		ret = _lttng_integer_field_statedump(session, field, nesting);
+		break;
+	case atype_enum_nestable:
+		ret = _lttng_enum_field_statedump(session, field, nesting);
+		break;
+	case atype_string:
+		ret = _lttng_string_field_statedump(session, field, nesting);
+		break;
+	case atype_struct_nestable:
+		ret = _lttng_struct_field_statedump(session, field, nesting);
+		break;
+	case atype_array_nestable:
+		ret = _lttng_array_field_statedump(session, field, nesting);
+		break;
+	case atype_sequence_nestable:
+		ret = _lttng_sequence_field_statedump(session, field, nesting);
+		break;
+	case atype_variant_nestable:
+		ret = _lttng_variant_field_statedump(session, field, nesting);
+		break;
+
+	default:
+		WARN_ON_ONCE(1);
+		return -EINVAL;
+	}
+	return ret;
+}
+
+static
+int _lttng_context_metadata_statedump(struct lttng_session *session,
+				    struct lttng_ctx *ctx)
+{
+	int ret = 0;
+	int i;
+
+	if (!ctx)
+		return 0;
+	for (i = 0; i < ctx->nr_fields; i++) {
+		const struct lttng_ctx_field *field = &ctx->fields[i];
+
+		ret = _lttng_field_statedump(session, &field->event_field, 2);
+		if (ret)
+			return ret;
+	}
+	return ret;
+}
+
+static
+int _lttng_fields_metadata_statedump(struct lttng_session *session,
+				   struct lttng_event *event)
+{
+	const struct lttng_event_desc *desc = event->desc;
+	int ret = 0;
+	int i;
+
+	for (i = 0; i < desc->nr_fields; i++) {
+		const struct lttng_event_field *field = &desc->fields[i];
+
+		ret = _lttng_field_statedump(session, field, 2);
+		if (ret)
+			return ret;
+	}
+	return ret;
+}
+
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_event_metadata_statedump(struct lttng_session *session,
+				  struct lttng_channel *chan,
+				  struct lttng_event *event)
+{
+	int ret = 0;
+
+	if (event->metadata_dumped || !READ_ONCE(session->active))
+		return 0;
+	if (chan->channel_type == METADATA_CHANNEL)
+		return 0;
+
+	ret = lttng_metadata_printf(session,
+		"event {\n"
 		"	name = \"%s\";\n"
 		"	id = %u;\n"
 		"	stream_id = %u;\n",
@@ -1798,7 +2387,7 @@ int _lttng_channel_metadata_statedump(struct lttng_session *session,
 {
 	int ret = 0;
 
-	if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
+	if (chan->metadata_dumped || !READ_ONCE(session->active))
 		return 0;
 
 	if (chan->channel_type == METADATA_CHANNEL)
@@ -1909,28 +2498,105 @@ int _lttng_event_header_declare(struct lttng_session *session)
  * taken at start of trace.
  * Yes, this is only an approximation. Yes, we can (and will) do better
  * in future versions.
+ * This function may return a negative offset. It may happen if the
+ * system sets the REALTIME clock to 0 after boot.
+ *
+ * Use 64bit timespec on kernels that have it, this makes 32bit arch
+ * y2038 compliant.
  */
 static
-uint64_t measure_clock_offset(void)
+int64_t measure_clock_offset(void)
 {
-	uint64_t offset, monotonic[2], realtime;
-	struct timespec rts = { 0, 0 };
+	uint64_t monotonic_avg, monotonic[2], realtime;
+	uint64_t tcf = trace_clock_freq();
+	int64_t offset;
 	unsigned long flags;
+#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
+	struct timespec64 rts = { 0, 0 };
+#else
+	struct timespec rts = { 0, 0 };
+#endif
 
 	/* Disable interrupts to increase correlation precision. */
 	local_irq_save(flags);
 	monotonic[0] = trace_clock_read64();
-	getnstimeofday(&rts);      
+#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
+	ktime_get_real_ts64(&rts);
+#else
+	getnstimeofday(&rts);
+#endif
 	monotonic[1] = trace_clock_read64();
 	local_irq_restore(flags);
 
-	offset = (monotonic[0] + monotonic[1]) >> 1;
-	realtime = (uint64_t) rts.tv_sec * NSEC_PER_SEC;
-	realtime += rts.tv_nsec;
-	offset = realtime - offset;
+	monotonic_avg = (monotonic[0] + monotonic[1]) >> 1;
+	realtime = (uint64_t) rts.tv_sec * tcf;
+	if (tcf == NSEC_PER_SEC) {
+		realtime += rts.tv_nsec;
+	} else {
+		uint64_t n = rts.tv_nsec * tcf;
+
+		do_div(n, NSEC_PER_SEC);
+		realtime += n;
+	}
+	offset = (int64_t) realtime - monotonic_avg;
 	return offset;
 }
 
+static
+int print_escaped_ctf_string(struct lttng_session *session, const char *string)
+{
+	int ret = 0;
+	size_t i;
+	char cur;
+
+	i = 0;
+	cur = string[i];
+	while (cur != '\0') {
+		switch (cur) {
+		case '\n':
+			ret = lttng_metadata_printf(session, "%s", "\\n");
+			break;
+		case '\\':
+		case '"':
+			ret = lttng_metadata_printf(session, "%c", '\\');
+			if (ret)
+				goto error;
+			/* We still print the current char */
+			/* Fallthrough */
+		default:
+			ret = lttng_metadata_printf(session, "%c", cur);
+			break;
+		}
+
+		if (ret)
+			goto error;
+
+		cur = string[++i];
+	}
+error:
+	return ret;
+}
+
+static
+int print_metadata_escaped_field(struct lttng_session *session, const char *field,
+		const char *field_value)
+{
+	int ret;
+
+	ret = lttng_metadata_printf(session, "	%s = \"", field);
+	if (ret)
+		goto error;
+
+	ret = print_escaped_ctf_string(session, field_value);
+	if (ret)
+		goto error;
+
+	ret = lttng_metadata_printf(session, "\";\n");
+
+error:
+	return ret;
+}
+
 /*
  * Output metadata into this session's metadata buffers.
  * Must be called with sessions_mutex held.
@@ -1940,11 +2606,12 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 {
 	unsigned char *uuid_c = session->uuid.b;
 	unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
+	const char *product_uuid;
 	struct lttng_channel *chan;
 	struct lttng_event *event;
 	int ret = 0;
 
-	if (!ACCESS_ONCE(session->active))
+	if (!READ_ONCE(session->active))
 		return 0;
 	if (session->metadata_dumped)
 		goto skip_session;
@@ -1974,6 +2641,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 		"		uint32_t magic;\n"
 		"		uint8_t  uuid[16];\n"
 		"		uint32_t stream_id;\n"
+		"		uint64_t stream_instance_id;\n"
 		"	};\n"
 		"};\n\n",
 		lttng_alignof(uint8_t) * CHAR_BIT,
@@ -1985,7 +2653,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 		CTF_SPEC_MAJOR,
 		CTF_SPEC_MINOR,
 		uuid_s,
-#ifdef __BIG_ENDIAN
+#if __BYTE_ORDER == __BIG_ENDIAN
 		"be"
 #else
 		"le"
@@ -2005,7 +2673,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 		"	tracer_major = %d;\n"
 		"	tracer_minor = %d;\n"
 		"	tracer_patchlevel = %d;\n"
-		"};\n\n",
+		"	trace_buffering_scheme = \"global\";\n",
 		current->nsproxy->uts_ns->name.nodename,
 		utsname()->sysname,
 		utsname()->release,
@@ -2017,10 +2685,34 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 	if (ret)
 		goto end;
 
+	ret = print_metadata_escaped_field(session, "trace_name", session->name);
+	if (ret)
+		goto end;
+	ret = print_metadata_escaped_field(session, "trace_creation_datetime",
+			session->creation_time);
+	if (ret)
+		goto end;
+
+	/* Add the product UUID to the 'env' section */
+	product_uuid = dmi_get_system_info(DMI_PRODUCT_UUID);
+	if (product_uuid) {
+		ret = lttng_metadata_printf(session,
+				"	product_uuid = \"%s\";\n",
+				product_uuid
+				);
+		if (ret)
+			goto end;
+	}
+
+	/* Close the 'env' section */
+	ret = lttng_metadata_printf(session, "};\n\n");
+	if (ret)
+		goto end;
+
 	ret = lttng_metadata_printf(session,
 		"clock {\n"
-		"	name = %s;\n",
-		"monotonic"
+		"	name = \"%s\";\n",
+		trace_clock_name()
 		);
 	if (ret)
 		goto end;
@@ -2035,13 +2727,14 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 	}
 
 	ret = lttng_metadata_printf(session,
-		"	description = \"Monotonic Clock\";\n"
+		"	description = \"%s\";\n"
 		"	freq = %llu; /* Frequency, in Hz */\n"
 		"	/* clock value offset from Epoch is: offset * (1/freq) */\n"
-		"	offset = %llu;\n"
+		"	offset = %lld;\n"
 		"};\n\n",
+		trace_clock_description(),
 		(unsigned long long) trace_clock_freq(),
-		(unsigned long long) measure_clock_offset()
+		(long long) measure_clock_offset()
 		);
 	if (ret)
 		goto end;
@@ -2049,20 +2742,23 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 	ret = lttng_metadata_printf(session,
 		"typealias integer {\n"
 		"	size = 27; align = 1; signed = false;\n"
-		"	map = clock.monotonic.value;\n"
+		"	map = clock.%s.value;\n"
 		"} := uint27_clock_monotonic_t;\n"
 		"\n"
 		"typealias integer {\n"
 		"	size = 32; align = %u; signed = false;\n"
-		"	map = clock.monotonic.value;\n"
+		"	map = clock.%s.value;\n"
 		"} := uint32_clock_monotonic_t;\n"
 		"\n"
 		"typealias integer {\n"
 		"	size = 64; align = %u; signed = false;\n"
-		"	map = clock.monotonic.value;\n"
+		"	map = clock.%s.value;\n"
 		"} := uint64_clock_monotonic_t;\n\n",
+		trace_clock_name(),
 		lttng_alignof(uint32_t) * CHAR_BIT,
-		lttng_alignof(uint64_t) * CHAR_BIT
+		trace_clock_name(),
+		lttng_alignof(uint64_t) * CHAR_BIT,
+		trace_clock_name()
 		);
 	if (ret)
 		goto end;
@@ -2099,9 +2795,9 @@ end:
  * Registers a transport which can be used as output to extract the data out of
  * LTTng. The module calling this registration function must ensure that no
  * trap-inducing code will be executed by the transport functions. E.g.
- * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
+ * vmalloc_sync_mappings() must be called between a vmalloc and the moment the memory
  * is made visible to the transport function. This registration acts as a
- * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
+ * vmalloc_sync_mappings. Therefore, only if the module allocates virtual memory
  * after its registration must it synchronize the TLBs.
  */
 void lttng_transport_register(struct lttng_transport *transport)
@@ -2109,9 +2805,9 @@ void lttng_transport_register(struct lttng_transport *transport)
 	/*
 	 * Make sure no page fault can be triggered by the module about to be
 	 * registered. We deal with this here so we don't have to call
-	 * vmalloc_sync_all() in each module's init.
+	 * vmalloc_sync_mappings() in each module's init.
 	 */
-	wrapper_vmalloc_sync_all();
+	wrapper_vmalloc_sync_mappings();
 
 	mutex_lock(&sessions_mutex);
 	list_add_tail(&transport->node, &lttng_transport_list);
@@ -2131,6 +2827,133 @@ void lttng_transport_unregister(struct lttng_transport *transport)
 }
 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+
+enum cpuhp_state lttng_hp_prepare;
+enum cpuhp_state lttng_hp_online;
+
+static int lttng_hotplug_prepare(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return 0;
+	case LTTNG_RING_BUFFER_BACKEND:
+		return lttng_cpuhp_rb_backend_prepare(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_dead(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_dead(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return lttng_cpuhp_perf_counter_dead(cpu, lttng_node);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_online(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_online(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return lttng_cpuhp_rb_iter_online(cpu, lttng_node);
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return lttng_cpuhp_perf_counter_online(cpu, lttng_node);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_offline(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_offline(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+static int __init lttng_init_cpu_hotplug(void)
+{
+	int ret;
+
+	ret = cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN, "lttng:prepare",
+			lttng_hotplug_prepare,
+			lttng_hotplug_dead);
+	if (ret < 0) {
+		return ret;
+	}
+	lttng_hp_prepare = ret;
+	lttng_rb_set_hp_prepare(ret);
+
+	ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "lttng:online",
+			lttng_hotplug_online,
+			lttng_hotplug_offline);
+	if (ret < 0) {
+		cpuhp_remove_multi_state(lttng_hp_prepare);
+		lttng_hp_prepare = 0;
+		return ret;
+	}
+	lttng_hp_online = ret;
+	lttng_rb_set_hp_online(ret);
+
+	return 0;
+}
+
+static void __exit lttng_exit_cpu_hotplug(void)
+{
+	lttng_rb_set_hp_online(0);
+	cpuhp_remove_multi_state(lttng_hp_online);
+	lttng_rb_set_hp_prepare(0);
+	cpuhp_remove_multi_state(lttng_hp_prepare);
+}
+
+#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+static int lttng_init_cpu_hotplug(void)
+{
+	return 0;
+}
+static void lttng_exit_cpu_hotplug(void)
+{
+}
+#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+
+
 static int __init lttng_events_init(void)
 {
 	int ret;
@@ -2139,6 +2962,12 @@ static int __init lttng_events_init(void)
 	if (ret)
 		return ret;
 	ret = wrapper_get_pfnblock_flags_mask_init();
+	if (ret)
+		return ret;
+	ret = wrapper_get_pageblock_flags_mask_init();
+	if (ret)
+		return ret;
+	ret = lttng_probes_init();
 	if (ret)
 		return ret;
 	ret = lttng_context_init();
@@ -2158,8 +2987,29 @@ static int __init lttng_events_init(void)
 	ret = lttng_logger_init();
 	if (ret)
 		goto error_logger;
+	ret = lttng_init_cpu_hotplug();
+	if (ret)
+		goto error_hotplug;
+	printk(KERN_NOTICE "LTTng: Loaded modules v%s.%s.%s%s (%s)%s%s\n",
+		__stringify(LTTNG_MODULES_MAJOR_VERSION),
+		__stringify(LTTNG_MODULES_MINOR_VERSION),
+		__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+		LTTNG_MODULES_EXTRAVERSION,
+		LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+		LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+		"",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+		LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+		"");
+#endif
 	return 0;
 
+error_hotplug:
+	lttng_logger_exit();
 error_logger:
 	lttng_abi_exit();
 error_abi:
@@ -2168,6 +3018,22 @@ error_kmem:
 	lttng_tracepoint_exit();
 error_tp:
 	lttng_context_exit();
+	printk(KERN_NOTICE "LTTng: Failed to load modules v%s.%s.%s%s (%s)%s%s\n",
+		__stringify(LTTNG_MODULES_MAJOR_VERSION),
+		__stringify(LTTNG_MODULES_MINOR_VERSION),
+		__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+		LTTNG_MODULES_EXTRAVERSION,
+		LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+		LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+		"",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+		LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+		"");
+#endif
 	return ret;
 }
 
@@ -2177,6 +3043,7 @@ static void __exit lttng_events_exit(void)
 {
 	struct lttng_session *session, *tmpsession;
 
+	lttng_exit_cpu_hotplug();
 	lttng_logger_exit();
 	lttng_abi_exit();
 	list_for_each_entry_safe(session, tmpsession, &sessions, list)
@@ -2184,13 +3051,36 @@ static void __exit lttng_events_exit(void)
 	kmem_cache_destroy(event_cache);
 	lttng_tracepoint_exit();
 	lttng_context_exit();
+	printk(KERN_NOTICE "LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",
+		__stringify(LTTNG_MODULES_MAJOR_VERSION),
+		__stringify(LTTNG_MODULES_MINOR_VERSION),
+		__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+		LTTNG_MODULES_EXTRAVERSION,
+		LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+		LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+		"",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+		LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+		"");
+#endif
 }
 
 module_exit(lttng_events_exit);
 
+#include "extra_version/patches.i"
+#ifdef LTTNG_EXTRA_VERSION_GIT
+MODULE_INFO(extra_version_git, LTTNG_EXTRA_VERSION_GIT);
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+MODULE_INFO(extra_version_name, LTTNG_EXTRA_VERSION_NAME);
+#endif
 MODULE_LICENSE("GPL and additional rights");
 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
-MODULE_DESCRIPTION("LTTng Events");
+MODULE_DESCRIPTION("LTTng tracer");
 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
 	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
 	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)