diff --git a/sys/kern/kern_condvar.c b/sys/kern/kern_condvar.c
index 89928e301305..560e3e387967 100644
--- a/sys/kern/kern_condvar.c
+++ b/sys/kern/kern_condvar.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: kern_condvar.c,v 1.5 2007/02/27 15:07:28 yamt Exp $	*/
+/*	$NetBSD: kern_condvar.c,v 1.6 2007/03/29 17:34:39 ad Exp $	*/
 
 /*-
  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
@@ -45,7 +45,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.5 2007/02/27 15:07:28 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.6 2007/03/29 17:34:39 ad Exp $");
 
 #include <sys/param.h>
 #include <sys/proc.h>
@@ -54,8 +54,8 @@ __KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.5 2007/02/27 15:07:28 yamt Exp $"
 #include <sys/condvar.h>
 #include <sys/sleepq.h>
 
-static void	cv_unsleep(struct lwp *);
-static void	cv_changepri(struct lwp *, pri_t);
+static void	cv_unsleep(lwp_t *);
+static void	cv_changepri(lwp_t *, pri_t);
 
 syncobj_t cv_syncobj = {
 	SOBJ_SLEEPQ_SORTED,
@@ -102,12 +102,13 @@ cv_destroy(kcondvar_t *cv)
  *	condition variable, and increment the number of waiters.
  */
 static inline sleepq_t *
-cv_enter(kcondvar_t *cv, kmutex_t *mtx, struct lwp *l)
+cv_enter(kcondvar_t *cv, kmutex_t *mtx, lwp_t *l)
 {
 	sleepq_t *sq;
 
 	KASSERT(cv->cv_wmesg != NULL);
 
+	l->l_cv_signalled = 0;
 	sq = sleeptab_lookup(&sleeptab, cv);
 	cv->cv_waiters++;
 	sleepq_enter(sq, l);
@@ -116,6 +117,27 @@ cv_enter(kcondvar_t *cv, kmutex_t *mtx, struct lwp *l)
 	return sq;
 }
 
+/*
+ * cv_exit:
+ *
+ *	After resuming execution, check to see if we have been restarted
+ *	as a result of cv_signal().  If we have, but cannot take the
+ *	wakeup (because of eg a pending Unix signal or timeout) then try
+ *	to ensure that another LWP sees it.  This is necessary because
+ *	there may be multiple waiters, and at least one should take the
+ *	wakeup if possible.
+ */
+static inline int
+cv_exit(kcondvar_t *cv, kmutex_t *mtx, lwp_t *l, const int error)
+{
+
+	mutex_enter(mtx);
+	if (__predict_false(error != 0) && l->l_cv_signalled != 0)
+		cv_signal(cv);
+
+	return error;
+}
+
 /*
  * cv_unsleep:
  *
@@ -125,7 +147,7 @@ cv_enter(kcondvar_t *cv, kmutex_t *mtx, struct lwp *l)
  *	called with the LWP locked, and must return it unlocked.
  */
 static void
-cv_unsleep(struct lwp *l)
+cv_unsleep(lwp_t *l)
 {
 	uintptr_t addr;
 
@@ -144,7 +166,7 @@ cv_unsleep(struct lwp *l)
  *	Adjust the real (user) priority of an LWP blocked on a CV.
  */
 static void
-cv_changepri(struct lwp *l, pri_t pri)
+cv_changepri(lwp_t *l, pri_t pri)
 {
 	sleepq_t *sq = l->l_sleepq;
 	pri_t opri;
@@ -169,7 +191,7 @@ cv_changepri(struct lwp *l, pri_t pri)
 void
 cv_wait(kcondvar_t *cv, kmutex_t *mtx)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 	sleepq_t *sq;
 
 	LOCK_ASSERT(mutex_owned(mtx));
@@ -182,7 +204,7 @@ cv_wait(kcondvar_t *cv, kmutex_t *mtx)
 	sq = cv_enter(cv, mtx, l);
 	sleepq_block(sq, sched_kpri(l), cv, cv->cv_wmesg, 0, 0, &cv_syncobj);
 	(void)sleepq_unblock(0, 0);
-	mutex_enter(mtx);
+	(void)cv_exit(cv, mtx, l, 0);
 }
 
 /*
@@ -196,7 +218,7 @@ cv_wait(kcondvar_t *cv, kmutex_t *mtx)
 int
 cv_wait_sig(kcondvar_t *cv, kmutex_t *mtx)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 	sleepq_t *sq;
 	int error;
 
@@ -208,9 +230,7 @@ cv_wait_sig(kcondvar_t *cv, kmutex_t *mtx)
 	sq = cv_enter(cv, mtx, l);
 	sleepq_block(sq, sched_kpri(l), cv, cv->cv_wmesg, 0, 1, &cv_syncobj);
 	error = sleepq_unblock(0, 1);
-	mutex_enter(mtx);
-
-	return error;
+	return cv_exit(cv, mtx, l, error);
 }
 
 /*
@@ -223,7 +243,7 @@ cv_wait_sig(kcondvar_t *cv, kmutex_t *mtx)
 int
 cv_timedwait(kcondvar_t *cv, kmutex_t *mtx, int timo)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 	sleepq_t *sq;
 	int error;
 
@@ -235,9 +255,7 @@ cv_timedwait(kcondvar_t *cv, kmutex_t *mtx, int timo)
 	sq = cv_enter(cv, mtx, l);
 	sleepq_block(sq, sched_kpri(l), cv, cv->cv_wmesg, timo, 0, &cv_syncobj);
 	error = sleepq_unblock(timo, 0);
-	mutex_enter(mtx);
-
- 	return error;
+	return cv_exit(cv, mtx, l, error);
 }
 
 /*
@@ -252,7 +270,7 @@ cv_timedwait(kcondvar_t *cv, kmutex_t *mtx, int timo)
 int
 cv_timedwait_sig(kcondvar_t *cv, kmutex_t *mtx, int timo)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 	sleepq_t *sq;
 	int error;
 
@@ -264,9 +282,7 @@ cv_timedwait_sig(kcondvar_t *cv, kmutex_t *mtx, int timo)
 	sq = cv_enter(cv, mtx, l);
 	sleepq_block(sq, sched_kpri(l), cv, cv->cv_wmesg, timo, 1, &cv_syncobj);
 	error = sleepq_unblock(timo, 1);
-	mutex_enter(mtx);
-
- 	return error;
+	return cv_exit(cv, mtx, l, error);
 }
 
 /*
@@ -278,6 +294,7 @@ cv_timedwait_sig(kcondvar_t *cv, kmutex_t *mtx, int timo)
 void
 cv_signal(kcondvar_t *cv)
 {
+	lwp_t *l;
 	sleepq_t *sq;
 
 	if (cv->cv_waiters == 0)
@@ -292,7 +309,8 @@ cv_signal(kcondvar_t *cv)
 	sq = sleeptab_lookup(&sleeptab, cv);
 	if (cv->cv_waiters != 0) {
 		cv->cv_waiters--;
-		sleepq_wake(sq, cv, 1);
+		l = sleepq_wake(sq, cv, 1);
+		l->l_cv_signalled = 1;
 	} else
 		sleepq_unlock(sq);
 }
@@ -320,27 +338,6 @@ cv_broadcast(kcondvar_t *cv)
 		sleepq_unlock(sq);
 }
 
-/*
- * cv_wakeup:
- *
- *	Wake all LWPs waiting on a condition variable.  The interlock
- *	need not be held, but it is the caller's responsibility to
- *	ensure correct synchronization.
- */
-void
-cv_wakeup(kcondvar_t *cv)
-{
-	sleepq_t *sq;
-	u_int cnt;
-
-	sq = sleeptab_lookup(&sleeptab, cv);
-	if ((cnt = cv->cv_waiters) != 0) {
-		cv->cv_waiters = 0;
-		sleepq_wake(sq, cv, cnt);
-	} else
-		sleepq_unlock(sq);
-}
-
 /*
  * cv_has_waiters:
  *
diff --git a/sys/kern/kern_sleepq.c b/sys/kern/kern_sleepq.c
index baf549403f03..18df7fa2e8f1 100644
--- a/sys/kern/kern_sleepq.c
+++ b/sys/kern/kern_sleepq.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: kern_sleepq.c,v 1.7 2007/02/27 15:07:29 yamt Exp $	*/
+/*	$NetBSD: kern_sleepq.c,v 1.8 2007/03/29 17:34:39 ad Exp $	*/
 
 /*-
  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
@@ -42,7 +42,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.7 2007/02/27 15:07:29 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.8 2007/03/29 17:34:39 ad Exp $");
 
 #include "opt_multiprocessor.h"
 #include "opt_lockdebug.h"
@@ -63,8 +63,8 @@ __KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.7 2007/02/27 15:07:29 yamt Exp $")
 
 #include <uvm/uvm_extern.h>
 
-int	sleepq_sigtoerror(struct lwp *, int);
-void	updatepri(struct lwp *);
+int	sleepq_sigtoerror(lwp_t *, int);
+void	updatepri(lwp_t *);
 
 /* General purpose sleep table, used by ltsleep() and condition variables. */
 sleeptab_t	sleeptab;
@@ -114,7 +114,7 @@ sleepq_init(sleepq_t *sq, kmutex_t *mtx)
  *	to bring the LWP into memory.
  */
 int
-sleepq_remove(sleepq_t *sq, struct lwp *l)
+sleepq_remove(sleepq_t *sq, lwp_t *l)
 {
 	struct cpu_info *ci;
 
@@ -193,9 +193,9 @@ sleepq_remove(sleepq_t *sq, struct lwp *l)
  *	Insert an LWP into the sleep queue, optionally sorting by priority.
  */
 inline void
-sleepq_insert(sleepq_t *sq, struct lwp *l, syncobj_t *sobj)
+sleepq_insert(sleepq_t *sq, lwp_t *l, syncobj_t *sobj)
 {
-	struct lwp *l2;
+	lwp_t *l2;
 	const int pri = lwp_eprio(l);
 
 	if ((sobj->sobj_flag & SOBJ_SLEEPQ_SORTED) != 0) {
@@ -214,7 +214,7 @@ void
 sleepq_enqueue(sleepq_t *sq, pri_t pri, wchan_t wchan, const char *wmesg,
     syncobj_t *sobj)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 
 	KASSERT(mutex_owned(sq->sq_mutex));
 	KASSERT(l->l_stat == LSONPROC);
@@ -235,9 +235,9 @@ sleepq_enqueue(sleepq_t *sq, pri_t pri, wchan_t wchan, const char *wmesg,
 }
 
 void
-sleepq_switch(int timo, int catch)
+sleepq_switch(int timo, bool catch)
 {
-	struct lwp *l = curlwp;
+	lwp_t *l = curlwp;
 
 #ifdef KTRACE
 	if (KTRPOINT(l->l_proc, KTR_CSW))
@@ -289,7 +289,7 @@ sleepq_switch(int timo, int catch)
  */
 void
 sleepq_block(sleepq_t *sq, pri_t pri, wchan_t wchan, const char *wmesg,
-	     int timo, int catch, syncobj_t *sobj)
+	     int timo, bool catch, syncobj_t *sobj)
 {
 
 	sleepq_enqueue(sq, pri, wchan, wmesg, sobj);
@@ -308,11 +308,11 @@ sleepq_block(sleepq_t *sq, pri_t pri, wchan_t wchan, const char *wmesg,
  *	those they went asleep on.
  */
 int
-sleepq_unblock(int timo, int catch)
+sleepq_unblock(int timo, bool catch)
 {
 	int error, expired, sig;
 	struct proc *p;
-	struct lwp *l;
+	lwp_t *l;
 
 	l = curlwp;
 	error = l->l_sleeperr;
@@ -361,10 +361,10 @@ sleepq_unblock(int timo, int catch)
  *
  *	Wake zero or more LWPs blocked on a single wait channel.
  */
-void
+lwp_t *
 sleepq_wake(sleepq_t *sq, wchan_t wchan, u_int expected)
 {
-	struct lwp *l, *next;
+	lwp_t *l, *next;
 	int swapin = 0;
 
 	KASSERT(mutex_owned(sq->sq_mutex));
@@ -387,6 +387,8 @@ sleepq_wake(sleepq_t *sq, wchan_t wchan, u_int expected)
 	 */
 	if (swapin)
 		uvm_kick_scheduler();
+
+	return l;
 }
 
 /*
@@ -397,7 +399,7 @@ sleepq_wake(sleepq_t *sq, wchan_t wchan, u_int expected)
  *	always release it.
  */
 void
-sleepq_unsleep(struct lwp *l)
+sleepq_unsleep(lwp_t *l)
 {
 	sleepq_t *sq = l->l_sleepq;
 	int swapin;
@@ -422,7 +424,7 @@ sleepq_unsleep(struct lwp *l)
 void
 sleepq_timeout(void *arg)
 {
-	struct lwp *l = arg;
+	lwp_t *l = arg;
 
 	/*
 	 * Lock the LWP.  Assuming it's still on the sleep queue, its
@@ -445,7 +447,7 @@ sleepq_timeout(void *arg)
  *	Given a signal number, interpret and return an error code.
  */
 int
-sleepq_sigtoerror(struct lwp *l, int sig)
+sleepq_sigtoerror(lwp_t *l, int sig)
 {
 	struct proc *p = l->l_proc;
 	int error;
@@ -494,7 +496,7 @@ sleepq_abort(kmutex_t *mtx, int unlock)
  *	assumed to have been fixed at the time of insertion into the queue.
  */
 void
-sleepq_changepri(struct lwp *l, pri_t pri)
+sleepq_changepri(lwp_t *l, pri_t pri)
 {
 
 	KASSERT(lwp_locked(l, l->l_sleepq->sq_mutex));
@@ -502,7 +504,7 @@ sleepq_changepri(struct lwp *l, pri_t pri)
 }
 
 void
-sleepq_lendpri(struct lwp *l, pri_t pri)
+sleepq_lendpri(lwp_t *l, pri_t pri)
 {
 	sleepq_t *sq = l->l_sleepq;
 	pri_t opri;
diff --git a/sys/sys/condvar.h b/sys/sys/condvar.h
index cb3fed4ea6f3..2399627e54c0 100644
--- a/sys/sys/condvar.h
+++ b/sys/sys/condvar.h
@@ -1,4 +1,4 @@
-/*	$NetBSD: condvar.h,v 1.2 2007/02/09 21:55:37 ad Exp $	*/
+/*	$NetBSD: condvar.h,v 1.3 2007/03/29 17:34:39 ad Exp $	*/
 
 /*-
  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
@@ -65,7 +65,6 @@ int	cv_timedwait_sig(kcondvar_t *, kmutex_t *, int);
 
 void	cv_signal(kcondvar_t *);
 void	cv_broadcast(kcondvar_t *);
-void	cv_wakeup(kcondvar_t *);
 
 int	cv_has_waiters(kcondvar_t *);
 
diff --git a/sys/sys/lwp.h b/sys/sys/lwp.h
index e825458e2a4d..4221a53482f8 100644
--- a/sys/sys/lwp.h
+++ b/sys/sys/lwp.h
@@ -1,4 +1,4 @@
-/* 	$NetBSD: lwp.h,v 1.57 2007/03/21 18:25:59 ad Exp $	*/
+/* 	$NetBSD: lwp.h,v 1.58 2007/03/29 17:34:39 ad Exp $	*/
 
 /*-
  * Copyright (c) 2001, 2006, 2007 The NetBSD Foundation, Inc.
@@ -58,6 +58,7 @@
  * Lightweight process.  Field markings and the corresponding locks: 
  *
  * a:	proclist_mutex
+ * c:	condition variable interlock, passed to cv_wait()
  * l:	*l_mutex
  * p:	l_proc->p_smutex
  * s:	sched_mutex, which may or may not be referenced by l_mutex
@@ -68,7 +69,7 @@
  * Fields are clustered together by usage (to increase the likelyhood
  * of cache hits) and by size (to reduce dead space in the structure).
  */
-struct	lwp {
+typedef struct lwp {
 	/* Scheduling and overall state */
 	struct lwp	*l_forw;	/* s: run queue */
 	struct lwp	*l_back;	/* s: run queue */
@@ -133,7 +134,8 @@ struct	lwp {
 	void		*l_private;	/* !: svr4-style lwp-private data */
 	struct kauth_cred *l_cred;	/* !: cached credentials */
 	void		*l_emuldata;	/* !: kernel lwp-private data */
-	u_short		l_acflag;	/* !: accounting flags */
+	u_int8_t	l_cv_signalled;	/* c: restarted by cv_signal() */
+	u_int8_t	l_unused;	/* !: currently unused */
 	u_short		l_shlocks;	/* !: lockdebug: shared locks held */
 	u_short		l_exlocks;	/* !: lockdebug: excl. locks held */
 	u_short		l_locks;	/* !: lockmgr count of held locks */
@@ -143,7 +145,7 @@ struct	lwp {
 	/* These are only used by 'options SYSCALL_TIMES' */
 	uint32_t        l_syscall_time; /* !: time epoch for current syscall */
 	uint64_t        *l_syscall_counter; /* !: counter for current process */
-};
+} lwp_t;
 
 #if !defined(USER_TO_UAREA)
 #if !defined(UAREA_USER_OFFSET)
@@ -162,7 +164,7 @@ extern struct lwplist alllwp;		/* List of all LWPs. */
 
 extern struct pool lwp_uc_pool;		/* memory pool for LWP startup args */
 
-extern struct lwp lwp0;			/* LWP for proc0 */
+extern lwp_t lwp0;			/* LWP for proc0 */
 #endif
 
 /* These flags are kept in l_flag. */
@@ -228,64 +230,64 @@ do {									\
 		lwp_update_creds(l);					\
 } while (/* CONSTCOND */ 0)
 
-void	preempt (void);
-int	mi_switch (struct lwp *, struct lwp *);
+void	preempt(void);
+int	mi_switch(lwp_t *, lwp_t *);
 #ifndef remrunqueue
-void	remrunqueue (struct lwp *);
+void	remrunqueue(lwp_t *);
 #endif
-void	resetpriority (struct lwp *);
-void	setrunnable (struct lwp *);
+void	resetpriority(lwp_t *);
+void	setrunnable(lwp_t *);
 #ifndef setrunqueue
-void	setrunqueue (struct lwp *);
+void	setrunqueue(lwp_t *);
 #endif
 #ifndef nextrunqueue
-struct lwp *nextrunqueue(void);
+lwp_t	*nextrunqueue(void);
 #endif
-void	unsleep (struct lwp *);
+void	unsleep(lwp_t *);
 #ifndef cpu_switch
-int	cpu_switch (struct lwp *, struct lwp *);
+int	cpu_switch(lwp_t *, lwp_t *);
 #endif
 #ifndef cpu_switchto
-void	cpu_switchto (struct lwp *, struct lwp *);
+void	cpu_switchto(lwp_t *, lwp_t *);
 #endif
 
-int	lwp_locked(struct lwp *, kmutex_t *);
-void	lwp_setlock(struct lwp *, kmutex_t *);
-void	lwp_unlock_to(struct lwp *, kmutex_t *);
-void	lwp_lock_retry(struct lwp *, kmutex_t *);
-void	lwp_relock(struct lwp *, kmutex_t *);
-int	lwp_trylock(struct lwp *);
-void	lwp_addref(struct lwp *);
-void	lwp_delref(struct lwp *);
-void	lwp_drainrefs(struct lwp *);
+int	lwp_locked(lwp_t *, kmutex_t *);
+void	lwp_setlock(lwp_t *, kmutex_t *);
+void	lwp_unlock_to(lwp_t *, kmutex_t *);
+void	lwp_lock_retry(lwp_t *, kmutex_t *);
+void	lwp_relock(lwp_t *, kmutex_t *);
+int	lwp_trylock(lwp_t *);
+void	lwp_addref(lwp_t *);
+void	lwp_delref(lwp_t *);
+void	lwp_drainrefs(lwp_t *);
 
 /* Flags for _lwp_wait1 */
 #define LWPWAIT_EXITCONTROL	0x00000001
 void	lwpinit(void);
-int 	lwp_wait1(struct lwp *, lwpid_t, lwpid_t *, int);
-void	lwp_continue(struct lwp *);
-void	cpu_setfunc(struct lwp *, void (*)(void *), void *);
+int 	lwp_wait1(lwp_t *, lwpid_t, lwpid_t *, int);
+void	lwp_continue(lwp_t *);
+void	cpu_setfunc(lwp_t *, void (*)(void *), void *);
 void	startlwp(void *);
-void	upcallret(struct lwp *);
-void	lwp_exit(struct lwp *);
-void	lwp_exit2(struct lwp *);
-struct lwp *proc_representative_lwp(struct proc *, int *, int);
-int	lwp_suspend(struct lwp *, struct lwp *);
-int	lwp_create1(struct lwp *, const void *, size_t, u_long, lwpid_t *);
-void	lwp_update_creds(struct lwp *);
-struct lwp *lwp_find(struct proc *, int);
-void	lwp_userret(struct lwp *);
-void	lwp_need_userret(struct lwp *);
-void	lwp_free(struct lwp *, bool, bool);
+void	upcallret(lwp_t *);
+void	lwp_exit(lwp_t *);
+void	lwp_exit2(lwp_t *);
+lwp_t	*proc_representative_lwp(struct proc *, int *, int);
+int	lwp_suspend(lwp_t *, lwp_t *);
+int	lwp_create1(lwp_t *, const void *, size_t, u_long, lwpid_t *);
+void	lwp_update_creds(lwp_t *);
+lwp_t	*lwp_find(struct proc *, int);
+void	lwp_userret(lwp_t *);
+void	lwp_need_userret(lwp_t *);
+void	lwp_free(lwp_t *, bool, bool);
 void	lwp_sys_init(void);
 
 int	lwp_specific_key_create(specificdata_key_t *, specificdata_dtor_t);
 void	lwp_specific_key_delete(specificdata_key_t);
-void 	lwp_initspecific(struct lwp *);
-void 	lwp_finispecific(struct lwp *);
-void *	lwp_getspecific(specificdata_key_t);
+void 	lwp_initspecific(lwp_t *);
+void 	lwp_finispecific(lwp_t *);
+void	*lwp_getspecific(specificdata_key_t);
 #if defined(_LWP_API_PRIVATE)
-void *	_lwp_getspecific_by_lwp(struct lwp *, specificdata_key_t);
+void	*_lwp_getspecific_by_lwp(lwp_t *, specificdata_key_t);
 #endif
 void	lwp_setspecific(specificdata_key_t, void *);
 
@@ -293,7 +295,7 @@ void	lwp_setspecific(specificdata_key_t, void *);
  * Lock an LWP. XXXLKM
  */
 static inline void
-lwp_lock(struct lwp *l)
+lwp_lock(lwp_t *l)
 {
 #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
 	kmutex_t *old;
@@ -315,7 +317,7 @@ lwp_lock(struct lwp *l)
  * Unlock an LWP. XXXLKM
  */
 static inline void
-lwp_unlock(struct lwp *l)
+lwp_unlock(lwp_t *l)
 {
 	LOCK_ASSERT(mutex_owned(l->l_mutex));
 
@@ -323,7 +325,7 @@ lwp_unlock(struct lwp *l)
 }
 
 static inline void
-lwp_changepri(struct lwp *l, pri_t pri)
+lwp_changepri(lwp_t *l, pri_t pri)
 {
 	LOCK_ASSERT(mutex_owned(l->l_mutex));
 
@@ -334,7 +336,7 @@ lwp_changepri(struct lwp *l, pri_t pri)
 }
 
 static inline void
-lwp_lendpri(struct lwp *l, pri_t pri)
+lwp_lendpri(lwp_t *l, pri_t pri)
 {
 	LOCK_ASSERT(mutex_owned(l->l_mutex));
 
@@ -345,7 +347,7 @@ lwp_lendpri(struct lwp *l, pri_t pri)
 }
 
 static inline void
-lwp_unsleep(struct lwp *l)
+lwp_unsleep(lwp_t *l)
 {
 	LOCK_ASSERT(mutex_owned(l->l_mutex));
 
@@ -353,14 +355,14 @@ lwp_unsleep(struct lwp *l)
 }
 
 static inline int
-lwp_eprio(struct lwp *l)
+lwp_eprio(lwp_t *l)
 {
 
 	return MIN(l->l_inheritedprio, l->l_priority);
 }
 
-int newlwp(struct lwp *, struct proc *, vaddr_t, bool, int,
-    void *, size_t, void (*)(void *), void *, struct lwp **);
+int newlwp(lwp_t *, struct proc *, vaddr_t, bool, int,
+    void *, size_t, void (*)(void *), void *, lwp_t **);
 
 /*
  * Once we have per-CPU run queues and a modular scheduler interface,
@@ -374,14 +376,14 @@ static inline void
 sched_lock(const int heldmutex)
 {
 	(void)heldmutex;
-	mutex_enter(&sched_mutex);
+	mutex_spin_enter(&sched_mutex);
 }
 
 static inline void
 sched_unlock(const int heldmutex)
 {
 	(void)heldmutex;
-	mutex_exit(&sched_mutex);
+	mutex_spin_exit(&sched_mutex);
 }
 
 #else	/* defined(MULTIPROCESSOR) || defined(LOCKDEBUG) */
@@ -390,14 +392,14 @@ static inline void
 sched_lock(const int heldmutex)
 {
 	if (!heldmutex)
-		mutex_enter(&sched_mutex);
+		mutex_spin_enter(&sched_mutex);
 }
 
 static inline void
-sched_unlock(int heldmutex)
+sched_unlock(const int heldmutex)
 {
 	if (!heldmutex)
-		mutex_exit(&sched_mutex);
+		mutex_spin_exit(&sched_mutex);
 }
 
 #endif	/* defined(MULTIPROCESSOR) || defined(LOCKDEBUG) */
diff --git a/sys/sys/sleepq.h b/sys/sys/sleepq.h
index 7934bfb3016b..057e1b8c7776 100644
--- a/sys/sys/sleepq.h
+++ b/sys/sys/sleepq.h
@@ -1,4 +1,4 @@
-/*	$NetBSD: sleepq.h,v 1.5 2007/02/27 15:07:28 yamt Exp $	*/
+/*	$NetBSD: sleepq.h,v 1.6 2007/03/29 17:34:39 ad Exp $	*/
 
 /*-
  * Copyright (c) 2002, 2006, 2007 The NetBSD Foundation, Inc.
@@ -58,8 +58,6 @@
 #define	SLEEPTAB_HASH_MASK	(SLEEPTAB_HASH_SIZE - 1)
 #define	SLEEPTAB_HASH(wchan)	(((uintptr_t)(wchan) >> 8) & SLEEPTAB_HASH_MASK)
 
-struct lwp;
-
 typedef struct sleepq {
 	TAILQ_HEAD(, lwp)	sq_queue;	/* queue of waiters */
 	kmutex_t		*sq_mutex;	/* mutex on struct & queue */
@@ -88,20 +86,20 @@ typedef struct sleeptab {
 #endif	/* defined(MULTIPROCESSOR) || defined(LOCKDEBUG) */
 
 void	sleepq_init(sleepq_t *, kmutex_t *);
-int	sleepq_remove(sleepq_t *, struct lwp *);
-void	sleepq_block(sleepq_t *, pri_t, wchan_t, const char *, int, int,
+int	sleepq_remove(sleepq_t *, lwp_t *);
+void	sleepq_block(sleepq_t *, pri_t, wchan_t, const char *, int, bool,
 		     syncobj_t *);
-void	sleepq_unsleep(struct lwp *);
+void	sleepq_unsleep(lwp_t *);
 void	sleepq_timeout(void *);
-void	sleepq_wake(sleepq_t *, wchan_t, u_int);
+lwp_t	*sleepq_wake(sleepq_t *, wchan_t, u_int);
 int	sleepq_abort(kmutex_t *, int);
-void	sleepq_changepri(struct lwp *, pri_t);
-void	sleepq_lendpri(struct lwp *, pri_t);
-int	sleepq_unblock(int, int);
-void	sleepq_insert(sleepq_t *, struct lwp *, syncobj_t *);
+void	sleepq_changepri(lwp_t *, pri_t);
+void	sleepq_lendpri(lwp_t *, pri_t);
+int	sleepq_unblock(int, bool);
+void	sleepq_insert(sleepq_t *, lwp_t *, syncobj_t *);
 
 void	sleepq_enqueue(sleepq_t *, pri_t, wchan_t, const char *, syncobj_t *);
-void	sleepq_switch(int, int);
+void	sleepq_switch(int, bool);
 
 void	sleeptab_init(sleeptab_t *);
 
@@ -112,8 +110,8 @@ extern sleeptab_t	sleeptab;
  *
  * XXX This only exists because panic() is broken.
  */
-static inline int
-sleepq_dontsleep(struct lwp *l)
+static inline bool
+sleepq_dontsleep(lwp_t *l)
 {
 	extern int cold;
 
@@ -143,7 +141,7 @@ sleeptab_lookup(sleeptab_t *st, wchan_t wchan)
  * safely released.
  */
 static inline void
-sleepq_enter(sleepq_t *sq, struct lwp *l)
+sleepq_enter(sleepq_t *sq, lwp_t *l)
 {
 #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
 	/*
@@ -197,7 +195,7 @@ typedef struct turnstile {
 
 	/* priority inheritance */
 	pri_t			ts_eprio;
-	struct lwp		*ts_inheritor;
+	lwp_t			*ts_inheritor;
 	SLIST_ENTRY(turnstile)	ts_pichain;
 } turnstile_t;
 
@@ -233,7 +231,7 @@ void	turnstile_init(void);
 turnstile_t	*turnstile_lookup(wchan_t);
 void	turnstile_exit(wchan_t);
 void	turnstile_block(turnstile_t *, int, wchan_t, syncobj_t *);
-void	turnstile_wakeup(turnstile_t *, int, int, struct lwp *);
+void	turnstile_wakeup(turnstile_t *, int, int, lwp_t *);
 void	turnstile_print(volatile void *, void (*)(const char *, ...));
 
 static inline void
@@ -242,8 +240,8 @@ turnstile_unblock(void)
 	(void)sleepq_unblock(0, 0);
 }
 
-void	turnstile_unsleep(struct lwp *);
-void	turnstile_changepri(struct lwp *, pri_t);
+void	turnstile_unsleep(lwp_t *);
+void	turnstile_changepri(lwp_t *, pri_t);
 
 extern struct pool_cache turnstile_cache;
 extern struct turnstile turnstile0;