X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Fio%2Fpoll.c;h=d7b9eb56b950b5a1b4772525c86bb944b3a60c6f;hp=31a56600fe487b836e8bf1b8bdb88ecfa75953e0;hb=12ab811533406e22b78ce8b227474f1056375ae4;hpb=641b511049e5c03d45ada0c3fd829691b173e5d1

diff --git a/ccan/io/poll.c b/ccan/io/poll.c
index 31a56600..d7b9eb56 100644
--- a/ccan/io/poll.c
+++ b/ccan/io/poll.c
@@ -10,6 +10,7 @@
 #include <errno.h>
 
 static size_t num_fds = 0, max_fds = 0, num_closing = 0, num_waiting = 0;
+static bool some_always = false;
 static struct pollfd *pollfds = NULL;
 static struct fd **fds = NULL;
 static struct timers timeouts;
@@ -28,7 +29,7 @@ static void io_loop_exit(void)
 		while (free_later) {
 			struct io_conn *c = free_later;
 			free_later = c->finish_arg;
-			free(c);
+			io_alloc.free(c);
 		}
 	}
 }
@@ -42,7 +43,7 @@ static void free_conn(struct io_conn *conn)
 		conn->finish_arg = free_later;
 		free_later = conn;
 	} else
-		free(conn);
+		io_alloc.free(conn);
 }
 #else
 static void io_loop_enter(void)
@@ -53,7 +54,7 @@ static void io_loop_exit(void)
 }
 static void free_conn(struct io_conn *conn)
 {
-	free(conn);
+	io_alloc.free(conn);
 }
 #endif
 
@@ -64,11 +65,11 @@ static bool add_fd(struct fd *fd, short events)
 		struct fd **newfds;
 		size_t num = max_fds ? max_fds * 2 : 8;
 
-		newpollfds = realloc(pollfds, sizeof(*newpollfds) * num);
+		newpollfds = io_alloc.realloc(pollfds, sizeof(*newpollfds)*num);
 		if (!newpollfds)
 			return false;
 		pollfds = newpollfds;
-		newfds = realloc(fds, sizeof(*newfds) * num);
+		newfds = io_alloc.realloc(fds, sizeof(*newfds) * num);
 		if (!newfds)
 			return false;
 		fds = newfds;
@@ -105,10 +106,18 @@ static void del_fd(struct fd *fd)
 		fds[n] = fds[num_fds-1];
 		assert(fds[n]->backend_info == num_fds-1);
 		fds[n]->backend_info = n;
+		/* If that happens to be a duplex, move that too. */
+		if (!fds[n]->listener) {
+			struct io_conn *c = (void *)fds[n];
+			if (c->duplex) {
+				assert(c->duplex->fd.backend_info == num_fds-1);
+				c->duplex->fd.backend_info = n;
+			}
+		}
 	} else if (num_fds == 1) {
 		/* Free everything when no more fds. */
-		free(pollfds);
-		free(fds);
+		io_alloc.free(pollfds);
+		io_alloc.free(fds);
 		pollfds = NULL;
 		fds = NULL;
 		max_fds = 0;
@@ -138,9 +147,9 @@ void backend_plan_changed(struct io_conn *conn)
 	if (pfd->events)
 		num_waiting--;
 
-	pfd->events = conn->plan.pollflag;
+	pfd->events = conn->plan.pollflag & (POLLIN|POLLOUT);
 	if (conn->duplex) {
-		int mask = conn->duplex->plan.pollflag;
+		int mask = conn->duplex->plan.pollflag & (POLLIN|POLLOUT);
 		/* You can't *both* read/write. */
 		assert(!mask || pfd->events != mask);
 		pfd->events |= mask;
@@ -153,15 +162,20 @@ void backend_plan_changed(struct io_conn *conn)
 
 	if (!conn->plan.next)
 		num_closing++;
+
+	if (conn->plan.pollflag == POLLALWAYS)
+		some_always = true;
 }
 
 bool add_conn(struct io_conn *c)
 {
-	if (!add_fd(&c->fd, c->plan.pollflag))
+	if (!add_fd(&c->fd, c->plan.pollflag & (POLLIN|POLLOUT)))
 		return false;
 	/* Immediate close is allowed. */
 	if (!c->plan.next)
 		num_closing++;
+	if (c->plan.pollflag == POLLALWAYS)
+		some_always = true;
 	return true;
 }
 
@@ -175,14 +189,16 @@ bool add_duplex(struct io_conn *c)
 void backend_del_conn(struct io_conn *conn)
 {
 	if (conn->finish) {
-		errno = conn->plan.u.close.saved_errno;
+		/* Saved by io_close */
+		errno = conn->plan.u1.s;
 		conn->finish(conn, conn->finish_arg);
 	}
 	if (timeout_active(conn))
 		backend_del_timeout(conn);
-	free(conn->timeout);
+	io_alloc.free(conn->timeout);
 	if (conn->duplex) {
 		/* In case fds[] pointed to the other one. */
+		assert(conn->duplex->fd.backend_info == conn->fd.backend_info);
 		fds[conn->fd.backend_info] = &conn->duplex->fd;
 		conn->duplex->duplex = NULL;
 		conn->fd.backend_info = -1;
@@ -257,6 +273,26 @@ void backend_del_timeout(struct io_conn *conn)
 	conn->timeout->conn = NULL;
 }
 
+static void handle_always(void)
+{
+	int i;
+
+	some_always = false;
+
+	for (i = 0; i < num_fds && !io_loop_return; i++) {
+		struct io_conn *c = (void *)fds[i];
+
+		if (fds[i]->listener)
+			continue;
+
+		if (c->plan.pollflag == POLLALWAYS)
+			io_ready(c);
+
+		if (c->duplex && c->duplex->plan.pollflag == POLLALWAYS)
+			io_ready(c->duplex);
+	}
+}
+
 /* This is the main loop. */
 void *do_io_loop(struct io_conn **ready)
 {
@@ -307,6 +343,11 @@ void *do_io_loop(struct io_conn **ready)
 		if (doing_debug() && some_timeouts)
 			continue;
 
+		if (some_always) {
+			handle_always();
+			continue;
+		}
+
 		if (num_fds == 0)
 			break;
 
@@ -345,7 +386,11 @@ void *do_io_loop(struct io_conn **ready)
 						 * anything can change. */
 						if (doing_debug())
 							break;
-						if (!(events&(POLLIN|POLLOUT)))
+
+						/* If no events, or it closed
+						 * the duplex, continue. */
+						if (!(events&(POLLIN|POLLOUT))
+						    || !c->plan.next)
 							continue;
 					}
 				}