From bc6dffaba97f724f323911d1cd13036090c358c8 Mon Sep 17 00:00:00 2001
From: Matthew Dillon <dillon@dragonflybsd.org>
Date: Sun, 22 Jun 2003 17:39:48 +0000
Subject: [PATCH] proc->thread stage 1: change kproc_*() API to take and return
 threads.  Note: we won't be able to turn off the underlying proc until we
 have a clean thread path all the way through, which aint now.

---
 sys/kern/kern_kthread.c  | 23 ++++++++++++++++-------
 sys/kern/kern_shutdown.c | 16 +++++++++++-----
 sys/kern/uipc_mbuf.c     |  8 ++++----
 sys/kern/vfs_bio.c       | 14 +++++++-------
 sys/kern/vfs_subr.c      | 34 ++++++++++++++++++----------------
 sys/opencrypto/crypto.c  |  6 +++---
 sys/sys/kthread.h        | 13 +++++++------
 sys/sys/proc.h           |  5 +++--
 sys/vm/swap_pager.c      |  4 ++--
 sys/vm/vm_page.c         |  6 +++---
 sys/vm/vm_pageout.c      | 12 ++++++------
 11 files changed, 80 insertions(+), 61 deletions(-)

diff --git a/sys/kern/kern_kthread.c b/sys/kern/kern_kthread.c
index 577b82d7c0..b6bb4229e6 100644
--- a/sys/kern/kern_kthread.c
+++ b/sys/kern/kern_kthread.c
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_kthread.c,v 1.5.2.3 2001/12/25 01:51:14 dillon Exp $
- * $DragonFly: src/sys/kern/kern_kthread.c,v 1.3 2003/06/22 04:30:42 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_kthread.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -54,7 +54,7 @@ kproc_start(udata)
 	int error;
 
 	error = kthread_create((void (*)(void *))kp->func, NULL,
-		    kp->global_procpp, kp->arg0);
+		    kp->global_threadpp, kp->arg0);
 	if (error)
 		panic("kproc_start: %s: error %d", kp->arg0, error);
 }
@@ -65,7 +65,7 @@ kproc_start(udata)
  */
 int
 kthread_create(void (*func)(void *), void *arg,
-    struct proc **newpp, const char *fmt, ...)
+    struct thread **newpp, const char *fmt, ...)
 {
 	int error;
 	va_list ap;
@@ -81,7 +81,7 @@ kthread_create(void (*func)(void *), void *arg,
 
 	/* save a global descriptor, if desired */
 	if (newpp != NULL)
-		*newpp = p2;
+		*newpp = p2->p_thread;
 
 	/* this is a non-swapped system process */
 	p2->p_flag |= P_INMEM | P_SYSTEM;
@@ -112,36 +112,45 @@ kthread_exit(int ecode)
  * Participation is voluntary.
  */
 int
-suspend_kproc(struct proc *p, int timo)
+suspend_kproc(struct thread *td, int timo)
 {
+	struct proc *p = td->td_proc;
+
 	/*
 	 * Make sure this is indeed a system process and we can safely
 	 * use the p_siglist field.
 	 */
 	if ((p->p_flag & P_SYSTEM) == 0)
 		return (EINVAL);
+	KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
 	SIGADDSET(p->p_siglist, SIGSTOP);
 	wakeup(p);
 	return tsleep((caddr_t)&p->p_siglist, PPAUSE, "suspkp", timo);
 }
 
 int
-resume_kproc(struct proc *p)
+resume_kproc(struct thread *td)
 {
+	struct proc *p = td->td_proc;
+
 	/*
 	 * Make sure this is indeed a system process and we can safely
 	 * use the p_siglist field.
 	 */
 	if ((p->p_flag & P_SYSTEM) == 0)
 		return (EINVAL);
+	KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
 	SIGDELSET(p->p_siglist, SIGSTOP);
 	wakeup((caddr_t)&p->p_siglist);
 	return (0);
 }
 
 void
-kproc_suspend_loop(struct proc *p)
+kproc_suspend_loop(struct thread *td)
 {
+	struct proc *p = td->td_proc;
+
+	KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
 	while (SIGISMEMBER(p->p_siglist, SIGSTOP)) {
 		wakeup((caddr_t)&p->p_siglist);
 		tsleep((caddr_t)&p->p_siglist, PPAUSE, "kpsusp", 0);
diff --git a/sys/kern/kern_shutdown.c b/sys/kern/kern_shutdown.c
index 2a1b773530..8acaa529e9 100644
--- a/sys/kern/kern_shutdown.c
+++ b/sys/kern/kern_shutdown.c
@@ -37,7 +37,7 @@
  *
  *	@(#)kern_shutdown.c	8.3 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_shutdown.c,v 1.72.2.12 2002/02/21 19:15:10 dillon Exp $
- * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include "opt_ddb.h"
@@ -630,16 +630,22 @@ SYSCTL_INT(_kern_shutdown, OID_AUTO, kproc_shutdown_wait, CTLFLAG_RW,
 void
 shutdown_kproc(void *arg, int howto)
 {
+	struct thread *td;
 	struct proc *p;
 	int error;
 
 	if (panicstr)
 		return;
 
-	p = (struct proc *)arg;
-	printf("Waiting (max %d seconds) for system process `%s' to stop...",
-	    kproc_shutdown_wait, p->p_comm);
-	error = suspend_kproc(p, kproc_shutdown_wait * hz);
+	td = (struct thread *)arg;
+	if ((p = td->td_proc) != NULL) {
+	    printf("Waiting (max %d seconds) for system process `%s' to stop...",
+		kproc_shutdown_wait, p->p_comm);
+	} else {
+	    printf("Waiting (max %d seconds) for system thread %p to stop...",
+		kproc_shutdown_wait, td);
+	}
+	error = suspend_kproc(td, kproc_shutdown_wait * hz);
 
 	if (error == EWOULDBLOCK)
 		printf("timed out\n");
diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c
index 7ef432f76d..f3826a58fd 100644
--- a/sys/kern/uipc_mbuf.c
+++ b/sys/kern/uipc_mbuf.c
@@ -32,7 +32,7 @@
  *
  *	@(#)uipc_mbuf.c	8.2 (Berkeley) 1/4/94
  * $FreeBSD: src/sys/kern/uipc_mbuf.c,v 1.51.2.24 2003/04/15 06:59:29 silby Exp $
- * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.2 2003/06/17 04:28:41 dillon Exp $
+ * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.3 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include "opt_param.h"
@@ -303,13 +303,13 @@ kproc_mclalloc(void)
 	}
 }
 
-static struct proc *mclallocproc;
+static struct thread *mclallocthread;
 static struct kproc_desc mclalloc_kp = {
 	"mclalloc",
 	kproc_mclalloc,
-	&mclallocproc
+	&mclallocthread
 };
-SYSINIT(mclallocproc, SI_SUB_KTHREAD_UPDATE, SI_ORDER_ANY, kproc_start,
+SYSINIT(mclallocthread, SI_SUB_KTHREAD_UPDATE, SI_ORDER_ANY, kproc_start,
 	   &mclalloc_kp);
 #endif
 
diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c
index 1e6892408c..76b4ae70c3 100644
--- a/sys/kern/vfs_bio.c
+++ b/sys/kern/vfs_bio.c
@@ -12,7 +12,7 @@
  *		John S. Dyson.
  *
  * $FreeBSD: src/sys/kern/vfs_bio.c,v 1.242.2.20 2003/05/28 18:38:10 alc Exp $
- * $DragonFly: src/sys/kern/vfs_bio.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_bio.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 /*
@@ -1785,12 +1785,12 @@ restart:
  *	take the load in an attempt to prevent getnewbuf() from blocking.
  */
 
-static struct proc *bufdaemonproc;
+static struct thread *bufdaemonthread;
 
 static struct kproc_desc buf_kp = {
 	"bufdaemon",
 	buf_daemon,
-	&bufdaemonproc
+	&bufdaemonthread
 };
 SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, kproc_start, &buf_kp)
 
@@ -1802,8 +1802,8 @@ buf_daemon()
 	/*
 	 * This process needs to be suspended prior to shutdown sync.
 	 */
-	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, bufdaemonproc,
-	    SHUTDOWN_PRI_LAST);
+	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc,
+	    bufdaemonthread, SHUTDOWN_PRI_LAST);
 
 	/*
 	 * This process is allowed to take the buffer cache to the limit
@@ -1811,7 +1811,7 @@ buf_daemon()
 	s = splbio();
 
 	for (;;) {
-		kproc_suspend_loop(bufdaemonproc);
+		kproc_suspend_loop(bufdaemonthread);
 
 		/*
 		 * Do the flush.  Limit the amount of in-transit I/O we
@@ -2550,7 +2550,7 @@ allocbuf(struct buf *bp, int size)
 				 * We have a good page.  Should we wakeup the
 				 * page daemon?
 				 */
-				if ((curproc != pageproc) &&
+				if ((curthread != pagethread) &&
 				    ((m->queue - m->pc) == PQ_CACHE) &&
 				    ((cnt.v_free_count + cnt.v_cache_count) <
 					(cnt.v_free_min + cnt.v_cache_min))) {
diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
index 720f9a5cca..9b461858b8 100644
--- a/sys/kern/vfs_subr.c
+++ b/sys/kern/vfs_subr.c
@@ -37,7 +37,7 @@
  *
  *	@(#)vfs_subr.c	8.31 (Berkeley) 5/26/95
  * $FreeBSD: src/sys/kern/vfs_subr.c,v 1.249.2.30 2003/04/04 20:35:57 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_subr.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_subr.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 /*
@@ -518,7 +518,7 @@ vlrureclaim(struct mount *mp)
  * Calling vlrurecycle() from the bowels of file system code has some
  * interesting deadlock problems.
  */
-static struct proc *vnlruproc;
+static struct thread *vnlruthread;
 static int vnlruproc_sig;
 
 static void 
@@ -527,18 +527,19 @@ vnlru_proc(void)
 	struct mount *mp, *nmp;
 	int s;
 	int done;
-	struct proc *p = vnlruproc;
+	struct thread *td = vnlruthread;
+	struct proc *p = td->td_proc;
 
-	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
+	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
 	    SHUTDOWN_PRI_FIRST);   
 
 	s = splbio();
 	for (;;) {
-		kproc_suspend_loop(p);
+		kproc_suspend_loop(td);
 		if (numvnodes - freevnodes <= desiredvnodes * 9 / 10) {
 			vnlruproc_sig = 0;
 			wakeup(&vnlruproc_sig);
-			tsleep(vnlruproc, PVFS, "vlruwt", hz);
+			tsleep(p, PVFS, "vlruwt", hz);
 			continue;
 		}
 		done = 0;
@@ -556,7 +557,7 @@ vnlru_proc(void)
 		simple_unlock(&mountlist_slock);
 		if (done == 0) {
 			vnlru_nowhere++;
-			tsleep(vnlruproc, PPAUSE, "vlrup", hz * 3);
+			tsleep(p, PPAUSE, "vlrup", hz * 3);
 		}
 	}
 	splx(s);
@@ -565,7 +566,7 @@ vnlru_proc(void)
 static struct kproc_desc vnlru_kp = {
 	"vnlru",
 	vnlru_proc,
-	&vnlruproc
+	&vnlruthread
 };
 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp)
 
@@ -600,7 +601,7 @@ getnewvnode(tag, mp, vops, vpp)
 	while (numvnodes - freevnodes > desiredvnodes) {
 		if (vnlruproc_sig == 0) {
 			vnlruproc_sig = 1;	/* avoid unnecessary wakeups */
-			wakeup(vnlruproc);
+			wakeup(vnlruthread);
 		}
 		tsleep(&vnlruproc_sig, PVFS, "vlruwk", hz);
 	}
@@ -1117,12 +1118,12 @@ vn_syncer_add_to_worklist(struct vnode *vp, int delay)
 	splx(s);
 }
 
-struct  proc *updateproc;
+struct  thread *updatethread;
 static void sched_sync __P((void));
 static struct kproc_desc up_kp = {
 	"syncer",
 	sched_sync,
-	&updateproc
+	&updatethread
 };
 SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
 
@@ -1136,13 +1137,14 @@ sched_sync(void)
 	struct vnode *vp;
 	long starttime;
 	int s;
-	struct proc *p = updateproc;
+	struct thread *td = updatethread;
+	struct proc *p = td->td_proc;
 
-	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
+	EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
 	    SHUTDOWN_PRI_LAST);   
 
 	for (;;) {
-		kproc_suspend_loop(p);
+		kproc_suspend_loop(td);
 
 		starttime = time_second;
 
@@ -1229,8 +1231,8 @@ speedup_syncer()
 	int s;
 
 	s = splhigh();
-	if (updateproc->p_wchan == &lbolt)
-		setrunnable(updateproc);
+	if (updatethread->td_proc->p_wchan == &lbolt) /* YYY */
+		setrunnable(updatethread->td_proc);
 	splx(s);
 	if (rushjob < syncdelay / 2) {
 		rushjob += 1;
diff --git a/sys/opencrypto/crypto.c b/sys/opencrypto/crypto.c
index fb6149629f..011163254a 100644
--- a/sys/opencrypto/crypto.c
+++ b/sys/opencrypto/crypto.c
@@ -1,5 +1,5 @@
 /*	$FreeBSD: src/sys/opencrypto/crypto.c,v 1.4.2.7 2003/06/03 00:09:02 sam Exp $	*/
-/*	$DragonFly: src/sys/opencrypto/crypto.c,v 1.2 2003/06/17 04:28:54 dillon Exp $	*/
+/*	$DragonFly: src/sys/opencrypto/crypto.c,v 1.3 2003/06/22 17:39:44 dillon Exp $	*/
 /*	$OpenBSD: crypto.c,v 1.38 2002/06/11 11:14:29 beck Exp $	*/
 /*
  * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
@@ -114,7 +114,7 @@ MALLOC_DEFINE(M_CRYPTO_DATA, "crypto", "crypto session records");
  */ 
 static	void cryptointr(void);		/* swi thread to dispatch ops */
 static	void cryptoret(void);		/* kernel thread for callbacks*/
-static	struct proc *cryptoproc;
+static	struct thread *cryptothread;
 static	void crypto_destroy(void);
 static	int crypto_invoke(struct cryptop *crp, int hint);
 static	int crypto_kinvoke(struct cryptkop *krp, int hint);
@@ -158,7 +158,7 @@ crypto_init(void)
 
 	register_swi(SWI_CRYPTO, cryptointr);
 	error = kthread_create((void (*)(void *)) cryptoret, NULL,
-		    &cryptoproc, "cryptoret");
+		    &cryptothread, "cryptoret");
 	if (error) {
 		printf("crypto_init: cannot start cryptoret thread; error %d",
 			error);
diff --git a/sys/sys/kthread.h b/sys/sys/kthread.h
index 532b3340c7..0ed6c5ab76 100644
--- a/sys/sys/kthread.h
+++ b/sys/sys/kthread.h
@@ -24,13 +24,14 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/sys/kthread.h,v 1.2 2000/01/07 08:36:44 luoqi Exp $
- * $DragonFly: src/sys/sys/kthread.h,v 1.2 2003/06/17 04:28:58 dillon Exp $
+ * $DragonFly: src/sys/sys/kthread.h,v 1.3 2003/06/22 17:39:46 dillon Exp $
  */
 
 #ifndef _SYS_KTHREAD_H_
 #define _SYS_KTHREAD_H_
 
 struct proc;
+struct thread;
 
 /* 
  * A kernel process descriptor; used to start "internal" daemons
@@ -40,17 +41,17 @@ struct proc;
 struct kproc_desc {
 	char		*arg0;			/* arg 0 (for 'ps' listing) */
 	void		(*func) __P((void));	/* "main" for kernel process */
-	struct proc	**global_procpp;	/* ptr to proc ptr save area */
+	struct thread	**global_threadpp;	/* ptr to proc ptr save area */
 };
 
 void	kproc_start __P((const void *));
-int     kthread_create __P((void (*)(void *), void *, struct proc **,
+int     kthread_create __P((void (*)(void *), void *, struct thread **,
 	    const char *, ...)) __printflike(4, 5);
 void    kthread_exit __P((int)) __dead2;
 
-int	suspend_kproc __P((struct proc *, int));
-int	resume_kproc __P((struct proc *));
-void	kproc_suspend_loop __P((struct proc *));
+int	suspend_kproc __P((struct thread *, int));
+int	resume_kproc __P((struct thread *));
+void	kproc_suspend_loop __P((struct thread *));
 void	shutdown_kproc __P((void *, int));
 
 #endif
diff --git a/sys/sys/proc.h b/sys/sys/proc.h
index 437a939eb2..82e7949229 100644
--- a/sys/sys/proc.h
+++ b/sys/sys/proc.h
@@ -37,7 +37,7 @@
  *
  *	@(#)proc.h	8.15 (Berkeley) 5/19/95
  * $FreeBSD: src/sys/sys/proc.h,v 1.99.2.9 2003/06/06 20:21:32 tegge Exp $
- * $DragonFly: src/sys/sys/proc.h,v 1.11 2003/06/22 04:30:43 dillon Exp $
+ * $DragonFly: src/sys/sys/proc.h,v 1.12 2003/06/22 17:39:46 dillon Exp $
  */
 
 #ifndef _SYS_PROC_H_
@@ -386,7 +386,8 @@ extern int sched_quantum;		/* Scheduling quantum in ticks */
 LIST_HEAD(proclist, proc);
 extern struct proclist allproc;		/* List of all processes. */
 extern struct proclist zombproc;	/* List of zombie processes. */
-extern struct proc *initproc, *pageproc, *updateproc; /* Process slots for init, pager. */
+extern struct proc *initproc;		/* Process slot for init */
+extern struct thread *pagethread, *updatethread;
 
 #define	NQS	32			/* 32 run queues. */
 TAILQ_HEAD(rq, proc);
diff --git a/sys/vm/swap_pager.c b/sys/vm/swap_pager.c
index cc61fe2214..fa6bc2e745 100644
--- a/sys/vm/swap_pager.c
+++ b/sys/vm/swap_pager.c
@@ -65,7 +65,7 @@
  *	@(#)swap_pager.c	8.9 (Berkeley) 3/21/94
  *
  * $FreeBSD: src/sys/vm/swap_pager.c,v 1.130.2.12 2002/08/31 21:15:55 dillon Exp $
- * $DragonFly: src/sys/vm/swap_pager.c,v 1.3 2003/06/19 01:55:08 dillon Exp $
+ * $DragonFly: src/sys/vm/swap_pager.c,v 1.4 2003/06/22 17:39:48 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1251,7 +1251,7 @@ swap_pager_putpages(object, m, count, sync, rtvals)
 	if (object->type != OBJT_SWAP)
 		swp_pager_meta_build(object, 0, SWAPBLK_NONE);
 
-	if (curproc != pageproc)
+	if (curthread != pagethread)
 		sync = TRUE;
 
 	/*
diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c
index d5f880caf6..f9fcdac732 100644
--- a/sys/vm/vm_page.c
+++ b/sys/vm/vm_page.c
@@ -35,7 +35,7 @@
  *
  *	from: @(#)vm_page.c	7.4 (Berkeley) 5/7/91
  * $FreeBSD: src/sys/vm/vm_page.c,v 1.147.2.18 2002/03/10 05:03:19 alc Exp $
- * $DragonFly: src/sys/vm/vm_page.c,v 1.3 2003/06/21 07:54:57 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_page.c,v 1.4 2003/06/22 17:39:48 dillon Exp $
  */
 
 /*
@@ -745,7 +745,7 @@ vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int page_req)
 	 * The pager is allowed to eat deeper into the free page list.
 	 */
 
-	if ((curproc == pageproc) && (page_req != VM_ALLOC_INTERRUPT)) {
+	if ((curthread == pagethread) && (page_req != VM_ALLOC_INTERRUPT)) {
 		page_req = VM_ALLOC_SYSTEM;
 	};
 
@@ -869,7 +869,7 @@ vm_wait(void)
 	int s;
 
 	s = splvm();
-	if (curproc == pageproc) {
+	if (curthread == pagethread) {
 		vm_pageout_pages_needed = 1;
 		tsleep(&vm_pageout_pages_needed, PSWP, "VMWait", 0);
 	} else {
diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index 00c132d193..7b473263d6 100644
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -66,7 +66,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pageout.c,v 1.151.2.15 2002/12/29 18:21:04 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pageout.c,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.3 2003/06/22 17:39:48 dillon Exp $
  */
 
 /*
@@ -105,24 +105,24 @@ static void vm_pageout __P((void));
 static int vm_pageout_clean __P((vm_page_t));
 static void vm_pageout_scan __P((int pass));
 static int vm_pageout_free_page_calc __P((vm_size_t count));
-struct proc *pageproc;
+struct thread *pagethread;
 
 static struct kproc_desc page_kp = {
 	"pagedaemon",
 	vm_pageout,
-	&pageproc
+	&pagethread
 };
 SYSINIT(pagedaemon, SI_SUB_KTHREAD_PAGE, SI_ORDER_FIRST, kproc_start, &page_kp)
 
 #if !defined(NO_SWAPPING)
 /* the kernel process "vm_daemon"*/
 static void vm_daemon __P((void));
-static struct	proc *vmproc;
+static struct	thread *vmthread;
 
 static struct kproc_desc vm_kp = {
 	"vmdaemon",
 	vm_daemon,
-	&vmproc
+	&vmthread
 };
 SYSINIT(vmdaemon, SI_SUB_KTHREAD_VM, SI_ORDER_FIRST, kproc_start, &vm_kp)
 #endif
@@ -1411,7 +1411,7 @@ vm_pageout()
 void
 pagedaemon_wakeup()
 {
-	if (!vm_pages_needed && curproc != pageproc) {
+	if (!vm_pages_needed && curthread != pagethread) {
 		vm_pages_needed++;
 		wakeup(&vm_pages_needed);
 	}
-- 
2.41.0