Version 2.0.8

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

diff --git a/libringbuffer/frontend_internal.h b/libringbuffer/frontend_internal.h
index 6d1a75bdceef83e06d982097b94e4cdc8d8bcf59..2f837f7d80134449816afcb3e97546bd311aea0e 100644 (file)
--- a/libringbuffer/frontend_internal.h
+++ b/libringbuffer/frontend_internal.h
@@ -32,6 +32,8 @@
  */
 
 #include <urcu/compiler.h>
+#include <signal.h>
+#include <pthread.h>
 
 #include <lttng/ringbuffer-config.h>
 #include "backend_types.h"
@@ -339,6 +341,12 @@ void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config
                 * The subbuffer size is least 2 bytes (minimum size: 1 page).
                 * This guarantees that old_commit_count + 1 != commit_count.
                 */
+
+               /*
+                * Order prior updates to reserve count prior to the
+                * commit_cold cc_sb update.
+                */
+               cmm_smp_wmb();
                if (caa_likely(v_cmpxchg(config, &shmp_index(handle, buf->commit_cold, idx)->cc_sb,
                                         old_commit_count, old_commit_count + 1)
                           == old_commit_count)) {
@@ -384,6 +392,11 @@ void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config
                        /* End of exclusive subbuffer access */
                        v_set(config, &shmp_index(handle, buf->commit_cold, idx)->cc_sb,
                              commit_count);
+                       /*
+                        * Order later updates to reserve count after
+                        * the commit cold cc_sb update.
+                        */
+                       cmm_smp_wmb();
                        lib_ring_buffer_vmcore_check_deliver(config, buf,
                                                 commit_count, idx, handle);
 
@@ -397,7 +410,9 @@ void lib_ring_buffer_check_deliver(const struct lttng_ust_lib_ring_buffer_config
                                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 +431,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);
+                                       }
                                }
                        }
-
                }
        }
 }