IPC send/recv works asynchronously for POSIX.

As with TCP, we're still using threads under the hood.  But this
completes the send/recv logic conversion for POSIX to our AIO framework,
and hence represents a substantial milestone towards full asyncronous
operation.

We still need to do accept/connect operations asynchronously, then making.
Windows overlapped IO work properly. After that, poll/epoll/kqueue, etc.

1 files changed, 178 insertions, 70 deletions

diff --git a/src/transport/ipc/ipc.c b/src/transport/ipc/ipc.c
index 46003487..7ffea62d 100644
--- a/src/transport/ipc/ipc.c
+++ b/src/transport/ipc/ipc.c
@@ -23,20 +23,33 @@ typedef struct nni_ipc_ep	nni_ipc_ep;
 // nni_ipc_pipe is one end of an IPC connection.
 struct nni_ipc_pipe {
 	const char *		addr;
-	nni_plat_ipcsock	fd;
+	nni_plat_ipcsock *	isp;
 	uint16_t		peer;
 	uint16_t		proto;
 	size_t			rcvmax;
+
+	uint8_t			txhead[1+sizeof (uint64_t)];
+	uint8_t			rxhead[1+sizeof (uint64_t)];
+
+	nni_aio *		user_txaio;
+	nni_aio *		user_rxaio;
+	nni_aio			txaio;
+	nni_aio			rxaio;
+	nni_msg *		rxmsg;
 };
 
 struct nni_ipc_ep {
 	char			addr[NNG_MAXADDRLEN+1];
-	nni_plat_ipcsock	fd;
+	nni_plat_ipcsock *	isp;
 	int			closed;
 	uint16_t		proto;
 	size_t			rcvmax;
 };
 
+
+static void nni_ipc_pipe_send_cb(void *);
+static void nni_ipc_pipe_recv_cb(void *);
+
 static int
 nni_ipc_tran_init(void)
 {
@@ -55,7 +68,7 @@ nni_ipc_pipe_close(void *arg)
 {
 	nni_ipc_pipe *pipe = arg;
 
-	nni_plat_ipc_shutdown(&pipe->fd);
+	nni_plat_ipc_shutdown(pipe->isp);
 }
 
 
@@ -68,7 +81,21 @@ nni_ipc_pipe_init(void **argp)
 	if ((pipe = NNI_ALLOC_STRUCT(pipe)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	if ((rv = nni_plat_ipc_init(&pipe->fd)) != 0) {
+	if ((rv = nni_plat_ipc_init(&pipe->isp)) != 0) {
+		NNI_FREE_STRUCT(pipe);
+		return (rv);
+	}
+	rv = nni_aio_init(&pipe->txaio, nni_ipc_pipe_send_cb, pipe);
+	if (rv != 0) {
+		nni_plat_ipc_fini(pipe->isp);
+		NNI_FREE_STRUCT(pipe);
+		return (rv);
+	}
+
+	rv = nni_aio_init(&pipe->rxaio, nni_ipc_pipe_recv_cb, pipe);
+	if (rv != 0) {
+		nni_aio_fini(&pipe->txaio);
+		nni_plat_ipc_fini(pipe->isp);
 		NNI_FREE_STRUCT(pipe);
 		return (rv);
 	}
@@ -82,81 +109,164 @@ nni_ipc_pipe_fini(void *arg)
 {
 	nni_ipc_pipe *pipe = arg;
 
-	nni_plat_ipc_fini(&pipe->fd);
+	if (pipe->rxmsg) {
+		nni_msg_free(pipe->rxmsg);
+	}
+	nni_aio_fini(&pipe->rxaio);
+	nni_aio_fini(&pipe->txaio);
+	nni_plat_ipc_fini(pipe->isp);
 	NNI_FREE_STRUCT(pipe);
 }
 
 
-static int
-nni_ipc_pipe_send(void *arg, nni_msg *msg)
+static void
+nni_ipc_pipe_send_cb(void *arg)
 {
 	nni_ipc_pipe *pipe = arg;
-	uint64_t len;
-	uint8_t buf[sizeof (len)];
-	nni_iov iov[4];
+	nni_aio *aio;
 	int rv;
-	uint8_t msgtype;
-
-	msgtype = 1; // "inband", the only defined option at present
+	size_t len;
 
-	iov[0].iov_buf = &msgtype;
-	iov[0].iov_len = 1;
-	iov[1].iov_buf = buf;
-	iov[1].iov_len = sizeof (buf);
-	iov[2].iov_buf = nni_msg_header(msg);
-	iov[2].iov_len = nni_msg_header_len(msg);
-	iov[3].iov_buf = nni_msg_body(msg);
-	iov[3].iov_len = nni_msg_len(msg);
+	if ((aio = pipe->user_txaio) == NULL) {
+		NNI_ASSERT(aio != NULL);
+		return;
+	}
+	pipe->user_txaio = NULL;
+	if ((rv = nni_aio_result(&pipe->txaio)) != 0) {
+		nni_aio_finish(aio, rv, 0);
+		return;
+	}
 
-	len = (uint64_t) iov[2].iov_len + (uint64_t) iov[3].iov_len;
-	NNI_PUT64(buf, len);
+	len = nni_msg_len(aio->a_msg);
+	nni_msg_free(aio->a_msg);
+	aio->a_msg = NULL;
 
-	if ((rv = nni_plat_ipc_send(&pipe->fd, iov, 4)) == 0) {
-		nni_msg_free(msg);
-	}
-	return (rv);
+	nni_aio_finish(aio, 0, len);
 }
 
 
-static int
-nni_ipc_pipe_recv(void *arg, nni_msg **msgp)
+static void
+nni_ipc_pipe_recv_cb(void *arg)
 {
 	nni_ipc_pipe *pipe = arg;
-	nni_msg *msg;
-	uint64_t len;
-	uint8_t buf[sizeof (len)];
-	nni_iov iov[2];
+	nni_aio *aio;
 	int rv;
-	uint8_t msgtype;
 
-	iov[0].iov_buf = &msgtype;
-	iov[0].iov_len = 1;
-	iov[1].iov_buf = buf;
-	iov[1].iov_len = sizeof (buf);
-	if ((rv = nni_plat_ipc_recv(&pipe->fd, iov, 2)) != 0) {
-		return (rv);
-	}
-	if (msgtype != 1) {
-		return (NNG_EPROTO);
-	}
-	NNI_GET64(buf, len);
-	if (len > pipe->rcvmax) {
-		return (NNG_EMSGSIZE);
+	aio = pipe->user_rxaio;
+	if (aio == NULL) {
+		// This should never ever happen.
+		NNI_ASSERT(aio != NULL);
+		return;
 	}
 
-	if ((rv = nng_msg_alloc(&msg, (size_t) len)) != 0) {
-		return (rv);
+	if ((rv = nni_aio_result(&pipe->rxaio)) != 0) {
+		// Error on receive.  This has to cause an error back
+		// to the user.  Also, if we had allocated an rxmsg, lets
+		// toss it.
+		if (pipe->rxmsg != NULL) {
+			nni_msg_free(pipe->rxmsg);
+			pipe->rxmsg = NULL;
+		}
+		pipe->user_rxaio = NULL;
+		nni_aio_finish(aio, rv, 0);
+		return;
 	}
 
-	iov[0].iov_len = nng_msg_len(msg);
-	iov[0].iov_buf = nng_msg_body(msg);
+	// If we don't have a message yet, we were reading the TCP message
+	// header, which is just the length.  This tells us the size of the
+	// message to allocate and how much more to expect.
+	if (pipe->rxmsg == NULL) {
+		uint64_t len;
 
-	if ((rv = nni_plat_ipc_recv(&pipe->fd, iov, 1)) == 0) {
-		*msgp = msg;
-	} else {
-		nni_msg_free(msg);
+		// Check to make sure we got msg type 1.
+		if (pipe->rxhead[0] != 1) {
+			nni_aio_finish(aio, NNG_EPROTO, 0);
+			return;
+		}
+
+		// We should have gotten a message header.
+		NNI_GET64(pipe->rxhead+1, len);
+
+		// Make sure the message payload is not too big.  If it is
+		// the caller will shut down the pipe.
+		if (len > pipe->rcvmax) {
+			pipe->user_rxaio = NULL;
+			nni_aio_finish(aio, NNG_EMSGSIZE, 0);
+			return;
+		}
+
+		if ((rv = nng_msg_alloc(&pipe->rxmsg, (size_t) len)) != 0) {
+			pipe->user_rxaio = NULL;
+			nni_aio_finish(aio, rv, 0);
+			return;
+		}
+
+		// Submit the rest of the data for a read -- we want to
+		// read the entire message now.
+		pipe->rxaio.a_iov[0].iov_buf = nni_msg_body(pipe->rxmsg);
+		pipe->rxaio.a_iov[0].iov_len = nni_msg_len(pipe->rxmsg);
+		pipe->rxaio.a_niov = 1;
+
+		rv = nni_plat_ipc_aio_recv(pipe->isp, &pipe->rxaio);
+		if (rv != 0) {
+			pipe->user_rxaio = NULL;
+			nni_msg_free(pipe->rxmsg);
+			pipe->rxmsg = NULL;
+			nni_aio_finish(aio, rv, 0);
+			return;
+		}
+		return;
 	}
-	return (rv);
+
+	// Otherwise we got a message read completely.  Let the user know the
+	// good news.
+	pipe->user_rxaio = NULL;
+	aio->a_msg = pipe->rxmsg;
+	pipe->rxmsg = NULL;
+	nni_aio_finish(aio, 0, nni_msg_len(aio->a_msg));
+}
+
+
+static int
+nni_ipc_pipe_aio_send(void *arg, nni_aio *aio)
+{
+	nni_ipc_pipe *pipe = arg;
+	nni_msg *msg = aio->a_msg;
+	uint64_t len;
+
+	pipe->user_txaio = aio;
+
+	pipe->txhead[0] = 1;    // message type, 1.
+	len = nni_msg_len(msg) + nni_msg_header_len(msg);
+	NNI_PUT64(pipe->txhead + 1, len);
+
+	pipe->txaio.a_iov[0].iov_buf = pipe->txhead;
+	pipe->txaio.a_iov[0].iov_len = sizeof (pipe->txhead);
+	pipe->txaio.a_iov[1].iov_buf = nni_msg_header(msg);
+	pipe->txaio.a_iov[1].iov_len = nni_msg_header_len(msg);
+	pipe->txaio.a_iov[2].iov_buf = nni_msg_body(msg);
+	pipe->txaio.a_iov[2].iov_len = nni_msg_len(msg);
+	pipe->txaio.a_niov = 3;
+
+	return (nni_plat_ipc_aio_send(pipe->isp, &pipe->txaio));
+}
+
+
+static int
+nni_ipc_pipe_aio_recv(void *arg, nni_aio *aio)
+{
+	nni_ipc_pipe *pipe = arg;
+
+	pipe->user_rxaio = aio;
+
+	NNI_ASSERT(pipe->rxmsg == NULL);
+
+	// Schedule a read of the IPC header.
+	pipe->rxaio.a_iov[0].iov_buf = pipe->rxhead;
+	pipe->rxaio.a_iov[0].iov_len = sizeof (pipe->rxhead);
+	pipe->rxaio.a_niov = 1;
+
+	return (nni_plat_ipc_aio_recv(pipe->isp, &pipe->rxaio));
 }
 
 
@@ -208,7 +318,7 @@ nni_ipc_ep_init(void **epp, const char *url, nni_sock *sock)
 	ep->closed = 0;
 	ep->proto = nni_sock_proto(sock);
 	ep->rcvmax = nni_sock_rcvmaxsz(sock);
-	if ((rv = nni_plat_ipc_init(&ep->fd)) != 0) {
+	if ((rv = nni_plat_ipc_init(&ep->isp)) != 0) {
 		NNI_FREE_STRUCT(ep);
 		return (rv);
 	}
@@ -225,7 +335,7 @@ nni_ipc_ep_fini(void *arg)
 {
 	nni_ipc_ep *ep = arg;
 
-	nni_plat_ipc_fini(&ep->fd);
+	nni_plat_ipc_fini(ep->isp);
 	NNI_FREE_STRUCT(ep);
 }
 
@@ -235,7 +345,7 @@ nni_ipc_ep_close(void *arg)
 {
 	nni_ipc_ep *ep = arg;
 
-	nni_plat_ipc_shutdown(&ep->fd);
+	nni_plat_ipc_shutdown(ep->isp);
 }
 
 
@@ -256,13 +366,13 @@ nni_ipc_negotiate(nni_ipc_pipe *pipe)
 
 	iov.iov_buf = buf;
 	iov.iov_len = 8;
-	if ((rv = nni_plat_ipc_send(&pipe->fd, &iov, 1)) != 0) {
+	if ((rv = nni_plat_ipc_send(pipe->isp, &iov, 1)) != 0) {
 		return (rv);
 	}
 
 	iov.iov_buf = buf;
 	iov.iov_len = 8;
-	if ((rv = nni_plat_ipc_recv(&pipe->fd, &iov, 1)) != 0) {
+	if ((rv = nni_plat_ipc_recv(pipe->isp, &iov, 1)) != 0) {
 		return (rv);
 	}
 
@@ -293,15 +403,13 @@ nni_ipc_ep_connect(void *arg, void *pipearg)
 	pipe->proto = ep->proto;
 	pipe->rcvmax = ep->rcvmax;
 
-	rv = nni_plat_ipc_connect(&pipe->fd, path);
+	rv = nni_plat_ipc_connect(pipe->isp, path);
 	if (rv != 0) {
-		nni_plat_ipc_fini(&pipe->fd);
-		NNI_FREE_STRUCT(pipe);
 		return (rv);
 	}
 
 	if ((rv = nni_ipc_negotiate(pipe)) != 0) {
-		nni_plat_ipc_shutdown(&pipe->fd);
+		nni_plat_ipc_shutdown(pipe->isp);
 		return (rv);
 	}
 	return (0);
@@ -321,7 +429,7 @@ nni_ipc_ep_bind(void *arg)
 	}
 	path = ep->addr + strlen("ipc://");
 
-	if ((rv = nni_plat_ipc_listen(&ep->fd, path)) != 0) {
+	if ((rv = nni_plat_ipc_listen(ep->isp, path)) != 0) {
 		return (rv);
 	}
 	return (0);
@@ -338,13 +446,11 @@ nni_ipc_ep_accept(void *arg, void *pipearg)
 	pipe->proto = ep->proto;
 	pipe->rcvmax = ep->rcvmax;
 
-	if ((rv = nni_plat_ipc_accept(&pipe->fd, &ep->fd)) != 0) {
-		nni_plat_ipc_fini(&pipe->fd);
-		NNI_FREE_STRUCT(pipe);
+	if ((rv = nni_plat_ipc_accept(pipe->isp, ep->isp)) != 0) {
 		return (rv);
 	}
 	if ((rv = nni_ipc_negotiate(pipe)) != 0) {
-		nni_plat_ipc_shutdown(&pipe->fd);
+		nni_plat_ipc_shutdown(pipe->isp);
 		return (rv);
 	}
 	return (0);
@@ -354,6 +460,8 @@ nni_ipc_ep_accept(void *arg, void *pipearg)
 static nni_tran_pipe nni_ipc_pipe_ops = {
 	.p_init		= nni_ipc_pipe_init,
 	.p_fini		= nni_ipc_pipe_fini,
+	.p_aio_send	= nni_ipc_pipe_aio_send,
+	.p_aio_recv	= nni_ipc_pipe_aio_recv,
 	.p_close	= nni_ipc_pipe_close,
 	.p_peer		= nni_ipc_pipe_peer,
 	.p_getopt	= nni_ipc_pipe_getopt,