From c9714ae3290feec9ba1dc5854ae1e55c6b994bfb Mon Sep 17 00:00:00 2001
From: Kirk McKusick <mckusick@ucbvax.Berkeley.EDU>
Date: Wed, 6 Jun 1990 05:02:17 -0800
Subject: [PATCH] update to new system call convention; expunge more u.u_error

SCCS-vsn: sys/kern/kern_exec.c 7.25
SCCS-vsn: sys/kern/kern_exit.c 7.22
SCCS-vsn: sys/kern/kern_fork.c 7.17
SCCS-vsn: sys/kern/kern_sig.c 7.19
SCCS-vsn: sys/kern/sys_generic.c 7.17
SCCS-vsn: sys/kern/sysv_shm.c 7.4
SCCS-vsn: sys/kern/uipc_syscalls.c 7.17
---
 usr/src/sys/kern/kern_exec.c     | 145 ++++++++++++++++---------------
 usr/src/sys/kern/kern_exit.c     |   2 +-
 usr/src/sys/kern/kern_fork.c     |  67 +++++++-------
 usr/src/sys/kern/kern_sig.c      |   2 +-
 usr/src/sys/kern/sys_generic.c   | 127 +++++++++++++++------------
 usr/src/sys/kern/sysv_shm.c      |  42 +++++----
 usr/src/sys/kern/uipc_syscalls.c |   2 +-
 7 files changed, 216 insertions(+), 171 deletions(-)

diff --git a/usr/src/sys/kern/kern_exec.c b/usr/src/sys/kern/kern_exec.c
index 6c9aa0b2ea..631892de70 100644
--- a/usr/src/sys/kern/kern_exec.c
+++ b/usr/src/sys/kern/kern_exec.c
@@ -14,13 +14,13 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)kern_exec.c	7.24 (Berkeley) %G%
+ *	@(#)kern_exec.c	7.25 (Berkeley) %G%
  */
 
 #include "param.h"
 #include "systm.h"
 #include "map.h"
-#include "user.h"
+#include "syscontext.h"
 #include "kernel.h"
 #include "proc.h"
 #include "mount.h"
@@ -48,25 +48,34 @@
 /*
  * exec system call, with and without environments.
  */
-struct execa {
-	char	*fname;
-	char	**argp;
-	char	**envp;
-};
-
-execv()
+execv(p, uap, retval)
+	struct proc *p;
+	struct args {
+		char	*fname;
+		char	**argp;
+		char	**envp;
+	} *uap;
+	int *retval;
 {
-	((struct execa *)u.u_ap)->envp = NULL;
-	execve();
+
+	uap->envp = NULL;
+	RETURN (execve(p, uap, retval));
 }
 
-execve()
+/* ARGSUSED */
+execve(p, uap, retval)
+	register struct proc *p;
+	register struct args {
+		char	*fname;
+		char	**argp;
+		char	**envp;
+	} *uap;
+	int *retval;
 {
 	register nc;
 	register char *cp;
 	register struct buf *bp;
 	struct buf *tbp;
-	register struct execa *uap;
 	int na, ne, ucp, ap, cc;
 	unsigned len;
 	int indir, uid, gid;
@@ -86,6 +95,7 @@ execve()
 #ifdef HPUXCOMPAT
 	struct hpux_exec hhead;
 #endif
+	register struct ucred *cred = u.u_cred;
 	register struct nameidata *ndp = &u.u_nd;
 	int resid, error, flags = 0;
 #ifdef SECSIZE
@@ -95,20 +105,19 @@ execve()
   start:
 	ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
 	ndp->ni_segflg = UIO_USERSPACE;
-	ndp->ni_dirp = ((struct execa *)u.u_ap)->fname;
-	if (u.u_error = namei(ndp)) {
-		return;
-	}
+	ndp->ni_dirp = uap->fname;
+	if (error = namei(ndp))
+		RETURN (error);
 	vp = ndp->ni_vp;
 	bno = 0;
 	bp = 0;
 	indir = 0;
-	uid = u.u_cred->cr_uid;
-	gid = u.u_cred->cr_gid;
-	if (u.u_error = VOP_GETATTR(vp, &vattr, u.u_cred))
+	uid = cred->cr_uid;
+	gid = cred->cr_gid;
+	if (error = VOP_GETATTR(vp, &vattr, cred))
 		goto bad;
 	if (vp->v_mount->mnt_flag & MNT_NOEXEC) {
-		u.u_error = EACCES;
+		error = EACCES;
 		goto bad;
 	}
 	if ((vp->v_mount->mnt_flag & MNT_NOSUID) == 0) {
@@ -119,14 +128,13 @@ execve()
 	}
 
   again:
-	if (u.u_error = VOP_ACCESS(vp, VEXEC, u.u_cred))
+	if (error = VOP_ACCESS(vp, VEXEC, cred))
 		goto bad;
-	if ((u.u_procp->p_flag & STRC) &&
-	    (u.u_error = VOP_ACCESS(vp, VREAD, u.u_cred)))
+	if ((p->p_flag & STRC) && (error = VOP_ACCESS(vp, VREAD, cred)))
 		goto bad;
 	if (vp->v_type != VREG ||
 	    (vattr.va_mode & (VEXEC|(VEXEC>>3)|(VEXEC>>6))) == 0) {
-		u.u_error = EACCES;
+		error = EACCES;
 		goto bad;
 	}
 
@@ -145,14 +153,14 @@ execve()
 	 * THE ASCII LINE.
 	 */
 	exdata.ex_shell[0] = '\0';	/* for zero length files */
-	u.u_error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata, sizeof (exdata),
-	    (off_t)0, UIO_SYSSPACE, (IO_UNIT|IO_NODELOCKED), u.u_cred, &resid);
-	if (u.u_error)
+	error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata, sizeof (exdata),
+	    (off_t)0, UIO_SYSSPACE, (IO_UNIT|IO_NODELOCKED), cred, &resid);
+	if (error)
 		goto bad;
 #ifndef lint
 	if (resid > sizeof(exdata) - sizeof(exdata.ex_exec) &&
 	    exdata.ex_shell[0] != '#') {
-		u.u_error = ENOEXEC;
+		error = ENOEXEC;
 		goto bad;
 	}
 #endif
@@ -231,7 +239,7 @@ execve()
 		flags |= SPAGV;
 	case NMAGIC:
 		if (exdata.ex_exec.a_text == 0) {
-			u.u_error = ENOEXEC;
+			error = ENOEXEC;
 			goto bad;
 		}
 		break;
@@ -240,12 +248,12 @@ execve()
 		if (exdata.ex_shell[0] != '#' ||
 		    exdata.ex_shell[1] != '!' ||
 		    indir) {
-			u.u_error = ENOEXEC;
+			error = ENOEXEC;
 			goto bad;
 		}
 		for (cp = &exdata.ex_shell[2];; ++cp) {
 			if (cp >= &exdata.ex_shell[MAXINTERP]) {
-				u.u_error = ENOEXEC;
+				error = ENOEXEC;
 				goto bad;
 			}
 			if (*cp == '\n') {
@@ -273,16 +281,16 @@ execve()
 		vput(vp);
 		ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
 		ndp->ni_segflg = UIO_SYSSPACE;
-		if (u.u_error = namei(ndp))
-			return;
+		if (error = namei(ndp))
+			RETURN (error);
 		vp = ndp->ni_vp;
-		if (u.u_error = VOP_GETATTR(vp, &vattr, u.u_cred))
+		if (error = VOP_GETATTR(vp, &vattr, cred))
 			goto bad;
 		bcopy((caddr_t)ndp->ni_dent.d_name, (caddr_t)cfname,
 		    MAXCOMLEN);
 		cfname[MAXCOMLEN] = '\0';
-		uid = u.u_cred->cr_uid;	/* shell scripts can't be setuid */
-		gid = u.u_cred->cr_gid;
+		uid = cred->cr_uid;	/* shell scripts can't be setuid */
+		gid = cred->cr_gid;
 		goto again;
 	}
 	/*
@@ -309,14 +317,13 @@ execve()
 	ne = 0;
 	nc = 0;
 	cc = 0;
-	uap = (struct execa *)u.u_ap;
 #ifdef SECSIZE
 	bno = rmalloc(argmap, (clrnd((int)btoc(NCARGS))) * CLBYTES / argdbsize);
 #else SECSIZE
 	bno = rmalloc(argmap, (long)ctod(clrnd((int)btoc(NCARGS))));
 #endif SECSIZE
 	if (bno == 0) {
-		swkill(u.u_procp, "exec: no swap space");
+		swkill(p, "exec: no swap space");
 		goto bad;
 	}
 	if (bno % CLSIZE)
@@ -353,7 +360,7 @@ execve()
 			break;
 		na++;
 		if (ap == -1) {
-			u.u_error = EFAULT;
+			error = EFAULT;
 			if (bp) {
 				brelse(bp);
 				bp = 0;
@@ -395,7 +402,6 @@ execve()
 			cc -= len;
 		} while (error == ENOENT);
 		if (error) {
-			u.u_error = error;
 			if (bp)
 				brelse(bp);
 			bp = 0;
@@ -406,9 +412,9 @@ execve()
 		bdwrite(bp);
 	bp = 0;
 	nc = (nc + NBPW-1) & ~(NBPW-1);
-	getxfile(vp, &exdata.ex_exec, flags, nc + (na+4)*NBPW,
-	    uid, gid, u.u_cred);
-	if (u.u_error) {
+	error = getxfile(p, vp, &exdata.ex_exec, flags, nc + (na+4)*NBPW,
+	    uid, gid);
+	if (error) {
 badarg:
 		for (cc = 0; cc < nc; cc += CLBYTES) {
 			(void) baddr(argdev_vp, bno + ctod(cc/NBPG),
@@ -484,7 +490,7 @@ badarg:
 	}
 	(void) suword((caddr_t)ap, 0);
 
-	execsigs(u.u_procp);
+	execsigs(p);
 
 	for (nc = u.u_lastfile; nc >= 0; --nc) {
 		if (u.u_pofile[nc] & UF_EXCLOSE) {
@@ -502,11 +508,11 @@ badarg:
 	 */
 	u.u_acflag &= ~AFORK;
 	if (indir)
-		bcopy((caddr_t)cfname, (caddr_t)u.u_procp->p_comm, MAXCOMLEN);
+		bcopy((caddr_t)cfname, (caddr_t)p->p_comm, MAXCOMLEN);
 	else {
 		if (ndp->ni_dent.d_namlen > MAXCOMLEN)
 			ndp->ni_dent.d_namlen = MAXCOMLEN;
-		bcopy((caddr_t)ndp->ni_dent.d_name, (caddr_t)u.u_procp->p_comm,
+		bcopy((caddr_t)ndp->ni_dent.d_name, (caddr_t)p->p_comm,
 		    (unsigned)(ndp->ni_dent.d_namlen + 1));
 	}
 bad:
@@ -521,20 +527,22 @@ bad:
 #endif SECSIZE
 	if (vp)
 		vput(vp);
+	RETURN (error);
 }
 
 /*
  * Read in and set up memory for executed file.
  */
-getxfile(vp, ep, flags, nargc, uid, gid, cred)
+getxfile(p, vp, ep, flags, nargc, uid, gid)
+	register struct proc *p;
 	register struct vnode *vp;
 	register struct exec *ep;
 	int flags, nargc, uid, gid;
-	struct ucred *cred;
 {
-	register struct proc *p = u.u_procp;
 	segsz_t ts, ds, ids, uds, ss;
+	register struct ucred *cred = u.u_cred;
 	off_t toff;
+	int error;
 
 #ifdef HPUXCOMPAT
 	if (ep->a_mid == MID_HPUX)
@@ -542,10 +550,8 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 	else
 #endif
 	toff = sizeof (struct exec);
-	if (vp->v_text && (vp->v_text->x_flag & XTRC)) {
-		u.u_error = ETXTBSY;
-		goto bad;
-	}
+	if (vp->v_text && (vp->v_text->x_flag & XTRC))
+		return (ETXTBSY);
 	if (ep->a_text != 0 && (vp->v_flag & VTEXT) == 0 &&
 	    vp->v_usecount != 1) {
 		register struct file *fp;
@@ -555,8 +561,7 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 			    fp->f_count > 0 &&
 			    (struct vnode *)fp->f_data == vp &&
 			    (fp->f_flag & FWRITE)) {
-				u.u_error = ETXTBSY;
-				goto bad;
+				return (ETXTBSY);
 			}
 		}
 	}
@@ -571,16 +576,17 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 	uds = clrnd(btoc(ep->a_bss));
 	ds = clrnd(btoc(ep->a_data + ep->a_bss));
 	ss = clrnd(SSIZE + btoc(nargc));
-	if (chksize((unsigned)ts, (unsigned)ids, (unsigned)uds, (unsigned)ss))
-		goto bad;
+	if (error =
+	    chksize((unsigned)ts, (unsigned)ids, (unsigned)uds, (unsigned)ss))
+		return (error);
 
 	/*
 	 * Make sure enough space to start process.
 	 */
 	u.u_cdmap = zdmap;
 	u.u_csmap = zdmap;
-	if (swpexpand(ds, ss, &u.u_cdmap, &u.u_csmap) == NULL)
-		goto bad;
+	if (error = swpexpand(ds, ss, &u.u_cdmap, &u.u_csmap))
+		return (error);
 
 	/*
 	 * At this point, we are committed to the new image!
@@ -592,8 +598,8 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 	 */
 	if ((p->p_flag & SVFORK) == 0) {
 #ifdef MAPMEM
-		if (u.u_mmap)
-			mmexec();
+		if (u.u_mmap && (error = mmexec(p)))
+			return (error);
 #endif
 		vrelvm();
 	} else {
@@ -619,7 +625,7 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 	vgetvm(ts, ds, ss);
 
 	if ((flags & SPAGV) == 0)
-		u.u_error = vn_rdwr(UIO_READ, vp,
+		(void) vn_rdwr(UIO_READ, vp,
 			(char *)ctob(dptov(p, 0)),
 			(int)ep->a_data,
 			(off_t)(toff + ep->a_text),
@@ -655,15 +661,15 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 	 * set SUID/SGID protections, if no tracing
 	 */
 	if ((p->p_flag&STRC)==0) {
-		if (uid != u.u_cred->cr_uid || gid != u.u_cred->cr_gid)
-			u.u_cred = crcopy(u.u_cred);
-		u.u_cred->cr_uid = uid;
-		u.u_cred->cr_gid = gid;
+		if (uid != cred->cr_uid || gid != cred->cr_gid)
+			u.u_cred = cred = crcopy(cred);
+		cred->cr_uid = uid;
+		cred->cr_gid = gid;
 		p->p_uid = uid;
 	} else
 		psignal(p, SIGTRAP);
 	p->p_svuid = p->p_uid;
-	p->p_svgid = u.u_cred->cr_gid;
+	p->p_svgid = cred->cr_gid;
 	u.u_tsize = ts;
 	u.u_dsize = ds;
 	u.u_ssize = ss;
@@ -671,6 +677,5 @@ getxfile(vp, ep, flags, nargc, uid, gid, cred)
 #if defined(tahoe)
 	u.u_pcb.pcb_savacc.faddr = (float *)NULL;
 #endif
-bad:
-	return;
+	return (0);
 }
diff --git a/usr/src/sys/kern/kern_exit.c b/usr/src/sys/kern/kern_exit.c
index 53bcd2304f..7041eb0ab5 100644
--- a/usr/src/sys/kern/kern_exit.c
+++ b/usr/src/sys/kern/kern_exit.c
@@ -14,7 +14,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)kern_exit.c	7.21 (Berkeley) %G%
+ *	@(#)kern_exit.c	7.22 (Berkeley) %G%
  */
 
 #include "param.h"
diff --git a/usr/src/sys/kern/kern_fork.c b/usr/src/sys/kern/kern_fork.c
index 0977bf3b9e..187529be38 100644
--- a/usr/src/sys/kern/kern_fork.c
+++ b/usr/src/sys/kern/kern_fork.c
@@ -14,13 +14,13 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)kern_fork.c	7.16 (Berkeley) %G%
+ *	@(#)kern_fork.c	7.17 (Berkeley) %G%
  */
 
 #include "param.h"
 #include "systm.h"
 #include "map.h"
-#include "user.h"
+#include "syscontext.h"
 #include "kernel.h"
 #include "proc.h"
 #include "vnode.h"
@@ -39,37 +39,47 @@
 /*
  * fork system call.
  */
-fork()
+/* ARGSUSED */
+fork(p, uap, retval)
+	struct proc *p;
+	struct args *uap;
+	int retval[];
 {
+	int error;
 
 	u.u_cdmap = zdmap;
 	u.u_csmap = zdmap;
-	if (swpexpand(u.u_dsize, u.u_ssize, &u.u_cdmap, &u.u_csmap) == 0) {
-		u.u_r.r_val2 = 0;
-		return;
+	if (error = swpexpand(u.u_dsize, u.u_ssize, &u.u_cdmap, &u.u_csmap)) {
+		retval[1] = 0;
+		RETURN (error);
 	}
-	fork1(0);
+	RETURN (fork1(p, 0, retval));
 }
 
-vfork()
+/* ARGSUSED */
+vfork(p, uap, retval)
+	struct proc *p;
+	struct args *uap;
+	int retval[];
 {
 
-	fork1(1);
+	RETURN (fork1(p, 1, retval));
 }
 
-fork1(isvfork)
-	int isvfork;
+fork1(p1, isvfork, retval)
+	register struct proc *p1;
+	int isvfork, retval[];
 {
-	register struct proc *p1, *p2;
-	register a;
+	register struct proc *p2;
+	register int a;
 
 	a = 0;
-	if (u.u_uid != 0) {
-		for (p1 = allproc; p1; p1 = p1->p_nxt)
-			if (p1->p_uid == u.u_uid)
+	if (p1->p_uid != 0) {
+		for (p2 = allproc; p2; p2 = p2->p_nxt)
+			if (p2->p_uid == p1->p_uid)
 				a++;
-		for (p1 = zombproc; p1; p1 = p1->p_nxt)
-			if (p1->p_uid == u.u_uid)
+		for (p2 = zombproc; p2; p2 = p2->p_nxt)
+			if (p2->p_uid == p1->p_uid)
 				a++;
 	}
 	/*
@@ -81,25 +91,24 @@ fork1(isvfork)
 	p2 = freeproc;
 	if (p2==NULL)
 		tablefull("proc");
-	if (p2==NULL || (u.u_uid!=0 && (p2->p_nxt == NULL || a>MAXUPRC))) {
-		u.u_error = EAGAIN;
+	if (p2 == NULL ||
+	    (p1->p_uid != 0 && (p2->p_nxt == NULL || a > MAXUPRC))) {
 		if (!isvfork) {
 			(void) vsexpand((segsz_t)0, &u.u_cdmap, 1);
 			(void) vsexpand((segsz_t)0, &u.u_csmap, 1);
 		}
-		goto out;
+		retval[1] = 0;
+		return (EAGAIN);
 	}
-	p1 = u.u_procp;
 	if (newproc(isvfork)) {
-		u.u_r.r_val1 = p1->p_pid;
-		u.u_r.r_val2 = 1;  /* child */
+		retval[0] = p1->p_pid;
+		retval[1] = 1;  /* child */
 		u.u_acflag = AFORK;
-		return;
+		return (0);
 	}
-	u.u_r.r_val1 = p2->p_pid;
-
-out:
-	u.u_r.r_val2 = 0;
+	retval[0] = p2->p_pid;
+	retval[1] = 0;
+	return (0);
 }
 
 /*
diff --git a/usr/src/sys/kern/kern_sig.c b/usr/src/sys/kern/kern_sig.c
index 87c2529c57..480cea8c5a 100644
--- a/usr/src/sys/kern/kern_sig.c
+++ b/usr/src/sys/kern/kern_sig.c
@@ -14,7 +14,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)kern_sig.c	7.18 (Berkeley) %G%
+ *	@(#)kern_sig.c	7.19 (Berkeley) %G%
  */
 
 #include "param.h"
diff --git a/usr/src/sys/kern/sys_generic.c b/usr/src/sys/kern/sys_generic.c
index e92dae5010..90e4af0b5e 100644
--- a/usr/src/sys/kern/sys_generic.c
+++ b/usr/src/sys/kern/sys_generic.c
@@ -14,7 +14,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)sys_generic.c	7.16 (Berkeley) %G%
+ *	@(#)sys_generic.c	7.17 (Berkeley) %G%
  */
 
 #include "param.h"
@@ -34,13 +34,15 @@
 /*
  * Read system call.
  */
-read()
-{
-	register struct a {
+read(p, uap, retval)
+	struct proc *p;
+	register struct args {
 		int	fdes;
 		char	*cbuf;
 		unsigned count;
-	} *uap = (struct a *)u.u_ap;
+	} *uap;
+	int *retval;
+{
 	register struct file *fp;
 	struct uio auio;
 	struct iovec aiov;
@@ -64,7 +66,7 @@ read()
 	/*
 	 * if tracing, save a copy of iovec
 	 */
-	if (KTRPOINT(u.u_procp, KTR_GENIO))
+	if (KTRPOINT(p, KTR_GENIO))
 		ktriov = aiov;
 #endif
 	cnt = uap->count;
@@ -74,20 +76,25 @@ read()
 			error = 0;
 	cnt -= auio.uio_resid;
 #ifdef KTRACE
-	if (KTRPOINT(u.u_procp, KTR_GENIO) && error == 0)
-		ktrgenio(u.u_procp->p_tracep, uap->fdes, UIO_READ, &ktriov, cnt);
+	if (KTRPOINT(p, KTR_GENIO) && error == 0)
+		ktrgenio(p->p_tracep, uap->fdes, UIO_READ, &ktriov, cnt);
 #endif
-	u.u_r.r_val1 = cnt;
+	*retval = cnt;
 	RETURN (error);
 }
 
-readv()
-{
-	register struct a {
+/*
+ * Scatter read system call.
+ */
+readv(p, uap, retval)
+	struct proc *p;
+	register struct args {
 		int	fdes;
 		struct	iovec *iovp;
 		unsigned iovcnt;
-	} *uap = (struct a *)u.u_ap;
+	} *uap;
+	int *retval;
+{
 	register struct file *fp;
 	struct uio auio;
 	register struct iovec *iov;
@@ -132,7 +139,7 @@ readv()
 	/*
 	 * if tracing, save a copy of iovec
 	 */
-	if (KTRPOINT(u.u_procp, KTR_GENIO))  {
+	if (KTRPOINT(p, KTR_GENIO))  {
 		unsigned iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 
 		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
@@ -148,12 +155,11 @@ readv()
 #ifdef KTRACE
 	if (ktriov != NULL) {
 		if (error == 0)
-			ktrgenio(u.u_procp->p_tracep, uap->fdes, UIO_READ, 
-				ktriov, cnt);
+			ktrgenio(p->p_tracep, uap->fdes, UIO_READ, ktriov, cnt);
 		FREE(ktriov, M_TEMP);
 	}
 #endif
-	u.u_r.r_val1 = cnt;
+	*retval = cnt;
 done:
 	if (uap->iovcnt > UIO_SMALLIOV)
 		FREE(iov, M_IOV);
@@ -163,13 +169,15 @@ done:
 /*
  * Write system call
  */
-write()
-{
-	register struct a {
+write(p, uap, retval)
+	struct proc *p;
+	register struct args {
 		int	fdes;
 		char	*cbuf;
 		unsigned count;
-	} *uap = (struct a *)u.u_ap;
+	} *uap;
+	int *retval;
+{
 	register struct file *fp;
 	struct uio auio;
 	struct iovec aiov;
@@ -193,7 +201,7 @@ write()
 	/*
 	 * if tracing, save a copy of iovec
 	 */
-	if (KTRPOINT(u.u_procp, KTR_GENIO))
+	if (KTRPOINT(p, KTR_GENIO))
 		ktriov = aiov;
 #endif
 	cnt = uap->count;
@@ -202,25 +210,30 @@ write()
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 		if (error == EPIPE)
-			psignal(u.u_procp, SIGPIPE);
+			psignal(p, SIGPIPE);
 	}
 	cnt -= auio.uio_resid;
 #ifdef KTRACE
-	if (KTRPOINT(u.u_procp, KTR_GENIO) && error == 0)
-		ktrgenio(u.u_procp->p_tracep, uap->fdes, UIO_WRITE,
+	if (KTRPOINT(p, KTR_GENIO) && error == 0)
+		ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE,
 		    &ktriov, cnt);
 #endif
-	u.u_r.r_val1 = cnt;
+	*retval = cnt;
 	RETURN (error);
 }
 
-writev()
-{
-	register struct a {
+/*
+ * Gather write system call
+ */
+writev(p, uap, retval)
+	struct proc *p;
+	register struct args {
 		int	fdes;
 		struct	iovec *iovp;
 		unsigned iovcnt;
-	} *uap = (struct a *)u.u_ap;
+	} *uap;
+	int *retval;
+{
 	register struct file *fp;
 	struct uio auio;
 	register struct iovec *iov;
@@ -265,7 +278,7 @@ writev()
 	/*
 	 * if tracing, save a copy of iovec
 	 */
-	if (KTRPOINT(u.u_procp, KTR_GENIO))  {
+	if (KTRPOINT(p, KTR_GENIO))  {
 		unsigned iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 
 		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
@@ -278,18 +291,18 @@ writev()
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 		if (error == EPIPE)
-			psignal(u.u_procp, SIGPIPE);
+			psignal(p, SIGPIPE);
 	}
 	cnt -= auio.uio_resid;
 #ifdef KTRACE
 	if (ktriov != NULL) {
 		if (error == 0)
-			ktrgenio(u.u_procp->p_tracep, uap->fdes, UIO_WRITE,
+			ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE,
 				ktriov, cnt);
 		FREE(ktriov, M_TEMP);
 	}
 #endif
-	u.u_r.r_val1 = cnt;
+	*retval = cnt;
 done:
 	if (uap->iovcnt > UIO_SMALLIOV)
 		FREE(iov, M_IOV);
@@ -299,14 +312,17 @@ done:
 /*
  * Ioctl system call
  */
-ioctl()
-{
-	register struct file *fp;
-	struct a {
+/* ARGSUSED */
+ioctl(p, uap, retval)
+	struct proc *p;
+	register struct args {
 		int	fdes;
 		int	cmd;
 		caddr_t	cmarg;
-	} *uap = (struct a *)u.u_ap;
+	} *uap;
+	int *retval;
+{
+	register struct file *fp;
 	register int com, error;
 	register u_int size;
 	caddr_t memp = 0;
@@ -399,13 +415,15 @@ int	nselcoll;
 /*
  * Select system call.
  */
-select()
-{
-	register struct uap  {
+select(p, uap, retval)
+	register struct proc *p;
+	register struct args {
 		int	nd;
 		fd_set	*in, *ou, *ex;
 		struct	timeval *tv;
-	} *uap = (struct uap *)u.u_ap;
+	} *uap;
+	int *retval;
+{
 	fd_set ibits[3], obits[3];
 	struct timeval atv;
 	int s, ncoll, ni, error = 0, timo;
@@ -443,11 +461,11 @@ select()
 		timo = 0;
 retry:
 	ncoll = nselcoll;
-	u.u_procp->p_flag |= SSEL;
-	u.u_r.r_val1 = selscan(ibits, obits, uap->nd, &error);
+	p->p_flag |= SSEL;
+	error = selscan(ibits, obits, uap->nd, retval);
 	if (error == 0)
 		error = u.u_error;		/* XXX */
-	if (error || u.u_r.r_val1)
+	if (error || *retval)
 		goto done;
 	s = splhigh();
 	/* this should be timercmp(&time, &atv, >=) */
@@ -456,17 +474,17 @@ retry:
 		splx(s);
 		goto done;
 	}
-	if ((u.u_procp->p_flag & SSEL) == 0 || nselcoll != ncoll) {
+	if ((p->p_flag & SSEL) == 0 || nselcoll != ncoll) {
 		splx(s);
 		goto retry;
 	}
-	u.u_procp->p_flag &= ~SSEL;
+	p->p_flag &= ~SSEL;
 	error = tsleep((caddr_t)&selwait, PSOCK | PCATCH, "select", timo);
 	splx(s);
 	if (error == 0)
 		goto retry;
 done:
-	u.u_procp->p_flag &= ~SSEL;
+	p->p_flag &= ~SSEL;
 	/* select is not restarted after signals... */
 	if (error == ERESTART)
 		error = EINTR;
@@ -488,15 +506,15 @@ done:
 	RETURN (error);
 }
 
-selscan(ibits, obits, nfd, errp)
+selscan(ibits, obits, nfd, retval)
 	fd_set *ibits, *obits;
-	int nfd, *errp;
+	int nfd, *retval;
 {
 	register int which, i, j;
 	register fd_mask bits;
 	int flag;
 	struct file *fp;
-	int n = 0;
+	int error = 0, n = 0;
 
 	for (which = 0; which < 3; which++) {
 		switch (which) {
@@ -516,7 +534,7 @@ selscan(ibits, obits, nfd, errp)
 				bits &= ~(1 << j);
 				fp = u.u_ofile[i + j];
 				if (fp == NULL) {
-					*errp = EBADF;
+					error = EBADF;
 					break;
 				}
 				if ((*fp->f_ops->fo_select)(fp, flag)) {
@@ -526,7 +544,8 @@ selscan(ibits, obits, nfd, errp)
 			}
 		}
 	}
-	return (n);
+	*retval = n;
+	return (error);
 }
 
 /*ARGSUSED*/
diff --git a/usr/src/sys/kern/sysv_shm.c b/usr/src/sys/kern/sysv_shm.c
index ca6db7efd8..bf6b92f4f3 100644
--- a/usr/src/sys/kern/sysv_shm.c
+++ b/usr/src/sys/kern/sysv_shm.c
@@ -11,7 +11,7 @@
  *
  * from: Utah $Hdr: uipc_shm.c 1.9 89/08/14$
  *
- *	@(#)sysv_shm.c	7.3 (Berkeley) %G%
+ *	@(#)sysv_shm.c	7.4 (Berkeley) %G%
  */
 
 /*
@@ -78,6 +78,7 @@ shmget(ap)
 		int size;
 		int shmflg;
 	} *uap = (struct a *)ap;
+	struct proc *p = u.u_procp;
 	register struct shmid_ds *shp;
 	register int i;
 	int rval = 0, size;
@@ -144,7 +145,7 @@ shmget(ap)
 		shp->shm_perm.mode = SHM_ALLOC | (uap->shmflg&0777);
 		shp->shm_handle = (void *) kvtopte(kva);
 		shp->shm_segsz = uap->size;
-		shp->shm_cpid = u.u_procp->p_pid;
+		shp->shm_cpid = p->p_pid;
 		shp->shm_lpid = shp->shm_nattch = 0;
 		shp->shm_atime = shp->shm_dtime = 0;
 		shp->shm_ctime = time.tv_sec;
@@ -178,6 +179,7 @@ shmctl(ap)
 		int cmd;
 		caddr_t buf;
 	} *uap = (struct a *)ap;
+	struct proc *p = u.u_procp;
 	register struct shmid_ds *shp;
 	struct shmid_ds sbuf;
 
@@ -224,7 +226,7 @@ shmctl(ap)
 	case SHM_LOCK:
 	case SHM_UNLOCK:
 		/* don't really do anything, but make them think we did */
-		if ((u.u_procp->p_flag & SHPUX) == 0)
+		if ((p->p_flag & SHPUX) == 0)
 			u.u_error = EINVAL;
 		else if (u.u_uid && u.u_uid != shp->shm_perm.uid &&
 			 u.u_uid != shp->shm_perm.cuid)
@@ -246,11 +248,12 @@ shmat(ap)
 		caddr_t	shmaddr;
 		int	shmflg;
 	} *uap = (struct a *)ap;
+	struct proc *p = u.u_procp;
 	register struct shmid_ds *shp;
 	register int size;
 	struct mapmem *mp;
 	caddr_t uva;
-	int prot, shmmapin();
+	int error, prot, shmmapin();
 
 	if (!shmvalid(uap->shmid))
 		return;
@@ -289,17 +292,20 @@ shmat(ap)
 	prot |= MM_CI;
 #endif
 	size = ctob(clrnd(btoc(shp->shm_segsz)));
-	mp = mmalloc(uap->shmid, &uva, (segsz_t)size, prot, &shmops);
-	if (mp == MMNIL)
+	error = mmalloc(p, uap->shmid, &uva, (segsz_t)size, prot, &shmops, &mp);
+	if (error) {
+		u.u_error = error;
 		return;
-	if (!mmmapin(mp, shmmapin)) {
-		mmfree(mp);
+	}
+	if (u.u_error = mmmapin(p, mp, shmmapin)) {
+		if (error = mmfree(p, mp))
+			u.u_error = error;
 		return;
 	}
 	/*
 	 * Fill in the remaining fields
 	 */
-	shp->shm_lpid = u.u_procp->p_pid;
+	shp->shm_lpid = p->p_pid;
 	shp->shm_atime = time.tv_sec;
 	shp->shm_nattch++;
 	u.u_r.r_val1 = (int) uva;
@@ -311,6 +317,7 @@ shmdt(ap)
 	register struct a {
 		caddr_t	shmaddr;
 	} *uap = (struct a *)ap;
+	struct proc *p = u.u_procp;
 	register struct mapmem *mp;
 
 	for (mp = u.u_mmap; mp; mp = mp->mm_next)
@@ -320,8 +327,8 @@ shmdt(ap)
 		u.u_error = EINVAL;
 		return;
 	}
-	shmsegs[mp->mm_id % SHMMMNI].shm_lpid = u.u_procp->p_pid;
-	shmufree(mp);
+	shmsegs[mp->mm_id % SHMMMNI].shm_lpid = p->p_pid;
+	u.u_error = shmufree(p, mp);
 }
 
 shmmapin(mp, off)
@@ -351,7 +358,9 @@ shmfork(mp, ischild)
 shmexit(mp)
 	register struct mapmem *mp;
 {
-	shmufree(mp);
+	struct proc *p = u.u_procp;		/* XXX */
+
+	u.u_error = shmufree(p, mp);
 }
 
 shmvalid(id)
@@ -372,17 +381,20 @@ shmvalid(id)
 /*
  * Free user resources associated with a shared memory segment
  */
-shmufree(mp)
+shmufree(p, mp)
+	struct proc *p;
 	struct mapmem *mp;
 {
 	register struct shmid_ds *shp;
+	int error;
 
 	shp = &shmsegs[mp->mm_id % SHMMMNI];
-	mmmapout(mp);
-	mmfree(mp);
+	mmmapout(p, mp);
+	error = mmfree(p, mp);
 	shp->shm_dtime = time.tv_sec;
 	if (--shp->shm_nattch <= 0 && (shp->shm_perm.mode & SHM_DEST))
 		shmfree(shp);
+	return (error);
 }
 
 /*
diff --git a/usr/src/sys/kern/uipc_syscalls.c b/usr/src/sys/kern/uipc_syscalls.c
index 64ac7847b8..b0ae6633b0 100644
--- a/usr/src/sys/kern/uipc_syscalls.c
+++ b/usr/src/sys/kern/uipc_syscalls.c
@@ -12,7 +12,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)uipc_syscalls.c	7.16 (Berkeley) %G%
+ *	@(#)uipc_syscalls.c	7.17 (Berkeley) %G%
  */
 
 #include "param.h"
-- 
2.20.1