X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=libust%2Fbuffers.c;h=c8976c7841834e82bd8fae53e0dbe8ca2783d51b;hb=d4d511d9f43d6d33c3a40b4aab69d976c4f93cec;hp=7d2dd47336ecfda237a6d6564b99f2bca38f3000;hpb=a0243ab12a9cdab191c624ef23e035d97f08d60e;p=ust.git

diff --git a/libust/buffers.c b/libust/buffers.c
index 7d2dd47..c8976c7 100644
--- a/libust/buffers.c
+++ b/libust/buffers.c
@@ -3,7 +3,7 @@
  * LTTng userspace tracer buffering system
  *
  * Copyright (C) 2009 - Pierre-Marc Fournier (pierre-marc dot fournier at polymtl dot ca)
- * Copyright (C) 2008 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ * Copyright (C) 2008-2011 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,55 +20,151 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
+/*
+ * Note: this code does not support the ref/noref flag and reader-owned
+ * subbuffer scheme needed for flight recorder mode.
+ */
+
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <fcntl.h>
-#include <ust/kernelcompat.h>
-#include <kcompat/kref.h>
+#include <stdlib.h>
+
+#include <ust/clock.h>
+
 #include "buffers.h"
 #include "channels.h"
 #include "tracer.h"
 #include "tracercore.h"
-#include "usterr.h"
+#include "usterr_signal_safe.h"
+
+struct ltt_reserve_switch_offsets {
+	long begin, end, old;
+	long begin_switch, end_switch_current, end_switch_old;
+	size_t before_hdr_pad, size;
+};
+
 
 static DEFINE_MUTEX(ust_buffers_channels_mutex);
-static LIST_HEAD(ust_buffers_channels);
+static CDS_LIST_HEAD(ust_buffers_channels);
+
+static void ltt_force_switch(struct ust_buffer *buf,
+		enum force_switch_mode mode);
 
 static int get_n_cpus(void)
 {
 	int result;
 	static int n_cpus = 0;
 
-	if(n_cpus) {
-		return n_cpus;
+	if(!n_cpus) {
+		/* On Linux, when some processors are offline
+		 * _SC_NPROCESSORS_CONF counts the offline
+		 * processors, whereas _SC_NPROCESSORS_ONLN
+		 * does not. If we used _SC_NPROCESSORS_ONLN,
+		 * getcpu() could return a value greater than
+		 * this sysconf, in which case the arrays
+		 * indexed by processor would overflow.
+		 */
+		result = sysconf(_SC_NPROCESSORS_CONF);
+		if(result == -1) {
+			return -1;
+		}
+
+		n_cpus = result;
 	}
 
-	/* On Linux, when some processors are offline
-	 * _SC_NPROCESSORS_CONF counts the offline
-	 * processors, whereas _SC_NPROCESSORS_ONLN
-	 * does not. If we used _SC_NPROCESSORS_ONLN,
-	 * getcpu() could return a value greater than
-	 * this sysconf, in which case the arrays
-	 * indexed by processor would overflow.
-	 */
-	result = sysconf(_SC_NPROCESSORS_CONF);
-	if(result == -1) {
-		return -1;
+	return n_cpus;
+}
+
+/**
+ * _ust_buffers_strncpy_fixup - Fix an incomplete string in a ltt_relay buffer.
+ * @buf : buffer
+ * @offset : offset within the buffer
+ * @len : length to write
+ * @copied: string actually copied
+ * @terminated: does string end with \0
+ *
+ * Fills string with "X" if incomplete.
+ */
+void _ust_buffers_strncpy_fixup(struct ust_buffer *buf, size_t offset,
+				size_t len, size_t copied, int terminated)
+{
+	size_t buf_offset, cpy;
+
+	if (copied == len) {
+		/*
+		 * Deal with non-terminated string.
+		 */
+		assert(!terminated);
+		offset += copied - 1;
+		buf_offset = BUFFER_OFFSET(offset, buf->chan);
+		/*
+		 * Underlying layer should never ask for writes across
+		 * subbuffers.
+		 */
+		assert(buf_offset
+		       < buf->chan->subbuf_size*buf->chan->subbuf_cnt);
+		ust_buffers_do_memset(buf->buf_data + buf_offset, '\0', 1);
+		return;
 	}
 
-	n_cpus = result;
+	/*
+	 * Deal with incomplete string.
+	 * Overwrite string's \0 with X too.
+	 */
+	cpy = copied - 1;
+	assert(terminated);
+	len -= cpy;
+	offset += cpy;
+	buf_offset = BUFFER_OFFSET(offset, buf->chan);
+
+	/*
+	 * Underlying layer should never ask for writes across subbuffers.
+	 */
+	assert(buf_offset
+	       < buf->chan->subbuf_size*buf->chan->subbuf_cnt);
+
+	ust_buffers_do_memset(buf->buf_data + buf_offset,
+			      'X', len);
 
-	return result;
+	/*
+	 * Overwrite last 'X' with '\0'.
+	 */
+	offset += len - 1;
+	buf_offset = BUFFER_OFFSET(offset, buf->chan);
+	/*
+	 * Underlying layer should never ask for writes across subbuffers.
+	 */
+	assert(buf_offset
+	       < buf->chan->subbuf_size*buf->chan->subbuf_cnt);
+	ust_buffers_do_memset(buf->buf_data + buf_offset, '\0', 1);
 }
 
-static int ust_buffers_init_buffer(struct ltt_trace_struct *trace,
-		struct ust_channel *ltt_chan,
-		struct ust_buffer *buf,
-		unsigned int n_subbufs);
+static void ltt_buffer_begin(struct ust_buffer *buf,
+			     u64 tsc, unsigned int subbuf_idx)
+{
+	struct ust_channel *channel = buf->chan;
+	struct ltt_subbuffer_header *header =
+		(struct ltt_subbuffer_header *)
+			ust_buffers_offset_address(buf,
+				subbuf_idx * buf->chan->subbuf_size);
+
+	header->cycle_count_begin = tsc;
+	header->data_size = 0xFFFFFFFF; /* for recognizing crashed buffers */
+	header->sb_size = 0xFFFFFFFF; /* for recognizing crashed buffers */
+	/*
+	 * No memory barrier needed to order data_data/sb_size vs commit count
+	 * update, because commit count update contains a compiler barrier that
+	 * ensures the order of the writes are OK from a program POV. It only
+	 * matters for crash dump recovery which is not executed concurrently,
+	 * so memory write order does not matter.
+	 */
+	ltt_write_trace_header(channel->trace, header);
+}
 
-static int ust_buffers_alloc_buf(struct ust_buffer *buf, size_t *size)
+static int map_buf_data(struct ust_buffer *buf, size_t *size)
 {
 	void *ptr;
 	int result;
@@ -76,18 +172,16 @@ static int ust_buffers_alloc_buf(struct ust_buffer *buf, size_t *size)
 	*size = PAGE_ALIGN(*size);
 
 	result = buf->shmid = shmget(getpid(), *size, IPC_CREAT | IPC_EXCL | 0700);
-	if(result == -1 && errno == EINVAL) {
+	if (result < 0 && errno == EINVAL) {
 		ERR("shmget() returned EINVAL; maybe /proc/sys/kernel/shmmax should be increased.");
 		return -1;
-	}
-	else if(result == -1) {
+	} else if (result < 0) {
 		PERROR("shmget");
 		return -1;
 	}
 
-	/* FIXME: should have matching call to shmdt */
 	ptr = shmat(buf->shmid, NULL, 0);
-	if(ptr == (void *) -1) {
+	if (ptr == (void *) -1) {
 		perror("shmat");
 		goto destroy_shmem;
 	}
@@ -106,7 +200,7 @@ static int ust_buffers_alloc_buf(struct ust_buffer *buf, size_t *size)
 
 	return 0;
 
-	destroy_shmem:
+destroy_shmem:
 	result = shmctl(buf->shmid, IPC_RMID, NULL);
 	if(result == -1) {
 		perror("shmctl");
@@ -115,78 +209,88 @@ static int ust_buffers_alloc_buf(struct ust_buffer *buf, size_t *size)
 	return -1;
 }
 
-int ust_buffers_create_buf(struct ust_channel *channel, int cpu)
+static int open_buf(struct ust_channel *chan, int cpu)
 {
-	int result;
-	struct ust_buffer *buf = channel->buf[cpu];
+	int result, fds[2];
+	unsigned int j;
+	struct ust_trace *trace = chan->trace;
+	struct ust_buffer *buf = chan->buf[cpu];
+	unsigned int n_subbufs = chan->subbuf_cnt;
 
-	buf->cpu = cpu;
-	result = ust_buffers_alloc_buf(buf, &channel->alloc_size);
-	if(result)
-		return -1;
 
-	buf->chan = channel;
-	kref_get(&channel->kref);
-	return 0;
-}
+	result = map_buf_data(buf, &chan->alloc_size);
+	if (result < 0)
+		return -1;
 
-static void ust_buffers_destroy_channel(struct kref *kref)
-{
-	struct ust_channel *chan = container_of(kref, struct ust_channel, kref);
-	free(chan);
-}
+	buf->commit_count =
+		zmalloc(sizeof(*buf->commit_count) * n_subbufs);
+	if (!buf->commit_count)
+		goto unmap_buf;
 
-static void ust_buffers_destroy_buf(struct ust_buffer *buf)
-{
-	struct ust_channel *chan = buf->chan;
-	int result;
+	result = pipe(fds);
+	if (result < 0) {
+		PERROR("pipe");
+		goto free_commit_count;
+	}
+	buf->data_ready_fd_read = fds[0];
+	buf->data_ready_fd_write = fds[1];
 
-	result = munmap(buf->buf_data, buf->buf_size);
-	if(result == -1) {
-		PERROR("munmap");
+	buf->cpu = cpu;
+	buf->chan = chan;
+
+	uatomic_set(&buf->offset, ltt_subbuffer_header_size());
+	uatomic_set(&buf->consumed, 0);
+	uatomic_set(&buf->active_readers, 0);
+	for (j = 0; j < n_subbufs; j++) {
+		uatomic_set(&buf->commit_count[j].cc, 0);
+		uatomic_set(&buf->commit_count[j].cc_sb, 0);
 	}
 
-//ust//	chan->buf[buf->cpu] = NULL;
-	free(buf);
-	kref_put(&chan->kref, ust_buffers_destroy_channel);
-}
+	ltt_buffer_begin(buf, trace->start_tsc, 0);
 
-/* called from kref_put */
-static void ust_buffers_remove_buf(struct kref *kref)
-{
-	struct ust_buffer *buf = container_of(kref, struct ust_buffer, kref);
-	ust_buffers_destroy_buf(buf);
-}
+	uatomic_add(&buf->commit_count[0].cc, ltt_subbuffer_header_size());
 
-int ust_buffers_open_buf(struct ust_channel *chan, int cpu)
-{
-	int result;
+	uatomic_set(&buf->events_lost, 0);
+	uatomic_set(&buf->corrupted_subbuffers, 0);
 
-	result = ust_buffers_create_buf(chan, cpu);
-	if (result == -1)
-		return -1;
+	memset(buf->commit_seq, 0, sizeof(buf->commit_seq[0]) * n_subbufs);
 
-	kref_init(&chan->buf[cpu]->kref);
+	return 0;
 
-	result = ust_buffers_init_buffer(chan->trace, chan, chan->buf[cpu], chan->subbuf_cnt);
-	if(result == -1)
-		return -1;
+free_commit_count:
+	free(buf->commit_count);
 
-	return 0;
+unmap_buf:
+	if (shmdt(buf->buf_data) < 0) {
+		PERROR("shmdt failed");
+	}
 
-	/* FIXME: decrementally destroy on error? */
+	return -1;
 }
 
-/**
- *	ust_buffers_close_buf - close a channel buffer
- *	@buf: buffer
- */
-static void ust_buffers_close_buf(struct ust_buffer *buf)
+static void close_buf(struct ust_buffer *buf)
 {
-	kref_put(&buf->kref, ust_buffers_remove_buf);
+	int result;
+
+	result = shmdt(buf->buf_data);
+	if (result < 0) {
+		PERROR("shmdt");
+	}
+
+	result = close(buf->data_ready_fd_read);
+	if (result < 0) {
+		PERROR("close");
+	}
+
+	result = close(buf->data_ready_fd_write);
+	if (result < 0 && errno != EBADF) {
+		PERROR("close");
+	}
 }
 
-int ust_buffers_channel_open(struct ust_channel *chan, size_t subbuf_size, size_t subbuf_cnt)
+
+static int open_channel(struct ust_channel *chan, size_t subbuf_size,
+			size_t subbuf_cnt)
 {
 	int i;
 	int result;
@@ -194,208 +298,91 @@ int ust_buffers_channel_open(struct ust_channel *chan, size_t subbuf_size, size_
 	if(subbuf_size == 0 || subbuf_cnt == 0)
 		return -1;
 
+	/* Check that the subbuffer size is larger than a page. */
+	WARN_ON_ONCE(subbuf_size < PAGE_SIZE);
+
+	/*
+	 * Make sure the number of subbuffers and subbuffer size are power of 2.
+	 */
+	WARN_ON_ONCE(hweight32(subbuf_size) != 1);
+	WARN_ON(hweight32(subbuf_cnt) != 1);
+
 	chan->version = UST_CHANNEL_VERSION;
 	chan->subbuf_cnt = subbuf_cnt;
 	chan->subbuf_size = subbuf_size;
 	chan->subbuf_size_order = get_count_order(subbuf_size);
-	chan->alloc_size = FIX_SIZE(subbuf_size * subbuf_cnt);
+	chan->alloc_size = subbuf_size * subbuf_cnt;
 
-	kref_init(&chan->kref);
-
-	mutex_lock(&ust_buffers_channels_mutex);
-	for(i=0; i<chan->n_cpus; i++) {
-		result = ust_buffers_open_buf(chan, i);
+	pthread_mutex_lock(&ust_buffers_channels_mutex);
+	for (i=0; i < chan->n_cpus; i++) {
+		result = open_buf(chan, i);
 		if (result == -1)
 			goto error;
 	}
-	list_add(&chan->list, &ust_buffers_channels);
-	mutex_unlock(&ust_buffers_channels_mutex);
+	cds_list_add(&chan->list, &ust_buffers_channels);
+	pthread_mutex_unlock(&ust_buffers_channels_mutex);
 
 	return 0;
 
-	/* Jump directly inside the loop to close the buffers that were already
-	 * opened. */
-	for(; i>=0; i--) {
-		ust_buffers_close_buf(chan->buf[i]);
+	/* Error handling */
 error:
-	}
+	for(i--; i >= 0; i--)
+		close_buf(chan->buf[i]);
 
-	kref_put(&chan->kref, ust_buffers_destroy_channel);
-	mutex_unlock(&ust_buffers_channels_mutex);
+	pthread_mutex_unlock(&ust_buffers_channels_mutex);
 	return -1;
 }
 
-void ust_buffers_channel_close(struct ust_channel *chan)
+static void close_channel(struct ust_channel *chan)
 {
 	int i;
 	if(!chan)
 		return;
 
-	mutex_lock(&ust_buffers_channels_mutex);
-	for(i=0; i<chan->n_cpus; i++) {
-	/* FIXME: if we make it here, then all buffers were necessarily allocated. Moreover, we don't
-	 * initialize to NULL so we cannot use this check. Should we? */
-//ust//		if (chan->buf[i])
-			ust_buffers_close_buf(chan->buf[i]);
+	pthread_mutex_lock(&ust_buffers_channels_mutex);
+	/*
+	 * checking for chan->buf[i] being NULL or not is useless in
+	 * practice because we allocate buffers for all possible cpus.
+	 * However, should we decide to change this and only allocate
+	 * for online cpus, this check becomes useful.
+	 */
+	for (i=0; i<chan->n_cpus; i++) {
+		if (chan->buf[i])
+			close_buf(chan->buf[i]);
 	}
 
-	list_del(&chan->list);
-	kref_put(&chan->kref, ust_buffers_destroy_channel);
-	mutex_unlock(&ust_buffers_channels_mutex);
-}
-
-/* _ust_buffers_write()
- *
- * @buf: destination buffer
- * @offset: offset in destination
- * @src: source buffer
- * @len: length of source
- * @cpy: already copied
- */
-
-void _ust_buffers_write(struct ust_buffer *buf, size_t offset,
-	const void *src, size_t len, ssize_t cpy)
-{
-	do {
-		len -= cpy;
-		src += cpy;
-		offset += cpy;
-
-		WARN_ON(offset >= buf->buf_size);
-
-		cpy = min_t(size_t, len, buf->buf_size - offset);
-		ust_buffers_do_copy(buf->buf_data + offset, src, cpy);
-	} while (unlikely(len != cpy));
-}
-
-void *ltt_buffers_offset_address(struct ust_buffer *buf, size_t offset)
-{
-	return ((char *)buf->buf_data)+offset;
-}
-
-/*
- * -------
- */
-
-/*
- * Last TSC comparison functions. Check if the current TSC overflows
- * LTT_TSC_BITS bits from the last TSC read. Reads and writes last_tsc
- * atomically.
- */
-
-/* FIXME: does this test work properly? */
-#if (BITS_PER_LONG == 32)
-static inline void save_last_tsc(struct ust_buffer *ltt_buf,
-					u64 tsc)
-{
-	ltt_buf->last_tsc = (unsigned long)(tsc >> LTT_TSC_BITS);
-}
-
-static inline int last_tsc_overflow(struct ust_buffer *ltt_buf,
-					u64 tsc)
-{
-	unsigned long tsc_shifted = (unsigned long)(tsc >> LTT_TSC_BITS);
-
-	if (unlikely((tsc_shifted - ltt_buf->last_tsc)))
-		return 1;
-	else
-		return 0;
-}
-#else
-static inline void save_last_tsc(struct ust_buffer *ltt_buf,
-					u64 tsc)
-{
-	ltt_buf->last_tsc = (unsigned long)tsc;
-}
-
-static inline int last_tsc_overflow(struct ust_buffer *ltt_buf,
-					u64 tsc)
-{
-	if (unlikely((tsc - ltt_buf->last_tsc) >> LTT_TSC_BITS))
-		return 1;
-	else
-		return 0;
-}
-#endif
-
-/*
- * A switch is done during tracing or as a final flush after tracing (so it
- * won't write in the new sub-buffer).
- */
-enum force_switch_mode { FORCE_ACTIVE, FORCE_FLUSH };
-
-static void ust_buffers_destroy_buffer(struct ust_channel *ltt_chan, int cpu);
-
-static void ltt_force_switch(struct ust_buffer *buf,
-		enum force_switch_mode mode);
-
-/*
- * Trace callbacks
- */
-static void ltt_buffer_begin_callback(struct ust_buffer *buf,
-			u64 tsc, unsigned int subbuf_idx)
-{
-	struct ust_channel *channel = buf->chan;
-	struct ltt_subbuffer_header *header =
-		(struct ltt_subbuffer_header *)
-			ltt_buffers_offset_address(buf,
-				subbuf_idx * buf->chan->subbuf_size);
+	cds_list_del(&chan->list);
 
-	header->cycle_count_begin = tsc;
-	header->lost_size = 0xFFFFFFFF; /* for debugging */
-	header->buf_size = buf->chan->subbuf_size;
-	ltt_write_trace_header(channel->trace, header);
+	pthread_mutex_unlock(&ust_buffers_channels_mutex);
 }
 
 /*
  * offset is assumed to never be 0 here : never deliver a completely empty
  * subbuffer. The lost size is between 0 and subbuf_size-1.
  */
-static notrace void ltt_buffer_end_callback(struct ust_buffer *buf,
+static notrace void ltt_buffer_end(struct ust_buffer *buf,
 		u64 tsc, unsigned int offset, unsigned int subbuf_idx)
 {
 	struct ltt_subbuffer_header *header =
 		(struct ltt_subbuffer_header *)
-			ltt_buffers_offset_address(buf,
+			ust_buffers_offset_address(buf,
 				subbuf_idx * buf->chan->subbuf_size);
+	u32 data_size = SUBBUF_OFFSET(offset - 1, buf->chan) + 1;
 
-	header->lost_size = SUBBUF_OFFSET((buf->chan->subbuf_size - offset),
-				buf->chan);
+	header->sb_size = PAGE_ALIGN(data_size);
 	header->cycle_count_end = tsc;
-	header->events_lost = local_read(&buf->events_lost);
-	header->subbuf_corrupt = local_read(&buf->corrupted_subbuffers);
-
-}
-
-void (*wake_consumer)(void *, int) = NULL;
-
-void relay_set_wake_consumer(void (*wake)(void *, int))
-{
-	wake_consumer = wake;
-}
-
-void relay_wake_consumer(void *arg, int finished)
-{
-	if(wake_consumer)
-		wake_consumer(arg, finished);
-}
-
-static notrace void ltt_deliver(struct ust_buffer *buf, unsigned int subbuf_idx,
-		long commit_count)
-{
-	int result;
-
-//ust// #ifdef CONFIG_LTT_VMCORE
-	local_set(&buf->commit_seq[subbuf_idx], commit_count);
-//ust// #endif
-
-	/* wakeup consumer */
-	result = write(buf->data_ready_fd_write, "1", 1);
-	if(result == -1) {
-		PERROR("write (in ltt_relay_buffer_flush)");
-		ERR("this should never happen!");
+	header->events_lost = uatomic_read(&buf->events_lost);
+	header->subbuf_corrupt = uatomic_read(&buf->corrupted_subbuffers);
+	if(unlikely(header->events_lost > 0)) {
+		DBG("Some events (%d) were lost in %s_%d", header->events_lost, buf->chan->channel_name, buf->cpu);
 	}
-//ust//	atomic_set(&ltt_buf->wakeup_readers, 1);
+	/*
+	 * Makes sure data_size write happens after write of the rest of the
+	 * buffer end data, because data_size is used to identify a completely
+	 * written subbuffer in a crash dump.
+	 */
+	cmm_barrier();
+	header->data_size = data_size;
 }
 
 /*
@@ -405,28 +392,42 @@ static notrace void ltt_buf_unfull(struct ust_buffer *buf,
 		unsigned int subbuf_idx,
 		long offset)
 {
-//ust//	struct ltt_channel_struct *ltt_channel =
-//ust//		(struct ltt_channel_struct *)buf->chan->private_data;
-//ust//	struct ltt_channel_buf_struct *ltt_buf = ltt_channel->buf;
-//ust//
-//ust//	ltt_relay_wake_writers(ltt_buf);
 }
 
-int ust_buffers_do_get_subbuf(struct ust_buffer *buf, long *pconsumed_old)
+/*
+ * Promote compiler cmm_barrier to a smp_mb().
+ * For the specific LTTng case, this IPI call should be removed if the
+ * architecture does not reorder writes.  This should eventually be provided by
+ * a separate architecture-specific infrastructure.
+ */
+//ust// static void remote_mb(void *info)
+//ust// {
+//ust// 	smp_mb();
+//ust// }
+
+int ust_buffers_get_subbuf(struct ust_buffer *buf, long *consumed)
 {
 	struct ust_channel *channel = buf->chan;
 	long consumed_old, consumed_idx, commit_count, write_offset;
-	consumed_old = atomic_long_read(&buf->consumed);
+//ust//	int retval;
+
+	consumed_old = uatomic_read(&buf->consumed);
 	consumed_idx = SUBBUF_INDEX(consumed_old, buf->chan);
-	commit_count = local_read(&buf->commit_count[consumed_idx]);
+	commit_count = uatomic_read(&buf->commit_count[consumed_idx].cc_sb);
 	/*
 	 * Make sure we read the commit count before reading the buffer
 	 * data and the write offset. Correct consumed offset ordering
 	 * wrt commit count is insured by the use of cmpxchg to update
 	 * the consumed offset.
 	 */
-	smp_rmb();
-	write_offset = local_read(&buf->offset);
+
+	/*
+	 * Local rmb to match the remote wmb to read the commit count before the
+	 * buffer data and the write offset.
+	 */
+	cmm_smp_rmb();
+
+	write_offset = uatomic_read(&buf->offset);
 	/*
 	 * Check that the subbuffer we are trying to consume has been
 	 * already fully committed.
@@ -447,28 +448,26 @@ int ust_buffers_do_get_subbuf(struct ust_buffer *buf, long *pconsumed_old)
 	   == 0) {
 		return -EAGAIN;
 	}
+	*consumed = consumed_old;
 
-	*pconsumed_old = consumed_old;
 	return 0;
 }
 
-int ust_buffers_do_put_subbuf(struct ust_buffer *buf, u32 uconsumed_old)
+int ust_buffers_put_subbuf(struct ust_buffer *buf, unsigned long uconsumed_old)
 {
 	long consumed_new, consumed_old;
 
-	consumed_old = atomic_long_read(&buf->consumed);
+	consumed_old = uatomic_read(&buf->consumed);
 	consumed_old = consumed_old & (~0xFFFFFFFFL);
 	consumed_old = consumed_old | uconsumed_old;
 	consumed_new = SUBBUF_ALIGN(consumed_old, buf->chan);
 
-//ust//	spin_lock(&ltt_buf->full_lock);
-	if (atomic_long_cmpxchg(&buf->consumed, consumed_old,
+	if (uatomic_cmpxchg(&buf->consumed, consumed_old,
 				consumed_new)
 	    != consumed_old) {
 		/* We have been pushed by the writer : the last
 		 * buffer read _is_ corrupted! It can also
 		 * happen if this is a buffer we never got. */
-//ust//		spin_unlock(&ltt_buf->full_lock);
 		return -EIO;
 	} else {
 		/* tell the client that buffer is now unfull */
@@ -477,197 +476,11 @@ int ust_buffers_do_put_subbuf(struct ust_buffer *buf, u32 uconsumed_old)
 		index = SUBBUF_INDEX(consumed_old, buf->chan);
 		data = BUFFER_OFFSET(consumed_old, buf->chan);
 		ltt_buf_unfull(buf, index, data);
-//ust//		spin_unlock(&ltt_buf->full_lock);
-	}
-	return 0;
-}
-
-static void ltt_relay_print_subbuffer_errors(
-		struct ust_channel *channel,
-		long cons_off, int cpu)
-{
-	struct ust_buffer *ltt_buf = channel->buf[cpu];
-	long cons_idx, commit_count, write_offset;
-
-	cons_idx = SUBBUF_INDEX(cons_off, channel);
-	commit_count = local_read(&ltt_buf->commit_count[cons_idx]);
-	/*
-	 * No need to order commit_count and write_offset reads because we
-	 * execute after trace is stopped when there are no readers left.
-	 */
-	write_offset = local_read(&ltt_buf->offset);
-	WARN( "LTT : unread channel %s offset is %ld "
-		"and cons_off : %ld\n",
-		channel->channel_name, write_offset, cons_off);
-	/* Check each sub-buffer for non filled commit count */
-	if (((commit_count - channel->subbuf_size) & channel->commit_count_mask)
-	    - (BUFFER_TRUNC(cons_off, channel) >> channel->n_subbufs_order) != 0) {
-		ERR("LTT : %s : subbuffer %lu has non filled "
-			"commit count %lu.\n",
-			channel->channel_name, cons_idx, commit_count);
-	}
-	ERR("LTT : %s : commit count : %lu, subbuf size %zd\n",
-			channel->channel_name, commit_count,
-			channel->subbuf_size);
-}
-
-static void ltt_relay_print_errors(struct ltt_trace_struct *trace,
-		struct ust_channel *channel, int cpu)
-{
-	struct ust_buffer *ltt_buf = channel->buf[cpu];
-	long cons_off;
-
-	/*
-	 * Can be called in the error path of allocation when
-	 * trans_channel_data is not yet set.
-	 */
-	if (!channel)
-	        return;
-
-	for (cons_off = atomic_long_read(&ltt_buf->consumed);
-			(SUBBUF_TRUNC(local_read(&ltt_buf->offset),
-				      channel)
-			 - cons_off) > 0;
-			cons_off = SUBBUF_ALIGN(cons_off, channel))
-		ltt_relay_print_subbuffer_errors(channel, cons_off, cpu);
-}
-
-static void ltt_relay_print_buffer_errors(struct ust_channel *channel, int cpu)
-{
-	struct ltt_trace_struct *trace = channel->trace;
-	struct ust_buffer *ltt_buf = channel->buf[cpu];
-
-	if (local_read(&ltt_buf->events_lost))
-		ERR("channel %s: %ld events lost",
-			channel->channel_name,
-			local_read(&ltt_buf->events_lost));
-	if (local_read(&ltt_buf->corrupted_subbuffers))
-		ERR("channel %s : %ld corrupted subbuffers",
-			channel->channel_name,
-			local_read(&ltt_buf->corrupted_subbuffers));
-
-	ltt_relay_print_errors(trace, channel, cpu);
-}
-
-static void ltt_relay_release_channel(struct kref *kref)
-{
-	struct ust_channel *ltt_chan = container_of(kref,
-			struct ust_channel, kref);
-	free(ltt_chan->buf);
-}
-
-/*
- * Create ltt buffer.
- */
-//ust// static int ltt_relay_create_buffer(struct ltt_trace_struct *trace,
-//ust// 		struct ltt_channel_struct *ltt_chan, struct rchan_buf *buf,
-//ust// 		unsigned int cpu, unsigned int n_subbufs)
-//ust// {
-//ust// 	struct ltt_channel_buf_struct *ltt_buf =
-//ust// 		percpu_ptr(ltt_chan->buf, cpu);
-//ust// 	unsigned int j;
-//ust// 
-//ust// 	ltt_buf->commit_count =
-//ust// 		kzalloc_node(sizeof(ltt_buf->commit_count) * n_subbufs,
-//ust// 			GFP_KERNEL, cpu_to_node(cpu));
-//ust// 	if (!ltt_buf->commit_count)
-//ust// 		return -ENOMEM;
-//ust// 	kref_get(&trace->kref);
-//ust// 	kref_get(&trace->ltt_transport_kref);
-//ust// 	kref_get(&ltt_chan->kref);
-//ust// 	local_set(&ltt_buf->offset, ltt_subbuffer_header_size());
-//ust// 	atomic_long_set(&ltt_buf->consumed, 0);
-//ust// 	atomic_long_set(&ltt_buf->active_readers, 0);
-//ust// 	for (j = 0; j < n_subbufs; j++)
-//ust// 		local_set(&ltt_buf->commit_count[j], 0);
-//ust// 	init_waitqueue_head(&ltt_buf->write_wait);
-//ust// 	atomic_set(&ltt_buf->wakeup_readers, 0);
-//ust// 	spin_lock_init(&ltt_buf->full_lock);
-//ust// 
-//ust// 	ltt_buffer_begin_callback(buf, trace->start_tsc, 0);
-//ust// 	/* atomic_add made on local variable on data that belongs to
-//ust// 	 * various CPUs : ok because tracing not started (for this cpu). */
-//ust// 	local_add(ltt_subbuffer_header_size(), &ltt_buf->commit_count[0]);
-//ust// 
-//ust// 	local_set(&ltt_buf->events_lost, 0);
-//ust// 	local_set(&ltt_buf->corrupted_subbuffers, 0);
-//ust// 
-//ust// 	return 0;
-//ust// }
-
-static int ust_buffers_init_buffer(struct ltt_trace_struct *trace,
-		struct ust_channel *ltt_chan, struct ust_buffer *buf,
-		unsigned int n_subbufs)
-{
-	unsigned int j;
-	int fds[2];
-	int result;
-
-	buf->commit_count =
-		zmalloc(sizeof(buf->commit_count) * n_subbufs);
-	if (!buf->commit_count)
-		return -ENOMEM;
-	kref_get(&trace->kref);
-	kref_get(&trace->ltt_transport_kref);
-	kref_get(&ltt_chan->kref);
-	local_set(&buf->offset, ltt_subbuffer_header_size());
-	atomic_long_set(&buf->consumed, 0);
-	atomic_long_set(&buf->active_readers, 0);
-	for (j = 0; j < n_subbufs; j++)
-		local_set(&buf->commit_count[j], 0);
-//ust//	init_waitqueue_head(&buf->write_wait);
-//ust//	atomic_set(&buf->wakeup_readers, 0);
-//ust//	spin_lock_init(&buf->full_lock);
-
-	ltt_buffer_begin_callback(buf, trace->start_tsc, 0);
-
-	local_add(ltt_subbuffer_header_size(), &buf->commit_count[0]);
-
-	local_set(&buf->events_lost, 0);
-	local_set(&buf->corrupted_subbuffers, 0);
-
-	result = pipe(fds);
-	if(result == -1) {
-		PERROR("pipe");
-		return -1;
-	}
-	buf->data_ready_fd_read = fds[0];
-	buf->data_ready_fd_write = fds[1];
-
-	/* FIXME: do we actually need this? */
-	result = fcntl(fds[0], F_SETFL, O_NONBLOCK);
-	if(result == -1) {
-		PERROR("fcntl");
 	}
-
-//ust//	buf->commit_seq = malloc(sizeof(buf->commit_seq) * n_subbufs);
-//ust//	if(!ltt_buf->commit_seq) {
-//ust//		return -1;
-//ust//	}
-
-	/* FIXME: decrementally destroy on error */
-
 	return 0;
 }
 
-/* FIXME: use this function */
-static void ust_buffers_destroy_buffer(struct ust_channel *ltt_chan, int cpu)
-{
-	struct ltt_trace_struct *trace = ltt_chan->trace;
-	struct ust_buffer *ltt_buf = ltt_chan->buf[cpu];
-
-	kref_put(&ltt_chan->trace->ltt_transport_kref,
-		ltt_release_transport);
-	ltt_relay_print_buffer_errors(ltt_chan, cpu);
-//ust//	free(ltt_buf->commit_seq);
-	kfree(ltt_buf->commit_count);
-	ltt_buf->commit_count = NULL;
-	kref_put(&ltt_chan->kref, ltt_relay_release_channel);
-	kref_put(&trace->kref, ltt_release_trace);
-//ust//	wake_up_interruptible(&trace->kref_wq);
-}
-
-static int ust_buffers_alloc_channel_buf_structs(struct ust_channel *chan)
+static int map_buf_structs(struct ust_channel *chan)
 {
 	void *ptr;
 	int result;
@@ -684,7 +497,6 @@ static int ust_buffers_alloc_channel_buf_structs(struct ust_channel *chan)
 			goto destroy_previous;
 		}
 
-		/* FIXME: should have matching call to shmdt */
 		ptr = shmat(chan->buf_struct_shmids[i], NULL, 0);
 		if(ptr == (void *) -1) {
 			perror("shmat");
@@ -722,148 +534,360 @@ static int ust_buffers_alloc_channel_buf_structs(struct ust_channel *chan)
 	return -1;
 }
 
+static int unmap_buf_structs(struct ust_channel *chan)
+{
+	int i;
+
+	for (i=0; i < chan->n_cpus; i++) {
+		if (shmdt(chan->buf[i]) < 0) {
+			PERROR("shmdt");
+		}
+	}
+	return 0;
+}
+
 /*
  * Create channel.
  */
-static int ust_buffers_create_channel(const char *trace_name, struct ltt_trace_struct *trace,
-	const char *channel_name, struct ust_channel *ltt_chan,
+static int create_channel(const char *trace_name, struct ust_trace *trace,
+	const char *channel_name, struct ust_channel *chan,
 	unsigned int subbuf_size, unsigned int n_subbufs, int overwrite)
 {
-	int result;
+	int i, result;
+
+	chan->trace = trace;
+	chan->overwrite = overwrite;
+	chan->n_subbufs_order = get_count_order(n_subbufs);
+	chan->commit_count_mask = (~0UL >> chan->n_subbufs_order);
+	chan->n_cpus = get_n_cpus();
 
-	kref_init(&ltt_chan->kref);
-
-	ltt_chan->trace = trace;
-	ltt_chan->buffer_begin = ltt_buffer_begin_callback;
-	ltt_chan->buffer_end = ltt_buffer_end_callback;
-	ltt_chan->overwrite = overwrite;
-	ltt_chan->n_subbufs_order = get_count_order(n_subbufs);
-	ltt_chan->commit_count_mask = (~0UL >> ltt_chan->n_subbufs_order);
-	ltt_chan->n_cpus = get_n_cpus();
-//ust//	ltt_chan->buf = percpu_alloc_mask(sizeof(struct ltt_channel_buf_struct), GFP_KERNEL, cpu_possible_map);
-	ltt_chan->buf = (void *) malloc(ltt_chan->n_cpus * sizeof(void *));
-	if(ltt_chan->buf == NULL) {
+	/* These mappings should ideall be per-cpu, if somebody can do that
+	 * from userspace, that would be cool!
+	 */
+	chan->buf = (void *) zmalloc(chan->n_cpus * sizeof(void *));
+	if(chan->buf == NULL) {
 		goto error;
 	}
-	ltt_chan->buf_struct_shmids = (int *) malloc(ltt_chan->n_cpus * sizeof(int));
-	if(ltt_chan->buf_struct_shmids == NULL)
+	chan->buf_struct_shmids = (int *) zmalloc(chan->n_cpus * sizeof(int));
+	if(chan->buf_struct_shmids == NULL)
 		goto free_buf;
 
-	result = ust_buffers_alloc_channel_buf_structs(ltt_chan);
+	result = map_buf_structs(chan);
 	if(result != 0) {
 		goto free_buf_struct_shmids;
 	}
 
-	result = ust_buffers_channel_open(ltt_chan, subbuf_size, n_subbufs);
+	result = open_channel(chan, subbuf_size, n_subbufs);
 	if (result != 0) {
 		ERR("Cannot open channel for trace %s", trace_name);
-		goto unalloc_buf_structs;
+		goto unmap_buf_structs;
 	}
 
 	return 0;
 
-unalloc_buf_structs:
-	/* FIXME: put a call here to unalloc the buf structs! */
+unmap_buf_structs:
+	for (i=0; i < chan->n_cpus; i++) {
+		if (shmdt(chan->buf[i]) < 0) {
+			PERROR("shmdt bufstruct");
+		}
+	}
 
 free_buf_struct_shmids:
-	free(ltt_chan->buf_struct_shmids);
+	free(chan->buf_struct_shmids);
 
 free_buf:
-	free(ltt_chan->buf);
+	free(chan->buf);
 
 error:
 	return -1;
 }
 
-/*
- * LTTng channel flush function.
- *
- * Must be called when no tracing is active in the channel, because of
- * accesses across CPUs.
- */
-static notrace void ltt_relay_buffer_flush(struct ust_buffer *buf)
+
+static void remove_channel(struct ust_channel *chan)
 {
-	int result;
+	close_channel(chan);
 
-//ust//	buf->finalized = 1;
-	ltt_force_switch(buf, FORCE_FLUSH);
+	unmap_buf_structs(chan);
 
-	result = write(buf->data_ready_fd_write, "1", 1);
-	if(result == -1) {
-		PERROR("write (in ltt_relay_buffer_flush)");
-		ERR("this should never happen!");
-	}
+	free(chan->buf_struct_shmids);
+
+	free(chan->buf);
 }
 
 static void ltt_relay_async_wakeup_chan(struct ust_channel *ltt_channel)
 {
-//ust//	unsigned int i;
-//ust//	struct rchan *rchan = ltt_channel->trans_channel_data;
-//ust//
-//ust//	for_each_possible_cpu(i) {
-//ust//		struct ltt_channel_buf_struct *ltt_buf =
-//ust//			percpu_ptr(ltt_channel->buf, i);
-//ust//
-//ust//		if (atomic_read(&ltt_buf->wakeup_readers) == 1) {
-//ust//			atomic_set(&ltt_buf->wakeup_readers, 0);
-//ust//			wake_up_interruptible(&rchan->buf[i]->read_wait);
-//ust//		}
-//ust//	}
 }
 
 static void ltt_relay_finish_buffer(struct ust_channel *channel, unsigned int cpu)
 {
-//	int result;
-
 	if (channel->buf[cpu]) {
 		struct ust_buffer *buf = channel->buf[cpu];
-		ltt_relay_buffer_flush(buf);
-//ust//		ltt_relay_wake_writers(ltt_buf);
+		ltt_force_switch(buf, FORCE_FLUSH);
+
 		/* closing the pipe tells the consumer the buffer is finished */
-		
-		//result = write(ltt_buf->data_ready_fd_write, "D", 1);
-		//if(result == -1) {
-		//	PERROR("write (in ltt_relay_finish_buffer)");
-		//	ERR("this should never happen!");
-		//}
 		close(buf->data_ready_fd_write);
 	}
 }
 
 
-static void ltt_relay_finish_channel(struct ust_channel *channel)
+static void finish_channel(struct ust_channel *channel)
 {
 	unsigned int i;
 
-	for(i=0; i<channel->n_cpus; i++) {
+	for (i=0; i<channel->n_cpus; i++) {
 		ltt_relay_finish_buffer(channel, i);
 	}
 }
 
-static void ltt_relay_remove_channel(struct ust_channel *channel)
+
+/*
+ * ltt_reserve_switch_old_subbuf: switch old subbuffer
+ *
+ * Concurrency safe because we are the last and only thread to alter this
+ * sub-buffer. As long as it is not delivered and read, no other thread can
+ * alter the offset, alter the reserve_count or call the
+ * client_buffer_end_callback on this sub-buffer.
+ *
+ * The only remaining threads could be the ones with pending commits. They will
+ * have to do the deliver themselves.  Not concurrency safe in overwrite mode.
+ * We detect corrupted subbuffers with commit and reserve counts. We keep a
+ * corrupted sub-buffers count and push the readers across these sub-buffers.
+ *
+ * Not concurrency safe if a writer is stalled in a subbuffer and another writer
+ * switches in, finding out it's corrupted.  The result will be than the old
+ * (uncommited) subbuffer will be declared corrupted, and that the new subbuffer
+ * will be declared corrupted too because of the commit count adjustment.
+ *
+ * Note : offset_old should never be 0 here.
+ */
+static void ltt_reserve_switch_old_subbuf(
+		struct ust_channel *chan, struct ust_buffer *buf,
+		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
 {
-	ust_buffers_channel_close(channel);
-	kref_put(&channel->kref, ltt_relay_release_channel);
+	long oldidx = SUBBUF_INDEX(offsets->old - 1, chan);
+	long commit_count, padding_size;
+
+	padding_size = chan->subbuf_size
+			- (SUBBUF_OFFSET(offsets->old - 1, chan) + 1);
+	ltt_buffer_end(buf, *tsc, offsets->old, oldidx);
+
+	/*
+	 * Must write slot data before incrementing commit count.
+	 * This compiler barrier is upgraded into a cmm_smp_wmb() by the IPI
+	 * sent by get_subbuf() when it does its cmm_smp_rmb().
+	 */
+	cmm_smp_wmb();
+	uatomic_add(&buf->commit_count[oldidx].cc, padding_size);
+	commit_count = uatomic_read(&buf->commit_count[oldidx].cc);
+	ltt_check_deliver(chan, buf, offsets->old - 1, commit_count, oldidx);
+	ltt_write_commit_counter(chan, buf, oldidx,
+		offsets->old, commit_count, padding_size);
 }
 
-struct ltt_reserve_switch_offsets {
-	long begin, end, old;
-	long begin_switch, end_switch_current, end_switch_old;
-	long commit_count, reserve_commit_diff;
-	size_t before_hdr_pad, size;
-};
+/*
+ * ltt_reserve_switch_new_subbuf: Populate new subbuffer.
+ *
+ * This code can be executed unordered : writers may already have written to the
+ * sub-buffer before this code gets executed, caution.  The commit makes sure
+ * that this code is executed before the deliver of this sub-buffer.
+ */
+static void ltt_reserve_switch_new_subbuf(
+		struct ust_channel *chan, struct ust_buffer *buf,
+		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
+{
+	long beginidx = SUBBUF_INDEX(offsets->begin, chan);
+	long commit_count;
+
+	ltt_buffer_begin(buf, *tsc, beginidx);
+
+	/*
+	 * Must write slot data before incrementing commit count.
+	 * This compiler barrier is upgraded into a cmm_smp_wmb() by the IPI
+	 * sent by get_subbuf() when it does its cmm_smp_rmb().
+	 */
+	cmm_smp_wmb();
+	uatomic_add(&buf->commit_count[beginidx].cc, ltt_subbuffer_header_size());
+	commit_count = uatomic_read(&buf->commit_count[beginidx].cc);
+	/* Check if the written buffer has to be delivered */
+	ltt_check_deliver(chan, buf, offsets->begin, commit_count, beginidx);
+	ltt_write_commit_counter(chan, buf, beginidx,
+		offsets->begin, commit_count, ltt_subbuffer_header_size());
+}
+
+/*
+ * ltt_reserve_end_switch_current: finish switching current subbuffer
+ *
+ * Concurrency safe because we are the last and only thread to alter this
+ * sub-buffer. As long as it is not delivered and read, no other thread can
+ * alter the offset, alter the reserve_count or call the
+ * client_buffer_end_callback on this sub-buffer.
+ *
+ * The only remaining threads could be the ones with pending commits. They will
+ * have to do the deliver themselves.  Not concurrency safe in overwrite mode.
+ * We detect corrupted subbuffers with commit and reserve counts. We keep a
+ * corrupted sub-buffers count and push the readers across these sub-buffers.
+ *
+ * Not concurrency safe if a writer is stalled in a subbuffer and another writer
+ * switches in, finding out it's corrupted.  The result will be than the old
+ * (uncommited) subbuffer will be declared corrupted, and that the new subbuffer
+ * will be declared corrupted too because of the commit count adjustment.
+ */
+static void ltt_reserve_end_switch_current(
+		struct ust_channel *chan,
+		struct ust_buffer *buf,
+		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
+{
+	long endidx = SUBBUF_INDEX(offsets->end - 1, chan);
+	long commit_count, padding_size;
+
+	padding_size = chan->subbuf_size
+			- (SUBBUF_OFFSET(offsets->end - 1, chan) + 1);
+
+	ltt_buffer_end(buf, *tsc, offsets->end, endidx);
+
+	/*
+	 * Must write slot data before incrementing commit count.
+	 * This compiler barrier is upgraded into a cmm_smp_wmb() by the IPI
+	 * sent by get_subbuf() when it does its cmm_smp_rmb().
+	 */
+	cmm_smp_wmb();
+	uatomic_add(&buf->commit_count[endidx].cc, padding_size);
+	commit_count = uatomic_read(&buf->commit_count[endidx].cc);
+	ltt_check_deliver(chan, buf,
+		offsets->end - 1, commit_count, endidx);
+	ltt_write_commit_counter(chan, buf, endidx,
+		offsets->end, commit_count, padding_size);
+}
+
+/*
+ * Returns :
+ * 0 if ok
+ * !0 if execution must be aborted.
+ */
+static int ltt_relay_try_switch_slow(
+		enum force_switch_mode mode,
+		struct ust_channel *chan,
+		struct ust_buffer *buf,
+		struct ltt_reserve_switch_offsets *offsets,
+		u64 *tsc)
+{
+	long subbuf_index;
+	long reserve_commit_diff;
+
+	offsets->begin = uatomic_read(&buf->offset);
+	offsets->old = offsets->begin;
+	offsets->begin_switch = 0;
+	offsets->end_switch_old = 0;
+
+	*tsc = trace_clock_read64();
+
+	if (SUBBUF_OFFSET(offsets->begin, buf->chan) != 0) {
+		offsets->begin = SUBBUF_ALIGN(offsets->begin, buf->chan);
+		offsets->end_switch_old = 1;
+	} else {
+		/* we do not have to switch : buffer is empty */
+		return -1;
+	}
+	if (mode == FORCE_ACTIVE)
+		offsets->begin += ltt_subbuffer_header_size();
+	/*
+	 * Always begin_switch in FORCE_ACTIVE mode.
+	 * Test new buffer integrity
+	 */
+	subbuf_index = SUBBUF_INDEX(offsets->begin, buf->chan);
+	reserve_commit_diff =
+		(BUFFER_TRUNC(offsets->begin, buf->chan)
+		 >> chan->n_subbufs_order)
+		- (uatomic_read(&buf->commit_count[subbuf_index].cc_sb)
+			& chan->commit_count_mask);
+	if (reserve_commit_diff == 0) {
+		/* Next buffer not corrupted. */
+		if (mode == FORCE_ACTIVE
+		    && !chan->overwrite
+		    && offsets->begin - uatomic_read(&buf->consumed)
+		       >= chan->alloc_size) {
+			/*
+			 * We do not overwrite non consumed buffers and we are
+			 * full : ignore switch while tracing is active.
+			 */
+			return -1;
+		}
+	} else {
+		/*
+		 * Next subbuffer corrupted. Force pushing reader even in normal
+		 * mode
+		 */
+	}
+	offsets->end = offsets->begin;
+	return 0;
+}
+
+/*
+ * Force a sub-buffer switch for a per-cpu buffer. This operation is
+ * completely reentrant : can be called while tracing is active with
+ * absolutely no lock held.
+ */
+void ltt_force_switch_lockless_slow(struct ust_buffer *buf,
+		enum force_switch_mode mode)
+{
+	struct ust_channel *chan = buf->chan;
+	struct ltt_reserve_switch_offsets offsets;
+	u64 tsc;
+
+	offsets.size = 0;
+
+	DBG("Switching (forced) %s_%d", chan->channel_name, buf->cpu);
+	/*
+	 * Perform retryable operations.
+	 */
+	do {
+		if (ltt_relay_try_switch_slow(mode, chan, buf,
+				&offsets, &tsc))
+			return;
+	} while (uatomic_cmpxchg(&buf->offset, offsets.old,
+			offsets.end) != offsets.old);
+
+	/*
+	 * Atomically update last_tsc. This update races against concurrent
+	 * atomic updates, but the race will always cause supplementary full TSC
+	 * events, never the opposite (missing a full TSC event when it would be
+	 * needed).
+	 */
+	save_last_tsc(buf, tsc);
+
+	/*
+	 * Push the reader if necessary
+	 */
+	if (mode == FORCE_ACTIVE) {
+		ltt_reserve_push_reader(chan, buf, offsets.end - 1);
+	}
+
+	/*
+	 * Switch old subbuffer if needed.
+	 */
+	if (offsets.end_switch_old) {
+		ltt_reserve_switch_old_subbuf(chan, buf, &offsets, &tsc);
+	}
+
+	/*
+	 * Populate new subbuffer.
+	 */
+	if (mode == FORCE_ACTIVE)
+		ltt_reserve_switch_new_subbuf(chan, buf, &offsets, &tsc);
+}
 
 /*
  * Returns :
  * 0 if ok
  * !0 if execution must be aborted.
  */
-static inline int ltt_relay_try_reserve(
-		struct ust_channel *channel, struct ust_buffer *buf,
+static int ltt_relay_try_reserve_slow(struct ust_channel *chan, struct ust_buffer *buf,
 		struct ltt_reserve_switch_offsets *offsets, size_t data_size,
 		u64 *tsc, unsigned int *rflags, int largest_align)
 {
-	offsets->begin = local_read(&buf->offset);
+	long reserve_commit_diff;
+
+	offsets->begin = uatomic_read(&buf->offset);
 	offsets->old = offsets->begin;
 	offsets->begin_switch = 0;
 	offsets->end_switch_current = 0;
@@ -873,59 +897,51 @@ static inline int ltt_relay_try_reserve(
 	if (last_tsc_overflow(buf, *tsc))
 		*rflags = LTT_RFLAG_ID_SIZE_TSC;
 
-	if (SUBBUF_OFFSET(offsets->begin, buf->chan) == 0) {
+	if (unlikely(SUBBUF_OFFSET(offsets->begin, buf->chan) == 0)) {
 		offsets->begin_switch = 1;		/* For offsets->begin */
 	} else {
-		offsets->size = ust_get_header_size(channel,
+		offsets->size = ust_get_header_size(chan,
 					offsets->begin, data_size,
 					&offsets->before_hdr_pad, *rflags);
 		offsets->size += ltt_align(offsets->begin + offsets->size,
 					   largest_align)
 				 + data_size;
-		if ((SUBBUF_OFFSET(offsets->begin, buf->chan) + offsets->size)
-				> buf->chan->subbuf_size) {
+		if (unlikely((SUBBUF_OFFSET(offsets->begin, buf->chan) +
+			     offsets->size) > buf->chan->subbuf_size)) {
 			offsets->end_switch_old = 1;	/* For offsets->old */
 			offsets->begin_switch = 1;	/* For offsets->begin */
 		}
 	}
-	if (offsets->begin_switch) {
+	if (unlikely(offsets->begin_switch)) {
 		long subbuf_index;
 
-		if (offsets->end_switch_old)
+		/*
+		 * We are typically not filling the previous buffer completely.
+		 */
+		if (likely(offsets->end_switch_old))
 			offsets->begin = SUBBUF_ALIGN(offsets->begin,
 						      buf->chan);
 		offsets->begin = offsets->begin + ltt_subbuffer_header_size();
 		/* Test new buffer integrity */
 		subbuf_index = SUBBUF_INDEX(offsets->begin, buf->chan);
-		offsets->reserve_commit_diff =
-			(BUFFER_TRUNC(offsets->begin, buf->chan)
-			 >> channel->n_subbufs_order)
-			- (local_read(&buf->commit_count[subbuf_index])
-				& channel->commit_count_mask);
-		if (offsets->reserve_commit_diff == 0) {
-			long consumed;
-
-			consumed = atomic_long_read(&buf->consumed);
-
+		reserve_commit_diff =
+		  (BUFFER_TRUNC(offsets->begin, buf->chan)
+		   >> chan->n_subbufs_order)
+		  - (uatomic_read(&buf->commit_count[subbuf_index].cc_sb)
+				& chan->commit_count_mask);
+		if (likely(reserve_commit_diff == 0)) {
 			/* Next buffer not corrupted. */
-			if (!channel->overwrite &&
+			if (unlikely(!chan->overwrite &&
 				(SUBBUF_TRUNC(offsets->begin, buf->chan)
-				 - SUBBUF_TRUNC(consumed, buf->chan))
-				>= channel->alloc_size) {
-
-				long consumed_idx = SUBBUF_INDEX(consumed, buf->chan);
-				long commit_count = local_read(&buf->commit_count[consumed_idx]);
-				if(((commit_count - buf->chan->subbuf_size) & channel->commit_count_mask) - (BUFFER_TRUNC(consumed, buf->chan) >> channel->n_subbufs_order) != 0) {
-					WARN("Event dropped. Caused by non-committed event.");
-				}
-				else {
-					WARN("Event dropped. Caused by non-consumed buffer.");
-				}
+				 - SUBBUF_TRUNC(uatomic_read(
+							&buf->consumed),
+						buf->chan))
+				>= chan->alloc_size)) {
 				/*
 				 * We do not overwrite non consumed buffers
 				 * and we are full : event is lost.
 				 */
-				local_inc(&buf->events_lost);
+				uatomic_inc(&buf->events_lost);
 				return -1;
 			} else {
 				/*
@@ -936,24 +952,26 @@ static inline int ltt_relay_try_reserve(
 			}
 		} else {
 			/*
-			 * Next subbuffer corrupted. Force pushing reader even
-			 * in normal mode. It's safe to write in this new
-			 * subbuffer.
+			 * Next subbuffer corrupted. Drop event in normal and
+			 * overwrite mode. Caused by either a writer OOPS or
+			 * too many nested writes over a reserve/commit pair.
 			 */
+			uatomic_inc(&buf->events_lost);
+			return -1;
 		}
-		offsets->size = ust_get_header_size(channel,
+		offsets->size = ust_get_header_size(chan,
 					offsets->begin, data_size,
 					&offsets->before_hdr_pad, *rflags);
 		offsets->size += ltt_align(offsets->begin + offsets->size,
 					   largest_align)
 				 + data_size;
-		if ((SUBBUF_OFFSET(offsets->begin, buf->chan) + offsets->size)
-				> buf->chan->subbuf_size) {
+		if (unlikely((SUBBUF_OFFSET(offsets->begin, buf->chan)
+			     + offsets->size) > buf->chan->subbuf_size)) {
 			/*
 			 * Event too big for subbuffers, report error, don't
 			 * complete the sub-buffer switch.
 			 */
-			local_inc(&buf->events_lost);
+			uatomic_inc(&buf->events_lost);
 			return -1;
 		} else {
 			/*
@@ -969,7 +987,7 @@ static inline int ltt_relay_try_reserve(
 	}
 	offsets->end = offsets->begin + offsets->size;
 
-	if ((SUBBUF_OFFSET(offsets->end, buf->chan)) == 0) {
+	if (unlikely((SUBBUF_OFFSET(offsets->end, buf->chan)) == 0)) {
 		/*
 		 * The offset_end will fall at the very beginning of the next
 		 * subbuffer.
@@ -979,252 +997,8 @@ static inline int ltt_relay_try_reserve(
 	return 0;
 }
 
-/*
- * Returns :
- * 0 if ok
- * !0 if execution must be aborted.
- */
-static inline int ltt_relay_try_switch(
-		enum force_switch_mode mode,
-		struct ust_channel *channel,
-		struct ust_buffer *buf,
-		struct ltt_reserve_switch_offsets *offsets,
-		u64 *tsc)
-{
-	long subbuf_index;
-
-	offsets->begin = local_read(&buf->offset);
-	offsets->old = offsets->begin;
-	offsets->begin_switch = 0;
-	offsets->end_switch_old = 0;
-
-	*tsc = trace_clock_read64();
-
-	if (SUBBUF_OFFSET(offsets->begin, buf->chan) != 0) {
-		offsets->begin = SUBBUF_ALIGN(offsets->begin, buf->chan);
-		offsets->end_switch_old = 1;
-	} else {
-		/* we do not have to switch : buffer is empty */
-		return -1;
-	}
-	if (mode == FORCE_ACTIVE)
-		offsets->begin += ltt_subbuffer_header_size();
-	/*
-	 * Always begin_switch in FORCE_ACTIVE mode.
-	 * Test new buffer integrity
-	 */
-	subbuf_index = SUBBUF_INDEX(offsets->begin, buf->chan);
-	offsets->reserve_commit_diff =
-		(BUFFER_TRUNC(offsets->begin, buf->chan)
-		 >> channel->n_subbufs_order)
-		- (local_read(&buf->commit_count[subbuf_index])
-			& channel->commit_count_mask);
-	if (offsets->reserve_commit_diff == 0) {
-		/* Next buffer not corrupted. */
-		if (mode == FORCE_ACTIVE
-		    && !channel->overwrite
-		    && offsets->begin - atomic_long_read(&buf->consumed)
-		       >= channel->alloc_size) {
-			/*
-			 * We do not overwrite non consumed buffers and we are
-			 * full : ignore switch while tracing is active.
-			 */
-			return -1;
-		}
-	} else {
-		/*
-		 * Next subbuffer corrupted. Force pushing reader even in normal
-		 * mode
-		 */
-	}
-	offsets->end = offsets->begin;
-	return 0;
-}
-
-static inline void ltt_reserve_push_reader(
-		struct ust_channel *channel,
-		struct ust_buffer *buf,
-		struct ltt_reserve_switch_offsets *offsets)
-{
-	long consumed_old, consumed_new;
-
-	do {
-		consumed_old = atomic_long_read(&buf->consumed);
-		/*
-		 * If buffer is in overwrite mode, push the reader consumed
-		 * count if the write position has reached it and we are not
-		 * at the first iteration (don't push the reader farther than
-		 * the writer). This operation can be done concurrently by many
-		 * writers in the same buffer, the writer being at the farthest
-		 * write position sub-buffer index in the buffer being the one
-		 * which will win this loop.
-		 * If the buffer is not in overwrite mode, pushing the reader
-		 * only happens if a sub-buffer is corrupted.
-		 */
-		if ((SUBBUF_TRUNC(offsets->end-1, buf->chan)
-		   - SUBBUF_TRUNC(consumed_old, buf->chan))
-		   >= channel->alloc_size)
-			consumed_new = SUBBUF_ALIGN(consumed_old, buf->chan);
-		else {
-			consumed_new = consumed_old;
-			break;
-		}
-	} while (atomic_long_cmpxchg(&buf->consumed, consumed_old,
-			consumed_new) != consumed_old);
-
-	if (consumed_old != consumed_new) {
-		/*
-		 * Reader pushed : we are the winner of the push, we can
-		 * therefore reequilibrate reserve and commit. Atomic increment
-		 * of the commit count permits other writers to play around
-		 * with this variable before us. We keep track of
-		 * corrupted_subbuffers even in overwrite mode :
-		 * we never want to write over a non completely committed
-		 * sub-buffer : possible causes : the buffer size is too low
-		 * compared to the unordered data input, or there is a writer
-		 * that died between the reserve and the commit.
-		 */
-		if (offsets->reserve_commit_diff) {
-			/*
-			 * We have to alter the sub-buffer commit count.
-			 * We do not deliver the previous subbuffer, given it
-			 * was either corrupted or not consumed (overwrite
-			 * mode).
-			 */
-			local_add(offsets->reserve_commit_diff,
-				  &buf->commit_count[
-					SUBBUF_INDEX(offsets->begin,
-						     buf->chan)]);
-			if (!channel->overwrite
-			    || offsets->reserve_commit_diff
-			       != channel->subbuf_size) {
-				/*
-				 * The reserve commit diff was not subbuf_size :
-				 * it means the subbuffer was partly written to
-				 * and is therefore corrupted. If it is multiple
-				 * of subbuffer size and we are in flight
-				 * recorder mode, we are skipping over a whole
-				 * subbuffer.
-				 */
-				local_inc(&buf->corrupted_subbuffers);
-			}
-		}
-	}
-}
-
-
-/*
- * ltt_reserve_switch_old_subbuf: switch old subbuffer
- *
- * Concurrency safe because we are the last and only thread to alter this
- * sub-buffer. As long as it is not delivered and read, no other thread can
- * alter the offset, alter the reserve_count or call the
- * client_buffer_end_callback on this sub-buffer.
- *
- * The only remaining threads could be the ones with pending commits. They will
- * have to do the deliver themselves.  Not concurrency safe in overwrite mode.
- * We detect corrupted subbuffers with commit and reserve counts. We keep a
- * corrupted sub-buffers count and push the readers across these sub-buffers.
- *
- * Not concurrency safe if a writer is stalled in a subbuffer and another writer
- * switches in, finding out it's corrupted.  The result will be than the old
- * (uncommited) subbuffer will be declared corrupted, and that the new subbuffer
- * will be declared corrupted too because of the commit count adjustment.
- *
- * Note : offset_old should never be 0 here.
- */
-static inline void ltt_reserve_switch_old_subbuf(
-		struct ust_channel *channel,
-		struct ust_buffer *buf,
-		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
-{
-	long oldidx = SUBBUF_INDEX(offsets->old - 1, channel);
-
-	channel->buffer_end(buf, *tsc, offsets->old, oldidx);
-	/* Must write buffer end before incrementing commit count */
-	smp_wmb();
-	offsets->commit_count =
-		local_add_return(channel->subbuf_size
-				 - (SUBBUF_OFFSET(offsets->old - 1, channel)
-				 + 1),
-				 &buf->commit_count[oldidx]);
-	if ((BUFFER_TRUNC(offsets->old - 1, channel)
-			>> channel->n_subbufs_order)
-			- ((offsets->commit_count - channel->subbuf_size)
-				& channel->commit_count_mask) == 0)
-		ltt_deliver(buf, oldidx, offsets->commit_count);
-}
-
-/*
- * ltt_reserve_switch_new_subbuf: Populate new subbuffer.
- *
- * This code can be executed unordered : writers may already have written to the
- * sub-buffer before this code gets executed, caution.  The commit makes sure
- * that this code is executed before the deliver of this sub-buffer.
- */
-static /*inline*/ void ltt_reserve_switch_new_subbuf(
-		struct ust_channel *channel,
-		struct ust_buffer *buf,
-		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
-{
-	long beginidx = SUBBUF_INDEX(offsets->begin, channel);
-
-	channel->buffer_begin(buf, *tsc, beginidx);
-	/* Must write buffer end before incrementing commit count */
-	smp_wmb();
-	offsets->commit_count = local_add_return(ltt_subbuffer_header_size(),
-			&buf->commit_count[beginidx]);
-	/* Check if the written buffer has to be delivered */
-	if ((BUFFER_TRUNC(offsets->begin, channel)
-			>> channel->n_subbufs_order)
-			- ((offsets->commit_count - channel->subbuf_size)
-				& channel->commit_count_mask) == 0)
-		ltt_deliver(buf, beginidx, offsets->commit_count);
-}
-
-
-/*
- * ltt_reserve_end_switch_current: finish switching current subbuffer
- *
- * Concurrency safe because we are the last and only thread to alter this
- * sub-buffer. As long as it is not delivered and read, no other thread can
- * alter the offset, alter the reserve_count or call the
- * client_buffer_end_callback on this sub-buffer.
- *
- * The only remaining threads could be the ones with pending commits. They will
- * have to do the deliver themselves.  Not concurrency safe in overwrite mode.
- * We detect corrupted subbuffers with commit and reserve counts. We keep a
- * corrupted sub-buffers count and push the readers across these sub-buffers.
- *
- * Not concurrency safe if a writer is stalled in a subbuffer and another writer
- * switches in, finding out it's corrupted.  The result will be than the old
- * (uncommited) subbuffer will be declared corrupted, and that the new subbuffer
- * will be declared corrupted too because of the commit count adjustment.
- */
-static inline void ltt_reserve_end_switch_current(
-		struct ust_channel *channel,
-		struct ust_buffer *buf,
-		struct ltt_reserve_switch_offsets *offsets, u64 *tsc)
-{
-	long endidx = SUBBUF_INDEX(offsets->end - 1, channel);
-
-	channel->buffer_end(buf, *tsc, offsets->end, endidx);
-	/* Must write buffer begin before incrementing commit count */
-	smp_wmb();
-	offsets->commit_count =
-		local_add_return(channel->subbuf_size
-				 - (SUBBUF_OFFSET(offsets->end - 1, channel)
-				 + 1),
-				 &buf->commit_count[endidx]);
-	if ((BUFFER_TRUNC(offsets->end - 1, channel)
-			>> channel->n_subbufs_order)
-			- ((offsets->commit_count - channel->subbuf_size)
-				& channel->commit_count_mask) == 0)
-		ltt_deliver(buf, endidx, offsets->commit_count);
-}
-
 /**
- * ltt_relay_reserve_slot - Atomic slot reservation in a LTTng buffer.
+ * ltt_relay_reserve_slot_lockless_slow - Atomic slot reservation in a buffer.
  * @trace: the trace structure to log to.
  * @ltt_channel: channel structure
  * @transport_data: data structure specific to ltt relay
@@ -1237,30 +1011,24 @@ static inline void ltt_reserve_end_switch_current(
  * Return : -ENOSPC if not enough space, else returns 0.
  * It will take care of sub-buffer switching.
  */
-static notrace int ltt_relay_reserve_slot(struct ltt_trace_struct *trace,
-		struct ust_channel *channel, void **transport_data,
-		size_t data_size, size_t *slot_size, long *buf_offset, u64 *tsc,
-		unsigned int *rflags, int largest_align, int cpu)
+int ltt_reserve_slot_lockless_slow(struct ust_channel *chan,
+		struct ust_trace *trace, size_t data_size,
+		int largest_align, int cpu,
+		struct ust_buffer **ret_buf,
+		size_t *slot_size, long *buf_offset,
+		u64 *tsc, unsigned int *rflags)
 {
-	struct ust_buffer *buf = *transport_data = channel->buf[cpu];
+	struct ust_buffer *buf = *ret_buf = chan->buf[cpu];
 	struct ltt_reserve_switch_offsets offsets;
 
-	offsets.reserve_commit_diff = 0;
 	offsets.size = 0;
 
-	/*
-	 * Perform retryable operations.
-	 */
-	if (ltt_nesting > 4) {
-		local_inc(&buf->events_lost);
-		return -EPERM;
-	}
 	do {
-		if (ltt_relay_try_reserve(channel, buf, &offsets, data_size, tsc, rflags,
-				largest_align))
+		if (unlikely(ltt_relay_try_reserve_slow(chan, buf, &offsets,
+				data_size, tsc, rflags, largest_align)))
 			return -ENOSPC;
-	} while (local_cmpxchg(&buf->offset, offsets.old,
-			offsets.end) != offsets.old);
+	} while (unlikely(uatomic_cmpxchg(&buf->offset, offsets.old,
+			offsets.end) != offsets.old));
 
 	/*
 	 * Atomically update last_tsc. This update races against concurrent
@@ -1273,167 +1041,40 @@ static notrace int ltt_relay_reserve_slot(struct ltt_trace_struct *trace,
 	/*
 	 * Push the reader if necessary
 	 */
-	ltt_reserve_push_reader(channel, buf, &offsets);
+	ltt_reserve_push_reader(chan, buf, offsets.end - 1);
 
 	/*
 	 * Switch old subbuffer if needed.
 	 */
-	if (offsets.end_switch_old)
-		ltt_reserve_switch_old_subbuf(channel, buf, &offsets, tsc);
+	if (unlikely(offsets.end_switch_old)) {
+		ltt_reserve_switch_old_subbuf(chan, buf, &offsets, tsc);
+		DBG("Switching %s_%d", chan->channel_name, cpu);
+	}
 
 	/*
 	 * Populate new subbuffer.
 	 */
-	if (offsets.begin_switch)
-		ltt_reserve_switch_new_subbuf(channel, buf, &offsets, tsc);
+	if (unlikely(offsets.begin_switch))
+		ltt_reserve_switch_new_subbuf(chan, buf, &offsets, tsc);
 
-	if (offsets.end_switch_current)
-		ltt_reserve_end_switch_current(channel, buf, &offsets, tsc);
+	if (unlikely(offsets.end_switch_current))
+		ltt_reserve_end_switch_current(chan, buf, &offsets, tsc);
 
 	*slot_size = offsets.size;
 	*buf_offset = offsets.begin + offsets.before_hdr_pad;
 	return 0;
 }
 
-/*
- * Force a sub-buffer switch for a per-cpu buffer. This operation is
- * completely reentrant : can be called while tracing is active with
- * absolutely no lock held.
- *
- * Note, however, that as a local_cmpxchg is used for some atomic
- * operations, this function must be called from the CPU which owns the buffer
- * for a ACTIVE flush.
- */
-static notrace void ltt_force_switch(struct ust_buffer *buf,
-		enum force_switch_mode mode)
-{
-	struct ust_channel *channel = buf->chan;
-	struct ltt_reserve_switch_offsets offsets;
-	u64 tsc;
-
-	offsets.reserve_commit_diff = 0;
-	offsets.size = 0;
-
-	/*
-	 * Perform retryable operations.
-	 */
-	do {
-		if (ltt_relay_try_switch(mode, channel, buf, &offsets, &tsc))
-			return;
-	} while (local_cmpxchg(&buf->offset, offsets.old,
-			offsets.end) != offsets.old);
-
-	/*
-	 * Atomically update last_tsc. This update races against concurrent
-	 * atomic updates, but the race will always cause supplementary full TSC
-	 * events, never the opposite (missing a full TSC event when it would be
-	 * needed).
-	 */
-	save_last_tsc(buf, tsc);
-
-	/*
-	 * Push the reader if necessary
-	 */
-	if (mode == FORCE_ACTIVE)
-		ltt_reserve_push_reader(channel, buf, &offsets);
-
-	/*
-	 * Switch old subbuffer if needed.
-	 */
-	if (offsets.end_switch_old)
-		ltt_reserve_switch_old_subbuf(channel, buf, &offsets, &tsc);
-
-	/*
-	 * Populate new subbuffer.
-	 */
-	if (mode == FORCE_ACTIVE)
-		ltt_reserve_switch_new_subbuf(channel, buf, &offsets, &tsc);
-}
-
 static struct ltt_transport ust_relay_transport = {
 	.name = "ustrelay",
 	.ops = {
-		.create_channel = ust_buffers_create_channel,
-		.finish_channel = ltt_relay_finish_channel,
-		.remove_channel = ltt_relay_remove_channel,
+		.create_channel = create_channel,
+		.finish_channel = finish_channel,
+		.remove_channel = remove_channel,
 		.wakeup_channel = ltt_relay_async_wakeup_chan,
-//		.commit_slot = ltt_relay_commit_slot,
-		.reserve_slot = ltt_relay_reserve_slot,
 	},
 };
 
-/*
- * for flight recording. must be called after relay_commit.
- * This function decrements de subbuffer's lost_size each time the commit count
- * reaches back the reserve offset (module subbuffer size). It is useful for
- * crash dump.
- */
-static /* inline */ void ltt_write_commit_counter(struct ust_buffer *buf,
-		struct ust_buffer *ltt_buf,
-		long idx, long buf_offset, long commit_count, size_t data_size)
-{
-	long offset;
-	long commit_seq_old;
-
-	offset = buf_offset + data_size;
-
-	/*
-	 * SUBBUF_OFFSET includes commit_count_mask. We can simply
-	 * compare the offsets within the subbuffer without caring about
-	 * buffer full/empty mismatch because offset is never zero here
-	 * (subbuffer header and event headers have non-zero length).
-	 */
-	if (unlikely(SUBBUF_OFFSET(offset - commit_count, buf->chan)))
-		return;
-
-	commit_seq_old = local_read(&ltt_buf->commit_seq[idx]);
-	while (commit_seq_old < commit_count)
-		commit_seq_old = local_cmpxchg(&ltt_buf->commit_seq[idx],
-					 commit_seq_old, commit_count);
-}
-
-/*
- * Atomic unordered slot commit. Increments the commit count in the
- * specified sub-buffer, and delivers it if necessary.
- *
- * Parameters:
- *
- * @ltt_channel : channel structure
- * @transport_data: transport-specific data
- * @buf_offset : offset following the event header.
- * @data_size : size of the event data.
- * @slot_size : size of the reserved slot.
- */
-/* FIXME: make this function static inline in the .h! */
-/*static*/ /* inline */ notrace void ltt_commit_slot(
-		struct ust_channel *channel,
-		void **transport_data, long buf_offset,
-		size_t data_size, size_t slot_size)
-{
-	struct ust_buffer *buf = *transport_data;
-	long offset_end = buf_offset;
-	long endidx = SUBBUF_INDEX(offset_end - 1, channel);
-	long commit_count;
-
-	/* Must write slot data before incrementing commit count */
-	smp_wmb();
-	commit_count = local_add_return(slot_size,
-		&buf->commit_count[endidx]);
-	/* Check if all commits have been done */
-	if ((BUFFER_TRUNC(offset_end - 1, channel)
-			>> channel->n_subbufs_order)
-			- ((commit_count - channel->subbuf_size)
-			   & channel->commit_count_mask) == 0)
-		ltt_deliver(buf, endidx, commit_count);
-	/*
-	 * Update lost_size for each commit. It's needed only for extracting
-	 * ltt buffers from vmcore, after crash.
-	 */
-	ltt_write_commit_counter(buf, buf, endidx,
-				 buf_offset, commit_count, data_size);
-}
-
-
 static char initialized = 0;
 
 void __attribute__((constructor)) init_ustrelay_transport(void)
@@ -1444,7 +1085,78 @@ void __attribute__((constructor)) init_ustrelay_transport(void)
 	}
 }
 
-static void __attribute__((destructor)) ltt_relay_exit(void)
+static void __attribute__((destructor)) ust_buffers_exit(void)
 {
 	ltt_transport_unregister(&ust_relay_transport);
 }
+
+size_t ltt_write_event_header_slow(struct ust_channel *channel,
+		struct ust_buffer *buf, long buf_offset,
+		u16 eID, u32 event_size,
+		u64 tsc, unsigned int rflags)
+{
+	struct ltt_event_header header;
+	u16 small_size;
+
+	switch (rflags) {
+	case LTT_RFLAG_ID_SIZE_TSC:
+		header.id_time = 29 << LTT_TSC_BITS;
+		break;
+	case LTT_RFLAG_ID_SIZE:
+		header.id_time = 30 << LTT_TSC_BITS;
+		break;
+	case LTT_RFLAG_ID:
+		header.id_time = 31 << LTT_TSC_BITS;
+		break;
+	default:
+		WARN_ON_ONCE(1);
+		header.id_time = 0;
+		break;
+	}
+
+	header.id_time |= (u32)tsc & LTT_TSC_MASK;
+	ust_buffers_write(buf, buf_offset, &header, sizeof(header));
+	buf_offset += sizeof(header);
+
+	switch (rflags) {
+	case LTT_RFLAG_ID_SIZE_TSC:
+		small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE);
+		ust_buffers_write(buf, buf_offset,
+			&eID, sizeof(u16));
+		buf_offset += sizeof(u16);
+		ust_buffers_write(buf, buf_offset,
+			&small_size, sizeof(u16));
+		buf_offset += sizeof(u16);
+		if (small_size == LTT_MAX_SMALL_SIZE) {
+			ust_buffers_write(buf, buf_offset,
+				&event_size, sizeof(u32));
+			buf_offset += sizeof(u32);
+		}
+		buf_offset += ltt_align(buf_offset, sizeof(u64));
+		ust_buffers_write(buf, buf_offset,
+			&tsc, sizeof(u64));
+		buf_offset += sizeof(u64);
+		break;
+	case LTT_RFLAG_ID_SIZE:
+		small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE);
+		ust_buffers_write(buf, buf_offset,
+			&eID, sizeof(u16));
+		buf_offset += sizeof(u16);
+		ust_buffers_write(buf, buf_offset,
+			&small_size, sizeof(u16));
+		buf_offset += sizeof(u16);
+		if (small_size == LTT_MAX_SMALL_SIZE) {
+			ust_buffers_write(buf, buf_offset,
+				&event_size, sizeof(u32));
+			buf_offset += sizeof(u32);
+		}
+		break;
+	case LTT_RFLAG_ID:
+		ust_buffers_write(buf, buf_offset,
+			&eID, sizeof(u16));
+		buf_offset += sizeof(u16);
+		break;
+	}
+
+	return buf_offset;
+}