X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flib%2Fringbuffer%2Fring_buffer_frontend.c;h=87a575d0bbf384bfcd9c731a55fca837ee91636d;hb=ffcc873470121ef1ebb110df3d9038a38d9cb7cb;hp=d9e64dff9d15eb616df6b5147f4f0b4ec557da1b;hpb=b1199bd39f4b617b99518b72ceeea644b164b901;p=lttng-modules.git

diff --git a/src/lib/ringbuffer/ring_buffer_frontend.c b/src/lib/ringbuffer/ring_buffer_frontend.c
index d9e64dff..87a575d0 100644
--- a/src/lib/ringbuffer/ring_buffer_frontend.c
+++ b/src/lib/ringbuffer/ring_buffer_frontend.c
@@ -48,6 +48,7 @@
 #include <ringbuffer/iterator.h>
 #include <ringbuffer/nohz.h>
 #include <wrapper/atomic.h>
+#include <wrapper/cpu.h>
 #include <wrapper/kref.h>
 #include <wrapper/percpu-defs.h>
 #include <wrapper/timer.h>
@@ -79,16 +80,16 @@ DEFINE_PER_CPU(unsigned int, lib_ring_buffer_nesting);
 EXPORT_PER_CPU_SYMBOL(lib_ring_buffer_nesting);
 
 static
-void lib_ring_buffer_print_errors(struct channel *chan,
-				  struct lib_ring_buffer *buf, int cpu);
+void lib_ring_buffer_print_errors(struct lttng_kernel_ring_buffer_channel *chan,
+				  struct lttng_kernel_ring_buffer *buf, int cpu);
 static
-void _lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf,
+void _lib_ring_buffer_switch_remote(struct lttng_kernel_ring_buffer *buf,
 		enum switch_mode mode);
 
 static
-int lib_ring_buffer_poll_deliver(const struct lib_ring_buffer_config *config,
-				 struct lib_ring_buffer *buf,
-			         struct channel *chan)
+int lib_ring_buffer_poll_deliver(const struct lttng_kernel_ring_buffer_config *config,
+				 struct lttng_kernel_ring_buffer *buf,
+			         struct lttng_kernel_ring_buffer_channel *chan)
 {
 	unsigned long consumed_old, consumed_idx, commit_count, write_offset;
 
@@ -129,9 +130,9 @@ int lib_ring_buffer_poll_deliver(const struct lib_ring_buffer_config *config,
 /*
  * Must be called under cpu hotplug protection.
  */
-void lib_ring_buffer_free(struct lib_ring_buffer *buf)
+void lib_ring_buffer_free(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
 
 	irq_work_sync(&buf->wakeup_pending);
 
@@ -152,10 +153,10 @@ void lib_ring_buffer_free(struct lib_ring_buffer *buf)
  * should not be using the iterator concurrently with reset. The previous
  * current iterator record is reset.
  */
-void lib_ring_buffer_reset(struct lib_ring_buffer *buf)
+void lib_ring_buffer_reset(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned int i;
 
 	/*
@@ -193,7 +194,7 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_reset);
  * be using the iterator concurrently with reset. The previous current iterator
  * record is reset.
  */
-void channel_reset(struct channel *chan)
+void channel_reset(struct lttng_kernel_ring_buffer_channel *chan)
 {
 	/*
 	 * Reset iterators first. Will put the subbuffer if held for reading.
@@ -210,25 +211,25 @@ EXPORT_SYMBOL_GPL(channel_reset);
 
 static void lib_ring_buffer_pending_wakeup_buf(struct irq_work *entry)
 {
-	struct lib_ring_buffer *buf = container_of(entry, struct lib_ring_buffer,
+	struct lttng_kernel_ring_buffer *buf = container_of(entry, struct lttng_kernel_ring_buffer,
 						   wakeup_pending);
 	wake_up_interruptible(&buf->read_wait);
 }
 
 static void lib_ring_buffer_pending_wakeup_chan(struct irq_work *entry)
 {
-	struct channel *chan = container_of(entry, struct channel, wakeup_pending);
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(entry, struct lttng_kernel_ring_buffer_channel, wakeup_pending);
 	wake_up_interruptible(&chan->read_wait);
 }
 
 /*
  * Must be called under cpu hotplug protection.
  */
-int lib_ring_buffer_create(struct lib_ring_buffer *buf,
+int lib_ring_buffer_create(struct lttng_kernel_ring_buffer *buf,
 			   struct channel_backend *chanb, int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chanb->config;
-	struct channel *chan = container_of(chanb, struct channel, backend);
+	const struct lttng_kernel_ring_buffer_config *config = &chanb->config;
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(chanb, struct lttng_kernel_ring_buffer_channel, backend);
 	void *priv = chanb->priv;
 	size_t subbuf_header_size;
 	u64 tsc;
@@ -333,9 +334,9 @@ free_chanbuf:
 
 static void switch_buffer_timer(LTTNG_TIMER_FUNC_ARG_TYPE t)
 {
-	struct lib_ring_buffer *buf = lttng_from_timer(buf, t, switch_timer);
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = lttng_from_timer(buf, t, switch_timer);
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	/*
 	 * Only flush buffers periodically if readers are active.
@@ -354,10 +355,10 @@ static void switch_buffer_timer(LTTNG_TIMER_FUNC_ARG_TYPE t)
 /*
  * Called with ring_buffer_nohz_lock held for per-cpu buffers.
  */
-static void lib_ring_buffer_start_switch_timer(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_start_switch_timer(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned int flags = 0;
 
 	if (!chan->switch_timer_interval || buf->switch_timer_enabled)
@@ -380,9 +381,9 @@ static void lib_ring_buffer_start_switch_timer(struct lib_ring_buffer *buf)
 /*
  * Called with ring_buffer_nohz_lock held for per-cpu buffers.
  */
-static void lib_ring_buffer_stop_switch_timer(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_stop_switch_timer(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
 
 	if (!chan->switch_timer_interval || !buf->switch_timer_enabled)
 		return;
@@ -396,9 +397,9 @@ static void lib_ring_buffer_stop_switch_timer(struct lib_ring_buffer *buf)
  */
 static void read_buffer_timer(LTTNG_TIMER_FUNC_ARG_TYPE t)
 {
-	struct lib_ring_buffer *buf = lttng_from_timer(buf, t, read_timer);
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = lttng_from_timer(buf, t, read_timer);
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	CHAN_WARN_ON(chan, !buf->backend.allocated);
 
@@ -419,10 +420,10 @@ static void read_buffer_timer(LTTNG_TIMER_FUNC_ARG_TYPE t)
 /*
  * Called with ring_buffer_nohz_lock held for per-cpu buffers.
  */
-static void lib_ring_buffer_start_read_timer(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_start_read_timer(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned int flags = 0;
 
 	if (config->wakeup != RING_BUFFER_WAKEUP_BY_TIMER
@@ -447,10 +448,10 @@ static void lib_ring_buffer_start_read_timer(struct lib_ring_buffer *buf)
 /*
  * Called with ring_buffer_nohz_lock held for per-cpu buffers.
  */
-static void lib_ring_buffer_stop_read_timer(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_stop_read_timer(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (config->wakeup != RING_BUFFER_WAKEUP_BY_TIMER
 	    || !chan->read_timer_interval
@@ -489,10 +490,10 @@ EXPORT_SYMBOL_GPL(lttng_rb_set_hp_online);
 int lttng_cpuhp_rb_frontend_dead(unsigned int cpu,
 		struct lttng_cpuhp_node *node)
 {
-	struct channel *chan = container_of(node, struct channel,
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(node, struct lttng_kernel_ring_buffer_channel,
 					    cpuhp_prepare);
-	struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	CHAN_WARN_ON(chan, config->alloc == RING_BUFFER_ALLOC_GLOBAL);
 
@@ -510,10 +511,10 @@ EXPORT_SYMBOL_GPL(lttng_cpuhp_rb_frontend_dead);
 int lttng_cpuhp_rb_frontend_online(unsigned int cpu,
 		struct lttng_cpuhp_node *node)
 {
-	struct channel *chan = container_of(node, struct channel,
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(node, struct lttng_kernel_ring_buffer_channel,
 					    cpuhp_online);
-	struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	CHAN_WARN_ON(chan, config->alloc == RING_BUFFER_ALLOC_GLOBAL);
 
@@ -527,10 +528,10 @@ EXPORT_SYMBOL_GPL(lttng_cpuhp_rb_frontend_online);
 int lttng_cpuhp_rb_frontend_offline(unsigned int cpu,
 		struct lttng_cpuhp_node *node)
 {
-	struct channel *chan = container_of(node, struct channel,
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(node, struct lttng_kernel_ring_buffer_channel,
 					    cpuhp_online);
-	struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	CHAN_WARN_ON(chan, config->alloc == RING_BUFFER_ALLOC_GLOBAL);
 
@@ -558,10 +559,10 @@ int lib_ring_buffer_cpu_hp_callback(struct notifier_block *nb,
 					      void *hcpu)
 {
 	unsigned int cpu = (unsigned long)hcpu;
-	struct channel *chan = container_of(nb, struct channel,
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(nb, struct lttng_kernel_ring_buffer_channel,
 					    cpu_hp_notifier);
-	struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf, cpu);
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (!chan->cpu_hp_enable)
 		return NOTIFY_DONE;
@@ -617,10 +618,10 @@ static int notrace ring_buffer_tick_nohz_callback(struct notifier_block *nb,
 						  unsigned long val,
 						  void *data)
 {
-	struct channel *chan = container_of(nb, struct channel,
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(nb, struct lttng_kernel_ring_buffer_channel,
 					    tick_nohz_notifier);
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
-	struct lib_ring_buffer *buf;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf;
 	int cpu = smp_processor_id();
 
 	if (config->alloc != RING_BUFFER_ALLOC_PER_CPU) {
@@ -689,9 +690,9 @@ void notrace lib_ring_buffer_tick_nohz_restart(void)
 /*
  * Holds CPU hotplug.
  */
-static void channel_unregister_notifiers(struct channel *chan)
+static void channel_unregister_notifiers(struct lttng_kernel_ring_buffer_channel *chan)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	channel_iterator_unregister_notifiers(chan);
 	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
@@ -724,19 +725,19 @@ static void channel_unregister_notifiers(struct channel *chan)
 			int cpu;
 
 #ifdef CONFIG_HOTPLUG_CPU
-			get_online_cpus();
+			lttng_cpus_read_lock();
 			chan->cpu_hp_enable = 0;
 			for_each_online_cpu(cpu) {
-				struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+				struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 								      cpu);
 				lib_ring_buffer_stop_switch_timer(buf);
 				lib_ring_buffer_stop_read_timer(buf);
 			}
-			put_online_cpus();
+			lttng_cpus_read_unlock();
 			unregister_cpu_notifier(&chan->cpu_hp_notifier);
 #else
 			for_each_possible_cpu(cpu) {
-				struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+				struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 								      cpu);
 				lib_ring_buffer_stop_switch_timer(buf);
 				lib_ring_buffer_stop_read_timer(buf);
@@ -745,7 +746,7 @@ static void channel_unregister_notifiers(struct channel *chan)
 		}
 #endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
 	} else {
-		struct lib_ring_buffer *buf = chan->backend.buf;
+		struct lttng_kernel_ring_buffer *buf = chan->backend.buf;
 
 		lib_ring_buffer_stop_switch_timer(buf);
 		lib_ring_buffer_stop_read_timer(buf);
@@ -753,7 +754,7 @@ static void channel_unregister_notifiers(struct channel *chan)
 	channel_backend_unregister_notifiers(&chan->backend);
 }
 
-static void lib_ring_buffer_set_quiescent(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_set_quiescent(struct lttng_kernel_ring_buffer *buf)
 {
 	if (!buf->quiescent) {
 		buf->quiescent = true;
@@ -761,56 +762,56 @@ static void lib_ring_buffer_set_quiescent(struct lib_ring_buffer *buf)
 	}
 }
 
-static void lib_ring_buffer_clear_quiescent(struct lib_ring_buffer *buf)
+static void lib_ring_buffer_clear_quiescent(struct lttng_kernel_ring_buffer *buf)
 {
 	buf->quiescent = false;
 }
 
-void lib_ring_buffer_set_quiescent_channel(struct channel *chan)
+void lib_ring_buffer_set_quiescent_channel(struct lttng_kernel_ring_buffer_channel *chan)
 {
 	int cpu;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
-		get_online_cpus();
+		lttng_cpus_read_lock();
 		for_each_channel_cpu(cpu, chan) {
-			struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+			struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 							      cpu);
 
 			lib_ring_buffer_set_quiescent(buf);
 		}
-		put_online_cpus();
+		lttng_cpus_read_unlock();
 	} else {
-		struct lib_ring_buffer *buf = chan->backend.buf;
+		struct lttng_kernel_ring_buffer *buf = chan->backend.buf;
 
 		lib_ring_buffer_set_quiescent(buf);
 	}
 }
 EXPORT_SYMBOL_GPL(lib_ring_buffer_set_quiescent_channel);
 
-void lib_ring_buffer_clear_quiescent_channel(struct channel *chan)
+void lib_ring_buffer_clear_quiescent_channel(struct lttng_kernel_ring_buffer_channel *chan)
 {
 	int cpu;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
-		get_online_cpus();
+		lttng_cpus_read_lock();
 		for_each_channel_cpu(cpu, chan) {
-			struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+			struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 							      cpu);
 
 			lib_ring_buffer_clear_quiescent(buf);
 		}
-		put_online_cpus();
+		lttng_cpus_read_unlock();
 	} else {
-		struct lib_ring_buffer *buf = chan->backend.buf;
+		struct lttng_kernel_ring_buffer *buf = chan->backend.buf;
 
 		lib_ring_buffer_clear_quiescent(buf);
 	}
 }
 EXPORT_SYMBOL_GPL(lib_ring_buffer_clear_quiescent_channel);
 
-static void channel_free(struct channel *chan)
+static void channel_free(struct lttng_kernel_ring_buffer_channel *chan)
 {
 	if (chan->backend.release_priv_ops) {
 		chan->backend.release_priv_ops(chan->backend.priv_ops);
@@ -838,20 +839,20 @@ static void channel_free(struct channel *chan)
  * Holds cpu hotplug.
  * Returns NULL on failure.
  */
-struct channel *channel_create(const struct lib_ring_buffer_config *config,
+struct lttng_kernel_ring_buffer_channel *channel_create(const struct lttng_kernel_ring_buffer_config *config,
 		   const char *name, void *priv, void *buf_addr,
 		   size_t subbuf_size,
 		   size_t num_subbuf, unsigned int switch_timer_interval,
 		   unsigned int read_timer_interval)
 {
 	int ret;
-	struct channel *chan;
+	struct lttng_kernel_ring_buffer_channel *chan;
 
 	if (lib_ring_buffer_check_config(config, switch_timer_interval,
 					 read_timer_interval))
 		return NULL;
 
-	chan = kzalloc(sizeof(struct channel), GFP_KERNEL);
+	chan = kzalloc(sizeof(struct lttng_kernel_ring_buffer_channel), GFP_KERNEL);
 	if (!chan)
 		return NULL;
 
@@ -899,9 +900,9 @@ struct channel *channel_create(const struct lib_ring_buffer_config *config,
 			chan->cpu_hp_notifier.priority = 6;
 			register_cpu_notifier(&chan->cpu_hp_notifier);
 
-			get_online_cpus();
+			lttng_cpus_read_lock();
 			for_each_online_cpu(cpu) {
-				struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+				struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 								       cpu);
 				spin_lock(&per_cpu(ring_buffer_nohz_lock, cpu));
 				lib_ring_buffer_start_switch_timer(buf);
@@ -909,10 +910,10 @@ struct channel *channel_create(const struct lib_ring_buffer_config *config,
 				spin_unlock(&per_cpu(ring_buffer_nohz_lock, cpu));
 			}
 			chan->cpu_hp_enable = 1;
-			put_online_cpus();
+			lttng_cpus_read_unlock();
 #else
 			for_each_possible_cpu(cpu) {
-				struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+				struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 								      cpu);
 				spin_lock(&per_cpu(ring_buffer_nohz_lock, cpu));
 				lib_ring_buffer_start_switch_timer(buf);
@@ -933,7 +934,7 @@ struct channel *channel_create(const struct lib_ring_buffer_config *config,
 #endif /* defined(CONFIG_NO_HZ) && defined(CONFIG_LIB_RING_BUFFER) */
 
 	} else {
-		struct lib_ring_buffer *buf = chan->backend.buf;
+		struct lttng_kernel_ring_buffer *buf = chan->backend.buf;
 
 		lib_ring_buffer_start_switch_timer(buf);
 		lib_ring_buffer_start_read_timer(buf);
@@ -959,7 +960,7 @@ EXPORT_SYMBOL_GPL(channel_create);
 static
 void channel_release(struct kref *kref)
 {
-	struct channel *chan = container_of(kref, struct channel, ref);
+	struct lttng_kernel_ring_buffer_channel *chan = container_of(kref, struct lttng_kernel_ring_buffer_channel, ref);
 	channel_free(chan);
 }
 
@@ -974,10 +975,10 @@ void channel_release(struct kref *kref)
  * They should release their handle at that point.  Returns the private
  * data pointer.
  */
-void *channel_destroy(struct channel *chan)
+void *channel_destroy(struct lttng_kernel_ring_buffer_channel *chan)
 {
 	int cpu;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	void *priv;
 
 	irq_work_sync(&chan->wakeup_pending);
@@ -990,7 +991,7 @@ void *channel_destroy(struct channel *chan)
 		 * unregistered.
 		 */
 		for_each_channel_cpu(cpu, chan) {
-			struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+			struct lttng_kernel_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
 							      cpu);
 
 			if (config->cb.buffer_finalize)
@@ -1005,7 +1006,7 @@ void *channel_destroy(struct channel *chan)
 			wake_up_interruptible(&buf->read_wait);
 		}
 	} else {
-		struct lib_ring_buffer *buf = chan->backend.buf;
+		struct lttng_kernel_ring_buffer *buf = chan->backend.buf;
 
 		if (config->cb.buffer_finalize)
 			config->cb.buffer_finalize(buf, chan->backend.priv, -1);
@@ -1025,9 +1026,9 @@ void *channel_destroy(struct channel *chan)
 }
 EXPORT_SYMBOL_GPL(channel_destroy);
 
-struct lib_ring_buffer *channel_get_ring_buffer(
-					const struct lib_ring_buffer_config *config,
-					struct channel *chan, int cpu)
+struct lttng_kernel_ring_buffer *channel_get_ring_buffer(
+					const struct lttng_kernel_ring_buffer_config *config,
+					struct lttng_kernel_ring_buffer_channel *chan, int cpu)
 {
 	if (config->alloc == RING_BUFFER_ALLOC_GLOBAL)
 		return chan->backend.buf;
@@ -1036,9 +1037,9 @@ struct lib_ring_buffer *channel_get_ring_buffer(
 }
 EXPORT_SYMBOL_GPL(channel_get_ring_buffer);
 
-int lib_ring_buffer_open_read(struct lib_ring_buffer *buf)
+int lib_ring_buffer_open_read(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
 
 	if (!atomic_long_add_unless(&buf->active_readers, 1, 1))
 		return -EBUSY;
@@ -1051,9 +1052,9 @@ int lib_ring_buffer_open_read(struct lib_ring_buffer *buf)
 }
 EXPORT_SYMBOL_GPL(lib_ring_buffer_open_read);
 
-void lib_ring_buffer_release_read(struct lib_ring_buffer *buf)
+void lib_ring_buffer_release_read(struct lttng_kernel_ring_buffer *buf)
 {
-	struct channel *chan = buf->backend.chan;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
 
 	CHAN_WARN_ON(chan, atomic_long_read(&buf->active_readers) != 1);
 	lttng_smp_mb__before_atomic();
@@ -1084,11 +1085,11 @@ static void remote_mb(void *info)
  * Busy-loop trying to get data if the tick_nohz sequence lock is held.
  */
 
-int lib_ring_buffer_snapshot(struct lib_ring_buffer *buf,
+int lib_ring_buffer_snapshot(struct lttng_kernel_ring_buffer *buf,
 			     unsigned long *consumed, unsigned long *produced)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long consumed_cur, write_offset;
 	int finalized;
 
@@ -1147,11 +1148,11 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_snapshot);
  * This function is meant to provide information on the exact producer and
  * consumer positions without regard for the "snapshot" feature.
  */
-int lib_ring_buffer_snapshot_sample_positions(struct lib_ring_buffer *buf,
+int lib_ring_buffer_snapshot_sample_positions(struct lttng_kernel_ring_buffer *buf,
 		unsigned long *consumed, unsigned long *produced)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	smp_rmb();
 	*consumed = atomic_long_read(&buf->consumed);
@@ -1174,11 +1175,11 @@ int lib_ring_buffer_snapshot_sample_positions(struct lib_ring_buffer *buf,
  * @buf: ring buffer
  * @consumed_new: new consumed count value
  */
-void lib_ring_buffer_move_consumer(struct lib_ring_buffer *buf,
+void lib_ring_buffer_move_consumer(struct lttng_kernel_ring_buffer *buf,
 				   unsigned long consumed_new)
 {
-	struct lib_ring_buffer_backend *bufb = &buf->backend;
-	struct channel *chan = bufb->chan;
+	struct lttng_kernel_ring_buffer_backend *bufb = &buf->backend;
+	struct lttng_kernel_ring_buffer_channel *chan = bufb->chan;
 	unsigned long consumed;
 
 	CHAN_WARN_ON(chan, atomic_long_read(&buf->active_readers) != 1);
@@ -1199,11 +1200,11 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_move_consumer);
 
 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 static void lib_ring_buffer_flush_read_subbuf_dcache(
-		const struct lib_ring_buffer_config *config,
-		struct channel *chan,
-		struct lib_ring_buffer *buf)
+		const struct lttng_kernel_ring_buffer_config *config,
+		struct lttng_kernel_ring_buffer_channel *chan,
+		struct lttng_kernel_ring_buffer *buf)
 {
-	struct lib_ring_buffer_backend_pages *pages;
+	struct lttng_kernel_ring_buffer_backend_pages *pages;
 	unsigned long sb_bindex, id, i, nr_pages;
 
 	if (config->output != RING_BUFFER_MMAP)
@@ -1223,7 +1224,7 @@ static void lib_ring_buffer_flush_read_subbuf_dcache(
 	pages = buf->backend.array[sb_bindex];
 	nr_pages = buf->backend.num_pages_per_subbuf;
 	for (i = 0; i < nr_pages; i++) {
-		struct lib_ring_buffer_backend_page *backend_page;
+		struct lttng_kernel_ring_buffer_backend_page *backend_page;
 
 		backend_page = &pages->p[i];
 		flush_dcache_page(pfn_to_page(backend_page->pfn));
@@ -1231,9 +1232,9 @@ static void lib_ring_buffer_flush_read_subbuf_dcache(
 }
 #else
 static void lib_ring_buffer_flush_read_subbuf_dcache(
-		const struct lib_ring_buffer_config *config,
-		struct channel *chan,
-		struct lib_ring_buffer *buf)
+		const struct lttng_kernel_ring_buffer_config *config,
+		struct lttng_kernel_ring_buffer_channel *chan,
+		struct lttng_kernel_ring_buffer *buf)
 {
 }
 #endif
@@ -1247,11 +1248,11 @@ static void lib_ring_buffer_flush_read_subbuf_dcache(
  * data to read at consumed position, or 0 if the get operation succeeds.
  * Busy-loop trying to get data if the tick_nohz sequence lock is held.
  */
-int lib_ring_buffer_get_subbuf(struct lib_ring_buffer *buf,
+int lib_ring_buffer_get_subbuf(struct lttng_kernel_ring_buffer *buf,
 			       unsigned long consumed)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long consumed_cur, consumed_idx, commit_count, write_offset;
 	int ret;
 	int finalized;
@@ -1402,11 +1403,11 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_get_subbuf);
  * lib_ring_buffer_put_subbuf - release exclusive subbuffer access
  * @buf: ring buffer
  */
-void lib_ring_buffer_put_subbuf(struct lib_ring_buffer *buf)
+void lib_ring_buffer_put_subbuf(struct lttng_kernel_ring_buffer *buf)
 {
-	struct lib_ring_buffer_backend *bufb = &buf->backend;
-	struct channel *chan = bufb->chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_backend *bufb = &buf->backend;
+	struct lttng_kernel_ring_buffer_channel *chan = bufb->chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long read_sb_bindex, consumed_idx, consumed;
 
 	CHAN_WARN_ON(chan, atomic_long_read(&buf->active_readers) != 1);
@@ -1460,12 +1461,12 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_put_subbuf);
  * position and the writer position. (inclusive)
  */
 static
-void lib_ring_buffer_print_subbuffer_errors(struct lib_ring_buffer *buf,
-					    struct channel *chan,
+void lib_ring_buffer_print_subbuffer_errors(struct lttng_kernel_ring_buffer *buf,
+					    struct lttng_kernel_ring_buffer_channel *chan,
 					    unsigned long cons_offset,
 					    int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long cons_idx, commit_count, commit_count_sb;
 
 	cons_idx = subbuf_index(cons_offset, chan);
@@ -1487,11 +1488,11 @@ void lib_ring_buffer_print_subbuffer_errors(struct lib_ring_buffer *buf,
 }
 
 static
-void lib_ring_buffer_print_buffer_errors(struct lib_ring_buffer *buf,
-					 struct channel *chan,
+void lib_ring_buffer_print_buffer_errors(struct lttng_kernel_ring_buffer *buf,
+					 struct lttng_kernel_ring_buffer_channel *chan,
 					 void *priv, int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long write_offset, cons_offset;
 
 	/*
@@ -1519,11 +1520,11 @@ void lib_ring_buffer_print_buffer_errors(struct lib_ring_buffer *buf,
 
 #ifdef LTTNG_RING_BUFFER_COUNT_EVENTS
 static
-void lib_ring_buffer_print_records_count(struct channel *chan,
-					 struct lib_ring_buffer *buf,
+void lib_ring_buffer_print_records_count(struct lttng_kernel_ring_buffer_channel *chan,
+					 struct lttng_kernel_ring_buffer *buf,
 					 int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (!strcmp(chan->backend.name, "relay-metadata")) {
 		printk(KERN_DEBUG "LTTng: ring buffer %s: %lu records written, "
@@ -1541,18 +1542,18 @@ void lib_ring_buffer_print_records_count(struct channel *chan,
 }
 #else
 static
-void lib_ring_buffer_print_records_count(struct channel *chan,
-					 struct lib_ring_buffer *buf,
+void lib_ring_buffer_print_records_count(struct lttng_kernel_ring_buffer_channel *chan,
+					 struct lttng_kernel_ring_buffer *buf,
 					 int cpu)
 {
 }
 #endif
 
 static
-void lib_ring_buffer_print_errors(struct channel *chan,
-				  struct lib_ring_buffer *buf, int cpu)
+void lib_ring_buffer_print_errors(struct lttng_kernel_ring_buffer_channel *chan,
+				  struct lttng_kernel_ring_buffer *buf, int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	void *priv = chan->backend.priv;
 
 	lib_ring_buffer_print_records_count(chan, buf, cpu);
@@ -1578,12 +1579,12 @@ void lib_ring_buffer_print_errors(struct channel *chan,
  * Only executed when the buffer is finalized, in SWITCH_FLUSH.
  */
 static
-void lib_ring_buffer_switch_old_start(struct lib_ring_buffer *buf,
-				      struct channel *chan,
+void lib_ring_buffer_switch_old_start(struct lttng_kernel_ring_buffer *buf,
+				      struct lttng_kernel_ring_buffer_channel *chan,
 				      struct switch_offsets *offsets,
 				      u64 tsc)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long oldidx = subbuf_index(offsets->old, chan);
 	unsigned long commit_count;
 	struct commit_counters_hot *cc_hot;
@@ -1623,12 +1624,12 @@ void lib_ring_buffer_switch_old_start(struct lib_ring_buffer *buf,
  * subbuffer.
  */
 static
-void lib_ring_buffer_switch_old_end(struct lib_ring_buffer *buf,
-				    struct channel *chan,
+void lib_ring_buffer_switch_old_end(struct lttng_kernel_ring_buffer *buf,
+				    struct lttng_kernel_ring_buffer_channel *chan,
 				    struct switch_offsets *offsets,
 				    u64 tsc)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long oldidx = subbuf_index(offsets->old - 1, chan);
 	unsigned long commit_count, padding_size, data_size;
 	struct commit_counters_hot *cc_hot;
@@ -1680,12 +1681,12 @@ void lib_ring_buffer_switch_old_end(struct lib_ring_buffer *buf,
  * that this code is executed before the deliver of this sub-buffer.
  */
 static
-void lib_ring_buffer_switch_new_start(struct lib_ring_buffer *buf,
-				      struct channel *chan,
+void lib_ring_buffer_switch_new_start(struct lttng_kernel_ring_buffer *buf,
+				      struct lttng_kernel_ring_buffer_channel *chan,
 				      struct switch_offsets *offsets,
 				      u64 tsc)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long beginidx = subbuf_index(offsets->begin, chan);
 	unsigned long commit_count;
 	struct commit_counters_hot *cc_hot;
@@ -1725,12 +1726,12 @@ void lib_ring_buffer_switch_new_start(struct lib_ring_buffer *buf,
  * we are currently doing the space reservation.
  */
 static
-void lib_ring_buffer_switch_new_end(struct lib_ring_buffer *buf,
-					    struct channel *chan,
+void lib_ring_buffer_switch_new_end(struct lttng_kernel_ring_buffer *buf,
+					    struct lttng_kernel_ring_buffer_channel *chan,
 					    struct switch_offsets *offsets,
 					    u64 tsc)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long endidx, data_size;
 	u64 *ts_end;
 
@@ -1756,12 +1757,12 @@ void lib_ring_buffer_switch_new_end(struct lib_ring_buffer *buf,
  */
 static
 int lib_ring_buffer_try_switch_slow(enum switch_mode mode,
-				    struct lib_ring_buffer *buf,
-				    struct channel *chan,
+				    struct lttng_kernel_ring_buffer *buf,
+				    struct lttng_kernel_ring_buffer_channel *chan,
 				    struct switch_offsets *offsets,
 				    u64 *tsc)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long off, reserve_commit_diff;
 
 	offsets->begin = v_read(config, &buf->offset);
@@ -1862,10 +1863,10 @@ int lib_ring_buffer_try_switch_slow(enum switch_mode mode,
  * operations, this function must be called from the CPU which owns the buffer
  * for a ACTIVE flush.
  */
-void lib_ring_buffer_switch_slow(struct lib_ring_buffer *buf, enum switch_mode mode)
+void lib_ring_buffer_switch_slow(struct lttng_kernel_ring_buffer *buf, enum switch_mode mode)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	struct switch_offsets offsets;
 	unsigned long oldidx;
 	u64 tsc;
@@ -1914,23 +1915,23 @@ void lib_ring_buffer_switch_slow(struct lib_ring_buffer *buf, enum switch_mode m
 EXPORT_SYMBOL_GPL(lib_ring_buffer_switch_slow);
 
 struct switch_param {
-	struct lib_ring_buffer *buf;
+	struct lttng_kernel_ring_buffer *buf;
 	enum switch_mode mode;
 };
 
 static void remote_switch(void *info)
 {
 	struct switch_param *param = info;
-	struct lib_ring_buffer *buf = param->buf;
+	struct lttng_kernel_ring_buffer *buf = param->buf;
 
 	lib_ring_buffer_switch_slow(buf, param->mode);
 }
 
-static void _lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf,
+static void _lib_ring_buffer_switch_remote(struct lttng_kernel_ring_buffer *buf,
 		enum switch_mode mode)
 {
-	struct channel *chan = buf->backend.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	int ret;
 	struct switch_param param;
 
@@ -1963,23 +1964,23 @@ static void _lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf,
 }
 
 /* Switch sub-buffer if current sub-buffer is non-empty. */
-void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf)
+void lib_ring_buffer_switch_remote(struct lttng_kernel_ring_buffer *buf)
 {
 	_lib_ring_buffer_switch_remote(buf, SWITCH_ACTIVE);
 }
 EXPORT_SYMBOL_GPL(lib_ring_buffer_switch_remote);
 
 /* Switch sub-buffer even if current sub-buffer is empty. */
-void lib_ring_buffer_switch_remote_empty(struct lib_ring_buffer *buf)
+void lib_ring_buffer_switch_remote_empty(struct lttng_kernel_ring_buffer *buf)
 {
 	_lib_ring_buffer_switch_remote(buf, SWITCH_FLUSH);
 }
 EXPORT_SYMBOL_GPL(lib_ring_buffer_switch_remote_empty);
 
-void lib_ring_buffer_clear(struct lib_ring_buffer *buf)
+void lib_ring_buffer_clear(struct lttng_kernel_ring_buffer *buf)
 {
-	struct lib_ring_buffer_backend *bufb = &buf->backend;
-	struct channel *chan = bufb->chan;
+	struct lttng_kernel_ring_buffer_backend *bufb = &buf->backend;
+	struct lttng_kernel_ring_buffer_channel *chan = bufb->chan;
 
 	lib_ring_buffer_switch_remote(buf);
 	lib_ring_buffer_clear_reader(buf, chan);
@@ -1994,13 +1995,13 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_clear);
  * -EIO if data cannot be written into the buffer for any other reason.
  */
 static
-int lib_ring_buffer_try_reserve_slow(struct lib_ring_buffer *buf,
-				     struct channel *chan,
+int lib_ring_buffer_try_reserve_slow(struct lttng_kernel_ring_buffer *buf,
+				     struct lttng_kernel_ring_buffer_channel *chan,
 				     struct switch_offsets *offsets,
-				     struct lib_ring_buffer_ctx *ctx,
+				     struct lttng_kernel_ring_buffer_ctx *ctx,
 				     void *client_ctx)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 	unsigned long reserve_commit_diff, offset_cmp;
 
 retry:
@@ -2145,9 +2146,9 @@ retry:
 	return 0;
 }
 
-static struct lib_ring_buffer *get_current_buf(struct channel *chan, int cpu)
+static struct lttng_kernel_ring_buffer *get_current_buf(struct lttng_kernel_ring_buffer_channel *chan, int cpu)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
 
 	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU)
 		return per_cpu_ptr(chan->backend.buf, cpu);
@@ -2155,10 +2156,10 @@ static struct lib_ring_buffer *get_current_buf(struct channel *chan, int cpu)
 		return chan->backend.buf;
 }
 
-void lib_ring_buffer_lost_event_too_big(struct channel *chan)
+void lib_ring_buffer_lost_event_too_big(struct lttng_kernel_ring_buffer_channel *chan)
 {
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
-	struct lib_ring_buffer *buf = get_current_buf(chan, smp_processor_id());
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf = get_current_buf(chan, smp_processor_id());
 
 	v_inc(config, &buf->records_lost_big);
 }
@@ -2172,12 +2173,12 @@ EXPORT_SYMBOL_GPL(lib_ring_buffer_lost_event_too_big);
  * -EIO for other errors, else returns 0.
  * It will take care of sub-buffer switching.
  */
-int lib_ring_buffer_reserve_slow(struct lib_ring_buffer_ctx *ctx,
+int lib_ring_buffer_reserve_slow(struct lttng_kernel_ring_buffer_ctx *ctx,
 		void *client_ctx)
 {
-	struct channel *chan = ctx->priv.chan;
-	const struct lib_ring_buffer_config *config = &chan->backend.config;
-	struct lib_ring_buffer *buf;
+	struct lttng_kernel_ring_buffer_channel *chan = ctx->priv.chan;
+	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
+	struct lttng_kernel_ring_buffer *buf;
 	struct switch_offsets offsets;
 	int ret;
 
@@ -2238,8 +2239,8 @@ int lib_ring_buffer_reserve_slow(struct lib_ring_buffer_ctx *ctx,
 EXPORT_SYMBOL_GPL(lib_ring_buffer_reserve_slow);
 
 static
-void lib_ring_buffer_vmcore_check_deliver(const struct lib_ring_buffer_config *config,
-					  struct lib_ring_buffer *buf,
+void lib_ring_buffer_vmcore_check_deliver(const struct lttng_kernel_ring_buffer_config *config,
+					  struct lttng_kernel_ring_buffer *buf,
 				          unsigned long commit_count,
 				          unsigned long idx)
 {
@@ -2253,8 +2254,8 @@ void lib_ring_buffer_vmcore_check_deliver(const struct lib_ring_buffer_config *c
  */
 #ifdef LTTNG_RING_BUFFER_COUNT_EVENTS
 static
-void deliver_count_events(const struct lib_ring_buffer_config *config,
-		struct lib_ring_buffer *buf,
+void deliver_count_events(const struct lttng_kernel_ring_buffer_config *config,
+		struct lttng_kernel_ring_buffer *buf,
 		unsigned long idx)
 {
 	v_add(config, subbuffer_get_records_count(config,
@@ -2266,17 +2267,17 @@ void deliver_count_events(const struct lib_ring_buffer_config *config,
 }
 #else /* LTTNG_RING_BUFFER_COUNT_EVENTS */
 static
-void deliver_count_events(const struct lib_ring_buffer_config *config,
-		struct lib_ring_buffer *buf,
+void deliver_count_events(const struct lttng_kernel_ring_buffer_config *config,
+		struct lttng_kernel_ring_buffer *buf,
 		unsigned long idx)
 {
 }
 #endif /* #else LTTNG_RING_BUFFER_COUNT_EVENTS */
 
 
-void lib_ring_buffer_check_deliver_slow(const struct lib_ring_buffer_config *config,
-				   struct lib_ring_buffer *buf,
-			           struct channel *chan,
+void lib_ring_buffer_check_deliver_slow(const struct lttng_kernel_ring_buffer_config *config,
+				   struct lttng_kernel_ring_buffer *buf,
+			           struct lttng_kernel_ring_buffer_channel *chan,
 			           unsigned long offset,
 				   unsigned long commit_count,
 			           unsigned long idx,