Attachment 10802 Details for Bug 11118 – updated patchset for 4.2 to upgrade to tevent 0.9.23

[patch] updated patchset for 4.2 to upgrade to tevent 0.9.23

tmp42.diff (text/plain), 34.72 KB, created by Michael Adam on 2015-02-27 16:03:23 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Michael Adam

Created: 2015-02-27 16:03:23 UTC

Size: 34.72 KB

patch

obsolete

>From 968039428d1a7a77fc8a125d584f7589ffaf1653 Mon Sep 17 00:00:00 2001
>From: Richard Sharpe <rsharpe@samba.org>
>Date: Fri, 23 Jan 2015 21:56:19 -0800
>Subject: [PATCH 1/3] Update the tevent_data.dox tutrial stuff to fix some
> errors, including white space problems.
>
>Signed-off-by: Richard Sharpe <rsharpe@samba.org>
>Reviewed-by: Ralph Boehme <rb@sernet.de>
>
>Autobuild-User(master): Richard Sharpe <sharpe@samba.org>
>Autobuild-Date(master): Sat Jan 24 09:33:03 CET 2015 on sn-devel-104
>
>(cherry picked from commit 6a56bdf9869162e57c816c067598552bd33c2910)
>---
> lib/tevent/doc/tevent_data.dox | 30 +++++++++++++++++-------------
> 1 file changed, 17 insertions(+), 13 deletions(-)
>
>diff --git a/lib/tevent/doc/tevent_data.dox b/lib/tevent/doc/tevent_data.dox
>index 4ee4ac2..dbe7a04 100644
>--- a/lib/tevent/doc/tevent_data.dox
>+++ b/lib/tevent/doc/tevent_data.dox
>@@ -46,18 +46,19 @@ struct testA {
> 
> 
> static void foo_done(struct tevent_req *req) {
>-// a->x contains 9
>-struct foo_state *a = tevent_req_data(req, struct foo_state);
>+    // a->x contains 10 since it came from foo_send
>+    struct foo_state *a = tevent_req_data(req, struct foo_state);
> 
>-// b->y contains 10
>-struct testA *b = tevent_req_callback_data(req, struct testA);
>+    // b->y contains 9 since it came from run
>+    struct testA *b = tevent_req_callback_data(req, struct testA);
> 
>-// c->y contains 10
>-struct testA *c = (struct testA *)tevent_req_callback_data_void(req);
>+    // c->y contains 9 since it came from run we just used a different way
>+    // of getting it.
>+    struct testA *c = (struct testA *)tevent_req_callback_data_void(req);
> 
>-printf("a->x: %d\n", a->x);
>-printf("b->y: %d\n", b->y);
>-printf("c->y: %d\n", c->y);
>+    printf("a->x: %d\n", a->x);
>+    printf("b->y: %d\n", b->y);
>+    printf("c->y: %d\n", c->y);
> }
> 
> 
>@@ -77,6 +78,9 @@ static void run(struct tevent_context *ev, struct tevent_timer *te,
>                 struct timeval current_time, void *private_data) {
>     struct tevent_req *req;
>     struct testA *tmp = talloc(ev, struct testA);
>+
>+    // Note that we did not use the private data passed in
>+
>     tmp->y = 9;
>     req = foo_send(ev, ev);
> 
>@@ -101,7 +105,7 @@ int main (int argc, char **argv) {
>         return EXIT_FAILURE;
> 
>     data = talloc(mem_ctx, struct testA);
>-    data->y = 10;
>+    data->y = 11;
> 
>     time_event = tevent_add_timer(event_ctx,
>                                   mem_ctx,
>@@ -125,9 +129,9 @@ int main (int argc, char **argv) {
> Output of this example is:
> 
> @code
>-a->x: 9
>-b->y: 10
>-c->y: 10
>+a->x: 10
>+b->y: 9
>+c->y: 9
> @endcode
> 
> */
>-- 
>1.9.1
>
>
>From 416cb04686bcd42845bcb1d06062158782820f73 Mon Sep 17 00:00:00 2001
>From: Jeremy Allison <jra@samba.org>
>Date: Mon, 22 Jul 2013 14:23:33 -0700
>Subject: [PATCH 2/3] Add Solaris ports as a tevent backend.
>
>Signed-off-by: Jeremy Allison <jra@samba.org>
>Reviewed-by: David Disseldorp <ddiss@samba.org>
>
>Autobuild-User(master): David Disseldorp <ddiss@samba.org>
>Autobuild-Date(master): Sun Feb 15 23:25:07 CET 2015 on sn-devel-104
>
>(cherry picked from commit 88c1eb4ae10a9f69d2e828b4e5543915c1d990c6)
>---
> lib/replace/system/select.h  |   4 +
> lib/replace/wscript          |   5 +
> lib/tevent/tevent.c          |   5 +-
> lib/tevent/tevent_internal.h |   3 +
> lib/tevent/tevent_port.c     | 779 +++++++++++++++++++++++++++++++++++++++++++
> lib/tevent/wscript           |   3 +
> 6 files changed, 798 insertions(+), 1 deletion(-)
> create mode 100644 lib/tevent/tevent_port.c
>
>diff --git a/lib/replace/system/select.h b/lib/replace/system/select.h
>index 11c5390..9e945c3 100644
>--- a/lib/replace/system/select.h
>+++ b/lib/replace/system/select.h
>@@ -34,6 +34,10 @@
> #include <sys/epoll.h>
> #endif
> 
>+#ifdef HAVE_SOLARIS_PORTS
>+#include <port.h>
>+#endif
>+
> #ifndef SELECT_CAST
> #define SELECT_CAST
> #endif
>diff --git a/lib/replace/wscript b/lib/replace/wscript
>index 4d4d182..f8a0179 100644
>--- a/lib/replace/wscript
>+++ b/lib/replace/wscript
>@@ -38,6 +38,7 @@ def configure(conf):
>     conf.CHECK_HEADERS('libaio.h locale.h ndir.h pwd.h')
>     conf.CHECK_HEADERS('shadow.h sys/acl.h')
>     conf.CHECK_HEADERS('sys/attributes.h attr/attributes.h sys/capability.h sys/dir.h sys/epoll.h')
>+    conf.CHECK_HEADERS('port.h')
>     conf.CHECK_HEADERS('sys/fcntl.h sys/filio.h sys/filsys.h sys/fs/s5param.h sys/fs/vx/quota.h')
>     conf.CHECK_HEADERS('sys/id.h sys/ioctl.h sys/ipc.h sys/mman.h sys/mode.h sys/ndir.h sys/priv.h')
>     conf.CHECK_HEADERS('sys/resource.h sys/security.h sys/shm.h sys/statfs.h sys/statvfs.h sys/termio.h')
>@@ -283,6 +284,7 @@ def configure(conf):
>     conf.CHECK_FUNCS('timegm getifaddrs freeifaddrs mmap setgroups syscall setsid')
>     conf.CHECK_FUNCS('getgrent_r getgrgid_r getgrnam_r getgrouplist getpagesize')
>     conf.CHECK_FUNCS('getpwent_r getpwnam_r getpwuid_r epoll_create')
>+    conf.CHECK_FUNCS('port_create')
> 
>     conf.SET_TARGET_TYPE('attr', 'EMPTY')
> 
>@@ -487,6 +489,9 @@ removeea setea
>     if conf.CONFIG_SET('HAVE_EPOLL_CREATE') and conf.CONFIG_SET('HAVE_SYS_EPOLL_H'):
>         conf.DEFINE('HAVE_EPOLL', 1)
> 
>+    if conf.CONFIG_SET('HAVE_PORT_CREATE') and conf.CONFIG_SET('HAVE_PORT_H'):
>+        conf.DEFINE('HAVE_SOLARIS_PORTS', 1)
>+
>     conf.CHECK_HEADERS('poll.h')
>     conf.CHECK_FUNCS('poll')
> 
>diff --git a/lib/tevent/tevent.c b/lib/tevent/tevent.c
>index be0afd4..843cf05 100644
>--- a/lib/tevent/tevent.c
>+++ b/lib/tevent/tevent.c
>@@ -123,9 +123,12 @@ static void tevent_backend_init(void)
> 	tevent_select_init();
> 	tevent_poll_init();
> 	tevent_poll_mt_init();
>-#ifdef HAVE_EPOLL
>+#if defined(HAVE_EPOLL)
> 	tevent_epoll_init();
>+#elif defined(HAVE_SOLARIS_PORTS)
>+	tevent_port_init();
> #endif
>+
> 	tevent_standard_init();
> }
> 
>diff --git a/lib/tevent/tevent_internal.h b/lib/tevent/tevent_internal.h
>index d25dc05..10cc4a4 100644
>--- a/lib/tevent/tevent_internal.h
>+++ b/lib/tevent/tevent_internal.h
>@@ -351,6 +351,9 @@ void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
> 			bool (*panic_fallback)(struct tevent_context *ev,
> 					       bool replay));
> #endif
>+#ifdef HAVE_SOLARIS_PORTS
>+bool tevent_port_init(void);
>+#endif
> 
> 
> void tevent_trace_point_callback(struct tevent_context *ev,
>diff --git a/lib/tevent/tevent_port.c b/lib/tevent/tevent_port.c
>new file mode 100644
>index 0000000..93e94b2
>--- /dev/null
>+++ b/lib/tevent/tevent_port.c
>@@ -0,0 +1,779 @@
>+/*
>+   Unix SMB/CIFS implementation.
>+
>+   Main select loop and event handling - Solaris port implementation.
>+   Losely based on the Linux epoll backend.
>+
>+   Copyright (C) Jeremy Allison		2013
>+
>+     ** NOTE! The following LGPL license applies to the tevent
>+     ** library. This does NOT imply that all of Samba is released
>+     ** under the LGPL
>+
>+   This library is free software; you can redistribute it and/or
>+   modify it under the terms of the GNU Lesser General Public
>+   License as published by the Free Software Foundation; either
>+   version 3 of the License, or (at your option) any later version.
>+
>+   This library is distributed in the hope that it will be useful,
>+   but WITHOUT ANY WARRANTY; without even the implied warranty of
>+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+   Lesser General Public License for more details.
>+
>+   You should have received a copy of the GNU Lesser General Public
>+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
>+*/
>+
>+#include "replace.h"
>+#include "system/filesys.h"
>+#include "system/select.h"
>+#include "tevent.h"
>+#include "tevent_internal.h"
>+#include "tevent_util.h"
>+
>+struct port_associate_vals {
>+	struct port_associate_vals *prev, *next;
>+	struct port_event_context *port_ev;
>+	int events;
>+	struct tevent_fd *fde;
>+	bool associated_event;
>+};
>+
>+struct port_event_context {
>+	/* a pointer back to the generic event_context */
>+	struct tevent_context *ev;
>+
>+	/* This is the handle from port_create */
>+	int port_fd;
>+
>+	pid_t pid;
>+
>+	/* List of associations. */
>+	struct port_associate_vals *po_vals;
>+};
>+
>+#define PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION	(1<<0)
>+#define PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR	(1<<1)
>+#define PORT_ADDITIONAL_FD_FLAG_GOT_ERROR	(1<<2)
>+#define PORT_ADDITIONAL_FD_FLAG_HAS_MPX		(1<<3)
>+
>+/*
>+  Map from TEVENT_FD_* to POLLIN/POLLOUT
>+*/
>+static int port_map_flags(uint16_t flags)
>+{
>+	int ret = 0;
>+	if (flags & TEVENT_FD_READ) ret |= (POLLIN | POLLERR | POLLHUP);
>+	if (flags & TEVENT_FD_WRITE) ret |= (POLLOUT | POLLERR | POLLHUP);
>+	return ret;
>+}
>+
>+/*
>+ Free the port fd
>+*/
>+static int port_ctx_destructor(struct port_event_context *port_ev)
>+{
>+	close(port_ev->port_fd);
>+	port_ev->port_fd = -1;
>+	return 0;
>+}
>+
>+/*
>+ Init the port fd
>+*/
>+static int port_init_ctx(struct port_event_context *port_ev)
>+{
>+	port_ev->port_fd = port_create();
>+	if (port_ev->port_fd == -1) {
>+		tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
>+			     "Failed to create port handle.\n");
>+		return -1;
>+	}
>+
>+	if (!ev_set_close_on_exec(port_ev->port_fd)) {
>+		tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
>+			     "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
>+	}
>+
>+	port_ev->pid = getpid();
>+	talloc_set_destructor(port_ev, port_ctx_destructor);
>+
>+	return 0;
>+}
>+
>+/*
>+ Functions to manage the lower level cache of associated events on the port_fd.
>+*/
>+
>+static int port_associate_vals_destructor(struct port_associate_vals *val)
>+{
>+	DLIST_REMOVE(val->port_ev->po_vals, val);
>+	memset(val, '\0', sizeof(struct port_associate_vals));
>+	return 0;
>+}
>+
>+/*
>+ * TODO: As the port_association is per-fde, it should be possible to store it
>+ * directly in fde->additional_data, alongside any multiplexed-fde. That way the
>+ * lookup on store and delete would be avoided, and associate_all_events() could
>+ * walk the ev->fd_events list.
>+ */
>+static bool store_port_association(struct port_event_context *port_ev,
>+				struct tevent_fd *fde,
>+				int events)
>+{
>+	struct port_associate_vals *val;
>+
>+	for (val = port_ev->po_vals; val; val = val->next) {
>+		if (val->fde->fd == fde->fd) {
>+			/* Association already attached to fd. */
>+			if (val->events != events) {
>+				val->events = events;
>+				val->associated_event = false;
>+			}
>+			return true;
>+		}
>+	}
>+
>+	val = talloc_zero(port_ev, struct port_associate_vals);
>+	if (val == NULL) {
>+		return false;
>+	}
>+
>+	val->port_ev = port_ev;
>+	val->fde = fde;
>+	val->events = events;
>+	val->associated_event = false;
>+
>+	DLIST_ADD(port_ev->po_vals, val);
>+	talloc_set_destructor(val, port_associate_vals_destructor);
>+
>+	return true;
>+}
>+
>+static void delete_port_association(struct port_event_context *port_ev,
>+				struct tevent_fd *fde)
>+{
>+	struct port_associate_vals *val;
>+
>+	for (val = port_ev->po_vals; val; val = val->next) {
>+		if (val->fde == fde) {
>+			if (val->associated_event) {
>+				(void)port_dissociate(port_ev->port_fd,
>+							PORT_SOURCE_FD,
>+							fde->fd);
>+			}
>+			talloc_free(val);
>+			return;
>+		}
>+	}
>+}
>+
>+static int associate_all_events(struct port_event_context *port_ev)
>+{
>+	struct port_associate_vals *val;
>+
>+	for (val = port_ev->po_vals; val; val = val->next) {
>+		if (val->associated_event) {
>+			continue;
>+		}
>+		int ret = port_associate(port_ev->port_fd,
>+					PORT_SOURCE_FD,
>+					(uintptr_t)val->fde->fd,
>+					val->events,
>+					(void *)val);
>+		if (ret != 0) {
>+			return -1;
>+		}
>+		val->associated_event = true;
>+	}
>+	return 0;
>+}
>+
>+static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde);
>+
>+/*
>+  Reopen the port handle when our pid changes.
>+ */
>+static int port_check_reopen(struct port_event_context *port_ev)
>+{
>+	struct tevent_fd *fde;
>+
>+	if (port_ev->pid == getpid()) {
>+		return 0;
>+	}
>+
>+	close(port_ev->port_fd);
>+	port_ev->port_fd = port_create();
>+	if (port_ev->port_fd == -1) {
>+		tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
>+				"port_create() failed");
>+		return -1;
>+	}
>+
>+	if (!ev_set_close_on_exec(port_ev->port_fd)) {
>+		tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
>+			     "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
>+	}
>+
>+	port_ev->pid = getpid();
>+	for (fde=port_ev->ev->fd_events;fde;fde=fde->next) {
>+		fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+		if (port_update_event(port_ev, fde) != 0) {
>+			return -1;
>+		}
>+	}
>+	return 0;
>+}
>+
>+/*
>+ * Solaris ports cannot add the same file descriptor twice, once
>+ * with read, once with write which is allowed by the tevent backend.
>+ * Multiplex the existing fde, flag it as such so we can search for the
>+ * correct fde on event triggering.
>+ */
>+
>+static void port_setup_multiplex_fd(struct port_event_context *port_ev,
>+				struct tevent_fd *add_fde,
>+				struct tevent_fd *mpx_fde)
>+{
>+	/*
>+	 * Make each fde->additional_data pointers point at each other
>+	 * so we can look them up from each other. They are now paired.
>+	 */
>+	mpx_fde->additional_data = add_fde;
>+	add_fde->additional_data = mpx_fde;
>+
>+	/* Now flag both fde's as being multiplexed. */
>+	mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
>+	add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
>+
>+	/* We need to keep the GOT_ERROR flag. */
>+	if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR) {
>+		add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
>+	}
>+}
>+
>+/*
>+ Add the port event to the given fd_event,
>+ Or modify an existing event.
>+*/
>+
>+static int port_add_event(struct port_event_context *port_ev, struct tevent_fd *fde)
>+{
>+	int flags = port_map_flags(fde->flags);
>+	struct tevent_fd *mpx_fde = NULL;
>+
>+	fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+	fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+
>+	if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+		/*
>+		 * This is already a multiplexed fde, we need to include both
>+		 * flags in the modified event.
>+		 */
>+		mpx_fde = talloc_get_type_abort(fde->additional_data,
>+						struct tevent_fd);
>+
>+		mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+		mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+
>+		flags |= port_map_flags(mpx_fde->flags);
>+	} else {
>+		/*
>+		 * Not (yet) a multiplexed event. See if there
>+		 * is already an event with the same fd.
>+		 */
>+		for (mpx_fde = port_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
>+			if (mpx_fde->fd != fde->fd) {
>+				continue;
>+			}
>+			if (mpx_fde == fde) {
>+				continue;
>+			}
>+			/* Same fd. */
>+			break;
>+		}
>+		if (mpx_fde) {
>+			if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+				/* Logic error. Can't have more then 2 multiplexed fde's. */
>+				tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
>+					"multiplex fde for fd[%d] is already multiplexed\n",
>+					mpx_fde->fd);
>+				return -1;
>+			}
>+			flags |= port_map_flags(mpx_fde->flags);
>+		}
>+	}
>+
>+	if (!store_port_association(port_ev,
>+				fde,
>+				flags)) {
>+		tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
>+			"store_port_association failed for fd[%d]\n",
>+			fde->fd);
>+		return -1;
>+	}
>+
>+	/* Note we have an association now. */
>+	fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+	/* Only if we want to read do we tell the event handler about errors. */
>+	if (fde->flags & TEVENT_FD_READ) {
>+		fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+	}
>+	if (mpx_fde == NULL) {
>+		return 0;
>+	}
>+	/* Set up the multiplex pointer. Does no harm if already multiplexed. */
>+	port_setup_multiplex_fd(port_ev,
>+				fde,
>+				mpx_fde);
>+
>+	mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+	/* Only if we want to read do we tell the event handler about errors. */
>+	if (mpx_fde->flags & TEVENT_FD_READ) {
>+		mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+	}
>+
>+	return 0;
>+}
>+
>+/*
>+ Delete the port association for the given fd_event.
>+*/
>+
>+static void port_del_event(struct port_event_context *port_ev, struct tevent_fd *fde)
>+{
>+	struct tevent_fd *mpx_fde = NULL;
>+
>+	fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+	fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+
>+	if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+		/*
>+		 * This is a multiplexed fde, we need to remove
>+		 * both associations.
>+		 */
>+		mpx_fde = talloc_get_type_abort(fde->additional_data,
>+						struct tevent_fd);
>+
>+		mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+		mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
>+		mpx_fde->additional_data = NULL;
>+
>+		fde->additional_data = NULL;
>+	}
>+	delete_port_association(port_ev, fde);
>+}
>+
>+/*
>+ Add or remove the port event from the given fd_event
>+*/
>+static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde)
>+{
>+	bool got_error = (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR);
>+	bool want_read = (fde->flags & TEVENT_FD_READ);
>+	bool want_write = (fde->flags & TEVENT_FD_WRITE);
>+	struct tevent_fd *mpx_fde = NULL;
>+
>+	if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+		/*
>+		 * work out what the multiplexed fde wants.
>+		 */
>+		mpx_fde = talloc_get_type_abort(fde->additional_data,
>+						struct tevent_fd);
>+		if (mpx_fde->flags & TEVENT_FD_READ) {
>+			want_read = true;
>+		}
>+		if (mpx_fde->flags & TEVENT_FD_WRITE) {
>+			want_write = true;
>+		}
>+	}
>+
>+	if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION) {
>+		/* There's already an association. */
>+		if (want_read || (want_write && !got_error)) {
>+			return port_add_event(port_ev, fde);
>+		}
>+		/*
>+		 * If we want to match the select behavior, we need to remove the port event
>+		 * when the caller isn't interested in events.
>+		 */
>+		port_del_event(port_ev, fde);
>+		return 0;
>+	}
>+
>+	/* There's no port event attached to the fde. */
>+	if (want_read || (want_write && !got_error)) {
>+		return port_add_event(port_ev, fde);
>+	}
>+	return 0;
>+}
>+
>+/*
>+ Cope with port_get returning EPOLLHP|EPOLLERR on an association.
>+ Return true if there's nothing else to do, false if this event
>+ needs further handling.
>+*/
>+
>+static bool port_handle_hup_or_err(struct port_event_context *port_ev,
>+				struct tevent_fd *fde)
>+{
>+	if (fde == NULL) {
>+		return true;
>+	}
>+
>+	fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
>+	/*
>+	 * If we only wait for TEVENT_FD_WRITE, we should not tell the
>+	 * event handler about it, and remove the port association,
>+	 * as we only report error when waiting for read events,
>+	 * to match the select() behavior.
>+	 */
>+	if (!(fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
>+		/*
>+		 * Do the same as the poll backend and
>+		 * remove the writable flag.
>+		 */
>+		fde->flags &= ~TEVENT_FD_WRITE;
>+		return true;
>+	}
>+	/* This has TEVENT_FD_READ set, we're not finished. */
>+	return false;
>+}
>+
>+/*
>+  Event loop handling using Solaris ports.
>+*/
>+static int port_event_loop(struct port_event_context *port_ev, struct timeval *tvalp)
>+{
>+	int ret;
>+#define MAXEVENTS 1
>+	port_event_t events[MAXEVENTS];
>+	uint_t nget = 1;
>+	uint_t max_events = MAXEVENTS;
>+	uint_t i;
>+	int port_errno;
>+	struct timespec ts;
>+	struct tevent_context *ev = port_ev->ev;
>+
>+	if (tvalp) {
>+		ts.tv_sec = tvalp->tv_sec;
>+		ts.tv_nsec = tvalp->tv_usec * 1000;
>+	}
>+
>+	if (port_ev->ev->signal_events &&
>+	    tevent_common_check_signal(ev)) {
>+		return 0;
>+	}
>+
>+	/*
>+	 * Solaris triggers sending the event to the port
>+	 * at the time the port association is done. Postpone
>+	 * associating fd's until just before we get the events,
>+	 * otherwise we can deadlock.
>+	 */
>+
>+	if (associate_all_events(port_ev) != 0) {
>+		return -1;
>+	}
>+
>+	tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_WAIT);
>+	ret = port_getn(port_ev->port_fd, events, max_events, &nget, &ts);
>+	port_errno = errno;
>+	tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_WAIT);
>+
>+	if (ret == -1 && port_errno == EINTR && ev->signal_events) {
>+		if (tevent_common_check_signal(ev)) {
>+			return 0;
>+		}
>+	}
>+
>+	if (ret == -1 && port_errno == ETIME && tvalp) {
>+		/* we don't care about a possible delay here */
>+		tevent_common_loop_timer_delay(ev);
>+		return 0;
>+	}
>+
>+	if (ret == -1) {
>+		tevent_debug(ev, TEVENT_DEBUG_ERROR,
>+				"port_get failed (%s)\n",
>+				strerror(errno));
>+		return -1;
>+	}
>+
>+	for (i = 0; i < nget; i++) {
>+		struct tevent_fd *mpx_fde = NULL;
>+		struct tevent_fd *fde = NULL;
>+		uint16_t flags = 0;
>+		struct port_associate_vals *val = talloc_get_type(events[i].portev_user,
>+							struct port_associate_vals);
>+		if (val == NULL) {
>+			tevent_debug(ev, TEVENT_DEBUG_ERROR,
>+				"port_getn() gave bad data");
>+			return -1;
>+		}
>+
>+		/* Mark this event as needing to be re-associated. */
>+		val->associated_event = false;
>+
>+		fde = val->fde;
>+
>+		if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+			/*
>+			 * Save off the multiplexed event in case we need
>+			 * to use it to call the handler function.
>+			 */
>+			mpx_fde = talloc_get_type_abort(fde->additional_data,
>+						struct tevent_fd);
>+		}
>+
>+		if (events[i].portev_events & (POLLHUP|POLLERR)) {
>+			bool handled_fde = port_handle_hup_or_err(port_ev, fde);
>+			bool handled_mpx = port_handle_hup_or_err(port_ev, mpx_fde);
>+
>+			if (handled_fde && handled_mpx) {
>+				return port_update_event(port_ev, fde);
>+			}
>+
>+			if (!handled_mpx) {
>+				/*
>+				 * If the mpx event was the one that needs
>+				 * further handling, it's the TEVENT_FD_READ
>+				 * event so switch over and call that handler.
>+				 */
>+				fde = mpx_fde;
>+				mpx_fde = NULL;
>+			}
>+			flags |= TEVENT_FD_READ;
>+		}
>+
>+		if (events[i].portev_events & POLLIN) {
>+			flags |= TEVENT_FD_READ;
>+		}
>+		if (events[i].portev_events & POLLOUT) {
>+			flags |= TEVENT_FD_WRITE;
>+		}
>+
>+		if (flags & TEVENT_FD_WRITE) {
>+			if (fde->flags & TEVENT_FD_WRITE) {
>+				mpx_fde = NULL;
>+			}
>+			if (mpx_fde && (mpx_fde->flags & TEVENT_FD_WRITE)) {
>+				fde = mpx_fde;
>+				mpx_fde = NULL;
>+			}
>+
>+			if (mpx_fde) {
>+				/* Ensure we got the right fde. */
>+				if ((flags & fde->flags) == 0) {
>+					fde = mpx_fde;
>+					mpx_fde = NULL;
>+				}
>+			}
>+		}
>+
>+		/*
>+		 * Make sure we only pass the flags
>+		 * the handler is expecting.
>+		 */
>+		flags &= fde->flags;
>+		if (flags) {
>+			fde->handler(ev, fde, flags, fde->private_data);
>+			break;
>+		}
>+	}
>+
>+	return 0;
>+}
>+
>+
>+/*
>+  create a port_event_context structure.
>+*/
>+static int port_event_context_init(struct tevent_context *ev)
>+{
>+	int ret;
>+	struct port_event_context *port_ev;
>+
>+	/*
>+	 * We might be called during tevent_re_initialise()
>+	 * which means we need to free our old additional_data.
>+	 */
>+	TALLOC_FREE(ev->additional_data);
>+
>+	port_ev = talloc_zero(ev, struct port_event_context);
>+	if (!port_ev) {
>+		return -1;
>+	}
>+	port_ev->ev = ev;
>+	port_ev->port_fd = -1;
>+	port_ev->pid = (pid_t)-1;
>+
>+	ret = port_init_ctx(port_ev);
>+	if (ret != 0) {
>+		talloc_free(port_ev);
>+		return ret;
>+	}
>+
>+	ev->additional_data = port_ev;
>+	return 0;
>+}
>+
>+/*
>+  destroy an fd_event
>+*/
>+static int port_event_fd_destructor(struct tevent_fd *fde)
>+{
>+	struct tevent_context *ev = fde->event_ctx;
>+	struct port_event_context *port_ev = NULL;
>+	struct tevent_fd *mpx_fde = NULL;
>+	int flags = (int)fde->flags;
>+
>+	if (ev == NULL) {
>+		return tevent_common_fd_destructor(fde);
>+	}
>+
>+	port_ev = talloc_get_type_abort(ev->additional_data,
>+					 struct port_event_context);
>+
>+	DLIST_REMOVE(ev->fd_events, fde);
>+
>+	if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
>+		mpx_fde = talloc_get_type_abort(fde->additional_data,
>+						struct tevent_fd);
>+
>+		fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
>+		mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
>+
>+		fde->additional_data = NULL;
>+		mpx_fde->additional_data = NULL;
>+
>+		fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
>+	}
>+
>+	(void)port_check_reopen(port_ev);
>+
>+	if (mpx_fde != NULL) {
>+		(void)port_update_event(port_ev, mpx_fde);
>+	}
>+
>+	fde->flags = 0;
>+	(void)port_update_event(port_ev, fde);
>+	fde->flags = flags;
>+
>+	return tevent_common_fd_destructor(fde);
>+}
>+
>+/*
>+  add a fd based event
>+  return NULL on failure (memory allocation error)
>+*/
>+static struct tevent_fd *port_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
>+					    int fd, uint16_t flags,
>+					    tevent_fd_handler_t handler,
>+					    void *private_data,
>+					    const char *handler_name,
>+					    const char *location)
>+{
>+	struct port_event_context *port_ev =
>+				talloc_get_type_abort(ev->additional_data,
>+				struct port_event_context);
>+	struct tevent_fd *fde;
>+
>+	fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
>+				   handler, private_data,
>+				   handler_name, location);
>+	if (!fde) {
>+		return NULL;
>+	}
>+
>+	talloc_set_destructor(fde, port_event_fd_destructor);
>+
>+	if (port_check_reopen(port_ev) != 0) {
>+		TALLOC_FREE(fde);
>+		return NULL;
>+	}
>+
>+	if (port_update_event(port_ev, fde) != 0) {
>+		TALLOC_FREE(fde);
>+		return NULL;
>+	}
>+
>+	return fde;
>+}
>+
>+/*
>+  set the fd event flags
>+*/
>+static void port_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
>+{
>+	struct tevent_context *ev;
>+	struct port_event_context *port_ev;
>+
>+	if (fde->flags == flags) {
>+		return;
>+	}
>+
>+	ev = fde->event_ctx;
>+	port_ev = talloc_get_type_abort(ev->additional_data,
>+				struct port_event_context);
>+
>+	fde->flags = flags;
>+
>+	(void)port_check_reopen(port_ev);
>+	(void)port_update_event(port_ev, fde);
>+}
>+
>+/*
>+  do a single event loop using the events defined in ev
>+*/
>+static int port_event_loop_once(struct tevent_context *ev, const char *location)
>+{
>+	struct port_event_context *port_ev = talloc_get_type(ev->additional_data,
>+							   struct port_event_context);
>+	struct timeval tval;
>+
>+	if (ev->signal_events &&
>+	    tevent_common_check_signal(ev)) {
>+		return 0;
>+	}
>+
>+	if (ev->immediate_events &&
>+	    tevent_common_loop_immediate(ev)) {
>+		return 0;
>+	}
>+
>+	tval = tevent_common_loop_timer_delay(ev);
>+	if (tevent_timeval_is_zero(&tval)) {
>+		return 0;
>+	}
>+
>+	if (port_check_reopen(port_ev) != 0) {
>+		errno = EINVAL;
>+		return -1;
>+	}
>+	return port_event_loop(port_ev, &tval);
>+}
>+
>+static const struct tevent_ops port_event_ops = {
>+	.context_init		= port_event_context_init,
>+	.add_fd			= port_event_add_fd,
>+	.set_fd_close_fn	= tevent_common_fd_set_close_fn,
>+	.get_fd_flags		= tevent_common_fd_get_flags,
>+	.set_fd_flags		= port_event_set_fd_flags,
>+	.add_timer		= tevent_common_add_timer_v2,
>+	.schedule_immediate	= tevent_common_schedule_immediate,
>+	.add_signal		= tevent_common_add_signal,
>+	.loop_once		= port_event_loop_once,
>+	.loop_wait		= tevent_common_loop_wait,
>+};
>+
>+_PRIVATE_ bool tevent_port_init(void)
>+{
>+	if (!tevent_register_backend("port", &port_event_ops)) {
>+		return false;
>+	}
>+	tevent_set_default_backend("port");
>+	return true;
>+}
>diff --git a/lib/tevent/wscript b/lib/tevent/wscript
>index a991fed..45f602c 100755
>--- a/lib/tevent/wscript
>+++ b/lib/tevent/wscript
>@@ -89,6 +89,9 @@ def build(bld):
>     if bld.CONFIG_SET('HAVE_EPOLL'):
>         SRC += ' tevent_epoll.c'
> 
>+    if bld.CONFIG_SET('HAVE_SOLARIS_PORTS'):
>+        SRC += ' tevent_port.c'
>+
>     if bld.env.standalone_tevent:
>         bld.env.PKGCONFIGDIR = '${LIBDIR}/pkgconfig'
>         private_library = False
>-- 
>1.9.1
>
>
>From b4b6e917c5aaea43c3bb78d259951c6c07c17316 Mon Sep 17 00:00:00 2001
>From: Michael Adam <obnox@samba.org>
>Date: Fri, 27 Feb 2015 00:27:29 +0100
>Subject: [PATCH 3/3] tevent: version 0.9.23
>
>* Add Solaris ports as tevent backend.
>* Improvements to the tevent_data tutorial.
>* Remove use of the 'staticforward' macro.
>
>Signed-off-by: Michael Adam <obnox@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>
>Autobuild-User(master): Michael Adam <obnox@samba.org>
>Autobuild-Date(master): Fri Feb 27 03:48:57 CET 2015 on sn-devel-104
>
>(cherry picked from commit 04b8e19e1708c5670d180f5cd86d8ed139e9e5a4)
>---
> lib/tevent/ABI/tevent-0.9.23.sigs | 88 +++++++++++++++++++++++++++++++++++++++
> lib/tevent/wscript                |  2 +-
> 2 files changed, 89 insertions(+), 1 deletion(-)
> create mode 100644 lib/tevent/ABI/tevent-0.9.23.sigs
>
>diff --git a/lib/tevent/ABI/tevent-0.9.23.sigs b/lib/tevent/ABI/tevent-0.9.23.sigs
>new file mode 100644
>index 0000000..d8b9f4b
>--- /dev/null
>+++ b/lib/tevent/ABI/tevent-0.9.23.sigs
>@@ -0,0 +1,88 @@
>+_tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
>+_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
>+_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
>+_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
>+_tevent_loop_once: int (struct tevent_context *, const char *)
>+_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
>+_tevent_loop_wait: int (struct tevent_context *, const char *)
>+_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
>+_tevent_req_callback_data: void *(struct tevent_req *)
>+_tevent_req_cancel: bool (struct tevent_req *, const char *)
>+_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
>+_tevent_req_data: void *(struct tevent_req *)
>+_tevent_req_done: void (struct tevent_req *, const char *)
>+_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
>+_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
>+_tevent_req_notify_callback: void (struct tevent_req *, const char *)
>+_tevent_req_oom: void (struct tevent_req *, const char *)
>+_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
>+tevent_backend_list: const char **(TALLOC_CTX *)
>+tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
>+tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
>+tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
>+tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
>+tevent_common_add_timer_v2: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
>+tevent_common_check_signal: int (struct tevent_context *)
>+tevent_common_context_destructor: int (struct tevent_context *)
>+tevent_common_fd_destructor: int (struct tevent_fd *)
>+tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
>+tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
>+tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
>+tevent_common_loop_immediate: bool (struct tevent_context *)
>+tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
>+tevent_common_loop_wait: int (struct tevent_context *, const char *)
>+tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
>+tevent_context_init: struct tevent_context *(TALLOC_CTX *)
>+tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
>+tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
>+tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
>+tevent_fd_get_flags: uint16_t (struct tevent_fd *)
>+tevent_fd_set_auto_close: void (struct tevent_fd *)
>+tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
>+tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
>+tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
>+tevent_loop_allow_nesting: void (struct tevent_context *)
>+tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
>+tevent_num_signals: size_t (void)
>+tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
>+tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
>+tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
>+tevent_queue_length: size_t (struct tevent_queue *)
>+tevent_queue_running: bool (struct tevent_queue *)
>+tevent_queue_start: void (struct tevent_queue *)
>+tevent_queue_stop: void (struct tevent_queue *)
>+tevent_queue_wait_recv: bool (struct tevent_req *)
>+tevent_queue_wait_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct tevent_queue *)
>+tevent_re_initialise: int (struct tevent_context *)
>+tevent_register_backend: bool (const char *, const struct tevent_ops *)
>+tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
>+tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
>+tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
>+tevent_req_is_in_progress: bool (struct tevent_req *)
>+tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
>+tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
>+tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
>+tevent_req_received: void (struct tevent_req *)
>+tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
>+tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
>+tevent_req_set_cleanup_fn: void (struct tevent_req *, tevent_req_cleanup_fn)
>+tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
>+tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
>+tevent_sa_info_queue_count: size_t (void)
>+tevent_set_abort_fn: void (void (*)(const char *))
>+tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
>+tevent_set_debug_stderr: int (struct tevent_context *)
>+tevent_set_default_backend: void (const char *)
>+tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
>+tevent_signal_support: bool (struct tevent_context *)
>+tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
>+tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
>+tevent_timeval_current: struct timeval (void)
>+tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
>+tevent_timeval_is_zero: bool (const struct timeval *)
>+tevent_timeval_set: struct timeval (uint32_t, uint32_t)
>+tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
>+tevent_timeval_zero: struct timeval (void)
>+tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
>+tevent_wakeup_recv: bool (struct tevent_req *)
>+tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
>diff --git a/lib/tevent/wscript b/lib/tevent/wscript
>index 45f602c..489ce31 100755
>--- a/lib/tevent/wscript
>+++ b/lib/tevent/wscript
>@@ -1,7 +1,7 @@
> #!/usr/bin/env python
> 
> APPNAME = 'tevent'
>-VERSION = '0.9.22'
>+VERSION = '0.9.23'
> 
> blddir = 'bin'
> 
>-- 
>1.9.1
>

Flags:

obnox: review+
ddiss: review+

Actions: View

Attachments on bug 11118: 10789 | 10792 | 10802 | 10810 | 10814