KSE Milestone 2

Note ALL MODULES MUST BE RECOMPILED
make the kernel aware that there are smaller units of scheduling than the
process. (but only allow one thread per process at this time).
This is functionally equivalent to teh previousl -current except
that there is a thread associated with each process.

Sorry john! (your next MFC will be a doosie!)

Reviewed by: peter@freebsd.org, dillon@freebsd.org

X-MFC after:    ha ha ha ha

18 files changed, 499 insertions, 481 deletions

diff --git a/sys/i386/ibcs2/ibcs2_fcntl.c b/sys/i386/ibcs2/ibcs2_fcntl.c
index 971adce..6151c5d 100644
--- a/sys/i386/ibcs2/ibcs2_fcntl.c
+++ b/sys/i386/ibcs2/ibcs2_fcntl.c
@@ -169,73 +169,74 @@ oflags2ioflags(flags)
 }
 
 int
-ibcs2_open(p, uap)
-	struct proc *p;
+ibcs2_open(td, uap)
+	struct thread *td;
 	struct ibcs2_open_args *uap;
 {
+	struct proc *p = td->td_proc;
 	int noctty = SCARG(uap, flags) & IBCS2_O_NOCTTY;
 	int ret;
 	caddr_t sg = stackgap_init();
 
 	SCARG(uap, flags) = cvt_o_flags(SCARG(uap, flags));
 	if (SCARG(uap, flags) & O_CREAT)
-		CHECKALTCREAT(p, &sg, SCARG(uap, path));
+		CHECKALTCREAT(td, &sg, SCARG(uap, path));
 	else
-		CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	ret = open(p, (struct open_args *)uap);
+		CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	ret = open(td, (struct open_args *)uap);
 
 #ifdef SPX_HACK
 	if (ret == ENXIO) {
 		if (!strcmp(SCARG(uap, path), "/compat/ibcs2/dev/spx"))
-			ret = spx_open(p, uap);
+			ret = spx_open(td, uap);
 	} else
 #endif /* SPX_HACK */
 	PROC_LOCK(p);
 	if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
 		struct filedesc *fdp = p->p_fd;
-		struct file *fp = fdp->fd_ofiles[p->p_retval[0]];
+		struct file *fp = fdp->fd_ofiles[td->td_retval[0]];
 
 		PROC_UNLOCK(p);
 		/* ignore any error, just give it a try */
 		if (fp->f_type == DTYPE_VNODE)
-			fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, p);
+			fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td);
 	} else
 		PROC_UNLOCK(p);
 	return ret;
 }
 
 int
-ibcs2_creat(p, uap)
-        struct proc *p;  
+ibcs2_creat(td, uap)
+        struct thread *td;  
 	struct ibcs2_creat_args *uap;
 {       
 	struct open_args cup;   
 	caddr_t sg = stackgap_init();
 
-	CHECKALTCREAT(p, &sg, SCARG(uap, path));
+	CHECKALTCREAT(td, &sg, SCARG(uap, path));
 	SCARG(&cup, path) = SCARG(uap, path);
 	SCARG(&cup, mode) = SCARG(uap, mode);
 	SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
-	return open(p, &cup);
+	return open(td, &cup);
 }       
 
 int
-ibcs2_access(p, uap)
-        struct proc *p;
+ibcs2_access(td, uap)
+        struct thread *td;
         struct ibcs2_access_args *uap;
 {
         struct access_args cup;
         caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+        CHECKALTEXIST(td, &sg, SCARG(uap, path));
         SCARG(&cup, path) = SCARG(uap, path);
         SCARG(&cup, flags) = SCARG(uap, flags);
-        return access(p, &cup);
+        return access(td, &cup);
 }
 
 int
-ibcs2_fcntl(p, uap)
-	struct proc *p;
+ibcs2_fcntl(td, uap)
+	struct thread *td;
 	struct ibcs2_fcntl_args *uap;
 {
 	int error;
@@ -248,32 +249,32 @@ ibcs2_fcntl(p, uap)
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_DUPFD;
 		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 	case IBCS2_F_GETFD:
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_GETFD;
 		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 	case IBCS2_F_SETFD:
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_SETFD;
 		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 	case IBCS2_F_GETFL:
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_GETFL;
 		SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg);
-		error = fcntl(p, &fa);
+		error = fcntl(td, &fa);
 		if (error)
 			return error;
-		p->p_retval[0] = oflags2ioflags(p->p_retval[0]);
+		td->td_retval[0] = oflags2ioflags(td->td_retval[0]);
 		return error;
 	case IBCS2_F_SETFL:
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_SETFL;
 		SCARG(&fa, arg) = (/* XXX */ int)
 				  ioflags2oflags((int)SCARG(uap, arg));
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 
 	case IBCS2_F_GETLK:
 	    {
@@ -287,7 +288,7 @@ ibcs2_fcntl(p, uap)
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_GETLK;
 		SCARG(&fa, arg) = (/* XXX */ int)flp;
-		error = fcntl(p, &fa);
+		error = fcntl(td, &fa);
 		if (error)
 			return error;
 		cvt_flock2iflock(flp, &ifl);
@@ -308,7 +309,7 @@ ibcs2_fcntl(p, uap)
 		SCARG(&fa, cmd) = F_SETLK;
 		SCARG(&fa, arg) = (/* XXX */ int)flp;
 
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 	    }
 
 	case IBCS2_F_SETLKW:
@@ -323,7 +324,7 @@ ibcs2_fcntl(p, uap)
 		SCARG(&fa, fd) = SCARG(uap, fd);
 		SCARG(&fa, cmd) = F_SETLKW;
 		SCARG(&fa, arg) = (/* XXX */ int)flp;
-		return fcntl(p, &fa);
+		return fcntl(td, &fa);
 	    }
 	}
 	return ENOSYS;
diff --git a/sys/i386/ibcs2/ibcs2_ioctl.c b/sys/i386/ibcs2/ibcs2_ioctl.c
index 4dfa80b..39fdc99 100644
--- a/sys/i386/ibcs2/ibcs2_ioctl.c
+++ b/sys/i386/ibcs2/ibcs2_ioctl.c
@@ -57,7 +57,7 @@ static void stio2stios  __P((struct ibcs2_termio *, struct ibcs2_termios *));
 
 
 int
-ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args)
+ibcs2_gtty(struct thread *td, struct ibcs2_gtty_args *args)
 {
 	struct ioctl_args ioctl_arg;
 
@@ -65,11 +65,11 @@ ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args)
 	ioctl_arg.com = TIOCGETC;
 	ioctl_arg.data = (caddr_t)args->buf;
 
-	return ioctl(p, &ioctl_arg);
+	return ioctl(td, &ioctl_arg);
 }
 
 int
-ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args)
+ibcs2_stty(struct thread *td, struct ibcs2_stty_args *args)
 {
 	struct ioctl_args ioctl_arg;
 
@@ -77,7 +77,7 @@ ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args)
 	ioctl_arg.com = TIOCSETC;
 	ioctl_arg.data = (caddr_t)args->buf;
 
-	return ioctl(p, &ioctl_arg);
+	return ioctl(td, &ioctl_arg);
 }
 
 
@@ -336,10 +336,11 @@ stio2stios(t, ts)
 }
 
 int
-ibcs2_ioctl(p, uap)
-	struct proc *p;
+ibcs2_ioctl(td, uap)
+	struct thread *td;
 	struct ibcs2_ioctl_args *uap;
 {
+	struct proc *p = td->td_proc;
 	struct filedesc *fdp = p->p_fd;
 	struct file *fp;
 	int error;
@@ -365,7 +366,7 @@ ibcs2_ioctl(p, uap)
 		struct ibcs2_termios sts;
 		struct ibcs2_termio st;
 	
-		if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0)
+		if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0)
 			return error;
 	
 		btios2stios (&bts, &sts);
@@ -401,7 +402,7 @@ ibcs2_ioctl(p, uap)
 		}
 
 		/* get full BSD termios so we don't lose information */
-		if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) {
+		if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) {
 			DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
 				 p->p_pid, SCARG(uap, fd)));
 			return error;
@@ -416,7 +417,7 @@ ibcs2_ioctl(p, uap)
 		stios2btios(&sts, &bts);
 
 		return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
-			      (caddr_t)&bts, p);
+			      (caddr_t)&bts, td);
 	    }
 
 	case IBCS2_XCSETA:
@@ -432,7 +433,7 @@ ibcs2_ioctl(p, uap)
 		}
 		stios2btios (&sts, &bts);
 		return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
-			      (caddr_t)&bts, p);
+			      (caddr_t)&bts, td);
 	    }
 
 	case IBCS2_OXCSETA:
@@ -448,7 +449,7 @@ ibcs2_ioctl(p, uap)
 		}
 		stios2btios (&sts, &bts);
 		return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
-			      (caddr_t)&bts, p);
+			      (caddr_t)&bts, td);
 	    }
 
 	case IBCS2_TCSBRK:
@@ -463,9 +464,9 @@ ibcs2_ioctl(p, uap)
 			DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
 			return ENOSYS;
 		case 2:
-			return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, p);
+			return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, td);
 		case 3:
-			return fo_ioctl(fp, TIOCSTART, (caddr_t)1, p);
+			return fo_ioctl(fp, TIOCSTART, (caddr_t)1, td);
 		default:
 			return EINVAL;
 		}
@@ -488,16 +489,16 @@ ibcs2_ioctl(p, uap)
 		default:
 			return EINVAL;
 		}
-		return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, p);
+		return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td);
 	    }
 
 	case IBCS2_TIOCGWINSZ:
 		SCARG(uap, cmd) = TIOCGWINSZ;
-		return ioctl(p, (struct ioctl_args *)uap);
+		return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_TIOCSWINSZ:
 		SCARG(uap, cmd) = TIOCSWINSZ;
-		return ioctl(p, (struct ioctl_args *)uap);
+		return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_TIOCGPGRP:
 		PROC_LOCK(p);
@@ -512,7 +513,7 @@ ibcs2_ioctl(p, uap)
 
 		SCARG(&sa, pid) = 0;
 		SCARG(&sa, pgid) = (int)SCARG(uap, data);
-		if ((error = setpgid(p, &sa)) != 0)
+		if ((error = setpgid(td, &sa)) != 0)
 			return error;
 		return 0;
 	    }
@@ -548,96 +549,96 @@ ibcs2_ioctl(p, uap)
 	case IBCS2_KDGKBMODE:        /* get keyboard translation mode */
 	        SCARG(uap, cmd) = KDGKBMODE;
 /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
 	        SCARG(uap, cmd) = KDSKBMODE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDMKTONE:        /* sound tone */
 	        SCARG(uap, cmd) = KDMKTONE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDGETMODE:        /* get text/graphics mode */  
 	        SCARG(uap, cmd) = KDGETMODE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDSETMODE:       /* set text/graphics mode */
 	        SCARG(uap, cmd) = KDSETMODE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDSBORDER:       /* set ega color border */
 	        SCARG(uap, cmd) = KDSBORDER;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDGKBSTATE:
 	        SCARG(uap, cmd) = KDGKBSTATE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDSETRAD:
 	        SCARG(uap, cmd) = KDSETRAD;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDENABIO:       /* enable direct I/O to ports */
 	        SCARG(uap, cmd) = KDENABIO;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
 	        SCARG(uap, cmd) = KDDISABIO;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KIOCSOUND:       /* start sound generation */
 	        SCARG(uap, cmd) = KIOCSOUND;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDGKBTYPE:       /* get keyboard type */
 	        SCARG(uap, cmd) = KDGKBTYPE;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDGETLED:       /* get keyboard LED status */
 	        SCARG(uap, cmd) = KDGETLED;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_KDSETLED:       /* set keyboard LED status */
 	        SCARG(uap, cmd) = KDSETLED;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	    /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
 	case IBCS2_GETFKEY:      /* Get function key */
 	        SCARG(uap, cmd) = GETFKEY;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_SETFKEY:      /* Set function key */
 	        SCARG(uap, cmd) = SETFKEY;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
 	        SCARG(uap, cmd) = GIO_SCRNMAP;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
 	        SCARG(uap, cmd) = PIO_SCRNMAP;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
 	        SCARG(uap, cmd) = GIO_KEYMAP;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
 	        SCARG(uap, cmd) = PIO_KEYMAP;
-	        return ioctl(p, (struct ioctl_args *)uap);
+	        return ioctl(td, (struct ioctl_args *)uap);
 
 	    /* socksys */
 	case IBCS2_SIOCSOCKSYS:
-		return ibcs2_socksys(p, (struct ibcs2_socksys_args *)uap);
+		return ibcs2_socksys(td, (struct ibcs2_socksys_args *)uap);
 
 	case IBCS2_I_NREAD:     /* STREAMS */
 	        SCARG(uap, cmd) = FIONREAD;
-		return ioctl(p, (struct ioctl_args *)uap);
+		return ioctl(td, (struct ioctl_args *)uap);
 
 	default:
 		DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
-			 p->p_pid, SCARG(uap, cmd)));
+			 td->proc->p_pid, SCARG(uap, cmd)));
 		return ENOSYS;
 	}
 	return ENOSYS;
diff --git a/sys/i386/ibcs2/ibcs2_ipc.c b/sys/i386/ibcs2/ibcs2_ipc.c
index 2acf3d2..804f82d 100644
--- a/sys/i386/ibcs2/ibcs2_ipc.c
+++ b/sys/i386/ibcs2/ibcs2_ipc.c
@@ -102,14 +102,14 @@ struct msqid_ds *bp;
 }
 
 int
-ibcs2_msgsys(p, uap)
-	struct proc *p;
+ibcs2_msgsys(td, uap)
+	struct thread *td;
 	struct ibcs2_msgsys_args *uap;
 {
 	switch (SCARG(uap, which)) {
 	case 0:				/* msgget */
 		SCARG(uap, which) = 1;
-		return msgsys(p, (struct msgsys_args *)uap);
+		return msgsys(td, (struct msgsys_args *)uap);
 	case 1: {			/* msgctl */
 		int error;
 		struct msgsys_args margs;
@@ -122,7 +122,7 @@ ibcs2_msgsys(p, uap)
 		SCARG(&margs, a3) = SCARG(uap, a3);
 		switch (SCARG(&margs, a3)) {
 		case IBCS2_IPC_STAT:
-			error = msgsys(p, &margs);
+			error = msgsys(td, &margs);
 			if (!error)
 				cvt_msqid2imsqid(
 				    (struct msqid_ds *)SCARG(&margs, a4),
@@ -132,18 +132,18 @@ ibcs2_msgsys(p, uap)
 			cvt_imsqid2msqid((struct ibcs2_msqid_ds *)SCARG(uap,
 									a4),
 					 (struct msqid_ds *)SCARG(&margs, a4));
-			return msgsys(p, &margs);
+			return msgsys(td, &margs);
 		case IBCS2_IPC_RMID:
-			return msgsys(p, &margs);
+			return msgsys(td, &margs);
 		}
 		return EINVAL;
 	}
 	case 2:				/* msgrcv */
 		SCARG(uap, which) = 3;
-		return msgsys(p, (struct msgsys_args *)uap);
+		return msgsys(td, (struct msgsys_args *)uap);
 	case 3:				/* msgsnd */
 		SCARG(uap, which) = 2;
-		return msgsys(p, (struct msgsys_args *)uap);
+		return msgsys(td, (struct msgsys_args *)uap);
 	default:
 		return EINVAL;
 	}
@@ -233,8 +233,8 @@ struct semid_ds *bp;
 }
 
 int
-ibcs2_semsys(p, uap)
-	struct proc *p;
+ibcs2_semsys(td, uap)
+	struct thread *td;
 	struct ibcs2_semsys_args *uap;
 {
 	int error;
@@ -255,7 +255,7 @@ ibcs2_semsys(p, uap)
 			sup = stackgap_alloc(&sg, sizeof(union semun));
 			sup->buf = sp;
 			SCARG(uap, a5) = (int)sup;
-			error = semsys(p, (struct semsys_args *)uap);
+			error = semsys(td, (struct semsys_args *)uap);
 			if (!error) {
 				SCARG(uap, a5) = (int)ssu.buf;
 				isp = stackgap_alloc(&sg, sizeof(*isp));
@@ -280,7 +280,7 @@ ibcs2_semsys(p, uap)
 				return error;
 			cvt_isemid2semid(isp, sp);
 			SCARG(uap, a5) = (int)sp;
-			return semsys(p, (struct semsys_args *)uap);
+			return semsys(td, (struct semsys_args *)uap);
 		    }
 		case IBCS2_SETVAL:
 		    {
@@ -290,17 +290,17 @@ ibcs2_semsys(p, uap)
 			sp = stackgap_alloc(&sg, sizeof(*sp));
 			sp->val = (int) SCARG(uap, a5);
 			SCARG(uap, a5) = (int)sp;
-			return semsys(p, (struct semsys_args *)uap);
+			return semsys(td, (struct semsys_args *)uap);
 		    }
 		}
 
-		return semsys(p, (struct semsys_args *)uap);
+		return semsys(td, (struct semsys_args *)uap);
 
 	case 1:				/* semget */
-		return semsys(p, (struct semsys_args *)uap);
+		return semsys(td, (struct semsys_args *)uap);
 
 	case 2:				/* semop */
-		return semsys(p, (struct semsys_args *)uap);
+		return semsys(td, (struct semsys_args *)uap);
 	}
 	return EINVAL;
 }
@@ -345,15 +345,15 @@ struct shmid_ds *bp;
 }
 
 int
-ibcs2_shmsys(p, uap)
-	struct proc *p;
+ibcs2_shmsys(td, uap)
+	struct thread *td;
 	struct ibcs2_shmsys_args *uap;
 {
 	int error;
 
 	switch (SCARG(uap, which)) {
 	case 0:						/* shmat */
-		return shmsys(p, (struct shmsys_args *)uap);
+		return shmsys(td, (struct shmsys_args *)uap);
 
 	case 1:						/* shmctl */
 		switch(SCARG(uap, a3)) {
@@ -366,7 +366,7 @@ ibcs2_shmsys(p, uap)
 			isp = (struct ibcs2_shmid_ds *)SCARG(uap, a4);
 			sp = stackgap_alloc(&sg, sizeof(*sp));
 			SCARG(uap, a4) = (int)sp;
-			error = shmsys(p, (struct shmsys_args *)uap);
+			error = shmsys(td, (struct shmsys_args *)uap);
 			if (!error) {
 				SCARG(uap, a4) = (int)isp;
 				isp = stackgap_alloc(&sg, sizeof(*isp));
@@ -391,17 +391,17 @@ ibcs2_shmsys(p, uap)
 				return error;
 			cvt_ishmid2shmid(isp, sp);
 			SCARG(uap, a4) = (int)sp;
-			return shmsys(p, (struct shmsys_args *)uap);
+			return shmsys(td, (struct shmsys_args *)uap);
 		    }
 		}
 
-		return shmsys(p, (struct shmsys_args *)uap);
+		return shmsys(td, (struct shmsys_args *)uap);
 
 	case 2:						/* shmdt */
-		return shmsys(p, (struct shmsys_args *)uap);
+		return shmsys(td, (struct shmsys_args *)uap);
 
 	case 3:						/* shmget */
-		return shmsys(p, (struct shmsys_args *)uap);
+		return shmsys(td, (struct shmsys_args *)uap);
 	}
 	return EINVAL;
 }
diff --git a/sys/i386/ibcs2/ibcs2_isc.c b/sys/i386/ibcs2/ibcs2_isc.c
index 9c690c9..31ebd0a 100644
--- a/sys/i386/ibcs2/ibcs2_isc.c
+++ b/sys/i386/ibcs2/ibcs2_isc.c
@@ -45,9 +45,9 @@
 extern struct sysent isc_sysent[];
 
 int
-ibcs2_isc(struct proc *p, struct ibcs2_isc_args *uap)
+ibcs2_isc(struct thread *td, struct ibcs2_isc_args *uap)
 {
-	struct trapframe *tf = p->p_frame;
+	struct trapframe *tf = td->td_frame;
         struct sysent *callp;
         u_int code;             
 
@@ -55,7 +55,7 @@ ibcs2_isc(struct proc *p, struct ibcs2_isc_args *uap)
 	callp = &isc_sysent[code];
 
 	if(code < IBCS2_ISC_MAXSYSCALL)
-	  return((*callp->sy_call)(p, (void *)uap));
+	  return((*callp->sy_call)(td, (void *)uap));
 	else
 	  return ENOSYS;
 }
diff --git a/sys/i386/ibcs2/ibcs2_misc.c b/sys/i386/ibcs2/ibcs2_misc.c
index c2e28b9..bbe32eb 100644
--- a/sys/i386/ibcs2/ibcs2_misc.c
+++ b/sys/i386/ibcs2/ibcs2_misc.c
@@ -85,8 +85,8 @@
 #include <i386/ibcs2/ibcs2_xenix.h>
 
 int
-ibcs2_ulimit(p, uap)
-	struct proc *p;
+ibcs2_ulimit(td, uap)
+	struct thread *td;
 	struct ibcs2_ulimit_args *uap;
 {
 #ifdef notyet
@@ -104,31 +104,31 @@ ibcs2_ulimit(p, uap)
 	
 	switch (SCARG(uap, cmd)) {
 	case IBCS2_GETFSIZE:
-		p->p_retval[0] = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
-		if (p->p_retval[0] == -1) p->p_retval[0] = 0x7fffffff;
+		td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+		if (td->td_retval[0] == -1) td->td_retval[0] = 0x7fffffff;
 		return 0;
 	case IBCS2_SETFSIZE:	/* XXX - fix this */
 #ifdef notyet
 		rl.rlim_cur = SCARG(uap, newlimit);
 		sra.resource = RLIMIT_FSIZE;
 		sra.rlp = &rl;
-		error = setrlimit(p, &sra);
+		error = setrlimit(td, &sra);
 		if (!error)
-			p->p_retval[0] = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+			td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur;
 		else
 			DPRINTF(("failed "));
 		return error;
 #else
-		p->p_retval[0] = SCARG(uap, newlimit);
+		td->td_retval[0] = SCARG(uap, newlimit);
 		return 0;
 #endif
 	case IBCS2_GETPSIZE:
 		mtx_assert(&Giant, MA_OWNED);
-		p->p_retval[0] = p->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */
+		td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */
 		return 0;
 	case IBCS2_GETDTABLESIZE:
 		uap->cmd = IBCS2_SC_OPEN_MAX;
-		return ibcs2_sysconf(p, (struct ibcs2_sysconf_args *)uap);
+		return ibcs2_sysconf(td, (struct ibcs2_sysconf_args *)uap);
 	default:
 		return ENOSYS;
 	}
@@ -137,13 +137,13 @@ ibcs2_ulimit(p, uap)
 #define IBCS2_WSTOPPED       0177
 #define IBCS2_STOPCODE(sig)  ((sig) << 8 | IBCS2_WSTOPPED)
 int
-ibcs2_wait(p, uap)
-	struct proc *p;
+ibcs2_wait(td, uap)
+	struct thread *td;
 	struct ibcs2_wait_args *uap;
 {
 	int error, status;
 	struct wait_args w4;
-        struct trapframe *tf = p->p_frame;
+        struct trapframe *tf = td->td_frame;
 	
 	SCARG(&w4, rusage) = NULL;
         if ((tf->tf_eflags & (PSL_Z|PSL_PF|PSL_N|PSL_V))
@@ -158,7 +158,7 @@ ibcs2_wait(p, uap)
 		SCARG(&w4, status) = (int *)SCARG(uap, a1);
 		SCARG(&w4, options) = 0;
 	}
-	if ((error = wait4(p, &w4)) != 0)
+	if ((error = wait4(td, &w4)) != 0)
 		return error;
 	if (SCARG(&w4, status))	{	/* this is real iBCS brain-damage */
 		error = copyin((caddr_t)SCARG(&w4, status), (caddr_t)&status,
@@ -175,7 +175,7 @@ ibcs2_wait(p, uap)
 		/* else exit status -- identical */
 
 		/* record result/status */
-		p->p_retval[1] = status;
+		td->td_retval[1] = status;
 		return copyout((caddr_t)&status, (caddr_t)SCARG(&w4, status),
 			       sizeof(SCARG(&w4, status)));
 	}
@@ -184,45 +184,45 @@ ibcs2_wait(p, uap)
 }
 
 int
-ibcs2_execv(p, uap)
-	struct proc *p;
+ibcs2_execv(td, uap)
+	struct thread *td;
 	struct ibcs2_execv_args *uap;
 {
 	struct execve_args ea;
 	caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+        CHECKALTEXIST(td, &sg, SCARG(uap, path));
 	SCARG(&ea, fname) = SCARG(uap, path);
 	SCARG(&ea, argv) = SCARG(uap, argp);
 	SCARG(&ea, envv) = NULL;
-	return execve(p, &ea);
+	return execve(td, &ea);
 }
 
 int
-ibcs2_execve(p, uap) 
-        struct proc *p;
+ibcs2_execve(td, uap) 
+        struct thread *td;
         struct ibcs2_execve_args *uap;
 {
         caddr_t sg = stackgap_init();
-        CHECKALTEXIST(p, &sg, SCARG(uap, path));
-        return execve(p, (struct execve_args *)uap);
+        CHECKALTEXIST(td, &sg, SCARG(uap, path));
+        return execve(td, (struct execve_args *)uap);
 }
 
 int
-ibcs2_umount(p, uap)
-	struct proc *p;
+ibcs2_umount(td, uap)
+	struct thread *td;
 	struct ibcs2_umount_args *uap;
 {
 	struct unmount_args um;
 
 	SCARG(&um, path) = SCARG(uap, name);
 	SCARG(&um, flags) = 0;
-	return unmount(p, &um);
+	return unmount(td, &um);
 }
 
 int
-ibcs2_mount(p, uap)
-	struct proc *p;
+ibcs2_mount(td, uap)
+	struct thread *td;
 	struct ibcs2_mount_args *uap;
 {
 #ifdef notyet
@@ -279,7 +279,7 @@ ibcs2_mount(p, uap)
 		if (error = copyout(&na, SCARG(uap, data), sizeof na))
 			return (error);
 	}
-	return (mount(p, uap));
+	return (mount(td, uap));
 #else
 	return EINVAL;
 #endif
@@ -294,8 +294,8 @@ ibcs2_mount(p, uap)
  */
 
 int
-ibcs2_getdents(p, uap)
-	struct proc *p;
+ibcs2_getdents(td, uap)
+	struct thread *td;
 	register struct ibcs2_getdents_args *uap;
 {
 	register struct vnode *vp;
@@ -314,7 +314,7 @@ ibcs2_getdents(p, uap)
 #define	BSD_DIRENT(cp)		((struct dirent *)(cp))
 #define	IBCS2_RECLEN(reclen)	(reclen + sizeof(u_short))
 
-	if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
 		return (error);
 	if ((fp->f_flag & FREAD) == 0)
 		return (EBADF);
@@ -327,7 +327,7 @@ ibcs2_getdents(p, uap)
 	buflen = max(DIRBLKSIZ, SCARG(uap, nbytes));
 	buflen = min(buflen, MAXBSIZE);
 	buf = malloc(buflen, M_TEMP, M_WAITOK);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 again:
 	aiov.iov_base = buf;
 	aiov.iov_len = buflen;
@@ -335,7 +335,7 @@ again:
 	auio.uio_iovcnt = 1;
 	auio.uio_rw = UIO_READ;
 	auio.uio_segflg = UIO_SYSSPACE;
-	auio.uio_procp = p;
+	auio.uio_td = td;
 	auio.uio_resid = buflen;
 	auio.uio_offset = off;
 
@@ -425,18 +425,18 @@ again:
 		goto again;
 	fp->f_offset = off;		/* update the vnode offset */
 eof:
-	p->p_retval[0] = SCARG(uap, nbytes) - resid;
+	td->td_retval[0] = SCARG(uap, nbytes) - resid;
 out:
 	if (cookies)
 		free(cookies, M_TEMP);
-	VOP_UNLOCK(vp, 0, p);
+	VOP_UNLOCK(vp, 0, td);
 	free(buf, M_TEMP);
 	return (error);
 }
 
 int
-ibcs2_read(p, uap)
-	struct proc *p;
+ibcs2_read(td, uap)
+	struct thread *td;
 	struct ibcs2_read_args *uap;
 {
 	register struct vnode *vp;
@@ -456,9 +456,9 @@ ibcs2_read(p, uap)
 	u_long *cookies = NULL, *cookiep;
 	int ncookies;
 
-	if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) {
+	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) {
 		if (error == EINVAL)
-			return read(p, (struct read_args *)uap);
+			return read(td, (struct read_args *)uap);
 		else
 			return error;
 	}
@@ -466,7 +466,7 @@ ibcs2_read(p, uap)
 		return (EBADF);
 	vp = (struct vnode *)fp->f_data;
 	if (vp->v_type != VDIR)
-		return read(p, (struct read_args *)uap);
+		return read(td, (struct read_args *)uap);
 
 	DPRINTF(("ibcs2_read: read directory\n"));
 
@@ -474,7 +474,7 @@ ibcs2_read(p, uap)
 	buflen = max(DIRBLKSIZ, SCARG(uap, nbytes));
 	buflen = min(buflen, MAXBSIZE);
 	buf = malloc(buflen, M_TEMP, M_WAITOK);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 again:
 	aiov.iov_base = buf;
 	aiov.iov_len = buflen;
@@ -482,7 +482,7 @@ again:
 	auio.uio_iovcnt = 1;
 	auio.uio_rw = UIO_READ;
 	auio.uio_segflg = UIO_SYSSPACE;
-	auio.uio_procp = p;
+	auio.uio_td = td;
 	auio.uio_resid = buflen;
 	auio.uio_offset = off;
 
@@ -576,40 +576,40 @@ again:
 		goto again;
 	fp->f_offset = off;		/* update the vnode offset */
 eof:
-	p->p_retval[0] = SCARG(uap, nbytes) - resid;
+	td->td_retval[0] = SCARG(uap, nbytes) - resid;
 out:
 	if (cookies)
 		free(cookies, M_TEMP);
-	VOP_UNLOCK(vp, 0, p);
+	VOP_UNLOCK(vp, 0, td);
 	free(buf, M_TEMP);
 	return (error);
 }
 
 int
-ibcs2_mknod(p, uap)
-	struct proc *p;
+ibcs2_mknod(td, uap)
+	struct thread *td;
 	struct ibcs2_mknod_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-        CHECKALTCREAT(p, &sg, SCARG(uap, path));
+        CHECKALTCREAT(td, &sg, SCARG(uap, path));
 	if (S_ISFIFO(SCARG(uap, mode))) {
                 struct mkfifo_args ap;
                 SCARG(&ap, path) = SCARG(uap, path);
                 SCARG(&ap, mode) = SCARG(uap, mode);
-		return mkfifo(p, &ap);
+		return mkfifo(td, &ap);
 	} else {
                 struct mknod_args ap;
                 SCARG(&ap, path) = SCARG(uap, path);
                 SCARG(&ap, mode) = SCARG(uap, mode);
                 SCARG(&ap, dev) = SCARG(uap, dev);
-                return mknod(p, &ap);
+                return mknod(td, &ap);
 	}
 }
 
 int
-ibcs2_getgroups(p, uap)
-	struct proc *p;
+ibcs2_getgroups(td, uap)
+	struct thread *td;
 	struct ibcs2_getgroups_args *uap;
 {
 	int error, i;
@@ -625,23 +625,23 @@ ibcs2_getgroups(p, uap)
 		iset = stackgap_alloc(&sg, SCARG(uap, gidsetsize) *
 				      sizeof(ibcs2_gid_t));
 	}
-	if ((error = getgroups(p, &sa)) != 0)
+	if ((error = getgroups(td, &sa)) != 0)
 		return error;
 	if (SCARG(uap, gidsetsize) == 0)
 		return 0;
 
-	for (i = 0, gp = SCARG(&sa, gidset); i < p->p_retval[0]; i++)
+	for (i = 0, gp = SCARG(&sa, gidset); i < td->td_retval[0]; i++)
 		iset[i] = (ibcs2_gid_t)*gp++;
-	if (p->p_retval[0] && (error = copyout((caddr_t)iset,
+	if (td->td_retval[0] && (error = copyout((caddr_t)iset,
 					  (caddr_t)SCARG(uap, gidset),
-					  sizeof(ibcs2_gid_t) * p->p_retval[0])))
+					  sizeof(ibcs2_gid_t) * td->td_retval[0])))
 		return error;
         return 0;
 }
 
 int
-ibcs2_setgroups(p, uap)
-	struct proc *p;
+ibcs2_setgroups(td, uap)
+	struct thread *td;
 	struct ibcs2_setgroups_args *uap;
 {
 	int error, i;
@@ -663,40 +663,40 @@ ibcs2_setgroups(p, uap)
 	}
 	for (i = 0, gp = SCARG(&sa, gidset); i < SCARG(&sa, gidsetsize); i++)
 		*gp++ = (gid_t)iset[i];
-	return setgroups(p, &sa);
+	return setgroups(td, &sa);
 }
 
 int
-ibcs2_setuid(p, uap)
-	struct proc *p;
+ibcs2_setuid(td, uap)
+	struct thread *td;
 	struct ibcs2_setuid_args *uap;
 {
 	struct setuid_args sa;
 
 	SCARG(&sa, uid) = (uid_t)SCARG(uap, uid);
-	return setuid(p, &sa);
+	return setuid(td, &sa);
 }
 
 int
-ibcs2_setgid(p, uap)
-	struct proc *p;
+ibcs2_setgid(td, uap)
+	struct thread *td;
 	struct ibcs2_setgid_args *uap;
 {
 	struct setgid_args sa;
 
 	SCARG(&sa, gid) = (gid_t)SCARG(uap, gid);
-	return setgid(p, &sa);
+	return setgid(td, &sa);
 }
 
 int
-ibcs2_time(p, uap)
-	struct proc *p;
+ibcs2_time(td, uap)
+	struct thread *td;
 	struct ibcs2_time_args *uap;
 {
 	struct timeval tv;
 
 	microtime(&tv);
-	p->p_retval[0] = tv.tv_sec;
+	td->td_retval[0] = tv.tv_sec;
 	if (SCARG(uap, tp))
 		return copyout((caddr_t)&tv.tv_sec, (caddr_t)SCARG(uap, tp),
 			       sizeof(ibcs2_time_t));
@@ -705,26 +705,26 @@ ibcs2_time(p, uap)
 }
 
 int
-ibcs2_pathconf(p, uap)
-	struct proc *p;
+ibcs2_pathconf(td, uap)
+	struct thread *td;
 	struct ibcs2_pathconf_args *uap;
 {
 	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
-        return pathconf(p, (struct pathconf_args *)uap);
+        return pathconf(td, (struct pathconf_args *)uap);
 }
 
 int
-ibcs2_fpathconf(p, uap)
-	struct proc *p;
+ibcs2_fpathconf(td, uap)
+	struct thread *td;
 	struct ibcs2_fpathconf_args *uap;
 {
 	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
-        return fpathconf(p, (struct fpathconf_args *)uap);
+        return fpathconf(td, (struct fpathconf_args *)uap);
 }
 
 int
-ibcs2_sysconf(p, uap)
-	struct proc *p;
+ibcs2_sysconf(td, uap)
+	struct thread *td;
 	struct ibcs2_sysconf_args *uap;
 {
 	int mib[2], value, len, error;
@@ -742,14 +742,14 @@ ibcs2_sysconf(p, uap)
 
 		SCARG(&ga, which) = RLIMIT_NPROC;
 		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
-		if ((error = getrlimit(p, &ga)) != 0)
+		if ((error = getrlimit(td, &ga)) != 0)
 			return error;
-		p->p_retval[0] = SCARG(&ga, rlp)->rlim_cur;
+		td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur;
 		return 0;
 	    }
 
 	case IBCS2_SC_CLK_TCK:
-		p->p_retval[0] = hz;
+		td->td_retval[0] = hz;
 		return 0;
 
 	case IBCS2_SC_NGROUPS_MAX:
@@ -762,9 +762,9 @@ ibcs2_sysconf(p, uap)
 
 		SCARG(&ga, which) = RLIMIT_NOFILE;
 		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
-		if ((error = getrlimit(p, &ga)) != 0)
+		if ((error = getrlimit(td, &ga)) != 0)
 			return error;
-		p->p_retval[0] = SCARG(&ga, rlp)->rlim_cur;
+		td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur;
 		return 0;
 	    }
 		
@@ -781,11 +781,11 @@ ibcs2_sysconf(p, uap)
 		break;
 		
 	case IBCS2_SC_PASS_MAX:
-		p->p_retval[0] = 128;		/* XXX - should we create PASS_MAX ? */
+		td->td_retval[0] = 128;		/* XXX - should we create PASS_MAX ? */
 		return 0;
 
 	case IBCS2_SC_XOPEN_VERSION:
-		p->p_retval[0] = 2;		/* XXX: What should that be? */
+		td->td_retval[0] = 2;		/* XXX: What should that be? */
 		return 0;
 		
 	default:
@@ -800,15 +800,15 @@ ibcs2_sysconf(p, uap)
 	SCARG(&sa, oldlenp) = &len;
 	SCARG(&sa, new) = NULL;
 	SCARG(&sa, newlen) = 0;
-	if ((error = __sysctl(p, &sa)) != 0)
+	if ((error = __sysctl(td, &sa)) != 0)
 		return error;
-	p->p_retval[0] = value;
+	td->td_retval[0] = value;
 	return 0;
 }
 
 int
-ibcs2_alarm(p, uap)
-	struct proc *p;
+ibcs2_alarm(td, uap)
+	struct thread *td;
 	struct ibcs2_alarm_args *uap;
 {
 	int error;
@@ -825,18 +825,18 @@ ibcs2_alarm(p, uap)
 	SCARG(&sa, which) = ITIMER_REAL;
 	SCARG(&sa, itv) = itp;
 	SCARG(&sa, oitv) = oitp;
-        error = setitimer(p, &sa);
+        error = setitimer(td, &sa);
 	if (error)
 		return error;
         if (oitp->it_value.tv_usec)
                 oitp->it_value.tv_sec++;
-        p->p_retval[0] = oitp->it_value.tv_sec;
+        td->td_retval[0] = oitp->it_value.tv_sec;
         return 0;
 }
 
 int
-ibcs2_times(p, uap)
-	struct proc *p;
+ibcs2_times(td, uap)
+	struct thread *td;
 	struct ibcs2_times_args *uap;
 {
 	int error;
@@ -849,29 +849,29 @@ ibcs2_times(p, uap)
 
 	SCARG(&ga, who) = RUSAGE_SELF;
 	SCARG(&ga, rusage) = ru;
-	error = getrusage(p, &ga);
+	error = getrusage(td, &ga);
 	if (error)
                 return error;
         tms.tms_utime = CONVTCK(ru->ru_utime);
         tms.tms_stime = CONVTCK(ru->ru_stime);
 
 	SCARG(&ga, who) = RUSAGE_CHILDREN;
-        error = getrusage(p, &ga);
+        error = getrusage(td, &ga);
 	if (error)
 		return error;
         tms.tms_cutime = CONVTCK(ru->ru_utime);
         tms.tms_cstime = CONVTCK(ru->ru_stime);
 
 	microtime(&t);
-        p->p_retval[0] = CONVTCK(t);
+        td->td_retval[0] = CONVTCK(t);
 	
 	return copyout((caddr_t)&tms, (caddr_t)SCARG(uap, tp),
 		       sizeof(struct tms));
 }
 
 int
-ibcs2_stime(p, uap)
-	struct proc *p;
+ibcs2_stime(td, uap)
+	struct thread *td;
 	struct ibcs2_stime_args *uap;
 {
 	int error;
@@ -884,14 +884,14 @@ ibcs2_stime(p, uap)
 			   &(SCARG(&sa, tv)->tv_sec), sizeof(long))) != 0)
 		return error;
 	SCARG(&sa, tv)->tv_usec = 0;
-	if ((error = settimeofday(p, &sa)) != 0)
+	if ((error = settimeofday(td, &sa)) != 0)
 		return EPERM;
 	return 0;
 }
 
 int
-ibcs2_utime(p, uap)
-	struct proc *p;
+ibcs2_utime(td, uap)
+	struct thread *td;
 	struct ibcs2_utime_args *uap;
 {
 	int error;
@@ -899,7 +899,7 @@ ibcs2_utime(p, uap)
 	struct timeval *tp;
 	caddr_t sg = stackgap_init();
 
-        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+        CHECKALTEXIST(td, &sg, SCARG(uap, path));
 	SCARG(&sa, path) = SCARG(uap, path);
 	if (SCARG(uap, buf)) {
 		struct ibcs2_utimbuf ubuf;
@@ -917,12 +917,12 @@ ibcs2_utime(p, uap)
 		tp->tv_usec = 0;
 	} else
 		SCARG(&sa, tptr) = NULL;
-	return utimes(p, &sa);
+	return utimes(td, &sa);
 }
 
 int
-ibcs2_nice(p, uap)
-	struct proc *p;
+ibcs2_nice(td, uap)
+	struct thread *td;
 	struct ibcs2_nice_args *uap;
 {
 	int error;
@@ -930,10 +930,10 @@ ibcs2_nice(p, uap)
 
 	SCARG(&sa, which) = PRIO_PROCESS;
 	SCARG(&sa, who) = 0;
-	SCARG(&sa, prio) = p->p_nice + SCARG(uap, incr);
-	if ((error = setpriority(p, &sa)) != 0)
+	SCARG(&sa, prio) = td->td_ksegrp->kg_nice + SCARG(uap, incr);
+	if ((error = setpriority(td, &sa)) != 0)
 		return EPERM;
-	p->p_retval[0] = p->p_nice;
+	td->td_retval[0] = td->td_ksegrp->kg_nice;
 	return 0;
 }
 
@@ -942,14 +942,15 @@ ibcs2_nice(p, uap)
  */
 
 int
-ibcs2_pgrpsys(p, uap)
-	struct proc *p;
+ibcs2_pgrpsys(td, uap)
+	struct thread *td;
 	struct ibcs2_pgrpsys_args *uap;
 {
+	struct proc *p = td->td_proc;
 	switch (SCARG(uap, type)) {
 	case 0:			/* getpgrp */
 		PROC_LOCK(p);
-		p->p_retval[0] = p->p_pgrp->pg_id;
+		td->td_retval[0] = p->p_pgrp->pg_id;
 		PROC_UNLOCK(p);
 		return 0;
 
@@ -959,9 +960,9 @@ ibcs2_pgrpsys(p, uap)
 
 		SCARG(&sa, pid) = 0;
 		SCARG(&sa, pgid) = 0;
-		setpgid(p, &sa);
+		setpgid(td, &sa);
 		PROC_LOCK(p);
-		p->p_retval[0] = p->p_pgrp->pg_id;
+		td->td_retval[0] = p->p_pgrp->pg_id;
 		PROC_UNLOCK(p);
 		return 0;
 	    }
@@ -972,11 +973,11 @@ ibcs2_pgrpsys(p, uap)
 
 		SCARG(&sa, pid) = SCARG(uap, pid);
 		SCARG(&sa, pgid) = SCARG(uap, pgid);
-		return setpgid(p, &sa);
+		return setpgid(td, &sa);
 	    }
 
 	case 3:			/* setsid */
-		return setsid(p, NULL);
+		return setsid(td, NULL);
 
 	default:
 		return EINVAL;
@@ -988,8 +989,8 @@ ibcs2_pgrpsys(p, uap)
  */
 
 int
-ibcs2_plock(p, uap)
-	struct proc *p;
+ibcs2_plock(td, uap)
+	struct thread *td;
 	struct ibcs2_plock_args *uap;
 {
 	int error;
@@ -999,7 +1000,7 @@ ibcs2_plock(p, uap)
 #define IBCS2_DATALOCK	4
 
 	
-        if ((error = suser(p)) != 0)
+        if ((error = suser_td(td)) != 0)
                 return EPERM;
 	switch(SCARG(uap, cmd)) {
 	case IBCS2_UNLOCK:
@@ -1012,8 +1013,8 @@ ibcs2_plock(p, uap)
 }
 
 int
-ibcs2_uadmin(p, uap)
-	struct proc *p;
+ibcs2_uadmin(td, uap)
+	struct thread *td;
 	struct ibcs2_uadmin_args *uap;
 {
 #define SCO_A_REBOOT        1
@@ -1034,7 +1035,7 @@ ibcs2_uadmin(p, uap)
 #define SCO_AD_GETBMAJ      0
 #define SCO_AD_GETCMAJ      1
 
-        if (suser(p))
+        if (suser_td(td))
                 return EPERM;
 
 	switch(SCARG(uap, cmd)) {
@@ -1046,11 +1047,11 @@ ibcs2_uadmin(p, uap)
 		case SCO_AD_PWRDOWN:
 		case SCO_AD_PWRNAP:
 			r.opt = RB_HALT;
-			reboot(p, &r);
+			reboot(td, &r);
 		case SCO_AD_BOOT:
 		case SCO_AD_IBOOT:
 			r.opt = RB_AUTOBOOT;
-			reboot(p, &r);
+			reboot(td, &r);
 		}
 		return EINVAL;
 	case SCO_A_REMOUNT:
@@ -1064,8 +1065,8 @@ ibcs2_uadmin(p, uap)
 }
 
 int
-ibcs2_sysfs(p, uap)
-	struct proc *p;
+ibcs2_sysfs(td, uap)
+	struct thread *td;
 	struct ibcs2_sysfs_args *uap;
 {
 #define IBCS2_GETFSIND        1
@@ -1082,102 +1083,102 @@ ibcs2_sysfs(p, uap)
 }
 
 int
-ibcs2_unlink(p, uap)
-	struct proc *p;
+ibcs2_unlink(td, uap)
+	struct thread *td;
 	struct ibcs2_unlink_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return unlink(p, (struct unlink_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return unlink(td, (struct unlink_args *)uap);
 }
 
 int
-ibcs2_chdir(p, uap)
-	struct proc *p;
+ibcs2_chdir(td, uap)
+	struct thread *td;
 	struct ibcs2_chdir_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return chdir(p, (struct chdir_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return chdir(td, (struct chdir_args *)uap);
 }
 
 int
-ibcs2_chmod(p, uap)
-	struct proc *p;
+ibcs2_chmod(td, uap)
+	struct thread *td;
 	struct ibcs2_chmod_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return chmod(p, (struct chmod_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return chmod(td, (struct chmod_args *)uap);
 }
 
 int
-ibcs2_chown(p, uap)
-	struct proc *p;
+ibcs2_chown(td, uap)
+	struct thread *td;
 	struct ibcs2_chown_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return chown(p, (struct chown_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return chown(td, (struct chown_args *)uap);
 }
 
 int
-ibcs2_rmdir(p, uap)
-	struct proc *p;
+ibcs2_rmdir(td, uap)
+	struct thread *td;
 	struct ibcs2_rmdir_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return rmdir(p, (struct rmdir_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return rmdir(td, (struct rmdir_args *)uap);
 }
 
 int
-ibcs2_mkdir(p, uap)
-	struct proc *p;
+ibcs2_mkdir(td, uap)
+	struct thread *td;
 	struct ibcs2_mkdir_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTCREAT(p, &sg, SCARG(uap, path));
-	return mkdir(p, (struct mkdir_args *)uap);
+	CHECKALTCREAT(td, &sg, SCARG(uap, path));
+	return mkdir(td, (struct mkdir_args *)uap);
 }
 
 int
-ibcs2_symlink(p, uap)
-	struct proc *p;
+ibcs2_symlink(td, uap)
+	struct thread *td;
 	struct ibcs2_symlink_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	CHECKALTCREAT(p, &sg, SCARG(uap, link));
-	return symlink(p, (struct symlink_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	CHECKALTCREAT(td, &sg, SCARG(uap, link));
+	return symlink(td, (struct symlink_args *)uap);
 }
 
 int
-ibcs2_rename(p, uap)
-	struct proc *p;
+ibcs2_rename(td, uap)
+	struct thread *td;
 	struct ibcs2_rename_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, from));
-	CHECKALTCREAT(p, &sg, SCARG(uap, to));
-	return rename(p, (struct rename_args *)uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, from));
+	CHECKALTCREAT(td, &sg, SCARG(uap, to));
+	return rename(td, (struct rename_args *)uap);
 }
 
 int
-ibcs2_readlink(p, uap)
-	struct proc *p;
+ibcs2_readlink(td, uap)
+	struct thread *td;
 	struct ibcs2_readlink_args *uap;
 {
         caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	return readlink(p, (struct readlink_args *) uap);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	return readlink(td, (struct readlink_args *) uap);
 }
diff --git a/sys/i386/ibcs2/ibcs2_msg.c b/sys/i386/ibcs2/ibcs2_msg.c
index 6c36cf8..413859a 100644
--- a/sys/i386/ibcs2/ibcs2_msg.c
+++ b/sys/i386/ibcs2/ibcs2_msg.c
@@ -41,16 +41,16 @@
 
 
 int
-ibcs2_getmsg(p, uap)
-	struct proc *p;
+ibcs2_getmsg(td, uap)
+	struct thread *td;
 	struct ibcs2_getmsg_args *uap;
 {
 	return 0; /* fake */
 }
 
 int
-ibcs2_putmsg(p, uap)
-	struct proc *p;
+ibcs2_putmsg(td, uap)
+	struct thread *td;
 	struct ibcs2_putmsg_args *uap;
 {
 	return 0; /* fake */
@@ -58,8 +58,8 @@ ibcs2_putmsg(p, uap)
 
 
 int
-ibcs2_poll(p, uap)
-	struct proc *p;
+ibcs2_poll(td, uap)
+	struct thread *td;
 	struct ibcs2_poll_args *uap;
 {
 	int error, i;
@@ -107,12 +107,12 @@ ibcs2_poll(p, uap)
 			FD_SET(conv.fd, writefds);
 		FD_SET(conv.fd, exceptfds);
 	}
-	if ((error = select(p, &tmp_select)) != 0)
+	if ((error = select(td, &tmp_select)) != 0)
 		return error;
-	if (p->p_retval[0] == 0)
+	if (td->td_retval[0] == 0)
 		return 0;
-	p->p_retval[0] = 0;
-	for (p->p_retval[0] = 0, i = 0; i < uap->nfds; i++) {
+	td->td_retval[0] = 0;
+	for (td->td_retval[0] = 0, i = 0; i < uap->nfds; i++) {
 		copyin(uap->fds + i*sizeof(struct ibcs2_poll),
 		       &conv, sizeof(conv));
 		conv.revents = 0;
@@ -127,7 +127,7 @@ ibcs2_poll(p, uap)
 			if (FD_ISSET(conv.fd, exceptfds))
 				conv.revents |= IBCS2_POLLERR;
 			if (conv.revents)
-				++p->p_retval[0];
+				++td->td_retval[0];
 		}
 		if ((error = copyout(&conv,
 				    uap->fds + i*sizeof(struct ibcs2_poll),
diff --git a/sys/i386/ibcs2/ibcs2_other.c b/sys/i386/ibcs2/ibcs2_other.c
index 4f90159..2881f42 100644
--- a/sys/i386/ibcs2/ibcs2_other.c
+++ b/sys/i386/ibcs2/ibcs2_other.c
@@ -45,14 +45,14 @@
 #define IBCS2_SECURE_SETLUID 2
 
 int
-ibcs2_secure(struct proc *p, struct ibcs2_secure_args *uap)
+ibcs2_secure(struct thread *td, struct ibcs2_secure_args *uap)
 {
 	switch (uap->cmd) {
 
 	case IBCS2_SECURE_GETLUID:		/* get login uid */
-		PROC_LOCK(p);
-		p->p_retval[0] = p->p_ucred->cr_uid;
-		PROC_UNLOCK(p);
+		PROC_LOCK(td->td_proc);
+		td->td_retval[0] = td->td_proc->p_ucred->cr_uid;
+		PROC_UNLOCK(td->td_proc);
 		return 0;
 
 	case IBCS2_SECURE_SETLUID:		/* set login uid */
@@ -66,7 +66,7 @@ ibcs2_secure(struct proc *p, struct ibcs2_secure_args *uap)
 }
 
 int
-ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap)
+ibcs2_lseek(struct thread *td, register struct ibcs2_lseek_args *uap)
 {
 	struct lseek_args largs;
 	int error;
@@ -74,7 +74,7 @@ ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap)
 	largs.fd = uap->fd;
 	largs.offset = uap->offset;
 	largs.whence = uap->whence;
-	error = lseek(p, &largs);
+	error = lseek(td, &largs);
 	return (error);
 }
 
@@ -83,7 +83,7 @@ ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap)
 #include <sys/un.h>     
 
 int
-spx_open(struct proc *p, void *uap)
+spx_open(struct thread *td, void *uap)
 {
 	struct socket_args sock;
 	struct connect_args conn;
@@ -96,7 +96,7 @@ spx_open(struct proc *p, void *uap)
 	sock.domain = AF_UNIX;
 	sock.type = SOCK_STREAM;
 	sock.protocol = 0;
-	error = socket(p, &sock);
+	error = socket(td, &sock);
 	if (error)
 		return error;
 
@@ -108,17 +108,17 @@ spx_open(struct proc *p, void *uap)
 	  strlen(Xaddr->sun_path) + 1;
 	copyout("/tmp/.X11-unix/X0", Xaddr->sun_path, 18);
 
-	conn.s = fd = p->p_retval[0];
+	conn.s = fd = td->td_retval[0];
 	conn.name = (caddr_t)Xaddr;
 	conn.namelen = sizeof(struct sockaddr_un);
-	error = connect(p, &conn);
+	error = connect(td, &conn);
 	if (error) {
 		struct close_args cl;
 		cl.fd = fd;
-		close(p, &cl);
+		close(td, &cl);
 		return error;
 	}
-	p->p_retval[0] = fd;
+	td->td_retval[0] = fd;
 	return 0;
 }
 #endif /* SPX_HACK */
diff --git a/sys/i386/ibcs2/ibcs2_proto.h b/sys/i386/ibcs2/ibcs2_proto.h
index a91c96d..c7ac3df 100644
--- a/sys/i386/ibcs2/ibcs2_proto.h
+++ b/sys/i386/ibcs2/ibcs2_proto.h
@@ -15,6 +15,8 @@
 
 struct proc;
 
+struct thread;
+
 #define	PAD_(t)	(sizeof(register_t) <= sizeof(t) ? \
 		0 : sizeof(register_t) - sizeof(t))
 
@@ -273,62 +275,62 @@ struct	ibcs2_readlink_args {
 struct	ibcs2_isc_args {
 	register_t dummy;
 };
-int	ibcs2_read __P((struct proc *, struct ibcs2_read_args *));
-int	ibcs2_open __P((struct proc *, struct ibcs2_open_args *));
-int	ibcs2_wait __P((struct proc *, struct ibcs2_wait_args *));
-int	ibcs2_creat __P((struct proc *, struct ibcs2_creat_args *));
-int	ibcs2_unlink __P((struct proc *, struct ibcs2_unlink_args *));
-int	ibcs2_execv __P((struct proc *, struct ibcs2_execv_args *));
-int	ibcs2_chdir __P((struct proc *, struct ibcs2_chdir_args *));
-int	ibcs2_time __P((struct proc *, struct ibcs2_time_args *));
-int	ibcs2_mknod __P((struct proc *, struct ibcs2_mknod_args *));
-int	ibcs2_chmod __P((struct proc *, struct ibcs2_chmod_args *));
-int	ibcs2_chown __P((struct proc *, struct ibcs2_chown_args *));
-int	ibcs2_stat __P((struct proc *, struct ibcs2_stat_args *));
-int	ibcs2_lseek __P((struct proc *, struct ibcs2_lseek_args *));
-int	ibcs2_mount __P((struct proc *, struct ibcs2_mount_args *));
-int	ibcs2_umount __P((struct proc *, struct ibcs2_umount_args *));
-int	ibcs2_setuid __P((struct proc *, struct ibcs2_setuid_args *));
-int	ibcs2_stime __P((struct proc *, struct ibcs2_stime_args *));
-int	ibcs2_alarm __P((struct proc *, struct ibcs2_alarm_args *));
-int	ibcs2_fstat __P((struct proc *, struct ibcs2_fstat_args *));
-int	ibcs2_pause __P((struct proc *, struct ibcs2_pause_args *));
-int	ibcs2_utime __P((struct proc *, struct ibcs2_utime_args *));
-int	ibcs2_stty __P((struct proc *, struct ibcs2_stty_args *));
-int	ibcs2_gtty __P((struct proc *, struct ibcs2_gtty_args *));
-int	ibcs2_access __P((struct proc *, struct ibcs2_access_args *));
-int	ibcs2_nice __P((struct proc *, struct ibcs2_nice_args *));
-int	ibcs2_statfs __P((struct proc *, struct ibcs2_statfs_args *));
-int	ibcs2_kill __P((struct proc *, struct ibcs2_kill_args *));
-int	ibcs2_fstatfs __P((struct proc *, struct ibcs2_fstatfs_args *));
-int	ibcs2_pgrpsys __P((struct proc *, struct ibcs2_pgrpsys_args *));
-int	ibcs2_xenix __P((struct proc *, struct ibcs2_xenix_args *));
-int	ibcs2_times __P((struct proc *, struct ibcs2_times_args *));
-int	ibcs2_plock __P((struct proc *, struct ibcs2_plock_args *));
-int	ibcs2_setgid __P((struct proc *, struct ibcs2_setgid_args *));
-int	ibcs2_sigsys __P((struct proc *, struct ibcs2_sigsys_args *));
-int	ibcs2_msgsys __P((struct proc *, struct ibcs2_msgsys_args *));
-int	ibcs2_sysi86 __P((struct proc *, struct ibcs2_sysi86_args *));
-int	ibcs2_shmsys __P((struct proc *, struct ibcs2_shmsys_args *));
-int	ibcs2_semsys __P((struct proc *, struct ibcs2_semsys_args *));
-int	ibcs2_ioctl __P((struct proc *, struct ibcs2_ioctl_args *));
-int	ibcs2_uadmin __P((struct proc *, struct ibcs2_uadmin_args *));
-int	ibcs2_utssys __P((struct proc *, struct ibcs2_utssys_args *));
-int	ibcs2_execve __P((struct proc *, struct ibcs2_execve_args *));
-int	ibcs2_fcntl __P((struct proc *, struct ibcs2_fcntl_args *));
-int	ibcs2_ulimit __P((struct proc *, struct ibcs2_ulimit_args *));
-int	ibcs2_rmdir __P((struct proc *, struct ibcs2_rmdir_args *));
-int	ibcs2_mkdir __P((struct proc *, struct ibcs2_mkdir_args *));
-int	ibcs2_getdents __P((struct proc *, struct ibcs2_getdents_args *));
-int	ibcs2_sysfs __P((struct proc *, struct ibcs2_sysfs_args *));
-int	ibcs2_getmsg __P((struct proc *, struct ibcs2_getmsg_args *));
-int	ibcs2_putmsg __P((struct proc *, struct ibcs2_putmsg_args *));
-int	ibcs2_poll __P((struct proc *, struct ibcs2_poll_args *));
-int	ibcs2_secure __P((struct proc *, struct ibcs2_secure_args *));
-int	ibcs2_symlink __P((struct proc *, struct ibcs2_symlink_args *));
-int	ibcs2_lstat __P((struct proc *, struct ibcs2_lstat_args *));
-int	ibcs2_readlink __P((struct proc *, struct ibcs2_readlink_args *));
-int	ibcs2_isc __P((struct proc *, struct ibcs2_isc_args *));
+int	ibcs2_read __P((struct thread *, struct ibcs2_read_args *));
+int	ibcs2_open __P((struct thread *, struct ibcs2_open_args *));
+int	ibcs2_wait __P((struct thread *, struct ibcs2_wait_args *));
+int	ibcs2_creat __P((struct thread *, struct ibcs2_creat_args *));
+int	ibcs2_unlink __P((struct thread *, struct ibcs2_unlink_args *));
+int	ibcs2_execv __P((struct thread *, struct ibcs2_execv_args *));
+int	ibcs2_chdir __P((struct thread *, struct ibcs2_chdir_args *));
+int	ibcs2_time __P((struct thread *, struct ibcs2_time_args *));
+int	ibcs2_mknod __P((struct thread *, struct ibcs2_mknod_args *));
+int	ibcs2_chmod __P((struct thread *, struct ibcs2_chmod_args *));
+int	ibcs2_chown __P((struct thread *, struct ibcs2_chown_args *));
+int	ibcs2_stat __P((struct thread *, struct ibcs2_stat_args *));
+int	ibcs2_lseek __P((struct thread *, struct ibcs2_lseek_args *));
+int	ibcs2_mount __P((struct thread *, struct ibcs2_mount_args *));
+int	ibcs2_umount __P((struct thread *, struct ibcs2_umount_args *));
+int	ibcs2_setuid __P((struct thread *, struct ibcs2_setuid_args *));
+int	ibcs2_stime __P((struct thread *, struct ibcs2_stime_args *));
+int	ibcs2_alarm __P((struct thread *, struct ibcs2_alarm_args *));
+int	ibcs2_fstat __P((struct thread *, struct ibcs2_fstat_args *));
+int	ibcs2_pause __P((struct thread *, struct ibcs2_pause_args *));
+int	ibcs2_utime __P((struct thread *, struct ibcs2_utime_args *));
+int	ibcs2_stty __P((struct thread *, struct ibcs2_stty_args *));
+int	ibcs2_gtty __P((struct thread *, struct ibcs2_gtty_args *));
+int	ibcs2_access __P((struct thread *, struct ibcs2_access_args *));
+int	ibcs2_nice __P((struct thread *, struct ibcs2_nice_args *));
+int	ibcs2_statfs __P((struct thread *, struct ibcs2_statfs_args *));
+int	ibcs2_kill __P((struct thread *, struct ibcs2_kill_args *));
+int	ibcs2_fstatfs __P((struct thread *, struct ibcs2_fstatfs_args *));
+int	ibcs2_pgrpsys __P((struct thread *, struct ibcs2_pgrpsys_args *));
+int	ibcs2_xenix __P((struct thread *, struct ibcs2_xenix_args *));
+int	ibcs2_times __P((struct thread *, struct ibcs2_times_args *));
+int	ibcs2_plock __P((struct thread *, struct ibcs2_plock_args *));
+int	ibcs2_setgid __P((struct thread *, struct ibcs2_setgid_args *));
+int	ibcs2_sigsys __P((struct thread *, struct ibcs2_sigsys_args *));
+int	ibcs2_msgsys __P((struct thread *, struct ibcs2_msgsys_args *));
+int	ibcs2_sysi86 __P((struct thread *, struct ibcs2_sysi86_args *));
+int	ibcs2_shmsys __P((struct thread *, struct ibcs2_shmsys_args *));
+int	ibcs2_semsys __P((struct thread *, struct ibcs2_semsys_args *));
+int	ibcs2_ioctl __P((struct thread *, struct ibcs2_ioctl_args *));
+int	ibcs2_uadmin __P((struct thread *, struct ibcs2_uadmin_args *));
+int	ibcs2_utssys __P((struct thread *, struct ibcs2_utssys_args *));
+int	ibcs2_execve __P((struct thread *, struct ibcs2_execve_args *));
+int	ibcs2_fcntl __P((struct thread *, struct ibcs2_fcntl_args *));
+int	ibcs2_ulimit __P((struct thread *, struct ibcs2_ulimit_args *));
+int	ibcs2_rmdir __P((struct thread *, struct ibcs2_rmdir_args *));
+int	ibcs2_mkdir __P((struct thread *, struct ibcs2_mkdir_args *));
+int	ibcs2_getdents __P((struct thread *, struct ibcs2_getdents_args *));
+int	ibcs2_sysfs __P((struct thread *, struct ibcs2_sysfs_args *));
+int	ibcs2_getmsg __P((struct thread *, struct ibcs2_getmsg_args *));
+int	ibcs2_putmsg __P((struct thread *, struct ibcs2_putmsg_args *));
+int	ibcs2_poll __P((struct thread *, struct ibcs2_poll_args *));
+int	ibcs2_secure __P((struct thread *, struct ibcs2_secure_args *));
+int	ibcs2_symlink __P((struct thread *, struct ibcs2_symlink_args *));
+int	ibcs2_lstat __P((struct thread *, struct ibcs2_lstat_args *));
+int	ibcs2_readlink __P((struct thread *, struct ibcs2_readlink_args *));
+int	ibcs2_isc __P((struct thread *, struct ibcs2_isc_args *));
 
 #ifdef COMPAT_43
 
diff --git a/sys/i386/ibcs2/ibcs2_signal.c b/sys/i386/ibcs2/ibcs2_signal.c
index 6049142..197c295 100644
--- a/sys/i386/ibcs2/ibcs2_signal.c
+++ b/sys/i386/ibcs2/ibcs2_signal.c
@@ -188,8 +188,8 @@ bsd_to_ibcs2_sigaction(bsa, isa)
 }
 
 int
-ibcs2_sigaction(p, uap)
-	register struct proc *p;
+ibcs2_sigaction(td, uap)
+	register struct thread *td;
 	struct ibcs2_sigaction_args *uap;
 {
 	struct ibcs2_sigaction *nisa, *oisa, tmpisa;
@@ -221,7 +221,7 @@ ibcs2_sigaction(p, uap)
 	SCARG(&sa, act) = nbsa;
 	SCARG(&sa, oact) = obsa;
 
-	if ((error = sigaction(p, &sa)) != 0)
+	if ((error = sigaction(td, &sa)) != 0)
 		return error;
 
 	if (oisa != NULL) {
@@ -236,10 +236,11 @@ ibcs2_sigaction(p, uap)
 }
 
 int
-ibcs2_sigsys(p, uap)
-	register struct proc *p;
+ibcs2_sigsys(td, uap)
+	register struct thread *td;
 	struct ibcs2_sigsys_args *uap;
 {
+	struct proc *p = td->td_proc;
 	struct sigaction sa;
 	int signum = ibcs2_to_bsd_sig[_SIG_IDX(IBCS2_SIGNO(SCARG(uap, sig)))];
 	int error;
@@ -248,7 +249,7 @@ ibcs2_sigsys(p, uap)
 	if (signum <= 0 || signum >= IBCS2_NSIG) {
 		if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK ||
 		    IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
-			p->p_retval[0] = (int)IBCS2_SIG_ERR;
+			td->td_retval[0] = (int)IBCS2_SIG_ERR;
 		return EINVAL;
 	}
 	
@@ -275,7 +276,7 @@ ibcs2_sigsys(p, uap)
 			SCARG(&sa, how) = SIG_BLOCK;
 			SCARG(&sa, set) = &mask;
 			SCARG(&sa, oset) = NULL;
-			return sigprocmask(p, &sa);
+			return sigprocmask(td, &sa);
 		}
 		
 	case IBCS2_SIGNAL_MASK:
@@ -305,19 +306,19 @@ ibcs2_sigsys(p, uap)
 			if (signum != SIGALRM)
 				sa.sa_flags |= SA_RESTART;
 #endif
-			p->p_retval[0] = (int)IBCS2_SIG_ERR; /* init error return */
+			td->td_retval[0] = (int)IBCS2_SIG_ERR; /* init error return */
 
 			/* perform native sigaction() */
 			if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
 				return error;
-			if ((error = sigaction(p, &sa_args)) != 0) {
+			if ((error = sigaction(td, &sa_args)) != 0) {
 				DPRINTF(("signal: sigaction failed: %d\n",
 					 error));
 				return error;
 			}
 			if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
 				return error;
-			p->p_retval[0] = (int)sa.sa_handler;
+			td->td_retval[0] = (int)sa.sa_handler;
 
 			/* special sigset() check */
                         if(IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK) {
@@ -325,7 +326,7 @@ ibcs2_sigsys(p, uap)
 			        /* check to make sure signal is not blocked */
                                 if(sigismember(&p->p_sigmask, signum)) {
 				        /* return SIG_HOLD and unblock signal*/
-                                        p->p_retval[0] = (int)IBCS2_SIG_HOLD;
+                                        td->td_retval[0] = (int)IBCS2_SIG_HOLD;
 					SIGDELSET(p->p_sigmask, signum);
 				}
 				PROC_UNLOCK(p);
@@ -344,7 +345,7 @@ ibcs2_sigsys(p, uap)
 			SCARG(&sa, how) = SIG_UNBLOCK;
 			SCARG(&sa, set) = &mask;
 			SCARG(&sa, oset) = NULL;
-			return sigprocmask(p, &sa);
+			return sigprocmask(td, &sa);
 		}
 		
 	case IBCS2_SIGIGNORE_MASK:
@@ -362,7 +363,7 @@ ibcs2_sigsys(p, uap)
 			sa.sa_flags = 0;
 			if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
 				return error;
-			if ((error = sigaction(p, &sa_args)) != 0) {
+			if ((error = sigaction(td, &sa_args)) != 0) {
 				DPRINTF(("sigignore: sigaction failed\n"));
 				return error;
 			}
@@ -379,7 +380,7 @@ ibcs2_sigsys(p, uap)
 			PROC_UNLOCK(p);
 			SIGDELSET(mask, signum);
 			SCARG(&sa, sigmask) = &mask;
-			return sigsuspend(p, &sa);
+			return sigsuspend(td, &sa);
 		}
 		
 	default:
@@ -388,10 +389,11 @@ ibcs2_sigsys(p, uap)
 }
 
 int
-ibcs2_sigprocmask(p, uap)
-	register struct proc *p;
+ibcs2_sigprocmask(td, uap)
+	register struct thread *td;
 	struct ibcs2_sigprocmask_args *uap;
 {
+	struct proc *p = td->td_proc;
 	ibcs2_sigset_t iss;
 	sigset_t bss;
 	int error = 0;
@@ -442,10 +444,11 @@ ibcs2_sigprocmask(p, uap)
 }
 
 int
-ibcs2_sigpending(p, uap)
-	register struct proc *p;
+ibcs2_sigpending(td, uap)
+	register struct thread *td;
 	struct ibcs2_sigpending_args *uap;
 {
+	struct proc *p = td->td_proc;
 	sigset_t bss;
 	ibcs2_sigset_t iss;
 
@@ -459,8 +462,8 @@ ibcs2_sigpending(p, uap)
 }
 
 int
-ibcs2_sigsuspend(p, uap)
-	register struct proc *p;
+ibcs2_sigsuspend(td, uap)
+	register struct thread *td;
 	struct ibcs2_sigsuspend_args *uap;
 {
 	ibcs2_sigset_t sss;
@@ -473,32 +476,33 @@ ibcs2_sigsuspend(p, uap)
 
 	ibcs2_to_bsd_sigset(&sss, &bss);
 	SCARG(&sa, sigmask) = &bss;
-	return sigsuspend(p, &sa);
+	return sigsuspend(td, &sa);
 }
 
 int
-ibcs2_pause(p, uap)
-	register struct proc *p;
+ibcs2_pause(td, uap)
+	register struct thread *td;
 	struct ibcs2_pause_args *uap;
 {
+	struct proc *p = td->td_proc;
 	sigset_t mask;
 	struct sigsuspend_args sa;
 
 	PROC_LOCK(p);
-	mask = p->p_sigmask;
+	mask = td->td_proc->p_sigmask;
 	PROC_UNLOCK(p);
 	SCARG(&sa, sigmask) = &mask;
-	return sigsuspend(p, &sa);
+	return sigsuspend(td, &sa);
 }
 
 int
-ibcs2_kill(p, uap)
-	register struct proc *p;
+ibcs2_kill(td, uap)
+	register struct thread *td;
 	struct ibcs2_kill_args *uap;
 {
 	struct kill_args ka;
 
 	SCARG(&ka, pid) = SCARG(uap, pid);
 	SCARG(&ka, signum) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, signo))];
-	return kill(p, &ka);
+	return kill(td, &ka);
 }
diff --git a/sys/i386/ibcs2/ibcs2_socksys.c b/sys/i386/ibcs2/ibcs2_socksys.c
index 16d964e..533b5c9 100644
--- a/sys/i386/ibcs2/ibcs2_socksys.c
+++ b/sys/i386/ibcs2/ibcs2_socksys.c
@@ -21,6 +21,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
  */
 
 #include <sys/param.h>
@@ -44,9 +46,9 @@ struct setipdomainname_args {
 };
 
 /* Local prototypes */
-static int ibcs2_getipdomainname __P((struct proc *,
+static int ibcs2_getipdomainname __P((struct thread *,
 				      struct getipdomainname_args *));
-static int ibcs2_setipdomainname __P((struct proc *,
+static int ibcs2_setipdomainname __P((struct thread *,
 				      struct setipdomainname_args *));
 
 /*
@@ -54,8 +56,8 @@ static int ibcs2_setipdomainname __P((struct proc *,
  */
 
 int
-ibcs2_socksys(p, uap)
-	register struct proc *p;
+ibcs2_socksys(td, uap)
+	register struct thread *td;
 	register struct ibcs2_socksys_args *uap;
 {
 	int error;
@@ -77,55 +79,55 @@ ibcs2_socksys(p, uap)
 	passargs = (void *)(realargs + 1);
 	switch (realargs[0]) {
 	case SOCKSYS_ACCEPT:
-		return accept(p, passargs);
+		return accept(td, passargs);
 	case SOCKSYS_BIND:
-		return bind(p, passargs);
+		return bind(td, passargs);
 	case SOCKSYS_CONNECT:
-		return connect(p, passargs);
+		return connect(td, passargs);
 	case SOCKSYS_GETPEERNAME:
-		return getpeername(p, passargs);
+		return getpeername(td, passargs);
 	case SOCKSYS_GETSOCKNAME:
-		return getsockname(p, passargs);
+		return getsockname(td, passargs);
 	case SOCKSYS_GETSOCKOPT:
-		return getsockopt(p, passargs);
+		return getsockopt(td, passargs);
 	case SOCKSYS_LISTEN:
-		return listen(p, passargs);
+		return listen(td, passargs);
 	case SOCKSYS_RECV:
 		realargs[5] = realargs[6] = 0;
 		/* FALLTHROUGH */
 	case SOCKSYS_RECVFROM:
-		return recvfrom(p, passargs);
+		return recvfrom(td, passargs);
 	case SOCKSYS_SEND:
 		realargs[5] = realargs[6] = 0;
 		/* FALLTHROUGH */
 	case SOCKSYS_SENDTO:
-		return sendto(p, passargs);
+		return sendto(td, passargs);
 	case SOCKSYS_SETSOCKOPT:
-		return setsockopt(p, passargs);
+		return setsockopt(td, passargs);
 	case SOCKSYS_SHUTDOWN:
-		return shutdown(p, passargs);
+		return shutdown(td, passargs);
 	case SOCKSYS_SOCKET:
-		return socket(p, passargs);
+		return socket(td, passargs);
 	case SOCKSYS_SELECT:
-		return select(p, passargs);
+		return select(td, passargs);
 	case SOCKSYS_GETIPDOMAIN:
-		return ibcs2_getipdomainname(p, passargs);
+		return ibcs2_getipdomainname(td, passargs);
 	case SOCKSYS_SETIPDOMAIN:
-		return ibcs2_setipdomainname(p, passargs);
+		return ibcs2_setipdomainname(td, passargs);
 	case SOCKSYS_ADJTIME:
-		return adjtime(p, passargs);
+		return adjtime(td, passargs);
 	case SOCKSYS_SETREUID:
-		return setreuid(p, passargs);
+		return setreuid(td, passargs);
 	case SOCKSYS_SETREGID:
-		return setregid(p, passargs);
+		return setregid(td, passargs);
 	case SOCKSYS_GETTIME:
-		return gettimeofday(p, passargs);
+		return gettimeofday(td, passargs);
 	case SOCKSYS_SETTIME:
-		return settimeofday(p, passargs);
+		return settimeofday(td, passargs);
 	case SOCKSYS_GETITIMER:
-		return getitimer(p, passargs);
+		return getitimer(td, passargs);
 	case SOCKSYS_SETITIMER:
-		return setitimer(p, passargs);
+		return setitimer(td, passargs);
 
 	default:
 		printf("socksys unknown %08x %08x %08x %08x %08x %08x %08x\n",
@@ -138,8 +140,8 @@ ibcs2_socksys(p, uap)
 
 /* ARGSUSED */
 static int
-ibcs2_getipdomainname(p, uap)
-        struct proc *p;
+ibcs2_getipdomainname(td, uap)
+        struct thread *td;
         struct getipdomainname_args *uap;
 {
 	char hname[MAXHOSTNAMELEN], *dptr;
@@ -162,14 +164,14 @@ ibcs2_getipdomainname(p, uap)
 
 /* ARGSUSED */
 static int
-ibcs2_setipdomainname(p, uap)
-        struct proc *p;
+ibcs2_setipdomainname(td, uap)
+        struct thread *td;
         struct setipdomainname_args *uap;
 {
 	char hname[MAXHOSTNAMELEN], *ptr;
 	int error, sctl[2], hlen;
 
-	if ((error = suser(p)))
+	if ((error = suser_td(td)))
 		return (error);
 
 	/* W/out a hostname a domain-name is nonsense */
@@ -200,5 +202,5 @@ ibcs2_setipdomainname(p, uap)
 	sctl[0] = CTL_KERN;
         sctl[1] = KERN_HOSTNAME;
  	hlen = strlen(hname) + 1;
-        return (kernel_sysctl(p, sctl, 2, 0, 0, hname, hlen, 0));
+        return (kernel_sysctl(td, sctl, 2, 0, 0, hname, hlen, 0));
 }
diff --git a/sys/i386/ibcs2/ibcs2_socksys.h b/sys/i386/ibcs2/ibcs2_socksys.h
index f6b212e..f0c72bd 100644
--- a/sys/i386/ibcs2/ibcs2_socksys.h
+++ b/sys/i386/ibcs2/ibcs2_socksys.h
@@ -21,6 +21,8 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
  */
 
 #ifndef	_I386_IBCS2_IBCS2_SOCKSYS_H_
@@ -121,6 +123,6 @@ struct ibcs2_socksys_args {
 	caddr_t argsp;
 };
 
-int ibcs2_socksys __P((struct proc *, struct ibcs2_socksys_args *));
+int ibcs2_socksys __P((struct thread *, struct ibcs2_socksys_args *));
 
 #endif /* !_I386_IBCS2_IBCS2_SOCKSYS_H_ */
diff --git a/sys/i386/ibcs2/ibcs2_stat.c b/sys/i386/ibcs2/ibcs2_stat.c
index 824118f..fd39853 100644
--- a/sys/i386/ibcs2/ibcs2_stat.c
+++ b/sys/i386/ibcs2/ibcs2_stat.c
@@ -95,8 +95,8 @@ cvt_statfs(sp, buf, len)
 }	
 
 int
-ibcs2_statfs(p, uap)
-	struct proc *p;
+ibcs2_statfs(td, uap)
+	struct thread *td;
 	struct ibcs2_statfs_args *uap;
 {
 	register struct mount *mp;
@@ -105,23 +105,23 @@ ibcs2_statfs(p, uap)
 	struct nameidata nd;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
-	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td);
 	if ((error = namei(&nd)) != 0)
 		return (error);
 	NDFREE(&nd, NDF_ONLY_PNBUF);
 	mp = nd.ni_vp->v_mount;
 	sp = &mp->mnt_stat;
 	vrele(nd.ni_vp);
-	if ((error = VFS_STATFS(mp, sp, p)) != 0)
+	if ((error = VFS_STATFS(mp, sp, td)) != 0)
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
 	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
 }
 
 int
-ibcs2_fstatfs(p, uap)
-	struct proc *p;
+ibcs2_fstatfs(td, uap)
+	struct thread *td;
 	struct ibcs2_fstatfs_args *uap;
 {
 	struct file *fp;
@@ -129,19 +129,19 @@ ibcs2_fstatfs(p, uap)
 	register struct statfs *sp;
 	int error;
 
-	if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
+	if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0)
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 	sp = &mp->mnt_stat;
-	if ((error = VFS_STATFS(mp, sp, p)) != 0)
+	if ((error = VFS_STATFS(mp, sp, td)) != 0)
 		return (error);
 	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
 	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
 }
 
 int
-ibcs2_stat(p, uap)
-	struct proc *p;
+ibcs2_stat(td, uap)
+	struct thread *td;
 	struct ibcs2_stat_args *uap;
 {
 	struct stat st;
@@ -150,11 +150,11 @@ ibcs2_stat(p, uap)
 	int error;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
 	SCARG(&cup, path) = SCARG(uap, path);
 	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
 
-	if ((error = stat(p, &cup)) != 0)
+	if ((error = stat(td, &cup)) != 0)
 		return error;
 
 	if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
@@ -165,8 +165,8 @@ ibcs2_stat(p, uap)
 }
 
 int
-ibcs2_lstat(p, uap)
-	struct proc *p;
+ibcs2_lstat(td, uap)
+	struct thread *td;
 	struct ibcs2_lstat_args *uap;
 {
 	struct stat st;
@@ -175,11 +175,11 @@ ibcs2_lstat(p, uap)
 	int error;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
 	SCARG(&cup, path) = SCARG(uap, path);
 	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
 
-	if ((error = lstat(p, &cup)) != 0)
+	if ((error = lstat(td, &cup)) != 0)
 		return error;
 
 	if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
@@ -190,8 +190,8 @@ ibcs2_lstat(p, uap)
 }
 
 int
-ibcs2_fstat(p, uap)
-	struct proc *p;
+ibcs2_fstat(td, uap)
+	struct thread *td;
 	struct ibcs2_fstat_args *uap;
 {
 	struct stat st;
@@ -203,7 +203,7 @@ ibcs2_fstat(p, uap)
 	SCARG(&cup, fd) = SCARG(uap, fd);
 	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st));
 
-	if ((error = fstat(p, &cup)) != 0)
+	if ((error = fstat(td, &cup)) != 0)
 		return error;
 
 	if ((error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0)
@@ -214,8 +214,8 @@ ibcs2_fstat(p, uap)
 }
 
 int
-ibcs2_utssys(p, uap)
-	struct proc *p;
+ibcs2_utssys(td, uap)
+	struct thread *td;
 	struct ibcs2_utssys_args *uap;
 {
 	switch (SCARG(uap, flag)) {
diff --git a/sys/i386/ibcs2/ibcs2_sysi86.c b/sys/i386/ibcs2/ibcs2_sysi86.c
index bcc758b..ae5215f 100644
--- a/sys/i386/ibcs2/ibcs2_sysi86.c
+++ b/sys/i386/ibcs2/ibcs2_sysi86.c
@@ -26,7 +26,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *	ibcs2_sysi86.c,v 1.1 1994/10/14 08:53:11 sos Exp
+ * $FreeBSD$
  */
 
 #include <sys/param.h>
@@ -51,7 +51,7 @@
 extern int hw_float;
 
 int
-ibcs2_sysi86(struct proc *p, struct ibcs2_sysi86_args *args)
+ibcs2_sysi86(struct thread *td, struct ibcs2_sysi86_args *args)
 {
 	switch (SCARG(args, cmd)) {
 	case SI86_FPHW: {	/* Floating Point information */
@@ -73,16 +73,16 @@ ibcs2_sysi86(struct proc *p, struct ibcs2_sysi86_args *args)
 	        int name[2];
 	        int error;
 
-		if ((error = suser(p)))
+		if ((error = suser_td(td)))
 		  return (error);
 		name[0] = CTL_KERN;
 		name[1] = KERN_HOSTNAME;
-		return (userland_sysctl(p, name, 2, 0, 0, 0, 
+		return (userland_sysctl(td, name, 2, 0, 0, 0, 
 			SCARG(args, arg), 7, 0));
 	}
 
 	case SI86_MEM:	/* size of physical memory */
-		p->p_retval[0] = ctob(physmem);
+		td->td_retval[0] = ctob(physmem);
 		return 0;
 
 	default:
diff --git a/sys/i386/ibcs2/ibcs2_util.c b/sys/i386/ibcs2/ibcs2_util.c
index bef94fd3..8b0720a 100644
--- a/sys/i386/ibcs2/ibcs2_util.c
+++ b/sys/i386/ibcs2/ibcs2_util.c
@@ -50,8 +50,8 @@ const char      ibcs2_emul_path[] = "/compat/ibcs2";
  * be in exists.
  */
 int
-ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
-	struct proc	 *p;
+ibcs2_emul_find(td, sgp, prefix, path, pbuf, cflag)
+	struct thread	 *td;
 	caddr_t		 *sgp;		/* Pointer to stackgap memory */
 	const char	 *prefix;
 	char		 *path;
@@ -104,7 +104,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
 		for (cp = &ptr[len] - 1; *cp != '/'; cp--);
 		*cp = '\0';
 
-		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);
+		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td);
 
 		if ((error = namei(&nd)) != 0) {
 			free(buf, M_TEMP);
@@ -114,7 +114,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
 		*cp = '/';
 	}
 	else {
-		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);
+		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td);
 
 		if ((error = namei(&nd)) != 0) {
 			free(buf, M_TEMP);
@@ -130,7 +130,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
 		 * to the emulation root directory. This is expensive :-(
 		 */
 		NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, ibcs2_emul_path,
-		       p);
+		       td);
 
 		if ((error = namei(&ndroot)) != 0) {
 			/* Cannot happen! */
@@ -140,11 +140,11 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
 			return error;
 		}
 
-		if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) {
+		if ((error = VOP_GETATTR(nd.ni_vp, &vat, td->td_proc->p_ucred, td)) != 0) {
 			goto done;
 		}
 
-		if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p))
+		if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, td->td_proc->p_ucred, td))
 		    != 0) {
 			goto done;
 		}
diff --git a/sys/i386/ibcs2/ibcs2_util.h b/sys/i386/ibcs2/ibcs2_util.h
index 4ef390f..93382c4 100644
--- a/sys/i386/ibcs2/ibcs2_util.h
+++ b/sys/i386/ibcs2/ibcs2_util.h
@@ -29,6 +29,8 @@
  *
  * from: svr4_util.h,v 1.5 1994/11/18 02:54:31 christos Exp
  * from: linux_util.h,v 1.2 1995/03/05 23:23:50 fvdl Exp
+ *
+ * $FreeBSD$
  */
 
 /*
@@ -60,7 +62,7 @@ static __inline void *stackgap_alloc(caddr_t *, size_t);
 static __inline caddr_t
 stackgap_init()
 {
-#define szsigcode (*(curproc->p_sysent->sv_szsigcode))
+#define szsigcode (*(curthread->td_proc->p_sysent->sv_szsigcode))
         return (caddr_t)(PS_STRINGS - szsigcode - SPARE_USRSPACE);
 }
 
@@ -82,17 +84,17 @@ stackgap_alloc(sgp, sz)
 
 extern const char ibcs2_emul_path[];
 
-int ibcs2_emul_find __P((struct proc *, caddr_t *, const char *, char *,
+int ibcs2_emul_find __P((struct thread *, caddr_t *, const char *, char *,
 			char **, int));
 
 #define CHECKALTEXIST(p, sgp, path) \
-    ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 0)
+    ibcs2_emul_find(td, sgp, ibcs2_emul_path, path, &(path), 0)
 
 #define CHECKALTCREAT(p, sgp, path) \
-    ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 1)
+    ibcs2_emul_find(td, sgp, ibcs2_emul_path, path, &(path), 1)
 
 #ifdef SPX_HACK
-int spx_open __P((struct proc *p, void *uap));
+int spx_open __P((struct thread *td, void *uap));
 #endif
 
 #endif /* !_IBCS2_UTIL_H_ */
diff --git a/sys/i386/ibcs2/ibcs2_xenix.c b/sys/i386/ibcs2/ibcs2_xenix.c
index b11275c2..2f30195 100644
--- a/sys/i386/ibcs2/ibcs2_xenix.c
+++ b/sys/i386/ibcs2/ibcs2_xenix.c
@@ -53,9 +53,9 @@
 extern struct sysent xenix_sysent[];
 
 int
-ibcs2_xenix(struct proc *p, struct ibcs2_xenix_args *uap)
+ibcs2_xenix(struct thread *td, struct ibcs2_xenix_args *uap)
 {
-	struct trapframe *tf = p->p_frame;
+	struct trapframe *tf = td->td_frame;
         struct sysent *callp;
         u_int code;             
 
@@ -63,14 +63,14 @@ ibcs2_xenix(struct proc *p, struct ibcs2_xenix_args *uap)
 	callp = &xenix_sysent[code];
 
 	if(code < IBCS2_XENIX_MAXSYSCALL)
-	  return((*callp->sy_call)(p, (void *)uap));
+	  return((*callp->sy_call)(td, (void *)uap));
 	else
 	  return ENOSYS;
 }
 
 int
-xenix_rdchk(p, uap)
-	struct proc *p;
+xenix_rdchk(td, uap)
+	struct thread *td;
 	struct xenix_rdchk_args *uap;
 {
 	int error;
@@ -81,15 +81,15 @@ xenix_rdchk(p, uap)
 	SCARG(&sa, fd) = SCARG(uap, fd);
 	SCARG(&sa, com) = FIONREAD;
 	SCARG(&sa, data) = stackgap_alloc(&sg, sizeof(int));
-	if ((error = ioctl(p, &sa)) != 0)
+	if ((error = ioctl(td, &sa)) != 0)
 		return error;
-	p->p_retval[0] = (*((int*)SCARG(&sa, data))) ? 1 : 0;
+	td->td_retval[0] = (*((int*)SCARG(&sa, data))) ? 1 : 0;
 	return 0;
 }
 
 int
-xenix_chsize(p, uap)
-	struct proc *p;
+xenix_chsize(td, uap)
+	struct thread *td;
 	struct xenix_chsize_args *uap;
 {
 	struct ftruncate_args sa;
@@ -98,13 +98,13 @@ xenix_chsize(p, uap)
 	SCARG(&sa, fd) = SCARG(uap, fd);
 	SCARG(&sa, pad) = 0;
 	SCARG(&sa, length) = SCARG(uap, size);
-	return ftruncate(p, &sa);
+	return ftruncate(td, &sa);
 }
 
 
 int
-xenix_ftime(p, uap)
-	struct proc *p;
+xenix_ftime(td, uap)
+	struct thread *td;
 	struct xenix_ftime_args *uap;
 {
 	struct timeval tv;
@@ -127,7 +127,7 @@ xenix_ftime(p, uap)
 }
 
 int
-xenix_nap(struct proc *p, struct xenix_nap_args *uap)
+xenix_nap(struct thread *td, struct xenix_nap_args *uap)
 {
 	long period;
 
@@ -140,7 +140,7 @@ xenix_nap(struct proc *p, struct xenix_nap_args *uap)
 }
 
 int
-xenix_utsname(struct proc *p, struct xenix_utsname_args *uap)
+xenix_utsname(struct thread *td, struct xenix_utsname_args *uap)
 {
 	struct ibcs2_sco_utsname {
 		char sysname[9];
@@ -183,26 +183,26 @@ xenix_utsname(struct proc *p, struct xenix_utsname_args *uap)
 }
 
 int
-xenix_scoinfo(struct proc *p, struct xenix_scoinfo_args *uap)
+xenix_scoinfo(struct thread *td, struct xenix_scoinfo_args *uap)
 {
   /* scoinfo (not documented) */
-  p->p_retval[0] = 0;
+  td->td_retval[0] = 0;
   return 0;
 }
 
 int     
-xenix_eaccess(struct proc *p, struct xenix_eaccess_args *uap)
+xenix_eaccess(struct thread *td, struct xenix_eaccess_args *uap)
 {
-	struct ucred *cred = p->p_ucred;
+	struct ucred *cred = td->td_proc->p_ucred;
 	struct vnode *vp;
         struct nameidata nd;
         int error, flags;
 	caddr_t sg = stackgap_init();
 
-	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	CHECKALTEXIST(td, &sg, SCARG(uap, path));
 
         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
-            SCARG(uap, path), p);
+            SCARG(uap, path), td);
         if ((error = namei(&nd)) != 0)
                 return error;
         vp = nd.ni_vp;
@@ -217,7 +217,7 @@ xenix_eaccess(struct proc *p, struct xenix_eaccess_args *uap)
                 if (SCARG(uap, flags) & IBCS2_X_OK)
                         flags |= VEXEC;
                 if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
-                        error = VOP_ACCESS(vp, flags, cred, p);
+                        error = VOP_ACCESS(vp, flags, cred, td);
         }
 	NDFREE(&nd, NDF_ONLY_PNBUF);
         vput(vp);
diff --git a/sys/i386/ibcs2/ibcs2_xenix.h b/sys/i386/ibcs2/ibcs2_xenix.h
index 3d487ee..07e827f 100644
--- a/sys/i386/ibcs2/ibcs2_xenix.h
+++ b/sys/i386/ibcs2/ibcs2_xenix.h
@@ -15,6 +15,8 @@
 
 struct proc;
 
+struct thread;
+
 #define	PAD_(t)	(sizeof(register_t) <= sizeof(t) ? \
 		0 : sizeof(register_t) - sizeof(t))
 
@@ -80,23 +82,23 @@ struct	ibcs2_rename_args {
 struct	xenix_utsname_args {
 	long	addr;	char addr_[PAD_(long)];
 };
-int	xenix_rdchk __P((struct proc *, struct xenix_rdchk_args *));
-int	xenix_chsize __P((struct proc *, struct xenix_chsize_args *));
-int	xenix_ftime __P((struct proc *, struct xenix_ftime_args *));
-int	xenix_nap __P((struct proc *, struct xenix_nap_args *));
-int	xenix_scoinfo __P((struct proc *, struct xenix_scoinfo_args *));
-int	xenix_eaccess __P((struct proc *, struct xenix_eaccess_args *));
-int	ibcs2_sigaction __P((struct proc *, struct ibcs2_sigaction_args *));
-int	ibcs2_sigprocmask __P((struct proc *, struct ibcs2_sigprocmask_args *));
-int	ibcs2_sigpending __P((struct proc *, struct ibcs2_sigpending_args *));
-int	ibcs2_sigsuspend __P((struct proc *, struct ibcs2_sigsuspend_args *));
-int	ibcs2_getgroups __P((struct proc *, struct ibcs2_getgroups_args *));
-int	ibcs2_setgroups __P((struct proc *, struct ibcs2_setgroups_args *));
-int	ibcs2_sysconf __P((struct proc *, struct ibcs2_sysconf_args *));
-int	ibcs2_pathconf __P((struct proc *, struct ibcs2_pathconf_args *));
-int	ibcs2_fpathconf __P((struct proc *, struct ibcs2_fpathconf_args *));
-int	ibcs2_rename __P((struct proc *, struct ibcs2_rename_args *));
-int	xenix_utsname __P((struct proc *, struct xenix_utsname_args *));
+int	xenix_rdchk __P((struct thread *, struct xenix_rdchk_args *));
+int	xenix_chsize __P((struct thread *, struct xenix_chsize_args *));
+int	xenix_ftime __P((struct thread *, struct xenix_ftime_args *));
+int	xenix_nap __P((struct thread *, struct xenix_nap_args *));
+int	xenix_scoinfo __P((struct thread *, struct xenix_scoinfo_args *));
+int	xenix_eaccess __P((struct thread *, struct xenix_eaccess_args *));
+int	ibcs2_sigaction __P((struct thread *, struct ibcs2_sigaction_args *));
+int	ibcs2_sigprocmask __P((struct thread *, struct ibcs2_sigprocmask_args *));
+int	ibcs2_sigpending __P((struct thread *, struct ibcs2_sigpending_args *));
+int	ibcs2_sigsuspend __P((struct thread *, struct ibcs2_sigsuspend_args *));
+int	ibcs2_getgroups __P((struct thread *, struct ibcs2_getgroups_args *));
+int	ibcs2_setgroups __P((struct thread *, struct ibcs2_setgroups_args *));
+int	ibcs2_sysconf __P((struct thread *, struct ibcs2_sysconf_args *));
+int	ibcs2_pathconf __P((struct thread *, struct ibcs2_pathconf_args *));
+int	ibcs2_fpathconf __P((struct thread *, struct ibcs2_fpathconf_args *));
+int	ibcs2_rename __P((struct thread *, struct ibcs2_rename_args *));
+int	xenix_utsname __P((struct thread *, struct xenix_utsname_args *));
 
 #ifdef COMPAT_43
 
diff --git a/sys/i386/ibcs2/imgact_coff.c b/sys/i386/ibcs2/imgact_coff.c
index a2f624d..3ea816b 100644
--- a/sys/i386/ibcs2/imgact_coff.c
+++ b/sys/i386/ibcs2/imgact_coff.c
@@ -54,7 +54,7 @@ MODULE_DEPEND(coff, ibcs2, 1, 1, 1);
 
 extern struct sysentvec ibcs2_svr3_sysvec;
 
-static int coff_load_file __P((struct proc *p, char *name));
+static int coff_load_file __P((struct thread *td, char *name));
 static int exec_coff_imgact __P((struct image_params *imgp));
 
 static int load_coff_section __P((struct vmspace *vmspace, struct vnode *vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot));
@@ -150,8 +150,9 @@ load_coff_section(struct vmspace *vmspace, struct vnode *vp, vm_offset_t offset,
 }
 
 static int
-coff_load_file(struct proc *p, char *name)
+coff_load_file(struct thread *td, char *name)
 {
+	struct proc *p = td->td_proc;
   	struct vmspace *vmspace = p->p_vmspace;
   	int error;
   	struct nameidata nd;
@@ -167,7 +168,7 @@ coff_load_file(struct proc *p, char *name)
   	unsigned long bss_size = 0;
   	int i;
 
-	NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, UIO_SYSSPACE, name, p);
+	NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, UIO_SYSSPACE, name, td);
 
   	error = namei(&nd);
   	if (error)
@@ -182,7 +183,7 @@ coff_load_file(struct proc *p, char *name)
     		goto fail;
   	}
 
-  	if ((error = VOP_GETATTR(vp, &attr, p->p_ucred, p)) != 0)
+  	if ((error = VOP_GETATTR(vp, &attr, p->p_ucred, td)) != 0)
     		goto fail;
 
   	if ((vp->v_mount->mnt_flag & MNT_NOEXEC)
@@ -195,17 +196,17 @@ coff_load_file(struct proc *p, char *name)
     		goto fail;
   	}
 
-  	if ((error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p)) != 0)
+  	if ((error = VOP_ACCESS(vp, VEXEC, p->p_ucred, td)) != 0)
     		goto fail;
 
-  	if ((error = VOP_OPEN(vp, FREAD, p->p_ucred, p)) != 0)
+  	if ((error = VOP_OPEN(vp, FREAD, p->p_ucred, td)) != 0)
     		goto fail;
 
 	/*
 	 * Lose the lock on the vnode. It's no longer needed, and must not
 	 * exist for the pagefault paging to work below.
 	 */
-	VOP_UNLOCK(vp, 0, p);
+	VOP_UNLOCK(vp, 0, td);
 
   	if ((error = vm_mmap(kernel_map,
 			    (vm_offset_t *) &ptr,
@@ -278,7 +279,7 @@ coff_load_file(struct proc *p, char *name)
     		panic(__FUNCTION__ " vm_map_remove failed");
 
  fail:
-	VOP_UNLOCK(vp, 0, p);
+	VOP_UNLOCK(vp, 0, td);
  unlocked_fail:
 	NDFREE(&nd, NDF_ONLY_PNBUF);
 	vrele(nd.ni_vp);
@@ -393,9 +394,9 @@ exec_coff_imgact(imgp)
 				DPRINTF(("%s(%d):  shared library %s\n",
 					 __FILE__, __LINE__, libname));
 				strcpy(&libbuf[emul_path_len], libname);
-		      		error = coff_load_file(imgp->proc, libbuf);
+/* XXXKSE only 1:1 in coff */		      		error = coff_load_file(&imgp->proc->p_thread, libbuf);
 		      		if (error)
-	      				error = coff_load_file(imgp->proc,
+	      				error = coff_load_file(&imgp->proc->p_thread,
 							       libname);
 		      		if (error)
 					break;