X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=libringbuffer%2Ffrontend_internal.h;h=77a431295a71b495d72fff3de74c31b8aff761eb;hb=111198c20e792773b4c7e2e95a3fe8e5cb95d144;hp=6d1a75bdceef83e06d982097b94e4cdc8d8bcf59;hpb=9501d22f55b3a23f382f631c99b2325d1419b5da;p=lttng-ust.git

diff --git a/libringbuffer/frontend_internal.h b/libringbuffer/frontend_internal.h
index 6d1a75bd..77a43129 100644
--- a/libringbuffer/frontend_internal.h
+++ b/libringbuffer/frontend_internal.h
@@ -32,6 +32,9 @@
  */
 
 #include <urcu/compiler.h>
+#include <urcu/tls-compat.h>
+#include <signal.h>
+#include <pthread.h>
 
 #include <lttng/ringbuffer-config.h>
 #include "backend_types.h"
@@ -297,6 +300,71 @@ int lib_ring_buffer_reserve_committed(const struct lttng_ust_lib_ring_buffer_con
 		     - (commit_count & chan->commit_count_mask) == 0);
 }
 
+static inline
+void lib_ring_buffer_wakeup(struct lttng_ust_lib_ring_buffer *buf,
+		struct lttng_ust_shm_handle *handle)
+{
+	int wakeup_fd = shm_get_wakeup_fd(handle, &buf->self._ref);
+	sigset_t sigpipe_set, pending_set, old_set;
+	int ret, sigpipe_was_pending = 0;
+
+	if (wakeup_fd < 0)
+		return;
+
+	/*
+	 * Wake-up the other end by writing a null byte in the pipe
+	 * (non-blocking).  Important note: Because writing into the
+	 * pipe is non-blocking (and therefore we allow dropping wakeup
+	 * data, as long as there is wakeup data present in the pipe
+	 * buffer to wake up the consumer), the consumer should perform
+	 * the following sequence for waiting:
+	 * 1) empty the pipe (reads).
+	 * 2) check if there is data in the buffer.
+	 * 3) wait on the pipe (poll).
+	 *
+	 * Discard the SIGPIPE from write(), not disturbing any SIGPIPE
+	 * that might be already pending. If a bogus SIGPIPE is sent to
+	 * the entire process concurrently by a malicious user, it may
+	 * be simply discarded.
+	 */
+	ret = sigemptyset(&pending_set);
+	assert(!ret);
+	/*
+	 * sigpending returns the mask of signals that are _both_
+	 * blocked for the thread _and_ pending for either the thread or
+	 * the entire process.
+	 */
+	ret = sigpending(&pending_set);
+	assert(!ret);
+	sigpipe_was_pending = sigismember(&pending_set, SIGPIPE);
+	/*
+	 * If sigpipe was pending, it means it was already blocked, so
+	 * no need to block it.
+	 */
+	if (!sigpipe_was_pending) {
+		ret = sigemptyset(&sigpipe_set);
+		assert(!ret);
+		ret = sigaddset(&sigpipe_set, SIGPIPE);
+		assert(!ret);
+		ret = pthread_sigmask(SIG_BLOCK, &sigpipe_set, &old_set);
+		assert(!ret);
+	}
+	do {
+		ret = write(wakeup_fd, "", 1);
+	} while (ret == -1L && errno == EINTR);
+	if (ret == -1L && errno == EPIPE && !sigpipe_was_pending) {
+		struct timespec timeout = { 0, 0 };
+		do {
+			ret = sigtimedwait(&sigpipe_set, NULL,
+				&timeout);
+		} while (ret == -1L && errno == EINTR);
+	}
+	if (!sigpipe_was_pending) {
+		ret = pthread_sigmask(SIG_SETMASK, &old_set, NULL);
+		assert(!ret);
+	}
+}
+
 static inline
 void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config *config,
 				   struct lttng_ust_lib_ring_buffer *buf,
@@ -391,38 +459,10 @@ void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config
 			 * RING_BUFFER_WAKEUP_BY_WRITER wakeup is not lock-free.
 			 */
 			if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER
-			    && (uatomic_read(&buf->active_readers)
-				|| uatomic_read(&buf->active_shadow_readers))
+			    && uatomic_read(&buf->active_readers)
 			    && lib_ring_buffer_poll_deliver(config, buf, chan, handle)) {
-				int wakeup_fd = shm_get_wakeup_fd(handle, &buf->self._ref);
-
-				if (wakeup_fd >= 0) {
-					int ret;
-					/*
-					 * Wake-up the other end by
-					 * writing a null byte in the
-					 * pipe (non-blocking).
-					 * Important note: Because
-					 * writing into the pipe is
-					 * non-blocking (and therefore
-					 * we allow dropping wakeup
-					 * data, as long as there is
-					 * wakeup data present in the
-					 * pipe buffer to wake up the
-					 * consumer), the consumer
-					 * should perform the following
-					 * sequence for waiting:
-					 * 1) empty the pipe (reads).
-					 * 2) check if there is data in
-					 *    the buffer.
-					 * 3) wait on the pipe (poll).
-					 */
-					do {
-						ret = write(wakeup_fd, "", 1);
-					} while (ret == -1L && errno == EINTR);
-				}
+				lib_ring_buffer_wakeup(buf, handle);
 			}
-
 		}
 	}
 }
@@ -475,6 +515,6 @@ extern void lib_ring_buffer_free(struct lttng_ust_lib_ring_buffer *buf,
 				 struct lttng_ust_shm_handle *handle);
 
 /* Keep track of trap nesting inside ring buffer code */
-extern __thread unsigned int lib_ring_buffer_nesting;
+extern DECLARE_URCU_TLS(unsigned int, lib_ring_buffer_nesting);
 
 #endif /* _LTTNG_RING_BUFFER_FRONTEND_INTERNAL_H */