 @@ -1,14 +1,14 @@
-/*      $NetBSD: rumpclient.c,v 1.25 2011/02/07 14:49:53 pooka Exp $	*/
+/*      $NetBSD: rumpclient.c,v 1.26 2011/02/07 15:25:41 pooka Exp $	*/
 /*
  * Copyright (c) 2010, 2011 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.
+ *
 @@ -257,56 +257,53 @@ cliwaitresp(struct spclient *spc, struct
+		}
+	}
 	TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);
 	pthread_mutex_unlock(&spc->spc_mtx);
 	pthread_cond_destroy(&rw->rw_cv);
 	if (spc->spc_generation != mygen || !imalive) {
 		return ENOTCONN;
+	}
 	return rw->rw_error;
+}
 static int
-syscall_req(struct spclient *spc, int sysnum,
+syscall_req(struct spclient *spc, sigset_t *omask, int sysnum,
 	const void *data, size_t dlen, void **resp)
+{
 	struct rsp_hdr rhdr;
 	struct respwait rw;
 	sigset_t omask;
 	int rv;
 	rhdr.rsp_len = sizeof(rhdr) + dlen;
 	rhdr.rsp_class = RUMPSP_REQ;
 	rhdr.rsp_type = RUMPSP_SYSCALL;
 	rhdr.rsp_sysnum = sysnum;
 	pthread_sigmask(SIG_SETMASK, &fullset, &omask);
 	do {
 		putwait(spc, &rw, &rhdr);
 		if ((rv = send_with_recon(spc, &rhdr, sizeof(rhdr))) != 0) {
 			unputwait(spc, &rw);
 			continue;
+		}
 		if ((rv = send_with_recon(spc, data, dlen)) != 0) {
 			unputwait(spc, &rw);
 			continue;
+		}
-		rv = cliwaitresp(spc, &rw, &omask, false);
+		rv = cliwaitresp(spc, &rw, omask, false);
 		if (rv == ENOTCONN)
 			rv = EAGAIN;
 	} while (rv == EAGAIN);
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	*resp = rw.rw_data;
 	return rv;
+}
 static int
 handshake_req(struct spclient *spc, uint32_t *auth, int cancel, bool haslock)
+{
 	struct handshake_fork rf;
 	struct rsp_hdr rhdr;
 	struct respwait rw;
 	sigset_t omask;
 	size_t bonus;
 @@ -336,69 +333,66 @@ handshake_req(struct spclient *spc, uint
 	if (auth) {
 		memcpy(rf.rf_auth, auth, AUTHLEN*sizeof(*auth));
 		rf.rf_cancel = cancel;
 		rv = send_with_recon(spc, &rf, sizeof(rf));
 	} else {
 		rv = dosend(spc, getprogname(), strlen(getprogname())+1);
+	}
 	if (rv || cancel) {
 		if (haslock)
 			unputwait_locked(spc, &rw);
 		else
 			unputwait(spc, &rw);
 		if (cancel) {
-			pthread_sigmask(SIG_SETMASK, &omask, NULL);
+			goto out;
 			return rv;
+		}
 	} else {
 		rv = cliwaitresp(spc, &rw, &omask, haslock);
+	}
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	if (rv)
-		return rv;
+		goto out;
 	rv = *(int *)rw.rw_data;
 	free(rw.rw_data);
  out:
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	return rv;
+}
 static int
-prefork_req(struct spclient *spc, void **resp)
+prefork_req(struct spclient *spc, sigset_t *omask, void **resp)
+{
 	struct rsp_hdr rhdr;
 	struct respwait rw;
 	sigset_t omask;
 	int rv;
 	rhdr.rsp_len = sizeof(rhdr);
 	rhdr.rsp_class = RUMPSP_REQ;
 	rhdr.rsp_type = RUMPSP_PREFORK;
 	rhdr.rsp_error = 0;
 	pthread_sigmask(SIG_SETMASK, &fullset, &omask);
 	do {
 		putwait(spc, &rw, &rhdr);
 		rv = send_with_recon(spc, &rhdr, sizeof(rhdr));
 		if (rv != 0) {
 			unputwait(spc, &rw);
 			continue;
+		}
-		rv = cliwaitresp(spc, &rw, &omask, false);
+		rv = cliwaitresp(spc, &rw, omask, false);
 		if (rv == ENOTCONN)
 			rv = EAGAIN;
 	} while (rv == EAGAIN);
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	*resp = rw.rw_data;
 	return rv;
+}
 /*
  * prevent response code from deadlocking with reconnect code
  */
 static int
 resp_sendlock(struct spclient *spc)
+{
 	int rv = 0;
 @@ -453,44 +447,49 @@ send_anonmmap_resp(struct spclient *spc,
 	if (resp_sendlock(spc) != 0)
 		return;
 	(void)dosend(spc, &rhdr, sizeof(rhdr));
 	(void)dosend(spc, &addr, sizeof(addr));
 	sendunlock(spc);
+}
 int
 rumpclient_syscall(int sysnum, const void *data, size_t dlen,
 	register_t *retval)
+{
 	struct rsp_sysresp *resp;
 	sigset_t omask;
 	void *rdata;
 	int rv;
 	pthread_sigmask(SIG_SETMASK, &fullset, &omask);
 	DPRINTF(("rumpsp syscall_req: syscall %d with %p/%zu\n",
 	    sysnum, data, dlen));
-	rv = syscall_req(&clispc, sysnum, data, dlen, &rdata);
+	rv = syscall_req(&clispc, &omask, sysnum, data, dlen, &rdata);
 	if (rv)
-		return rv;
+		goto out;
 	resp = rdata;
 	DPRINTF(("rumpsp syscall_resp: syscall %d error %d, rv: %d/%d\n",
 	    sysnum, rv, resp->rsys_retval[0], resp->rsys_retval[1]));
 	memcpy(retval, &resp->rsys_retval, sizeof(resp->rsys_retval));
 	rv = resp->rsys_error;
 	free(rdata);
  out:
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	return rv;
+}
 static void
 handlereq(struct spclient *spc)
+{
 	struct rsp_copydata *copydata;
 	struct rsp_hdr *rhdr = &spc->spc_hdr;
 	void *mapaddr;
 	size_t maplen;
 	int reqtype = spc->spc_hdr.rsp_type;
 	switch (reqtype) {
 @@ -747,42 +746,47 @@ rumpclient_init()
+	}
 	return 0;
+}
 struct rumpclient_fork {
 	uint32_t fork_auth[AUTHLEN];
 };
 struct rumpclient_fork *
 rumpclient_prefork(void)
+{
 	struct rumpclient_fork *rpf;
 	sigset_t omask;
 	void *resp;
 	int rv;
 	pthread_sigmask(SIG_SETMASK, &fullset, &omask);
 	rpf = malloc(sizeof(*rpf));
 	if (rpf == NULL)
 		return NULL;
-	if ((rv = prefork_req(&clispc, &resp)) != 0) {
+	if ((rv = prefork_req(&clispc, &omask, &resp)) != 0) {
 		free(rpf);
 		errno = rv;
-		return NULL;
+		rpf = NULL;
 		goto out;
+	}
 	memcpy(rpf->fork_auth, resp, sizeof(rpf->fork_auth));
 	free(resp);
  out:
 	pthread_sigmask(SIG_SETMASK, &omask, NULL);
 	return rpf;
+}
 int
 rumpclient_fork_init(struct rumpclient_fork *rpf)
+{
 	int error;
 	int osock;
 	osock = clispc.spc_fd;
 	memset(&clispc, 0, sizeof(clispc));
 	clispc.spc_fd = osock;