Fix: set wait/wake fd to -1 before close

[lttng-ust.git] / libringbuffer / frontend_internal.h

diff --git a/libringbuffer/frontend_internal.h b/libringbuffer/frontend_internal.h
index 6d1a75bdceef83e06d982097b94e4cdc8d8bcf59..a96746dcc53533910e76baaa15ab28e0133fd566 100644 (file)
--- 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"
@@ -391,13 +394,14 @@ 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;
+                                       sigset_t sigpipe_set, pending_set, old_set;
+                                       int ret, sigpipe_was_pending = 0;
+
                                        /*
                                         * Wake-up the other end by
                                         * writing a null byte in the
@@ -416,13 +420,55 @@ void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config
                                         * 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);
+                                       }
                                }
                        }
-
                }
        }
 }
@@ -475,6 +521,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 */