[SCM] Samba Shared Repository - branch master updated - release-4-0-0alpha7-831-g3bbad34

Stefan Metzmacher metze at samba.org
Thu Apr 2 20:24:52 GMT 2009


The branch, master has been updated
       via  3bbad34a02350c96cb44d53da510c6273b6910d7 (commit)
       via  7e1411b5c7afa8b47d76ddb1fb93973201bb08a8 (commit)
       via  c59ee5a139421762adb6f3f4bbfc21723c2ce407 (commit)
       via  85742dbc0651a3413e90afa18023cd55ae72e6db (commit)
       via  8d98070a9f0a1a17d05e381b8e4c5a8f7a7e8233 (commit)
      from  37aff885a62cdc5c3298e6f44165f9d9a22729c5 (commit)

http://gitweb.samba.org/?p=samba.git;a=shortlog;h=master


- Log -----------------------------------------------------------------
commit 3bbad34a02350c96cb44d53da510c6273b6910d7
Author: Stefan Metzmacher <metze at samba.org>
Date:   Thu Apr 2 21:06:27 2009 +0200

    tsocket: remove DGRAM support from tsocket_context
    
    metze

commit 7e1411b5c7afa8b47d76ddb1fb93973201bb08a8
Author: Stefan Metzmacher <metze at samba.org>
Date:   Sat Mar 28 23:31:01 2009 +0100

    libcli/cldap: convert to tsocket_* function to tdgram_*
    
    metze

commit c59ee5a139421762adb6f3f4bbfc21723c2ce407
Author: Stefan Metzmacher <metze at samba.org>
Date:   Thu Apr 2 10:36:03 2009 +0200

    tsocket: optimize tdgram_bsd a lot
    
    The desire is to do as less syscalls during the
    tdgram_sendto_send/recv() and tdgram_recvfrom_send/recv()
    operations.
    
    1. we first try the sendto()/recvfrom() syscall and
       only use a fd event if we got EAGAIN.
    
    2. we cache the fd event and only change it's flags
       if really needed.
    
    For the highload case we do almost no epoll_ctl() and epoll_wait()/select()
    syscalls anymore. This speeds up the LDAP-BENCH-CLDAP test
    by more than 20%. (With a modified version of this test
    which let the server skip any ldb calls and just return success
    I'm getting about 8000 requests per second, while I'm getting
    just about 6000 requests per second without optimization)
    
    metze

commit 85742dbc0651a3413e90afa18023cd55ae72e6db
Author: Stefan Metzmacher <metze at samba.org>
Date:   Sat Mar 28 23:25:28 2009 +0100

    tsocket: add tdgram_sendto_queue_send/recv()
    
    metze

commit 8d98070a9f0a1a17d05e381b8e4c5a8f7a7e8233
Author: Stefan Metzmacher <metze at samba.org>
Date:   Thu Mar 26 14:27:45 2009 +0100

    tsocket: split out a smaller tdgram_context abstraction
    
    The idea is to have a tdgram and a tstream abstraction
    which only provide tevent_req based io functions.
    
    metze

-----------------------------------------------------------------------

Summary of changes:
 lib/tsocket/config.mk          |    2 -
 lib/tsocket/tsocket.c          |  409 +++++++++++++++++-
 lib/tsocket/tsocket.h          |   88 +++--
 lib/tsocket/tsocket_bsd.c      |  943 +++++++++++++++++++++++++++++++++++++---
 lib/tsocket/tsocket_internal.h |   49 ++-
 lib/tsocket/tsocket_recvfrom.c |  164 -------
 lib/tsocket/tsocket_sendto.c   |  271 ------------
 libcli/cldap/cldap.c           |   83 ++--
 8 files changed, 1400 insertions(+), 609 deletions(-)
 delete mode 100644 lib/tsocket/tsocket_recvfrom.c
 delete mode 100644 lib/tsocket/tsocket_sendto.c


Changeset truncated at 500 lines:

diff --git a/lib/tsocket/config.mk b/lib/tsocket/config.mk
index c35f0af..2e05f54 100644
--- a/lib/tsocket/config.mk
+++ b/lib/tsocket/config.mk
@@ -5,8 +5,6 @@ LIBTSOCKET_OBJ_FILES = $(addprefix ../lib/tsocket/, \
 					tsocket.o \
 					tsocket_helpers.o \
 					tsocket_bsd.o \
-					tsocket_recvfrom.o \
-					tsocket_sendto.o \
 					tsocket_connect.o \
 					tsocket_writev.o \
 					tsocket_readv.o)
diff --git a/lib/tsocket/tsocket.c b/lib/tsocket/tsocket.c
index 1a12e69..076c647 100644
--- a/lib/tsocket/tsocket.c
+++ b/lib/tsocket/tsocket.c
@@ -118,21 +118,6 @@ int tsocket_writev(struct tsocket_context *sock,
 	return sock->ops->writev_data(sock, vector, count);
 }
 
-ssize_t tsocket_recvfrom(struct tsocket_context *sock,
-			 uint8_t *data, size_t len,
-			 TALLOC_CTX *addr_ctx,
-			 struct tsocket_address **src_addr)
-{
-	return sock->ops->recvfrom_data(sock, data, len, addr_ctx, src_addr);
-}
-
-ssize_t tsocket_sendto(struct tsocket_context *sock,
-		       const uint8_t *data, size_t len,
-		       const struct tsocket_address *dest_addr)
-{
-	return sock->ops->sendto_data(sock, data, len, dest_addr);
-}
-
 int tsocket_get_status(const struct tsocket_context *sock)
 {
 	return sock->ops->get_status(sock);
@@ -229,3 +214,397 @@ int _tsocket_address_create_socket(const struct tsocket_address *addr,
 	return addr->ops->create_socket(addr, type, mem_ctx, sock, location);
 }
 
+struct tdgram_context {
+	const char *location;
+	const struct tdgram_context_ops *ops;
+	void *private_data;
+};
+
+struct tdgram_context *_tdgram_context_create(TALLOC_CTX *mem_ctx,
+					const struct tdgram_context_ops *ops,
+					void *pstate,
+					size_t psize,
+					const char *type,
+					const char *location)
+{
+	struct tdgram_context *dgram;
+	void **ppstate = (void **)pstate;
+	void *state;
+
+	dgram = talloc(mem_ctx, struct tdgram_context);
+	if (dgram == NULL) {
+		return NULL;
+	}
+	dgram->location	= location;
+	dgram->ops	= ops;
+
+	state = talloc_size(dgram, psize);
+	if (state == NULL) {
+		talloc_free(dgram);
+		return NULL;
+	}
+	talloc_set_name_const(state, type);
+
+	dgram->private_data = state;
+
+	*ppstate = state;
+	return dgram;
+}
+
+void *_tdgram_context_data(struct tdgram_context *dgram)
+{
+	return dgram->private_data;
+}
+
+struct tdgram_recvfrom_state {
+	const struct tdgram_context_ops *ops;
+	uint8_t *buf;
+	size_t len;
+	struct tsocket_address *src;
+};
+
+static void tdgram_recvfrom_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev,
+					struct tdgram_context *dgram)
+{
+	struct tevent_req *req;
+	struct tdgram_recvfrom_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_recvfrom_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+
+	subreq = state->ops->recvfrom_send(state, ev, dgram);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_recvfrom_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_recvfrom_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_recvfrom_state *state = tevent_req_data(req,
+					      struct tdgram_recvfrom_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = state->ops->recvfrom_recv(subreq, &sys_errno, state,
+					&state->buf, &state->src);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	state->len = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
+			     int *perrno,
+			     TALLOC_CTX *mem_ctx,
+			     uint8_t **buf,
+			     struct tsocket_address **src)
+{
+	struct tdgram_recvfrom_state *state = tevent_req_data(req,
+					      struct tdgram_recvfrom_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		*buf = talloc_move(mem_ctx, &state->buf);
+		ret = state->len;
+		if (src) {
+			*src = talloc_move(mem_ctx, &state->src);
+		}
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_sendto_state {
+	const struct tdgram_context_ops *ops;
+	ssize_t ret;
+};
+
+static void tdgram_sendto_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev,
+				      struct tdgram_context *dgram,
+				      const uint8_t *buf, size_t len,
+				      const struct tsocket_address *dst)
+{
+	struct tevent_req *req;
+	struct tdgram_sendto_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_sendto_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+	state->ret = -1;
+
+	subreq = state->ops->sendto_send(state, ev, dgram,
+					 buf, len, dst);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_sendto_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_sendto_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_sendto_state *state = tevent_req_data(req,
+					    struct tdgram_sendto_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = state->ops->sendto_recv(subreq, &sys_errno);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	state->ret = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_sendto_recv(struct tevent_req *req,
+			   int *perrno)
+{
+	struct tdgram_sendto_state *state = tevent_req_data(req,
+					    struct tdgram_sendto_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		ret = state->ret;
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_disconnect_state {
+	const struct tdgram_context_ops *ops;
+};
+
+static void tdgram_disconnect_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
+					  struct tevent_context *ev,
+					  struct tdgram_context *dgram)
+{
+	struct tevent_req *req;
+	struct tdgram_disconnect_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_disconnect_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+
+	subreq = state->ops->disconnect_send(state, ev, dgram);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_disconnect_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_disconnect_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_disconnect_state *state = tevent_req_data(req,
+						struct tdgram_disconnect_state);
+	int ret;
+	int sys_errno;
+
+	ret = state->ops->disconnect_recv(subreq, &sys_errno);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	tevent_req_done(req);
+}
+
+int tdgram_disconnect_recv(struct tevent_req *req,
+			   int *perrno)
+{
+	int ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_sendto_queue_state {
+	/* this structs are owned by the caller */
+	struct {
+		struct tevent_context *ev;
+		struct tdgram_context *dgram;
+		const uint8_t *buf;
+		size_t len;
+		const struct tsocket_address *dst;
+	} caller;
+	ssize_t ret;
+};
+
+static void tdgram_sendto_queue_trigger(struct tevent_req *req,
+					 void *private_data);
+static void tdgram_sendto_queue_done(struct tevent_req *subreq);
+
+/**
+ * @brief Queue a dgram blob for sending through the socket
+ * @param[in] mem_ctx	The memory context for the result
+ * @param[in] ev	The event context the operation should work on
+ * @param[in] dgram	The tdgram_context to send the message buffer
+ * @param[in] queue	The existing dgram queue
+ * @param[in] buf	The message buffer
+ * @param[in] len	The message length
+ * @param[in] dst	The destination socket address
+ * @retval		The async request handle
+ *
+ * This function queues a blob for sending to destination through an existing
+ * dgram socket. The async callback is triggered when the whole blob is
+ * delivered to the underlying system socket.
+ *
+ * The caller needs to make sure that all non-scalar input parameters hang
+ * arround for the whole lifetime of the request.
+ */
+struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct tdgram_context *dgram,
+					    struct tevent_queue *queue,
+					    const uint8_t *buf,
+					    size_t len,
+					    struct tsocket_address *dst)
+{
+	struct tevent_req *req;
+	struct tdgram_sendto_queue_state *state;
+	bool ok;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_sendto_queue_state);
+	if (!req) {
+		return NULL;
+	}
+
+	state->caller.ev	= ev;
+	state->caller.dgram	= dgram;
+	state->caller.buf	= buf;
+	state->caller.len	= len;
+	state->caller.dst	= dst;
+	state->ret		= -1;
+
+	ok = tevent_queue_add(queue,
+			      ev,
+			      req,
+			      tdgram_sendto_queue_trigger,
+			      NULL);
+	if (!ok) {
+		tevent_req_nomem(NULL, req);
+		goto post;
+	}
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_sendto_queue_trigger(struct tevent_req *req,
+					 void *private_data)
+{
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	struct tevent_req *subreq;
+
+	subreq = tdgram_sendto_send(state,
+				    state->caller.ev,
+				    state->caller.dgram,
+				    state->caller.buf,
+				    state->caller.len,
+				    state->caller.dst);
+	if (tevent_req_nomem(subreq, req)) {
+		return;
+	}
+	tevent_req_set_callback(subreq, tdgram_sendto_queue_done, req);
+}
+
+static void tdgram_sendto_queue_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = tdgram_sendto_recv(subreq, &sys_errno);
+	talloc_free(subreq);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+	state->ret = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno)
+{
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		ret = state->ret;
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
diff --git a/lib/tsocket/tsocket.h b/lib/tsocket/tsocket.h
index 9bcfb5c..8f69490 100644
--- a/lib/tsocket/tsocket.h
+++ b/lib/tsocket/tsocket.h
@@ -29,11 +29,11 @@
 
 struct tsocket_context;
 struct tsocket_address;
+struct tdgram_context;
 struct iovec;
 
 enum tsocket_type {
 	TSOCKET_TYPE_STREAM = 1,
-	TSOCKET_TYPE_DGRAM,
 	TSOCKET_TYPE_MESSAGE
 };
 
@@ -67,14 +67,6 @@ int tsocket_readv(struct tsocket_context *sock,
 int tsocket_writev(struct tsocket_context *sock,
 		   const struct iovec *vector, size_t count);
 
-ssize_t tsocket_recvfrom(struct tsocket_context *sock,
-			 uint8_t *data, size_t len,
-			 TALLOC_CTX *addr_ctx,
-			 struct tsocket_address **src_addr);
-ssize_t tsocket_sendto(struct tsocket_context *sock,
-		       const uint8_t *data, size_t len,
-		       const struct tsocket_address *dest_addr);
-
 int tsocket_get_status(const struct tsocket_context *sock);
 
 int _tsocket_get_local_address(const struct tsocket_context *sock,
@@ -121,6 +113,32 @@ int _tsocket_address_create_socket(const struct tsocket_address *addr,
 				       __location__)
 
 /*
+ * tdgram_context related functions
+ */
+struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev,
+					struct tdgram_context *dgram);
+ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
+			     int *perrno,
+			     TALLOC_CTX *mem_ctx,
+			     uint8_t **buf,
+			     struct tsocket_address **src);
+
+struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev,
+				      struct tdgram_context *dgram,
+				      const uint8_t *buf, size_t len,
+				      const struct tsocket_address *dst);
+ssize_t tdgram_sendto_recv(struct tevent_req *req,
+			   int *perrno);
+
+struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
+					  struct tevent_context *ev,
+					  struct tdgram_context *dgram);
+int tdgram_disconnect_recv(struct tevent_req *req,
+			   int *perrno);
+
+/*
  * BSD sockets: inet, inet6 and unix


-- 
Samba Shared Repository


More information about the samba-cvs mailing list