X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=lib%2Fringbuffer%2Fring_buffer_frontend.c;h=42cf317a01d56482ae07401b8d1d8123b332a1d5;hb=b63af41cb645dcf8513e997714e47fafcb4492b4;hp=ae0b9e3986267a8b79e8395d13cd23d55cc357c7;hpb=505fb41059f97c7c4ee456bafabcb6528df8ebe2;p=lttng-modules.git

diff --git a/lib/ringbuffer/ring_buffer_frontend.c b/lib/ringbuffer/ring_buffer_frontend.c
index ae0b9e39..42cf317a 100644
--- a/lib/ringbuffer/ring_buffer_frontend.c
+++ b/lib/ringbuffer/ring_buffer_frontend.c
@@ -61,6 +61,7 @@
 #include "../../wrapper/ringbuffer/iterator.h"
 #include "../../wrapper/ringbuffer/nohz.h"
 #include "../../wrapper/atomic.h"
+#include "../../wrapper/percpu-defs.h"
 
 /*
  * Internal structure representing offsets to use at a sub-buffer switch.
@@ -90,6 +91,9 @@ 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);
+static
+void _lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf,
+		enum switch_mode mode);
 
 /*
  * Must be called under cpu hotplug protection.
@@ -498,16 +502,16 @@ static int notrace ring_buffer_tick_nohz_callback(struct notifier_block *nb,
 		raw_spin_unlock(&buf->raw_tick_nohz_spinlock);
 		break;
 	case TICK_NOHZ_STOP:
-		spin_lock(&__get_cpu_var(ring_buffer_nohz_lock));
+		spin_lock(lttng_this_cpu_ptr(&ring_buffer_nohz_lock));
 		lib_ring_buffer_stop_switch_timer(buf);
 		lib_ring_buffer_stop_read_timer(buf);
-		spin_unlock(&__get_cpu_var(ring_buffer_nohz_lock));
+		spin_unlock(lttng_this_cpu_ptr(&ring_buffer_nohz_lock));
 		break;
 	case TICK_NOHZ_RESTART:
-		spin_lock(&__get_cpu_var(ring_buffer_nohz_lock));
+		spin_lock(lttng_this_cpu_ptr(&ring_buffer_nohz_lock));
 		lib_ring_buffer_start_read_timer(buf);
 		lib_ring_buffer_start_switch_timer(buf);
-		spin_unlock(&__get_cpu_var(ring_buffer_nohz_lock));
+		spin_unlock(lttng_this_cpu_ptr(&ring_buffer_nohz_lock));
 		break;
 	}
 
@@ -584,6 +588,63 @@ 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)
+{
+	if (!buf->quiescent) {
+		buf->quiescent = true;
+		_lib_ring_buffer_switch_remote(buf, SWITCH_FLUSH);
+	}
+}
+
+static void lib_ring_buffer_clear_quiescent(struct lib_ring_buffer *buf)
+{
+	buf->quiescent = false;
+}
+
+void lib_ring_buffer_set_quiescent_channel(struct channel *chan)
+{
+	int cpu;
+	const struct lib_ring_buffer_config *config = &chan->backend.config;
+
+	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
+		get_online_cpus();
+		for_each_channel_cpu(cpu, chan) {
+			struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+							      cpu);
+
+			lib_ring_buffer_set_quiescent(buf);
+		}
+		put_online_cpus();
+	} else {
+		struct lib_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)
+{
+	int cpu;
+	const struct lib_ring_buffer_config *config = &chan->backend.config;
+
+	if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) {
+		get_online_cpus();
+		for_each_channel_cpu(cpu, chan) {
+			struct lib_ring_buffer *buf = per_cpu_ptr(chan->backend.buf,
+							      cpu);
+
+			lib_ring_buffer_clear_quiescent(buf);
+		}
+		put_online_cpus();
+	} else {
+		struct lib_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)
 {
 	if (chan->backend.release_priv_ops) {
@@ -744,7 +805,7 @@ void *channel_destroy(struct channel *chan)
 							   chan->backend.priv,
 							   cpu);
 			if (buf->backend.allocated)
-				lib_ring_buffer_switch_slow(buf, SWITCH_FLUSH);
+				lib_ring_buffer_set_quiescent(buf);
 			/*
 			 * Perform flush before writing to finalized.
 			 */
@@ -758,7 +819,7 @@ void *channel_destroy(struct channel *chan)
 		if (config->cb.buffer_finalize)
 			config->cb.buffer_finalize(buf, chan->backend.priv, -1);
 		if (buf->backend.allocated)
-			lib_ring_buffer_switch_slow(buf, SWITCH_FLUSH);
+			lib_ring_buffer_set_quiescent(buf);
 		/*
 		 * Perform flush before writing to finalized.
 		 */
@@ -1545,7 +1606,8 @@ static void remote_switch(void *info)
 	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
 }
 
-void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf)
+static void _lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf,
+		enum switch_mode mode)
 {
 	struct channel *chan = buf->backend.chan;
 	const struct lib_ring_buffer_config *config = &chan->backend.config;
@@ -1555,7 +1617,7 @@ void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf)
 	 * With global synchronization we don't need to use the IPI scheme.
 	 */
 	if (config->sync == RING_BUFFER_SYNC_GLOBAL) {
-		lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+		lib_ring_buffer_switch_slow(buf, mode);
 		return;
 	}
 
@@ -1574,10 +1636,15 @@ void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf)
 				 remote_switch, buf, 1);
 	if (ret) {
 		/* Remote CPU is offline, do it ourself. */
-		lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+		lib_ring_buffer_switch_slow(buf, mode);
 	}
 	put_online_cpus();
 }
+
+void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf)
+{
+	_lib_ring_buffer_switch_remote(buf, SWITCH_ACTIVE);
+}
 EXPORT_SYMBOL_GPL(lib_ring_buffer_switch_remote);
 
 /*