Module Name: src
Committed By: pooka
Date: Tue Mar 8 12:39:30 UTC 2011
Modified Files:
src/lib/librumpuser: rumpuser_sp.c sp_common.c
src/sys/rump/include/rump: rumpuser.h
src/sys/rump/librump/rumpkern: locks.c lwproc.c rump.c
src/sys/sys: lwp.h proc.h
Log Message:
Nuke all threads belonging to a process calling exec before allowing
the exec handshake to return.
In addition to being The Right Thing To Do, fixes some nasty
conditions for CLOEXEC fd's (or at least does so in theory, I
couldn't create any problems although I tried).
To generate a diff of this commit:
cvs rdiff -u -r1.43 -r1.44 src/lib/librumpuser/rumpuser_sp.c
cvs rdiff -u -r1.29 -r1.30 src/lib/librumpuser/sp_common.c
cvs rdiff -u -r1.66 -r1.67 src/sys/rump/include/rump/rumpuser.h
cvs rdiff -u -r1.50 -r1.51 src/sys/rump/librump/rumpkern/locks.c
cvs rdiff -u -r1.16 -r1.17 src/sys/rump/librump/rumpkern/lwproc.c
cvs rdiff -u -r1.231 -r1.232 src/sys/rump/librump/rumpkern/rump.c
cvs rdiff -u -r1.149 -r1.150 src/sys/sys/lwp.h
cvs rdiff -u -r1.301 -r1.302 src/sys/sys/proc.h
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/lib/librumpuser/rumpuser_sp.c
diff -u src/lib/librumpuser/rumpuser_sp.c:1.43 src/lib/librumpuser/rumpuser_sp.c:1.44
--- src/lib/librumpuser/rumpuser_sp.c:1.43 Mon Mar 7 21:57:15 2011
+++ src/lib/librumpuser/rumpuser_sp.c Tue Mar 8 12:39:28 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rumpuser_sp.c,v 1.43 2011/03/07 21:57:15 pooka Exp $ */
+/* $NetBSD: rumpuser_sp.c,v 1.44 2011/03/08 12:39:28 pooka Exp $ */
/*
* Copyright (c) 2010, 2011 Antti Kantee. All Rights Reserved.
@@ -35,7 +35,7 @@
*/
#include <sys/cdefs.h>
-__RCSID("$NetBSD: rumpuser_sp.c,v 1.43 2011/03/07 21:57:15 pooka Exp $");
+__RCSID("$NetBSD: rumpuser_sp.c,v 1.44 2011/03/08 12:39:28 pooka Exp $");
#include <sys/types.h>
#include <sys/atomic.h>
@@ -195,6 +195,7 @@
return p;
}
+
static void
lwproc_execnotify(const char *comm)
{
@@ -205,11 +206,11 @@
}
static void
-lwproc_procexit(void)
+lwproc_lwpexit(void)
{
spops.spop_schedule();
- spops.spop_procexit();
+ spops.spop_lwpexit();
spops.spop_unschedule();
}
@@ -453,6 +454,8 @@
pthread_mutex_lock(&spc->spc_mtx);
ref = --spc->spc_refcnt;
+ if (__predict_false(spc->spc_inexec && ref <= 2))
+ pthread_cond_broadcast(&spc->spc_cv);
pthread_mutex_unlock(&spc->spc_mtx);
if (ref > 0)
@@ -480,6 +483,7 @@
serv_handledisco(unsigned int idx)
{
struct spclient *spc = &spclist[idx];
+ int dolwpexit;
DPRINTF(("rump_sp: disconnecting [%u]\n", idx));
@@ -489,11 +493,13 @@
spc->spc_state = SPCSTATE_DYING;
kickall(spc);
sendunlockl(spc);
+ /* exec uses mainlwp in another thread, but also nuked all lwps */
+ dolwpexit = !spc->spc_inexec;
pthread_mutex_unlock(&spc->spc_mtx);
- if (spc->spc_mainlwp) {
+ if (dolwpexit && spc->spc_mainlwp) {
lwproc_switch(spc->spc_mainlwp);
- lwproc_procexit();
+ lwproc_lwpexit();
lwproc_switch(NULL);
}
@@ -591,7 +597,11 @@
DPRINTF(("rump_sp: handling syscall %d from client %d\n",
sysnum, spc->spc_pid));
- lwproc_newlwp(spc->spc_pid);
+ if (__predict_false((rv = lwproc_newlwp(spc->spc_pid)) != 0)) {
+ retval[0] = -1;
+ send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
+ return;
+ }
spc->spc_syscallreq = rhdr->rsp_reqno;
rv = rumpsyscall(sysnum, data, retval);
spc->spc_syscallreq = 0;
@@ -603,23 +613,57 @@
send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
}
-struct sysbouncearg {
+static void
+serv_handleexec(struct spclient *spc, struct rsp_hdr *rhdr, char *comm)
+{
+ size_t commlen = rhdr->rsp_len - HDRSZ;
+
+ pthread_mutex_lock(&spc->spc_mtx);
+ /* one for the connection and one for us */
+ while (spc->spc_refcnt > 2)
+ pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);
+ pthread_mutex_unlock(&spc->spc_mtx);
+
+ /*
+ * ok, all the threads are dead (or one is still alive and
+ * the connection is dead, in which case this doesn't matter
+ * very much). proceed with exec.
+ */
+
+ /* ensure comm is 0-terminated */
+ /* TODO: make sure it contains sensible chars? */
+ comm[commlen] = '\0';
+
+ lwproc_switch(spc->spc_mainlwp);
+ lwproc_execnotify(comm);
+ lwproc_switch(NULL);
+
+ pthread_mutex_lock(&spc->spc_mtx);
+ spc->spc_inexec = 0;
+ pthread_mutex_unlock(&spc->spc_mtx);
+ send_handshake_resp(spc, rhdr->rsp_reqno, 0);
+}
+
+enum sbatype { SBA_SYSCALL, SBA_EXEC };
+
+struct servbouncearg {
struct spclient *sba_spc;
struct rsp_hdr sba_hdr;
+ enum sbatype sba_type;
uint8_t *sba_data;
- TAILQ_ENTRY(sysbouncearg) sba_entries;
+ TAILQ_ENTRY(servbouncearg) sba_entries;
};
static pthread_mutex_t sbamtx;
static pthread_cond_t sbacv;
static int nworker, idleworker, nwork;
-static TAILQ_HEAD(, sysbouncearg) syslist = TAILQ_HEAD_INITIALIZER(syslist);
+static TAILQ_HEAD(, servbouncearg) wrklist = TAILQ_HEAD_INITIALIZER(wrklist);
/*ARGSUSED*/
static void *
-serv_syscallbouncer(void *arg)
+serv_workbouncer(void *arg)
{
- struct sysbouncearg *sba;
+ struct servbouncearg *sba;
for (;;) {
pthread_mutex_lock(&sbamtx);
@@ -629,19 +673,25 @@
break;
}
idleworker++;
- while (TAILQ_EMPTY(&syslist)) {
+ while (TAILQ_EMPTY(&wrklist)) {
_DIAGASSERT(nwork == 0);
pthread_cond_wait(&sbacv, &sbamtx);
}
idleworker--;
- sba = TAILQ_FIRST(&syslist);
- TAILQ_REMOVE(&syslist, sba, sba_entries);
+ sba = TAILQ_FIRST(&wrklist);
+ TAILQ_REMOVE(&wrklist, sba, sba_entries);
nwork--;
pthread_mutex_unlock(&sbamtx);
- serv_handlesyscall(sba->sba_spc,
- &sba->sba_hdr, sba->sba_data);
+ if (__predict_true(sba->sba_type == SBA_SYSCALL)) {
+ serv_handlesyscall(sba->sba_spc,
+ &sba->sba_hdr, sba->sba_data);
+ } else {
+ _DIAGASSERT(sba->sba_type == SBA_EXEC);
+ serv_handleexec(sba->sba_spc, &sba->sba_hdr,
+ (char *)sba->sba_data);
+ }
spcrelease(sba->sba_spc);
free(sba->sba_data);
free(sba);
@@ -761,6 +811,54 @@
return rv;
}
+static pthread_attr_t pattr_detached;
+static void
+schedulework(struct spclient *spc, enum sbatype sba_type)
+{
+ struct servbouncearg *sba;
+ pthread_t pt;
+ uint64_t reqno;
+ int retries = 0;
+
+ reqno = spc->spc_hdr.rsp_reqno;
+ while ((sba = malloc(sizeof(*sba))) == NULL) {
+ if (nworker == 0 || retries > 10) {
+ send_error_resp(spc, reqno, EAGAIN);
+ spcfreebuf(spc);
+ return;
+ }
+ /* slim chance of more memory? */
+ usleep(10000);
+ }
+
+ sba->sba_spc = spc;
+ sba->sba_type = sba_type;
+ sba->sba_hdr = spc->spc_hdr;
+ sba->sba_data = spc->spc_buf;
+ spcresetbuf(spc);
+
+ spcref(spc);
+
+ pthread_mutex_lock(&sbamtx);
+ TAILQ_INSERT_TAIL(&wrklist, sba, sba_entries);
+ nwork++;
+ if (nwork <= idleworker) {
+ /* do we have a daemon's tool (i.e. idle threads)? */
+ pthread_cond_signal(&sbacv);
+ } else if (nworker < rumpsp_maxworker) {
+ /*
+ * Else, need to create one
+ * (if we can, otherwise just expect another
+ * worker to pick up the syscall)
+ */
+ if (pthread_create(&pt, &pattr_detached,
+ serv_workbouncer, NULL) == 0) {
+ nworker++;
+ }
+ }
+ pthread_mutex_unlock(&sbamtx);
+}
+
/*
*
* Startup routines and mainloop for server.
@@ -772,14 +870,11 @@
connecthook_fn sps_connhook;
};
-static pthread_attr_t pattr_detached;
static void
handlereq(struct spclient *spc)
{
- struct sysbouncearg *sba;
- pthread_t pt;
uint64_t reqno;
- int retries, error, i;
+ int error, i;
reqno = spc->spc_hdr.rsp_reqno;
if (__predict_false(spc->spc_state == SPCSTATE_NEW)) {
@@ -874,6 +969,11 @@
lwproc_switch(spc->spc_mainlwp);
send_handshake_resp(spc, reqno, 0);
+ } else {
+ send_error_resp(spc, reqno, EAUTH);
+ shutdown(spc->spc_fd, SHUT_RDWR);
+ spcfreebuf(spc);
+ return;
}
spc->spc_pid = lwproc_getpid();
@@ -889,10 +989,20 @@
if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_PREFORK)) {
struct prefork *pf;
uint32_t auth[AUTHLEN];
+ int inexec;
DPRINTF(("rump_sp: prefork handler executing for %p\n", spc));
spcfreebuf(spc);
+ pthread_mutex_lock(&spc->spc_mtx);
+ inexec = spc->spc_inexec;
+ pthread_mutex_unlock(&spc->spc_mtx);
+ if (inexec) {
+ send_error_resp(spc, reqno, EBUSY);
+ shutdown(spc->spc_fd, SHUT_RDWR);
+ return;
+ }
+
pf = malloc(sizeof(*pf));
if (pf == NULL) {
send_error_resp(spc, reqno, ENOMEM);
@@ -901,8 +1011,8 @@
/*
* Use client main lwp to fork. this is never used by
- * worker threads (except if spc refcount goes to 0),
- * so we can safely use it here.
+ * worker threads (except in exec, but we checked for that
+ * above) so we can safely use it here.
*/
lwproc_switch(spc->spc_mainlwp);
if ((error = lwproc_rfork(spc, RUMP_RFFDG, NULL)) != 0) {
@@ -932,25 +1042,42 @@
}
if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_HANDSHAKE)) {
- char *comm = (char *)spc->spc_buf;
- size_t commlen = spc->spc_hdr.rsp_len - HDRSZ;
+ int inexec;
if (spc->spc_hdr.rsp_handshake != HANDSHAKE_EXEC) {
send_error_resp(spc, reqno, EINVAL);
+ shutdown(spc->spc_fd, SHUT_RDWR);
spcfreebuf(spc);
return;
}
- /* ensure it's 0-terminated */
- /* XXX make sure it contains sensible chars? */
- comm[commlen] = '\0';
+ pthread_mutex_lock(&spc->spc_mtx);
+ inexec = spc->spc_inexec;
+ pthread_mutex_unlock(&spc->spc_mtx);
+ if (inexec) {
+ send_error_resp(spc, reqno, EBUSY);
+ shutdown(spc->spc_fd, SHUT_RDWR);
+ spcfreebuf(spc);
+ return;
+ }
+ pthread_mutex_lock(&spc->spc_mtx);
+ spc->spc_inexec = 1;
+ pthread_mutex_unlock(&spc->spc_mtx);
+
+ /*
+ * start to drain lwps. we will wait for it to finish
+ * in another thread
+ */
lwproc_switch(spc->spc_mainlwp);
- lwproc_execnotify(comm);
+ lwproc_lwpexit();
lwproc_switch(NULL);
- send_handshake_resp(spc, reqno, 0);
- spcfreebuf(spc);
+ /*
+ * exec has to wait for lwps to drain, so finish it off
+ * in another thread
+ */
+ schedulework(spc, SBA_EXEC);
return;
}
@@ -960,42 +1087,7 @@
return;
}
- retries = 0;
- while ((sba = malloc(sizeof(*sba))) == NULL) {
- if (nworker == 0 || retries > 10) {
- send_error_resp(spc, reqno, EAGAIN);
- spcfreebuf(spc);
- return;
- }
- /* slim chance of more memory? */
- usleep(10000);
- }
-
- sba->sba_spc = spc;
- sba->sba_hdr = spc->spc_hdr;
- sba->sba_data = spc->spc_buf;
- spcresetbuf(spc);
-
- spcref(spc);
-
- pthread_mutex_lock(&sbamtx);
- TAILQ_INSERT_TAIL(&syslist, sba, sba_entries);
- nwork++;
- if (nwork <= idleworker) {
- /* do we have a daemon's tool (i.e. idle threads)? */
- pthread_cond_signal(&sbacv);
- } else if (nworker < rumpsp_maxworker) {
- /*
- * Else, need to create one
- * (if we can, otherwise just expect another
- * worker to pick up the syscall)
- */
- if (pthread_create(&pt, &pattr_detached,
- serv_syscallbouncer, NULL) == 0) {
- nworker++;
- }
- }
- pthread_mutex_unlock(&sbamtx);
+ schedulework(spc, SBA_SYSCALL);
}
static void *
Index: src/lib/librumpuser/sp_common.c
diff -u src/lib/librumpuser/sp_common.c:1.29 src/lib/librumpuser/sp_common.c:1.30
--- src/lib/librumpuser/sp_common.c:1.29 Tue Mar 8 10:02:01 2011
+++ src/lib/librumpuser/sp_common.c Tue Mar 8 12:39:28 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: sp_common.c,v 1.29 2011/03/08 10:02:01 pooka Exp $ */
+/* $NetBSD: sp_common.c,v 1.30 2011/03/08 12:39:28 pooka Exp $ */
/*
* Copyright (c) 2010, 2011 Antti Kantee. All Rights Reserved.
@@ -180,6 +180,7 @@
uint64_t spc_generation;
int spc_ostatus, spc_istatus;
int spc_reconnecting;
+ int spc_inexec;
LIST_HEAD(, prefork) spc_pflist;
};
Index: src/sys/rump/include/rump/rumpuser.h
diff -u src/sys/rump/include/rump/rumpuser.h:1.66 src/sys/rump/include/rump/rumpuser.h:1.67
--- src/sys/rump/include/rump/rumpuser.h:1.66 Tue Feb 15 10:35:05 2011
+++ src/sys/rump/include/rump/rumpuser.h Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rumpuser.h,v 1.66 2011/02/15 10:35:05 pooka Exp $ */
+/* $NetBSD: rumpuser.h,v 1.67 2011/03/08 12:39:29 pooka Exp $ */
/*
* Copyright (c) 2007 Antti Kantee. All Rights Reserved.
@@ -36,7 +36,7 @@
#include <stdint.h>
#endif
-#define RUMPUSER_VERSION 13
+#define RUMPUSER_VERSION 14
int rumpuser_getversion(void);
int rumpuser_daemonize_begin(void);
@@ -218,7 +218,7 @@
int (*spop_lwproc_newlwp)(pid_t);
struct lwp * (*spop_lwproc_curlwp)(void);
int (*spop_syscall)(int, void *, register_t *);
- void (*spop_procexit)(void);
+ void (*spop_lwpexit)(void);
void (*spop_execnotify)(const char *);
pid_t (*spop_getpid)(void);
};
Index: src/sys/rump/librump/rumpkern/locks.c
diff -u src/sys/rump/librump/rumpkern/locks.c:1.50 src/sys/rump/librump/rumpkern/locks.c:1.51
--- src/sys/rump/librump/rumpkern/locks.c:1.50 Fri Jan 28 17:04:39 2011
+++ src/sys/rump/librump/rumpkern/locks.c Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: locks.c,v 1.50 2011/01/28 17:04:39 pooka Exp $ */
+/* $NetBSD: locks.c,v 1.51 2011/03/08 12:39:29 pooka Exp $ */
/*
* Copyright (c) 2007, 2008 Antti Kantee. All Rights Reserved.
@@ -29,7 +29,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: locks.c,v 1.50 2011/01/28 17:04:39 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: locks.c,v 1.51 2011/03/08 12:39:29 pooka Exp $");
#include <sys/param.h>
#include <sys/kmem.h>
@@ -283,7 +283,7 @@
struct lwp *l = curlwp;
int rv;
- if (__predict_false(l->l_flag & LW_RUMP_DYING)) {
+ if (__predict_false(l->l_flag & LW_RUMP_QEXIT)) {
/*
* yield() here, someone might want the cpu
* to set a condition. otherwise we'll just
@@ -306,21 +306,21 @@
}
/*
- * Check for DYING. if so, we need to wait here until we
+ * Check for QEXIT. if so, we need to wait here until we
* are allowed to exit.
*/
- if (__predict_false(l->l_flag & LW_RUMP_DYING)) {
+ if (__predict_false(l->l_flag & LW_RUMP_QEXIT)) {
struct proc *p = l->l_proc;
mutex_exit(mtx); /* drop and retake later */
mutex_enter(p->p_lock);
- while (p->p_stat != SDYING) {
+ while ((p->p_sflag & PS_RUMP_LWPEXIT) == 0) {
/* avoid recursion */
rumpuser_cv_wait(RUMPCV(&p->p_waitcv),
RUMPMTX(p->p_lock));
}
- KASSERT(p->p_stat == SDYING);
+ KASSERT(p->p_sflag & PS_RUMP_LWPEXIT);
mutex_exit(p->p_lock);
/* ok, we can exit and remove "reference" to l->private */
Index: src/sys/rump/librump/rumpkern/lwproc.c
diff -u src/sys/rump/librump/rumpkern/lwproc.c:1.16 src/sys/rump/librump/rumpkern/lwproc.c:1.17
--- src/sys/rump/librump/rumpkern/lwproc.c:1.16 Mon Mar 7 21:04:47 2011
+++ src/sys/rump/librump/rumpkern/lwproc.c Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: lwproc.c,v 1.16 2011/03/07 21:04:47 pooka Exp $ */
+/* $NetBSD: lwproc.c,v 1.17 2011/03/08 12:39:29 pooka Exp $ */
/*
* Copyright (c) 2010, 2011 Antti Kantee. All Rights Reserved.
@@ -26,7 +26,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lwproc.c,v 1.16 2011/03/07 21:04:47 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lwproc.c,v 1.17 2011/03/08 12:39:29 pooka Exp $");
#include <sys/param.h>
#include <sys/atomic.h>
@@ -269,6 +269,7 @@
l = kmem_zalloc(sizeof(*l), KM_SLEEP);
mutex_enter(p->p_lock);
+ KASSERT((p->p_sflag & PS_RUMP_LWPEXIT) == 0);
lwproc_makelwp(p, l, false, newproc);
return l;
@@ -289,6 +290,12 @@
return ESRCH;
}
mutex_enter(p->p_lock);
+ if (p->p_sflag & PS_RUMP_LWPEXIT) {
+ mutex_exit(proc_lock);
+ mutex_exit(p->p_lock);
+ kmem_free(l, sizeof(*l));
+ return EBUSY;
+ }
mutex_exit(proc_lock);
lwproc_makelwp(p, l, true, false);
@@ -308,6 +315,7 @@
p = lwproc_newproc(curproc, flags);
l = kmem_zalloc(sizeof(*l), KM_SLEEP);
mutex_enter(p->p_lock);
+ KASSERT((p->p_sflag & PS_RUMP_LWPEXIT) == 0);
lwproc_makelwp(p, l, true, true);
return 0;
Index: src/sys/rump/librump/rumpkern/rump.c
diff -u src/sys/rump/librump/rumpkern/rump.c:1.231 src/sys/rump/librump/rumpkern/rump.c:1.232
--- src/sys/rump/librump/rumpkern/rump.c:1.231 Tue Feb 15 15:54:28 2011
+++ src/sys/rump/librump/rumpkern/rump.c Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rump.c,v 1.231 2011/02/15 15:54:28 pooka Exp $ */
+/* $NetBSD: rump.c,v 1.232 2011/03/08 12:39:29 pooka Exp $ */
/*
* Copyright (c) 2007 Antti Kantee. All Rights Reserved.
@@ -28,7 +28,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rump.c,v 1.231 2011/02/15 15:54:28 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rump.c,v 1.232 2011/03/08 12:39:29 pooka Exp $");
#include <sys/systm.h>
#define ELFSIZE ARCH_ELFSIZE
@@ -101,7 +101,7 @@
static int rump_proxy_syscall(int, void *, register_t *);
static int rump_proxy_rfork(void *, int, const char *);
-static void rump_proxy_procexit(void);
+static void rump_proxy_lwpexit(void);
static void rump_proxy_execnotify(const char *);
static char rump_msgbuf[16*1024]; /* 16k should be enough for std rump needs */
@@ -213,7 +213,7 @@
.spop_lwproc_rfork = rump_proxy_rfork,
.spop_lwproc_newlwp = rump_lwproc_newlwp,
.spop_lwproc_curlwp = rump_lwproc_curlwp,
- .spop_procexit = rump_proxy_procexit,
+ .spop_lwpexit = rump_proxy_lwpexit,
.spop_syscall = rump_proxy_syscall,
.spop_execnotify = rump_proxy_execnotify,
.spop_getpid = spgetpid,
@@ -781,17 +781,11 @@
return 0;
}
+/*
+ * Order all lwps in a process to exit. does *not* wait for them to drain.
+ */
static void
-rump_proxy_execnotify(const char *comm)
-{
- struct proc *p = curproc;
-
- fd_closeexec();
- strlcpy(p->p_comm, comm, sizeof(p->p_comm));
-}
-
-static void
-rump_proxy_procexit(void)
+rump_proxy_lwpexit(void)
{
struct proc *p = curproc;
uint64_t where;
@@ -799,13 +793,13 @@
mutex_enter(p->p_lock);
/*
- * First pass: mark all lwps in the process with LSDEAD
+ * First pass: mark all lwps in the process with LW_RUMP_QEXIT
* so that they know they should exit.
*/
LIST_FOREACH(l, &p->p_lwps, l_sibling) {
if (l == curlwp)
continue;
- l->l_flag |= LW_RUMP_DYING;
+ l->l_flag |= LW_RUMP_QEXIT;
}
mutex_exit(p->p_lock);
@@ -825,8 +819,8 @@
* 2) sleeping on l->l_private
* 3) sleeping on p->p_waitcv
*
- * Either way, l_private is stable until we change the lwps
- * state to LSZOMB.
+ * Either way, l_private is stable until we set PS_RUMP_LWPEXIT
+ * in p->p_sflag.
*/
mutex_enter(p->p_lock);
@@ -834,15 +828,25 @@
if (l->l_private)
cv_broadcast(l->l_private);
}
- p->p_stat = SDYING;
+ p->p_sflag |= PS_RUMP_LWPEXIT;
cv_broadcast(&p->p_waitcv);
mutex_exit(p->p_lock);
+}
- /*
- * Don't wait for lwps to exit. There's refcounting in the
- * rumpuser sp code which makes this safe. Also, this routine
- * should not sleep for a long time.
- */
+/*
+ * Notify process that all threads have been drained and exec is complete.
+ */
+static void
+rump_proxy_execnotify(const char *comm)
+{
+ struct proc *p = curproc;
+
+ fd_closeexec();
+ mutex_enter(p->p_lock);
+ KASSERT(p->p_nlwps == 1 && p->p_sflag & PS_RUMP_LWPEXIT);
+ p->p_sflag &= ~PS_RUMP_LWPEXIT;
+ mutex_exit(p->p_lock);
+ strlcpy(p->p_comm, comm, sizeof(p->p_comm));
}
int
Index: src/sys/sys/lwp.h
diff -u src/sys/sys/lwp.h:1.149 src/sys/sys/lwp.h:1.150
--- src/sys/sys/lwp.h:1.149 Mon Feb 21 20:23:28 2011
+++ src/sys/sys/lwp.h Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: lwp.h,v 1.149 2011/02/21 20:23:28 pooka Exp $ */
+/* $NetBSD: lwp.h,v 1.150 2011/03/08 12:39:29 pooka Exp $ */
/*-
* Copyright (c) 2001, 2006, 2007, 2008, 2009, 2010
@@ -234,7 +234,7 @@
#define LW_SA_YIELD 0x40000000 /* LWP on VP is yielding */
#define LW_SA_IDLE 0x80000000 /* VP is idle */
#define LW_RUMP_CLEAR LW_SA_IDLE /* clear curlwp in rump scheduler */
-#define LW_RUMP_DYING LW_SA_YIELD/* lwp is part of a dying process */
+#define LW_RUMP_QEXIT LW_SA_YIELD/* lwp should exit ASAP */
/* The second set of flags is kept in l_pflag. */
#define LP_KTRACTIVE 0x00000001 /* Executing ktrace operation */
Index: src/sys/sys/proc.h
diff -u src/sys/sys/proc.h:1.301 src/sys/sys/proc.h:1.302
--- src/sys/sys/proc.h:1.301 Fri Mar 4 22:25:32 2011
+++ src/sys/sys/proc.h Tue Mar 8 12:39:29 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: proc.h,v 1.301 2011/03/04 22:25:32 joerg Exp $ */
+/* $NetBSD: proc.h,v 1.302 2011/03/08 12:39:29 pooka Exp $ */
/*-
* Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc.
@@ -367,6 +367,7 @@
#define PS_NOTIFYSTOP 0x10000000 /* Notify parent of successful STOP */
#define PS_NOSA 0x40000000 /* Do not enable SA */
#define PS_STOPPING 0x80000000 /* Transitioning SACTIVE -> SSTOP */
+#define PS_RUMP_LWPEXIT PS_SA /* LWPs in rump kernel should exit for g/c */
/*
* These flags are kept in p_sflag and are protected by the proc_lock
