 @@ -1,14 +1,14 @@
-/*      $NetBSD: rumpuser_sp.c,v 1.16 2010/11/26 10:59:14 pooka Exp $	*/
+/*      $NetBSD: rumpuser_sp.c,v 1.17 2010/11/26 14:37:08 pooka Exp $	*/
 /*
  * Copyright (c) 2010 Antti Kantee.  All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
 @@ -28,27 +28,27 @@
 /*
  * Sysproxy routines.  This provides system RPC support over host sockets.
  * The most notable limitation is that the client and server must share
  * the same ABI.  This does not mean that they have to be the same
  * machine or that they need to run the same version of the host OS,
  * just that they must agree on the data structures.  This even *might*
  * work correctly from one hardware architecture to another.
+ *
  * Not finished yet, i.e. don't use in production.  Lacks locking plus
  * handling of multiple clients and unexpected connection closes.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: rumpuser_sp.c,v 1.16 2010/11/26 10:59:14 pooka Exp $");
+__RCSID("$NetBSD: rumpuser_sp.c,v 1.17 2010/11/26 14:37:08 pooka Exp $");
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 @@ -335,26 +335,33 @@ spcrelease(struct spclient *spc)
 static void
 serv_handledisco(unsigned int idx)
+{
 	struct spclient *spc = &spclist[idx];
 	DPRINTF(("rump_sp: disconnecting [%u]\n", idx));
 	pfdlist[idx].fd = -1;
 	pfdlist[idx].revents = 0;
 	pthread_mutex_lock(&spc->spc_mtx);
 	spc->spc_dying = 1;
 	kickall(spc);
 	pthread_mutex_unlock(&spc->spc_mtx);
 	/*
 	 * Nobody's going to attempt to send/receive anymore,
 	 * so reinit info relevant to that.
 	 */
 	memset((char *)spc + SPC_ZEROFF, 0, sizeof(*spc) - SPC_ZEROFF);
 	spcrelease(spc);
+}
 static unsigned
 serv_handleconn(int fd, connecthook_fn connhook, int busy)
+{
 	struct sockaddr_storage ss;
 	socklen_t sl = sizeof(ss);
 	int newfd, flags;
 	unsigned i;
 	/*LINTED: cast ok */
 	newfd = accept(fd, (struct sockaddr *)&ss, &sl);

 @@ -1,14 +1,14 @@
-/*      $NetBSD: sp_common.c,v 1.10 2010/11/25 17:59:02 pooka Exp $	*/
+/*      $NetBSD: sp_common.c,v 1.11 2010/11/26 14:37:08 pooka Exp $	*/
 /*
  * Copyright (c) 2010 Antti Kantee.  All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
 @@ -37,26 +37,27 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 //#define DEBUG
 #ifdef DEBUG
 #define DPRINTF(x) mydprintf x
 static void
 mydprintf(const char *fmt, ...)
+{
 	va_list ap;
 @@ -113,42 +114,44 @@ struct respwait {
 	void *rw_data;
 	size_t rw_dlen;
 	pthread_cond_t rw_cv;
 	TAILQ_ENTRY(respwait) rw_entries;
 };
 struct spclient {
 	int spc_fd;
 	int spc_refcnt;
 	int spc_dying;
 	pthread_mutex_t spc_mtx;
 	pthread_cond_t spc_cv;
 	struct lwp *spc_mainlwp;
 	pid_t spc_pid;
 	TAILQ_HEAD(, respwait) spc_respwait;
 	/* rest of the fields are zeroed upon disconnect */
 #define SPC_ZEROFF offsetof(struct spclient, spc_pid)
 	struct pollfd *spc_pfd;
 	struct rsp_hdr spc_hdr;
 	uint8_t *spc_buf;
 	size_t spc_off;
 	pthread_mutex_t spc_mtx;
 	pthread_cond_t spc_cv;
 	uint64_t spc_nextreq;
 	int spc_ostatus, spc_istatus;
 	TAILQ_HEAD(, respwait) spc_respwait;
 };
 #define SPCSTATUS_FREE 0
 #define SPCSTATUS_BUSY 1
 #define SPCSTATUS_WANTED 2
 typedef int (*addrparse_fn)(const char *, struct sockaddr **, int);
 typedef int (*connecthook_fn)(int);
 static int readframe(struct spclient *);
 static void handlereq(struct spclient *);
 static void
 sendlock(struct spclient *spc)
 @@ -239,27 +242,27 @@ kickwaiter(struct spclient *spc)
 	pthread_mutex_lock(&spc->spc_mtx);
 	TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) {
 		if (rw->rw_reqno == spc->spc_hdr.rsp_reqno)
 			break;
+	}
 	if (rw == NULL) {
 		printf("PANIC: no waiter\n");
 		abort();
 		return;
+	}
 	DPRINTF(("rump_sp: client %p woke up waiter at %p\n", spc, rw));
 	rw->rw_data = spc->spc_buf;
-	rw->rw_dlen = (size_t)spc->spc_off;
+	rw->rw_dlen = (size_t)(spc->spc_off - HDRSZ);
 	pthread_cond_signal(&rw->rw_cv);
 	pthread_mutex_unlock(&spc->spc_mtx);
 	spc->spc_buf = NULL;
 	spc->spc_off = 0;
+}
 static void
 kickall(struct spclient *spc)
+{
 	struct respwait *rw;
 	/* DIAGASSERT(mutex_owned(spc_lock)) */
 @@ -282,60 +285,63 @@ waitresp(struct spclient *spc, struct re
 			pthread_mutex_unlock(&spc->spc_mtx);
 			pfd.fd = spc->spc_fd;
 			pfd.events = POLLIN;
 			for (gotresp = 0; !gotresp; ) {
 				switch (readframe(spc)) {
 				case 0:
 					poll(&pfd, 1, INFTIM);
 					continue;
 				case -1:
 					rv = errno;
 					spc->spc_dying = 1;
-					break;
+					goto cleanup;
 				default:
 					break;
+				}
 				switch (spc->spc_hdr.rsp_class) {
 				case RUMPSP_RESP:
 					kickwaiter(spc);
 					gotresp = spc->spc_hdr.rsp_reqno ==
 					    rw->rw_reqno;
 					break;
 				case RUMPSP_REQ:
 					handlereq(spc);
 					break;
 				default:
 					/* panic */
 					break;
+				}
+			}
  cleanup:
 			pthread_mutex_lock(&spc->spc_mtx);
 			if (spc->spc_istatus == SPCSTATUS_WANTED)
 				kickall(spc);
 			spc->spc_istatus = SPCSTATUS_FREE;
 		} else {
 			spc->spc_istatus = SPCSTATUS_WANTED;
 			pthread_cond_wait(&rw->rw_cv, &spc->spc_mtx);
+		}
+	}
 	TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);
 	pthread_mutex_unlock(&spc->spc_mtx);
 	pthread_cond_destroy(&rw->rw_cv);
 	if (rv == 0 && spc->spc_dying)
 		rv = ENOTCONN;
 	return rv;
+}
 static int
 readframe(struct spclient *spc)
+{
 	int fd = spc->spc_fd;
 	size_t left;
 	size_t framelen;
 	ssize_t n;
 	/* still reading header? */
 	if (spc->spc_off < HDRSZ) {