Changeset 860 for vendor/current/lib/tsocket

Timestamp:

May 12, 2014, 8:58:38 PM (11 years ago)

Author:

Silvan Scherrer

Message:

Samba 3.6: updated vendor to latest version

Location:

vendor/current/lib/tsocket

Files:

• tsocket.h (modified) (2 diffs)
• tsocket_bsd.c (modified) (7 diffs)
• tsocket_helpers.c (modified) (3 diffs)

vendor/current/lib/tsocket/tsocket.h

@@ -627 +627 @@
 char *tsocket_address_unix_path(const struct tsocket_address *addr,
                                 TALLOC_CTX *mem_ctx);
+
+/**
+ * @brief Request a syscall optimization for tdgram_recvfrom_send()
+ *
+ * This function is only used to reduce the amount of syscalls and
+ * optimize performance. You should only use this if you know
+ * what you're doing.
+ *
+ * The optimization is off by default.
+ *
+ * @param[in]  dgram    The tdgram_context of a bsd socket, if this
+ *                      not a bsd socket the function does nothing.
+ *
+ * @param[in]  on       The boolean value to turn the optimization on and off.
+ *
+ * @return              The old boolean value.
+ *
+ * @see tdgram_recvfrom_send()
+ */
+bool tdgram_bsd_optimize_recvfrom(struct tdgram_context *dgram,
+                                  bool on);
 
 #ifdef DOXYGEN
@@ -688 +709 @@
         _tdgram_unix_socket(local, remote, mem_ctx, dgram, __location__)
 #endif
+
+/**
+ * @brief Request a syscall optimization for tstream_readv_send()
+ *
+ * This function is only used to reduce the amount of syscalls and
+ * optimize performance. You should only use this if you know
+ * what you're doing.
+ *
+ * The optimization is off by default.
+ *
+ * @param[in]  stream   The tstream_context of a bsd socket, if this
+ *                      not a bsd socket the function does nothing.
+ *
+ * @param[in]  on       The boolean value to turn the optimization on and off.
+ *
+ * @return              The old boolean value.
+ *
+ * @see tstream_readv_send()
+ */
+bool tstream_bsd_optimize_readv(struct tstream_context *stream,
+                                bool on);
 
 /**

vendor/current/lib/tsocket/tsocket_bsd.c

@@ -655 +655 @@
         void *event_ptr;
         struct tevent_fd *fde;
+        bool optimize_recvfrom;
 
         void *readable_private;
@@ -661 +662 @@
         void (*writeable_handler)(void *private_data);
 };
+
+bool tdgram_bsd_optimize_recvfrom(struct tdgram_context *dgram,
+                                  bool on)
+{
+        struct tdgram_bsd *bsds =
+                talloc_get_type(_tdgram_context_data(dgram),
+                struct tdgram_bsd);
+        bool old;
+
+        if (bsds == NULL) {
+                /* not a bsd socket */
+                return false;
+        }
+
+        old = bsds->optimize_recvfrom;
+        bsds->optimize_recvfrom = on;
+
+        return old;
+}
 
 static void tdgram_bsd_fde_handler(struct tevent_context *ev,
@@ -838 +858 @@
         }
 
+
         /*
          * this is a fast path, not waiting for the
@@ -843 +864 @@
          * about 10%-20% performance in benchmark tests.
          */
-        tdgram_bsd_recvfrom_handler(req);
-        if (!tevent_req_is_in_progress(req)) {
-                goto post;
+        if (bsds->optimize_recvfrom) {
+                /*
+                 * We only do the optimization on
+                 * recvfrom if the caller asked for it.
+                 *
+                 * This is needed because in most cases
+                 * we preferr to flush send buffers before
+                 * receiving incoming requests.
+                 */
+                tdgram_bsd_recvfrom_handler(req);
+                if (!tevent_req_is_in_progress(req)) {
+                        goto post;
+                }
         }
 
@@ -1401 +1432 @@
         void *event_ptr;
         struct tevent_fd *fde;
+        bool optimize_readv;
 
         void *readable_private;
@@ -1407 +1439 @@
         void (*writeable_handler)(void *private_data);
 };
+
+bool tstream_bsd_optimize_readv(struct tstream_context *stream,
+                                bool on)
+{
+        struct tstream_bsd *bsds =
+                talloc_get_type(_tstream_context_data(stream),
+                struct tstream_bsd);
+        bool old;
+
+        if (bsds == NULL) {
+                /* not a bsd socket */
+                return false;
+        }
+
+        old = bsds->optimize_readv;
+        bsds->optimize_readv = on;
+
+        return old;
+}
 
 static void tstream_bsd_fde_handler(struct tevent_context *ev,
@@ -1620 +1671 @@
          * about 10%-20% performance in benchmark tests.
          */
-        tstream_bsd_readv_handler(req);
-        if (!tevent_req_is_in_progress(req)) {
-                goto post;
+        if (bsds->optimize_readv) {
+                /*
+                 * We only do the optimization on
+                 * readv if the caller asked for it.
+                 *
+                 * This is needed because in most cases
+                 * we preferr to flush send buffers before
+                 * receiving incoming requests.
+                 */
+                tstream_bsd_readv_handler(req);
+                if (!tevent_req_is_in_progress(req)) {
+                        goto post;
+                }
         }
 

vendor/current/lib/tsocket/tsocket_helpers.c

@@ -213 +213 @@
         size_t i;
         struct tevent_req *subreq;
+        bool optimize = false;
+        bool save_optimize = false;
+
+        if (state->count > 0) {
+                /*
+                 * This is not the first time we asked for a vector,
+                 * which means parts of the pdu already arrived.
+                 *
+                 * In this case it make sense to enable
+                 * a syscall/performance optimization if the
+                 * low level tstream implementation supports it.
+                 */
+                optimize = true;
+        }
 
         TALLOC_FREE(state->vector);
@@ -256 +270 @@
         }
 
+        if (optimize) {
+                /*
+                 * If the low level stream is a bsd socket
+                 * we will get syscall optimization.
+                 *
+                 * If it is not a bsd socket
+                 * tstream_bsd_optimize_readv() just returns.
+                 */
+                save_optimize = tstream_bsd_optimize_readv(state->caller.stream,
+                                                           true);
+        }
         subreq = tstream_readv_send(state,
                                     state->caller.ev,
@@ -261 +286 @@
                                     state->vector,
                                     state->count);
+        if (optimize) {
+                tstream_bsd_optimize_readv(state->caller.stream,
+                                           save_optimize);
+        }
         if (tevent_req_nomem(subreq, req)) {
                 return;